refactor(agent): consolidate skill definition into single SKILL.md with YAML frontmatter

Merge skill.yaml (metadata) and prompt.md (prompt template) into a
single SKILL.md file with YAML frontmatter, matching the agent-skill
convention used by opencode and Claude Code.

- Add frontmatter parser (_parse_skill_file) to SkillRegistry
- Remove skill.yaml, prompt.md, empty skills/__init__.py
- Remove obsolete load_handler method
- Update tests for new format and cleaned-up fields

.docs/batch-import-design.md

@@ -1,153 +0,0 @@
-# Recipe Batch Import Feature Design
-
-## Overview
-Enable users to import multiple images as recipes in a single operation, rather than processing them individually. This feature addresses the need for efficient bulk recipe creation from existing image collections.
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        Frontend                                  │
-├─────────────────────────────────────────────────────────────────┤
-│  BatchImportManager.js                                          │
-│  ├── InputCollector (收集URL列表/目录路径)                        │
-│  ├── ConcurrencyController (自适应并发控制)                       │
-│  ├── ProgressTracker (进度追踪)                                   │
-│  └── ResultAggregator (结果汇总)                                  │
-├─────────────────────────────────────────────────────────────────┤
-│  batch_import_modal.html                                        │
-│  └── 批量导入UI组件                                              │
-├─────────────────────────────────────────────────────────────────┤
-│  batch_import_progress.css                                      │
-│  └── 进度显示样式                                                │
-└─────────────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                        Backend                                   │
-├─────────────────────────────────────────────────────────────────┤
-│  py/routes/handlers/recipe_handlers.py                          │
-│  ├── start_batch_import() - 启动批量导入                         │
-│  ├── get_batch_import_progress() - 查询进度                      │
-│  └── cancel_batch_import() - 取消导入                            │
-├─────────────────────────────────────────────────────────────────┤
-│  py/services/batch_import_service.py                            │
-│  ├── 自适应并发执行                                              │
-│  ├── 结果汇总                                                    │
-│  └── WebSocket进度广播                                           │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## API Endpoints
-
-| 端点 | 方法 | 说明 |
-|------|------|------|
-| `/api/lm/recipes/batch-import/start` | POST | 启动批量导入，返回 operation_id |
-| `/api/lm/recipes/batch-import/progress` | GET | 查询进度状态 |
-| `/api/lm/recipes/batch-import/cancel` | POST | 取消导入 |
-
-## Backend Implementation Details
-
-### BatchImportService
-
-Location: `py/services/batch_import_service.py`
-
-Key classes:
-- `BatchImportItem`: Dataclass for individual import item
-- `BatchImportProgress`: Dataclass for tracking progress
-- `BatchImportService`: Main service class
-
-Features:
-- Adaptive concurrency control (adjusts based on success/failure rate)
-- WebSocket progress broadcasting
-- Graceful error handling (individual failures don't stop the batch)
-- Result aggregation
-
-### WebSocket Message Format
-
-```json
-{
-    "type": "batch_import_progress",
-    "operation_id": "xxx",
-    "total": 50,
-    "completed": 23,
-    "success": 21,
-    "failed": 2,
-    "skipped": 0,
-    "current_item": "image_024.png",
-    "status": "running"
-}
-```
-
-### Input Types
-
-1. **URL List**: Array of URLs (http/https)
-2. **Local Paths**: Array of local file paths
-3. **Directory**: Path to directory with optional recursive flag
-
-### Error Handling
-
-- Invalid URLs/paths: Skip and record error
-- Download failures: Record error, continue
-- Metadata extraction failures: Mark as "no metadata"
-- Duplicate detection: Option to skip duplicates
-
-## Frontend Implementation Details (TODO)
-
-### UI Components
-
-1. **BatchImportModal**: Main modal with tabs for URLs/Directory input
-2. **ProgressDisplay**: Real-time progress bar and status
-3. **ResultsSummary**: Final results with success/failure breakdown
-
-### Adaptive Concurrency Controller
-
-```javascript
-class AdaptiveConcurrencyController {
-    constructor(options = {}) {
-        this.minConcurrency = options.minConcurrency || 1;
-        this.maxConcurrency = options.maxConcurrency || 5;
-        this.currentConcurrency = options.initialConcurrency || 3;
-    }
-
-    adjustConcurrency(taskDuration, success) {
-        if (success && taskDuration < 1000 && this.currentConcurrency < this.maxConcurrency) {
-            this.currentConcurrency = Math.min(this.currentConcurrency + 1, this.maxConcurrency);
-        }
-        if (!success || taskDuration > 10000) {
-            this.currentConcurrency = Math.max(this.currentConcurrency - 1, this.minConcurrency);
-        }
-        return this.currentConcurrency;
-    }
-}
-```
-
-## File Structure
-
-```
-Backend (implemented):
-├── py/services/batch_import_service.py            # 后端服务
-├── py/routes/handlers/batch_import_handler.py     # API处理器 (added to recipe_handlers.py)
-├── tests/services/test_batch_import_service.py    # 单元测试
-└── tests/routes/test_batch_import_routes.py       # API集成测试
-
-Frontend (TODO):
-├── static/js/managers/BatchImportManager.js       # 主管理器
-├── static/js/managers/batch/                       # 子模块
-│   ├── ConcurrencyController.js                    # 并发控制
-│   ├── ProgressTracker.js                          # 进度追踪
-│   └── ResultAggregator.js                         # 结果汇总
-├── static/css/components/batch-import-modal.css   # 样式
-└── templates/components/batch_import_modal.html    # Modal模板
-```
-
-## Implementation Status
-
-- [x] Backend BatchImportService
-- [x] Backend API handlers
-- [x] WebSocket progress broadcasting
-- [x] Unit tests
-- [x] Integration tests
-- [ ] Frontend BatchImportManager
-- [ ] Frontend UI components
-- [ ] E2E tests

.github/ISSUE_TEMPLATE/feature_request.md

@@ -13,8 +13,5 @@ A clear and concise description of what the problem is. Ex. I'm always frustrate
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
 **Additional context**
 Add any other context or screenshots about the feature request here.

.gitignore

@@ -7,15 +7,24 @@ py/run_test.py
 .vscode/
 cache/
 civitai/
+stats/
+wildcards/
+backups/
+logs/
 node_modules/
 coverage/
 .coverage
 model_cache/
 
-# agent
+# agent / dev tooling
 .opencode/
 .claude/
+.sisyphus/
 .codex
+.omo
+reasonix.toml
+.reasonix/
+.codegraph/
 
 # Vue widgets development cache (but keep build output)
 vue-widgets/node_modules/
@@ -24,3 +33,6 @@ vue-widgets/dist/
 
 # Hypothesis test cache
 .hypothesis/
+
+# Working/research notes (not committed)
+.docs/

.omo/plans/embeddings-hybrid-approach.md

@@ -0,0 +1,181 @@
+# Embeddings Usage Tracking — Hybrid Approach (Plan C)
+
+> **Status**: Reference document for future implementation
+> **Current implementation**: Plan A (prompt text parsing only, see `usage_stats.py:_process_embeddings`)
+> **Next step**: Add Plan B as a supplement when edge-case coverage is needed
+
+## Problem
+
+Embeddings in ComfyUI are not loaded through dedicated ComfyUI nodes like LoRAs or
+Checkpoints. They are resolved during CLIP tokenization when the prompt text contains
+`embedding:<name>` syntax (see `comfy/sd1_clip.py:SDTokenizer.tokenize_with_weights`).
+
+This means the existing metadata_collector hook (which intercepts node execution via
+`_map_node_over_list`) cannot capture embeddings the same way it captures LoRAs and
+checkpoints — there is no "EmbeddingLoader" node to intercept.
+
+## Solution Architecture
+
+The hybrid approach combines **two complementary mechanisms** to capture embedding
+usage from all possible paths.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                 Plan A (已实现)                          │
+│                                                         │
+│  MetadataRegistry.prompt_metadata["prompts"]            │
+│       │                                                  │
+│       ▼                                                  │
+│  _process_embeddings()                                   │
+│       │                                                  │
+│       ├─ Iterate all prompt node texts                   │
+│       ├─ regex extract "embedding:<name>"                │
+│       ├─ resolve name → sha256 via EmbeddingScanner      │
+│       └─ UsageStats.stats["embeddings"][sha256]++        │
+│                                                         │
+│  Coverage: ~95% — all CLIPTextEncode/Flux/etc nodes     │
+│                                                         │
+│  Gap: Custom nodes that load embeddings programmatically │
+│       without putting embedding:name in prompt text      │
+└─────────────────────────────────────────────────────────┘
+
+                         +
+                         ↓  (future: enable Plan B when needed)
+
+┌─────────────────────────────────────────────────────────┐
+│                 Plan B (未来 — monkey-patch)              │
+│                                                         │
+│  comfy/sd1_clip.py:load_embed()                         │
+│       │                                                  │
+│       ▼                                                  │
+│  Monkey-patch intercepts EVERY embedding file load       │
+│       │                                                  │
+│       ├─ Records embedding_name + success/failure        │
+│       ├─ Associates with current prompt_id (via registry)│
+│       └─ Feeds into UsageStats same as Plan A            │
+│                                                         │
+│  Coverage: 100% — catches ALL embedding loads            │
+│                                                         │
+│  Cost: Requires patching into ComfyUI internals          │
+│        (sd1_clip.py, sdxl_clip.py, some text_encoders)   │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Plan B Detail — Monkey-patch `load_embed`
+
+### Target Function
+
+**`comfy.sd1_clip.load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None)`**
+at line 415 of `sd1_clip.py`.
+
+This is the **single choke point** for all embedding file loads in ComfyUI. Every
+CLIP variant (SD1, SDXL, SD3, Flux) calls this same function.
+
+### Implementation Sketch
+
+```python
+# In metadata_collector/metadata_hook.py (or a new module)
+import comfy.sd1_clip as sd1_clip
+
+_original_load_embed = sd1_clip.load_embed
+
+def _patched_load_embed(embedding_name, embedding_directory, embedding_size, embed_key=None):
+    result = _original_load_embed(
+        embedding_name, embedding_directory, embedding_size, embed_key
+    )
+    if result is not None:
+        _record_embedding_usage(embedding_name)
+    return result
+
+sd1_clip.load_embed = _patched_load_embed
+```
+
+### Prompt ID Association
+
+The challenge is associating the `load_embed` call with the current `prompt_id`.
+Options:
+
+1. **Thread-local / contextvar**: Store current `prompt_id` in a `contextvars.ContextVar`
+   that the metadata_collector sets at the start of each prompt execution.
+
+2. **MetadataRegistry singleton**: The MetadataRegistry already has `current_prompt_id`.
+   The patch can read it directly since both run in the same thread.
+
+3. **Lazy aggregation**: Instead of associating with prompt_id at load time, collect
+   all loaded embedding names in a global set during execution, then flush to
+   UsageStats after the prompt completes.
+
+### Files to Patch
+
+| File | Function | Coverage |
+|------|----------|----------|
+| `comfy/sd1_clip.py:415` | `load_embed()` | Primary — SD1.x, SDXL, SD3, Flux |
+| `comfy/sdxl_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
+| `comfy/text_encoders/sd3_clip.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
+| `comfy/text_encoders/flux.py` | Not needed (calls `sd1_clip.SDTokenizer`) | — |
+
+The SD1 tokenizer is the base class for all CLIP variants' tokenizers, so patching
+`load_embed` covers them all.
+
+### Edge Cases
+
+| Edge Case | Plan A | Plan B |
+|-----------|--------|--------|
+| `embedding:name` in CLIPTextEncode | ✅ | ✅ |
+| `embedding:name` in CLIPTextEncodeFlux | ✅ | ✅ |
+| `embedding:name` in PromptLM (LoRA Manager) | ✅ | ✅ |
+| `embedding:name` in WAS_Text_to_Conditioning | ✅ | ✅ |
+| Custom node that loads embedding programmatically | ❌ | ✅ |
+| Embedding loaded multiple times in same prompt | ✅ (dedup via set) | ✅ (dedup via set) |
+| Embedding file not found | N/A | ✅ (can log) |
+| Embedding dimension mismatch | N/A | ✅ (can log) |
+| Text encoder with non-standard tokenizer (LLaMA, T5...) | Partial | ✅ (if it calls load_embed) |
+
+## Migration Path: Standalone → Hybrid
+
+### Phase 1 — Plan A (当前状态)
+- Prompt text parsing only
+- No monkey-patching required
+- Covers all standard workflows
+
+### Phase 2 — Enable Plan B (未来工作)
+1. Add monkey-patch of `load_embed` in `metadata_collector/metadata_hook.py` (alongside
+   the existing `_map_node_over_list` hook)
+2. Collect loaded embedding names in a `set()` on the registry
+3. In `UsageStats._process_embeddings()`, merge the Plan A results (from prompt text)
+   with the Plan B results (from the patch)
+4. Add `prompt_data` field on MetadataRegistry to store loaded embeddings per prompt
+
+### Deduplication
+
+```python
+# Merge Plan A + Plan B results in _process_embeddings
+plan_a_names = extract_from_prompt_texts(prompts_data)
+plan_b_names = registry.get_loaded_embeddings(prompt_id)
+
+all_names = plan_a_names | plan_b_names
+```
+
+## Testing the Hybrid
+
+| Scenario | What to verify |
+|----------|---------------|
+| Standard `embedding:name` in prompt | Plan A captures it |
+| Embedding loaded by custom node script | Plan B captures it |
+| Both paths fire for same embedding | No double-counting (dedup) |
+| Embedding name resolves to hash | EmbeddingScanner.get_hash_by_filename works |
+| No embedding scanner available | Graceful skip, no crash |
+| Missing embedding file | Plan B logs warning, Plan A skips gracefully |
+| Empty prompt | No crash, no entries |
+| Standalone mode | Both plans disabled gracefully |
+
+## Key Files Reference
+
+| File | Role |
+|------|------|
+| `py/utils/usage_stats.py` | Core — `_process_embeddings()` for Plan A |
+| `py/metadata_collector/constants.py` | `EMBEDDINGS` category constant |
+| `py/metadata_collector/metadata_hook.py` | Future — monkey-patch for Plan B |
+| `py/services/embedding_scanner.py` | Hash resolution service |
+| `py/routes/stats_routes.py` | Already handles `usage_data.get('embeddings', {})` |
+| `comfy/sd1_clip.py` (ComfyUI) | `load_embed()` — Plan B target |

docs/agent_skills.md

@@ -0,0 +1,208 @@
+# Agent Skills System
+
+The LoRA Manager agent skills system enables LLM-powered metadata enrichment and other AI-driven tasks. Users configure their own LLM provider (BYOK), and skills are executed through right-click context menu actions.
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────┐
+│              LoRA Manager Backend             │
+│                                               │
+│  ┌──────────────┐    ┌────────────────┐       │
+│  │ LLMService    │───▶│ LLM Provider   │       │
+│  │ (BYOK config, │◀───│ (OpenAI/Ollama │       │
+│  │  API calls)   │    │ /custom)       │       │
+│  └───────┬───────┘    └────────────────┘       │
+│          │                                     │
+│  ┌───────▼───────────────────────┐             │
+│  │     AgentService              │             │
+│  │  (orchestration: validate     │             │
+│  │   → LLM call → post-process   │             │
+│  │   → WebSocket broadcast)      │             │
+│  └───────┬───────────────────────┘             │
+│          │                                     │
+│  ┌───────▼───────────────────────┐             │
+│  │     SkillRegistry             │             │
+│  │  ┌─────────────────────────┐  │             │
+│  │  │ enrich_hf_metadata:     │  │             │
+│  │  │  - skill.yaml           │  │             │
+│  │  │  - prompt.md            │  │             │
+│  │  │  - handler.py           │  │             │
+│  │  └─────────────────────────┘  │             │
+│  └───────────────────────────────┘             │
+└──────────────────────────────────────────────┘
+```
+
+### Key Design Principle
+
+**Skills define *what* to do (prompt + post-processing). The AgentService handles *how* (LLM calls, validation, progress).**
+
+Skills never call the LLM directly. This keeps BYOK configuration centralized and provider-agnostic.
+
+## BYOK Configuration
+
+Users configure their LLM provider in **Settings → AI Provider**:
+
+| Setting | Description | Example |
+|---|---|---|
+| `llm_provider` | Provider type | `openai`, `ollama`, or `custom` |
+| `llm_api_key` | API key (not needed for local Ollama) | `sk-...` |
+| `llm_api_base` | Custom API base URL (empty = provider default) | `https://api.openai.com/v1` |
+| `llm_model` | Model name | `gpt-4o-mini` |
+
+Environment variable overrides: `LLM_API_KEY`, `LLM_MODEL`, `LLM_API_BASE`, `LLM_PROVIDER`.
+
+### Supported Providers
+
+- **OpenAI**: Uses `https://api.openai.com/v1` by default
+- **Ollama** (local): Uses `http://localhost:11434/v1`, no API key required
+- **Custom**: Any OpenAI-compatible endpoint (vLLM, LM Studio, etc.) — set `llm_api_base` explicitly
+
+## Available Skills
+
+### enrich_hf_metadata
+
+Enriches HuggingFace-downloaded models with metadata extracted by an LLM from the HF model card.
+
+**Entry point**: Right-click context menu → "Enrich Metadata (Agent)"
+
+**What it does**:
+1. Reads the model's `.metadata.json` to get the `hf_url`
+2. Fetches the README.md from the HuggingFace repository
+3. Sends the README + local metadata to the LLM for structured extraction
+4. Writes extracted fields to `.metadata.json`:
+   - `base_model` — only if current value is empty
+   - `trainedWords` — trigger words (LoRA only, if none exist)
+   - `modelDescription` — concise summary (if none exists)
+   - `tags` — merged with existing tags, deduplicated
+   - `metadata_source` — audit trail: `agent:enrich_hf_metadata`
+   - `llm_enriched_at` — ISO timestamp
+5. Downloads and optimizes preview image (if LLM found one in the README)
+6. Updates the scanner cache
+7. Broadcasts WebSocket progress events
+
+**Model types**: LoRA, Checkpoint, Embedding
+
+## Adding a New Skill
+
+### 1. Create the skill directory
+
+```
+py/services/agent/skills/<skill_name>/
+├── skill.yaml      # Skill metadata and schemas
+├── prompt.md       # LLM prompt template
+└── handler.py      # Pre-processing and post-processing
+```
+
+### 2. Write skill.yaml
+
+```yaml
+name: my_skill
+title: "My Skill"
+description: "What this skill does"
+llm_required: true
+model_type_filter: ["lora"]  # or null for all types
+input_schema:
+  type: object
+  properties:
+    model_paths:
+      type: array
+      items:
+        type: string
+  required:
+    - model_paths
+output_schema:
+  type: object
+  properties:
+    # ... JSON schema for LLM output
+permissions:
+  write_metadata: true
+  write_previews: false
+  network_domains:
+    - "example.com"
+```
+
+### 3. Write prompt.md
+
+Use `{{variable}}` placeholders that will be replaced with data from the `prepare` function:
+
+```markdown
+You are an expert assistant...
+
+Model URL: {{hf_url}}
+README content:
+{{readme_content}}
+
+Current metadata:
+{{current_metadata}}
+```
+
+### 4. Write handler.py
+
+```python
+async def prepare(model_path: str, input_data: dict) -> dict:
+    """Gather context for the LLM prompt. Returns variables for template rendering."""
+    return {
+        "model_path": model_path,
+        # ... other variables used in prompt.md
+    }
+
+async def post_process(context) -> dict:
+    """Apply the LLM-extracted data to the model."""
+    llm_response = context.llm_response
+    # ... write metadata, download previews, update cache
+    return {
+        "success": True,
+        "updated_fields": ["base_model", "tags"],
+        "errors": [],
+    }
+```
+
+**Important**: Use absolute imports (`from py.utils.metadata_manager import MetadataManager`) because skills are loaded via `importlib.util.spec_from_file_location`, which doesn't support relative imports.
+
+### 5. Test
+
+The skill is automatically discovered by `SkillRegistry` on startup. Test with:
+
+```python
+pytest tests/services/test_agent_service.py
+```
+
+## API Endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/lm/agent/skills` | List available skills |
+| POST | `/api/lm/agent/execute/{skill_name}` | Execute a skill (body: `{"model_paths": [...]}`) |
+| POST | `/api/lm/agent/cancel` | Cancel running skill (stub) |
+
+## WebSocket Events
+
+| Type | When | Key fields |
+|---|---|---|
+| `agent_progress` | Skill started/processing | `skill`, `status`, `total`, `processed`, `success`, `current_path` |
+| `agent_progress` | Skill completed | `skill`, `status`, `updated_models`, `errors`, `summary` |
+| `agent_progress` | Skill error | `skill`, `status`, `error` |
+
+## Security Model
+
+Skills declare permissions in `skill.yaml`:
+- `write_metadata` — can write `.metadata.json` files
+- `write_previews` — can download/replace preview images
+- `network_domains` — allowed domains for HTTP requests
+
+These are declarative constraints checked by `AgentService`. They are defense-in-depth, not a sandbox — the Python process can technically do anything, but the contract is clear and auditable.
+
+## File Locations
+
+| Component | Path |
+|---|---|
+| LLMService | `py/services/llm_service.py` |
+| AgentService | `py/services/agent/agent_service.py` |
+| SkillRegistry | `py/services/agent/skill_registry.py` |
+| SkillDefinition | `py/services/agent/skill_definition.py` |
+| Skills directory | `py/services/agent/skills/` |
+| Route handlers | `py/routes/handlers/agent_handlers.py` |
+| Frontend manager | `static/js/managers/AgentManager.js` |
+| Settings UI | `templates/components/modals/settings_modal.html` |
+| Context menu | `templates/components/context_menu.html` |

locales/de.json

@@ -16,10 +16,13 @@
             "help": "Hilfe",
             "add": "Hinzufügen",
             "close": "Schließen",
-            "menu": "Menü"
+            "menu": "Menü",
+            "remove": "Entfernen",
+            "change": "Ändern"
         },
         "status": {
             "loading": "Wird geladen...",
+            "cancelling": "Abbrechen...",
             "unknown": "Unbekannt",
             "date": "Datum",
             "version": "Version",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "Aus Favoriten entfernen",
             "viewOnCivitai": "Auf Civitai anzeigen",
             "notAvailableFromCivitai": "Nicht auf Civitai verfügbar",
+            "viewOnHuggingFace": "Auf Hugging Face ansehen",
             "sendToWorkflow": "An ComfyUI senden (Klick: Anhängen, Shift+Klick: Ersetzen)",
             "copyLoRASyntax": "LoRA-Syntax kopieren",
             "checkpointNameCopied": "Checkpoint-Name kopiert",
@@ -111,6 +115,7 @@
             "replacePreview": "Vorschau ersetzen",
             "copyCheckpointName": "Checkpoint-Name kopieren",
             "copyEmbeddingName": "Embedding-Name kopieren",
+            "embeddingNameCopied": "Embedding-Syntax kopiert",
             "sendCheckpointToWorkflow": "An ComfyUI senden",
             "sendEmbeddingToWorkflow": "An ComfyUI senden"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "Verwendungsanzahl"
+        },
+        "footer": {
+            "versionCount": "{count} Versionen",
+            "viewAllVersions": "Alle lokalen Versionen anzeigen"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "Ausgeschlossene Modelle verwalten"
+        },
+        "groupByModel": {
+            "label": "Nach Modell gruppieren"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "Statistiken"
         },
         "search": {
-            "placeholder": "Suchen...",
-            "placeholders": {
-                "loras": "LoRAs suchen...",
-                "recipes": "Rezepte suchen...",
-                "checkpoints": "Checkpoints suchen...",
-                "embeddings": "Embeddings suchen..."
-            },
+            "placeholder": "Suchen",
             "options": "Suchoptionen",
             "searchIn": "Suchen in:",
             "notAvailable": "Suche auf Statistikseite nicht verfügbar",
@@ -232,7 +238,10 @@
             "license": "Lizenz",
             "noCreditRequired": "Kein Credit erforderlich",
             "allowSellingGeneratedContent": "Verkauf erlaubt",
+            "allowSellingGeneratedContentTooltip": "Verkauf generierter Bilder erlauben",
+            "noCreditRequiredTooltip": "Modell ohne Nennung des Erstellers verwenden",
             "noTags": "Keine Tags",
+            "autoTags": "Auto-Tags",
             "noBaseModelMatches": "Keine Basismodelle entsprechen der aktuellen Suche.",
             "clearAll": "Alle Filter löschen",
             "any": "Beliebig",
@@ -244,7 +253,18 @@
             "toggle": "Theme wechseln",
             "switchToLight": "Zu hellem Theme wechseln",
             "switchToDark": "Zu dunklem Theme wechseln",
-            "switchToAuto": "Zu automatischem Theme wechseln"
+            "switchToAuto": "Zu automatischem Theme wechseln",
+            "presets": "Theme-Voreinstellungen",
+            "default": "Standard",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "Modus",
+            "light": "Hell",
+            "dark": "Dunkel",
+            "auto": "Auto"
         },
         "actions": {
             "checkUpdates": "Updates prüfen",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Civitai API Key",
         "civitaiApiKeyPlaceholder": "Geben Sie Ihren Civitai API Key ein",
         "civitaiApiKeyHelp": "Wird für die Authentifizierung beim Herunterladen von Modellen von Civitai verwendet",
+        "civitaiApiKeyConfigured": "Konfiguriert",
+        "civitaiApiKeyNotConfigured": "Nicht konfiguriert",
+        "civitaiApiKeySet": "Einrichten",
         "civitaiHost": {
             "label": "Civitai-Host",
             "help": "Wählen Sie aus, welche Civitai-Seite geöffnet wird, wenn Sie „View on Civitai“-Links verwenden.",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "Download-Backend",
-            "help": "Wähle aus, wie Modelldateien heruntergeladen werden. Python verwendet den eingebauten Downloader. aria2 verwendet den experimentellen externen Downloader-Prozess.",
+            "help": "Wähle aus, wie Modelldateien heruntergeladen werden. Python verwendet den eingebauten Downloader. aria2 verwendet den empfohlenen externen Downloader-Prozess.",
             "options": {
                 "python": "Python (integriert)",
-                "aria2": "aria2 (experimentell)"
+                "aria2": "aria2 (empfohlen)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "Downloads",
             "videoSettings": "Video-Einstellungen",
             "layoutSettings": "Layout-Einstellungen",
+            "licenseIcons": "Lizenzsymbole",
             "misc": "Verschiedenes",
             "backup": "Backups",
             "folderSettings": "Standard-Roots",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "Zusätzliche Ordnerpfade",
             "downloadPathTemplates": "Download-Pfad-Vorlagen",
             "priorityTags": "Prioritäts-Tags",
-            "updateFlags": "Update-Markierungen",
+            "versionScope": "Update-Markierungen",
             "exampleImages": "Beispielbilder",
             "autoOrganize": "Auto-Organisierung",
             "metadata": "Metadaten",
@@ -408,6 +432,8 @@
             "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": {
+            "groupByModel": "Nach Modell gruppieren",
+            "groupByModelHelp": "Wenn aktiviert, wird nur die neueste Version jedes Civitai-Modells als einzelne Karte angezeigt. Ältere Versionen werden ausgeblendet.",
             "displayDensity": "Anzeige-Dichte",
             "displayDensityOptions": {
                 "default": "Standard",
@@ -442,7 +468,9 @@
                 "modelName": "Modellname",
                 "fileName": "Dateiname"
             },
-            "modelNameDisplayHelp": "Wählen Sie aus, was in der Fußzeile der Modellkarte angezeigt werden soll"
+            "modelNameDisplayHelp": "Wählen Sie aus, was in der Fußzeile der Modellkarte angezeigt werden soll",
+            "cardBlurAmount": "Karten-Overlay-Unschärfe",
+            "cardBlurAmountHelp": "Passen Sie die Unschärfeintensität der Kopf- und Fußzeilen-Overlays auf Modell- und Rezeptkarten an (0 = keine Unschärfe, 20 = maximale Unschärfe)."
         },
         "folderSettings": {
             "activeLibrary": "Aktive Bibliothek",
@@ -562,7 +590,7 @@
             "download": "Herunterladen",
             "restartRequired": "Neustart erforderlich"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "Strategie für Update-Markierungen",
             "help": "Entscheide, ob Update-Badges nur dann erscheinen, wenn eine neue Version dasselbe Basismodell wie deine lokalen Dateien verwendet, oder sobald es irgendein neueres Release für dieses Modell gibt.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "Früher Zugriff Updates ausblenden",
             "help": "Nur Early-Access-Updates"
         },
+        "licenseIcons": {
+            "useNewStyle": "Aktualisierte Lizenzsymbole verwenden",
+            "useNewStyleHelp": "Lizenzberechtigungen mit farbigen Indikatoren (neuer Stil) oder nur Einschränkungssymbolen (klassischer Stil) anzeigen. Orientiert sich am aktuellen CivitAI-Design."
+        },
         "misc": {
             "includeTriggerWords": "Trigger Words in LoRA-Syntax einschließen",
-            "includeTriggerWordsHelp": "Trainierte Trigger Words beim Kopieren der LoRA-Syntax in die Zwischenablage einschließen"
+            "includeTriggerWordsHelp": "Trainierte Trigger Words beim Kopieren der LoRA-Syntax in die Zwischenablage einschließen",
+            "loraSyntaxFormat": "LoRA-Syntaxformat",
+            "loraSyntaxFormatHelp": "LoRA-Syntaxformat. Der vollständige Pfad enthält den Unterordnerpfad (<lora:style/anime/x:1.0>) für verlustfreie Modellauflösung. Legacy verwendet nur den Dateinamen (<lora:x:1.0>) — A1111-Konvention, kann bei doppelten Dateinamen in verschiedenen Ordnern zu Mehrdeutigkeiten führen.",
+            "loraSyntaxFormatOptions": {
+                "full": "Vollständiger Pfad (Unterordner/Name)",
+                "legacy": "Legacy A1111 (nur Name)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "Metadaten-Archiv-Datenbank aktivieren",
@@ -619,6 +657,23 @@
             "proxyPassword": "Passwort (optional)",
             "proxyPasswordPlaceholder": "passwort",
             "proxyPasswordHelp": "Passwort für die Proxy-Authentifizierung (falls erforderlich)"
+        },
+        "aiProvider": {
+            "title": "KI-Anbieter",
+            "provider": "Anbieter",
+            "providerHelp": "Wählen Sie Ihren LLM-Anbieter. OpenAI und Ollama verwenden voreingestellte API-Endpunkte. Mit \"Benutzerdefiniert\" können Sie jeden OpenAI-kompatiblen Endpunkt angeben.",
+            "custom": "Benutzerdefiniert (OpenAI-kompatibel)",
+            "apiBase": "API-Basis-URL",
+            "apiBaseHelp": "Die Basis-URL für die LLM-API (z.B. https://api.openai.com/v1). Leer lassen, um die Anbietervoreinstellung zu verwenden.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "API-Schlüssel",
+            "apiKeyHelp": "Ihr LLM-API-Schlüssel. Wird lokal gespeichert und niemals an einen anderen Server außer Ihrem gewählten LLM-Anbieter gesendet.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "Nicht festgelegt",
+            "apiKeyConfigured": "Konfiguriert",
+            "apiKeySet": "Einrichten",
+            "model": "Modell",
+            "modelHelp": "Der zu verwendende Modellname (z.B. deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). Prüfen Sie Ihren Anbieter auf verfügbare Modelle."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "Kleinste",
                 "usage": "Anzahl Nutzung",
                 "usageDesc": "Meiste",
-                "usageAsc": "Wenigste"
+                "usageAsc": "Wenigste",
+                "versionsCount": "Lokale Versionen",
+                "versionsCountDesc": "Meiste Versionen zuerst",
+                "versionsCountAsc": "Wenigste Versionen zuerst",
+                "versionIdDesc": "Neueste Version zuerst"
             },
             "refresh": {
                 "title": "Modelliste aktualisieren",
-                "quick": "Änderungen synchronisieren",
-                "quickTooltip": "Nach neuen oder fehlenden Modelldateien suchen, damit die Liste aktuell bleibt.",
                 "full": "Cache neu aufbauen",
                 "fullTooltip": "Alle Modelldetails aus Metadatendateien neu laden – nutzen, wenn die Bibliothek veraltet wirkt oder nach manuellen Änderungen."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "Inhaltsbewertung für alle festlegen",
             "copyAll": "Alle Syntax kopieren",
             "refreshAll": "Alle Metadaten aktualisieren",
+            "repairMetadata": "Metadaten der Auswahl reparieren",
+            "reimportMetadata": "Aus Quelle neu importieren",
             "checkUpdates": "Auswahl auf Updates prüfen",
             "moveAll": "Alle in Ordner verschieben",
             "autoOrganize": "Automatisch organisieren",
@@ -692,9 +751,18 @@
             "unfavorite": "Aus Favoriten entfernen",
             "deleteAll": "Ausgewählte löschen",
             "downloadMissingLoras": "Fehlende LoRAs herunterladen",
+            "downloadExamples": "Beispielbilder herunterladen",
             "clear": "Auswahl löschen",
             "skipMetadataRefreshCount": "Überspringen（{count} Modelle）",
             "resumeMetadataRefreshCount": "Fortsetzen（{count} Modelle）",
+            "sendToWorkflow": "An Workflow senden",
+            "sections": {
+                "workflow": "Workflow",
+                "metadata": "Metadaten",
+                "attributes": "Attribute",
+                "organize": "Organisieren",
+                "download": "Download"
+            },
             "autoOrganizeProgress": {
                 "initializing": "Automatische Organisation wird initialisiert...",
                 "starting": "Automatische Organisation für {type} wird gestartet...",
@@ -703,7 +771,8 @@
                 "completed": "Abgeschlossen: {success} verschoben, {skipped} übersprungen, {failures} fehlgeschlagen",
                 "complete": "Automatische Organisation abgeschlossen",
                 "error": "Fehler: {error}"
-            }
+            },
+            "enrichHfAgent": "Metadaten mit KI anreichern"
         },
         "contextMenu": {
             "refreshMetadata": "Civitai-Daten aktualisieren",
@@ -720,13 +789,15 @@
             "setContentRating": "Inhaltsbewertung festlegen",
             "moveToFolder": "In Ordner verschieben",
             "repairMetadata": "Metadaten reparieren",
+            "reimportMetadata": "Aus Quelle neu importieren",
             "excludeModel": "Modell ausschließen",
             "restoreModel": "Modell wiederherstellen",
             "deleteModel": "Modell löschen",
             "shareRecipe": "Rezept teilen",
             "viewAllLoras": "Alle LoRAs anzeigen",
             "downloadMissingLoras": "Fehlende LoRAs herunterladen",
-            "deleteRecipe": "Rezept löschen"
+            "deleteRecipe": "Rezept löschen",
+            "enrichHfAgent": "Metadaten mit KI anreichern"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "Rezeptliste aktualisieren",
-                "quick": "Änderungen synchronisieren",
-                "quickTooltip": "Änderungen synchronisieren - schnelle Aktualisierung ohne Cache-Neubau",
                 "full": "Cache neu aufbauen",
                 "fullTooltip": "Cache neu aufbauen - vollständiger Rescan aller Rezeptdateien"
             },
@@ -849,6 +918,13 @@
                 "skipped": "Rezept bereits in der neuesten Version, keine Reparatur erforderlich",
                 "failed": "Rezept-Reparatur fehlgeschlagen: {message}",
                 "missingId": "Rezept kann nicht repariert werden: Fehlende Rezept-ID"
+            },
+            "reimport": {
+                "starting": "Rezept wird aus Quelle neu importiert...",
+                "success": "Rezept erfolgreich neu importiert",
+                "noSourceUrl": "Rezept hat keine Quell-URL, Neuimport nicht möglich",
+                "failed": "Neuimport des Rezepts fehlgeschlagen: {message}",
+                "missingId": "Neuimport nicht möglich: Rezept-ID fehlt"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "Stammverzeichnis",
         "collapseAll": "Alle Ordner einklappen",
-        "pinSidebar": "Sidebar anheften",
-        "unpinSidebar": "Sidebar lösen",
+        "hideOnThisPage": "Seitenleiste auf dieser Seite ausblenden",
+        "showSidebar": "Seitenleiste anzeigen",
+        "sidebarHiddenNotification": "Seitenleiste auf der Seite {page} ausgeblendet",
         "switchToListView": "Zur Listenansicht wechseln",
         "switchToTreeView": "Zur Baumansicht wechseln",
         "recursiveOn": "Unterordner einbeziehen",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "Keine Ordner gefunden",
             "dragHint": "Elemente hierher ziehen, um Ordner zu erstellen"
+        },
+        "folderUpdateCheck": {
+            "label": "Auf Updates in diesem Ordner prüfen",
+            "loading": "Prüfe {type}-Updates in diesem Ordner...",
+            "success": "{count} Update(s) für {type}s in diesem Ordner gefunden",
+            "none": "Alle {type}s in diesem Ordner sind aktuell",
+            "error": "Fehler beim Prüfen des Ordners auf {type}-Updates: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "Speicher",
             "insights": "Erkenntnisse"
         },
+        "metrics": {
+            "totalModels": "Modelle gesamt",
+            "totalStorage": "Speicher gesamt",
+            "totalGenerations": "Generationen gesamt",
+            "usageRate": "Nutzungsrate",
+            "loras": "LoRAs",
+            "checkpoints": "Checkpoints",
+            "embeddings": "Embeddings",
+            "uniqueTags": "Einzigartige Tags",
+            "unusedModels": "Ungenutzte Modelle",
+            "avgUsesPerModel": "Ø Nutzungen/Modell"
+        },
         "usage": {
             "mostUsedLoras": "Meistgenutzte LoRAs",
             "mostUsedCheckpoints": "Meistgenutzte Checkpoints",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "Intelligente Erkenntnisse",
-            "recommendations": "Empfehlungen"
+            "recommendations": "Empfehlungen",
+            "noInsights": "Keine Erkenntnisse verfügbar",
+            "unusedLoras": {
+                "high": {
+                    "title": "Hohe Anzahl ungenutzter LoRAs",
+                    "description": "{percent}% Ihrer LoRAs ({count}/{total}) wurden noch nie verwendet.",
+                    "suggestion": "Erwägen Sie, ungenutzte Modelle zu organisieren oder zu archivieren, um Speicherplatz freizugeben."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "Ungenutzte Checkpoints erkannt",
+                    "description": "{percent}% Ihrer Checkpoints ({count}/{total}) wurden noch nie verwendet.",
+                    "suggestion": "Überprüfen Sie nicht mehr benötigte Checkpoints und erwägen Sie deren Entfernung."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "Hohe Anzahl ungenutzter Embeddings",
+                    "description": "{percent}% Ihrer Embeddings ({count}/{total}) wurden noch nie verwendet.",
+                    "suggestion": "Organisieren oder archivieren Sie ungenutzte Embeddings, um Ihre Sammlung zu optimieren."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "Große Sammlung erkannt",
+                    "description": "Ihre Modellsammlung verwendet {size} Speicher.",
+                    "suggestion": "Erwägen Sie externe Speicher- oder Cloud-Lösungen für eine bessere Organisation."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "Aktiver Benutzer",
+                    "description": "Sie haben {count} Generationen abgeschlossen!",
+                    "suggestion": "Entdecken und erstellen Sie weiterhin großartige Inhalte mit Ihren Modellen."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "Sammlungsübersicht",
             "baseModelDistribution": "Basis-Modell-Verteilung",
             "usageTrends": "Nutzungstrends (Letzte 30 Tage)",
-            "usageDistribution": "Nutzungsverteilung"
+            "usageDistribution": "Nutzungsverteilung",
+            "date": "Datum",
+            "usageCount": "Nutzungsanzahl",
+            "fileSizeBytes": "Dateigröße (Bytes)",
+            "models": "Modelle",
+            "loraUsage": "LoRA-Nutzung",
+            "checkpointUsage": "Checkpoint-Nutzung",
+            "embeddingUsage": "Embedding-Nutzung"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "Diffusionsmodell",
+            "embedding": "Embeddings"
+        },
+        "placeholders": {
+            "loading": "Lädt...",
+            "noModels": "Keine Modelle gefunden",
+            "errorLoading": "Fehler beim Laden der Daten",
+            "noStorageData": "Keine Speicherdaten verfügbar",
+            "rootFolder": "Root",
+            "chartLibraryMissing": "Diagramm benötigt Chart.js-Bibliothek"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} Modelle",
+            "chartUsage": "{name}: {size}, {count} Nutzungen",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "Modell von URL herunterladen",
             "titleWithType": "{type} von URL herunterladen",
-            "url": "Civitai URL",
             "civitaiUrl": "Civitai URL:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "Geben Sie eine CivitAI-, CivArchive- oder Hugging Face-URL pro Zeile ein. Unterstützt mehrere URLs für den Batch-Download.",
+            "selectHfFiles": "Datei(en) zum Herunterladen aus diesem Repository auswählen:",
+            "selectAll": "Alle auswählen",
+            "fetchingRepoFiles": "Repository-Dateien werden abgerufen...",
             "locationPreview": "Download-Speicherort Vorschau",
             "useDefaultPath": "Standardpfad verwenden",
             "useDefaultPathTooltip": "Wenn aktiviert, werden Dateien automatisch mit konfigurierten Pfadvorlagen organisiert",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "Zuvor heruntergeladen, aber derzeit nicht in Ihrer Bibliothek.",
             "alreadyInLibrary": "Bereits in Bibliothek",
             "autoOrganizedPath": "[Automatisch organisiert durch Pfadvorlage]",
+            "fileSelection": {
+                "title": "Dateiformat auswählen",
+                "files": "Dateien",
+                "select": "Datei auswählen"
+            },
             "errors": {
                 "invalidUrl": "Ungültiges Civitai URL-Format",
-                "noVersions": "Keine Versionen für dieses Modell verfügbar"
+                "noVersions": "Keine Versionen für dieses Modell verfügbar",
+                "mixedSources": "CivitAI- und Hugging Face-URLs können nicht in derselben Charge gemischt werden.",
+                "noModelFiles": "In diesem Repository wurden keine Modelldateien gefunden."
             },
             "status": {
                 "preparing": "Download wird vorbereitet...",
@@ -1080,6 +1250,12 @@
             "countMessage": "Modelle werden dauerhaft gelöscht.",
             "action": "Alle löschen"
         },
+        "bulkDeleteRecipes": {
+            "title": "Mehrere Rezepte löschen",
+            "message": "Sind Sie sicher, dass Sie alle ausgewählten Rezepte und ihre zugehörigen Dateien löschen möchten?",
+            "countMessage": "Rezepte werden dauerhaft gelöscht.",
+            "action": "Alle löschen"
+        },
         "checkUpdates": {
             "title": "Alle {typePlural} auf Updates prüfen?",
             "message": "Damit werden alle {typePlural} in deiner Bibliothek auf Updates geprüft. Bei großen Sammlungen kann das etwas länger dauern.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "Modellname bearbeiten",
                 "editFileName": "Dateiname bearbeiten",
                 "editBaseModel": "Basis-Modell bearbeiten",
+                "editVersionName": "Versionsname bearbeiten",
                 "viewOnCivitai": "Auf Civitai anzeigen",
                 "viewOnCivitaiText": "Auf Civitai anzeigen",
+                "viewOnHuggingFace": "Auf Hugging Face ansehen",
+                "viewOnHuggingFaceText": "Auf Hugging Face ansehen",
                 "viewCreatorProfile": "Ersteller-Profil anzeigen",
                 "openFileLocation": "Dateispeicherort öffnen",
                 "sendToWorkflow": "An ComfyUI senden",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "Zusätzliche Notizen",
                 "notesHint": "Enter zum Speichern, Shift+Enter für neue Zeile",
                 "addNotesPlaceholder": "Fügen Sie hier Ihre Notizen hinzu...",
-                "aboutThisVersion": "Über diese Version"
+                "aboutThisVersion": "Über diese Version",
+                "baseModelSearchPlaceholder": "Basismodell suchen…",
+                "baseModelSuggested": "Vorschlag",
+                "baseModelNoMatch": "Keine passenden Basismodelle"
             },
             "notes": {
                 "saved": "Notizen erfolgreich gespeichert",
-                "saveFailed": "Fehler beim Speichern der Notizen"
+                "saveFailed": "Fehler beim Speichern der Notizen",
+                "showMore": "Mehr anzeigen",
+                "showLess": "Weniger anzeigen"
             },
             "usageTips": {
                 "addPresetParameter": "Voreingestellten Parameter hinzufügen...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "Version gelöscht"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "Metadaten abrufen — Zusammenfassung",
+            "statSuccess": "Erfolgreich",
+            "statFailed": "Fehlgeschlagen",
+            "statSkipped": "Übersprungen",
+            "statTotal": "Gesamt geprüft",
+            "statDuration": "Dauer",
+            "successMessage": "Alle {count} {type}s erfolgreich aktualisiert!",
+            "failedItems": "Fehlgeschlagene Elemente ({count})",
+            "close": "Schließen",
+            "copyReport": "Bericht kopieren",
+            "downloadCsv": "CSV herunterladen",
+            "columnModelName": "Modellname",
+            "columnError": "Fehler"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "Dieser Tag existiert bereits"
         }
     },
-    "keyboard": {
-        "navigation": "Tastatur-Navigation:",
-        "shortcuts": {
-            "pageUp": "Eine Seite nach oben scrollen",
-            "pageDown": "Eine Seite nach unten scrollen",
-            "home": "Zum Anfang springen",
-            "end": "Zum Ende springen"
-        }
-    },
     "initialization": {
         "title": "Initialisierung",
         "message": "Ihr Arbeitsbereich wird vorbereitet...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "Keine kompatiblen Knoten im aktuellen Workflow verfügbar",
             "noTargetNodeSelected": "Kein Zielknoten ausgewählt",
             "modelUpdated": "Modell im Workflow aktualisiert",
-            "modelFailed": "Fehler beim Aktualisieren des Modellknotens"
+            "modelFailed": "Fehler beim Aktualisieren des Modellknotens",
+            "embeddingAdded": "Embedding zum Workflow hinzugefügt",
+            "embeddingFailed": "Fehler beim Hinzufügen des Embeddings",
+            "promptSent": "Prompt an Workflow gesendet",
+            "promptFailed": "Fehler beim Senden des Prompts"
         },
         "nodeSelector": {
             "recipe": "Rezept",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "Prompt",
             "replace": "Ersetzen",
             "append": "Anhängen",
             "selectTargetNode": "Zielknoten auswählen",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "Keine Rezept-ID verfügbar",
             "sendToWorkflowFailed": "Fehler beim Senden des Rezepts an den Workflow: {message}",
             "copyFailed": "Fehler beim Kopieren der Rezept-Syntax: {message}",
+            "createError": "Fehler beim Erstellen des Rezepts：{message}",
+            "createFailed": "Fehler beim Erstellen des Rezepts：{error}",
+            "createMissingData": "Erforderliche Daten zum Erstellen des Rezepts fehlen",
+            "created": "Rezept erfolgreich erstellt",
             "noMissingLoras": "Keine fehlenden LoRAs zum Herunterladen",
             "missingLorasInfoFailed": "Fehler beim Abrufen der Informationen für fehlende LoRAs",
             "preparingForDownloadFailed": "Fehler beim Vorbereiten der LoRAs für den Download",
             "enterLoraName": "Bitte geben Sie einen LoRA-Namen oder Syntax ein",
             "reconnectedSuccessfully": "LoRA erfolgreich neu verbunden",
             "reconnectFailed": "Fehler beim Neuverbinden des LoRA: {message}",
+            "noPromptToSend": "Kein zu sendender Prompt",
             "cannotSend": "Kann Rezept nicht senden: Fehlende Rezept-ID",
             "sendFailed": "Fehler beim Senden des Rezepts an Workflow",
             "sendError": "Fehler beim Senden des Rezepts an Workflow",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "Keine Rezepte ausgewählt",
+            "repairBulkComplete": "Reparatur abgeschlossen: {repaired} repariert, {skipped} übersprungen (von {total})",
+            "repairBulkSkipped": "Keine Reparatur für die {total} ausgewählten Rezepte erforderlich",
+            "repairBulkFailed": "Reparatur der ausgewählten Rezepte fehlgeschlagen: {message}",
+            "reimporting": "Rezept wird aus Quelle neu importiert...",
+            "reimportSuccess": "Rezept erfolgreich neu importiert",
+            "reimportBulkComplete": "Neuimport abgeschlossen: {completed} importiert, {failed} fehlgeschlagen (von {total})",
+            "reimportBulkFailed": "Neuimport einiger Rezepte fehlgeschlagen",
             "noMissingLorasInSelection": "Keine fehlenden LoRAs in ausgewählten Rezepten gefunden",
             "noLoraRootConfigured": "Kein LoRA-Stammverzeichnis konfiguriert. Bitte legen Sie ein Standard-LoRA-Stammverzeichnis in den Einstellungen fest."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "{successCount} {type}s erfolgreich verschoben",
             "exampleImagesDownloadSuccess": "Beispielbilder erfolgreich heruntergeladen!",
             "exampleImagesDownloadFailed": "Fehler beim Herunterladen der Beispielbilder: {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "In die Zwischenablage kopiert",
+            "downloadStarted": "Download gestartet"
+        },
+        "agent": {
+            "llmNotConfigured": "KI-Anbieter nicht konfiguriert. Aktivieren Sie ihn unter Einstellungen → KI-Anbieter.",
+            "enrichStarted": "Metadaten werden mit KI angereichert...",
+            "enrichComplete": "Metadatenanreicherung abgeschlossen: {{summary}}",
+            "enrichFailed": "Metadatenanreicherung fehlgeschlagen: {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "Handlungsbedarf",
             "error": "Aktion erforderlich"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API Key"
+            },
+            "cache_health": {
+                "title": "Model Cache Health"
+            },
+            "filename_conflicts": {
+                "title": "Duplicate Filename Conflicts"
+            },
+            "ui_version": {
+                "title": "UI Version"
+            }
+        },
         "actions": {
             "runAgain": "Erneut ausführen",
-            "exportBundle": "Paket exportieren"
+            "exportBundle": "Paket exportieren",
+            "open-settings": "Open Settings",
+            "open-settings-syntax-format": "Switch to Full Path Syntax",
+            "repair-cache": "Rebuild Cache",
+            "resolve-filename-conflicts": "Resolve Conflicts",
+            "reload-page": "Reload UI"
+        },
+        "labels": {
+            "conflicts": "Conflicts",
+            "version": "Version"
         },
         "toast": {
             "loadFailed": "Diagnose konnte nicht geladen werden: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "Auflösung der Dateinamenskonflikte fehlgeschlagen: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "Dateinamenskonflikte auflösen",
+        "message": "Umbenennen durch Anhängen eines 4-stelligen Hashs an jeden doppelten Dateinamen.",
+        "note": "Dieser Vorgang benennt Dateien auf der Festplatte um. Modellreferenzen in vorhandenen Workflows müssen möglicherweise aktualisiert werden, wenn Sie das A1111-Syntaxformat verwenden.",
+        "detail": "Beispiel: <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "Benennt <strong>{count}</strong> Datei(en) in <strong>{groups}</strong> Duplikatgruppe(n) um",
+        "confirm": "Dateien umbenennen",
+        "cancel": "Abbrechen"
+    },
     "banners": {
         "versionMismatch": {
             "title": "Anwendungs-Update erkannt",

locales/es.json

@@ -16,10 +16,13 @@
             "help": "Ayuda",
             "add": "Añadir",
             "close": "Cerrar",
-            "menu": "Menú"
+            "menu": "Menú",
+            "remove": "Eliminar",
+            "change": "Cambiar"
         },
         "status": {
             "loading": "Cargando...",
+            "cancelling": "Cancelando...",
             "unknown": "Desconocido",
             "date": "Fecha",
             "version": "Versión",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "Eliminar de favoritos",
             "viewOnCivitai": "Ver en Civitai",
             "notAvailableFromCivitai": "No disponible en Civitai",
+            "viewOnHuggingFace": "Ver en Hugging Face",
             "sendToWorkflow": "Enviar a ComfyUI (Clic: Añadir, Shift+Clic: Reemplazar)",
             "copyLoRASyntax": "Copiar sintaxis de LoRA",
             "checkpointNameCopied": "Nombre del checkpoint copiado",
@@ -111,6 +115,7 @@
             "replacePreview": "Reemplazar vista previa",
             "copyCheckpointName": "Copiar nombre del checkpoint",
             "copyEmbeddingName": "Copiar nombre del embedding",
+            "embeddingNameCopied": "Sintaxis de embedding copiada",
             "sendCheckpointToWorkflow": "Enviar a ComfyUI",
             "sendEmbeddingToWorkflow": "Enviar a ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "Veces usado"
+        },
+        "footer": {
+            "versionCount": "{count} versiones",
+            "viewAllVersions": "Ver todas las versiones locales"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "Gestionar modelos excluidos"
+        },
+        "groupByModel": {
+            "label": "Agrupar por modelo"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "Estadísticas"
         },
         "search": {
-            "placeholder": "Buscar...",
-            "placeholders": {
-                "loras": "Buscar LoRAs...",
-                "recipes": "Buscar recetas...",
-                "checkpoints": "Buscar checkpoints...",
-                "embeddings": "Buscar embeddings..."
-            },
+            "placeholder": "Buscar",
             "options": "Opciones de búsqueda",
             "searchIn": "Buscar en:",
             "notAvailable": "Búsqueda no disponible en la página de estadísticas",
@@ -232,7 +238,10 @@
             "license": "Licencia",
             "noCreditRequired": "Sin crédito requerido",
             "allowSellingGeneratedContent": "Venta permitida",
+            "allowSellingGeneratedContentTooltip": "Permitir la venta de imágenes generadas",
+            "noCreditRequiredTooltip": "Usar el modelo sin atribuir al creador",
             "noTags": "Sin etiquetas",
+            "autoTags": "Etiquetas automáticas",
             "noBaseModelMatches": "Ningún modelo base coincide con la búsqueda actual.",
             "clearAll": "Limpiar todos los filtros",
             "any": "Cualquiera",
@@ -244,7 +253,18 @@
             "toggle": "Cambiar tema",
             "switchToLight": "Cambiar a tema claro",
             "switchToDark": "Cambiar a tema oscuro",
-            "switchToAuto": "Cambiar a tema automático"
+            "switchToAuto": "Cambiar a tema automático",
+            "presets": "Preajustes de tema",
+            "default": "Predeterminado",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "Modo",
+            "light": "Claro",
+            "dark": "Oscuro",
+            "auto": "Auto"
         },
         "actions": {
             "checkUpdates": "Comprobar actualizaciones",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Clave API de Civitai",
         "civitaiApiKeyPlaceholder": "Introduce tu clave API de Civitai",
         "civitaiApiKeyHelp": "Utilizada para autenticación al descargar modelos de Civitai",
+        "civitaiApiKeyConfigured": "Configurado",
+        "civitaiApiKeyNotConfigured": "No configurado",
+        "civitaiApiKeySet": "Configurar",
         "civitaiHost": {
             "label": "Host de Civitai",
             "help": "Elige qué sitio de Civitai se abre al usar los enlaces de \"View on Civitai\".",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "Backend de descarga",
-            "help": "Elige cómo se descargan los archivos del modelo. Python usa el descargador integrado. aria2 usa el proceso externo experimental de descarga.",
+            "help": "Elige cómo se descargan los archivos del modelo. Python usa el descargador integrado. aria2 usa el proceso externo recomendado de descarga.",
             "options": {
                 "python": "Python (integrado)",
-                "aria2": "aria2 (experimental)"
+                "aria2": "aria2 (recomendado)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "Descargas",
             "videoSettings": "Configuración de video",
             "layoutSettings": "Configuración de diseño",
+            "licenseIcons": "Iconos de licencia",
             "misc": "Varios",
             "backup": "Copias de seguridad",
             "folderSettings": "Raíces predeterminadas",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "Rutas de carpetas adicionales",
             "downloadPathTemplates": "Plantillas de rutas de descarga",
             "priorityTags": "Etiquetas prioritarias",
-            "updateFlags": "Indicadores de actualización",
+            "versionScope": "Indicadores de actualización",
             "exampleImages": "Imágenes de ejemplo",
             "autoOrganize": "Organización automática",
             "metadata": "Metadatos",
@@ -408,6 +432,8 @@
             "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": {
+            "groupByModel": "Agrupar por modelo",
+            "groupByModelHelp": "Cuando está activado, solo se muestra la versión más reciente de cada modelo de Civitai como una tarjeta única. Las versiones anteriores están ocultas.",
             "displayDensity": "Densidad de visualización",
             "displayDensityOptions": {
                 "default": "Predeterminado",
@@ -442,7 +468,9 @@
                 "modelName": "Nombre del modelo",
                 "fileName": "Nombre del archivo"
             },
-            "modelNameDisplayHelp": "Elige qué mostrar en el pie de la tarjeta del modelo"
+            "modelNameDisplayHelp": "Elige qué mostrar en el pie de la tarjeta del modelo",
+            "cardBlurAmount": "Desenfoque de superposición de tarjetas",
+            "cardBlurAmountHelp": "Ajuste la intensidad de desenfoque de las superposiciones del encabezado y pie de página en las tarjetas de modelos y recetas (0 = sin desenfoque, 20 = desenfoque máximo)."
         },
         "folderSettings": {
             "activeLibrary": "Biblioteca activa",
@@ -562,7 +590,7 @@
             "download": "Descargar",
             "restartRequired": "Requiere reinicio"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "Estrategia de indicadores de actualización",
             "help": "Decide si las insignias de actualización deben mostrarse solo cuando una nueva versión comparte el mismo modelo base que tus archivos locales o siempre que exista cualquier versión más reciente de ese modelo.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "Ocultar actualizaciones de acceso temprano",
             "help": "Solo actualizaciones de acceso temprano"
         },
+        "licenseIcons": {
+            "useNewStyle": "Usar iconos de licencia actualizados",
+            "useNewStyleHelp": "Mostrar permisos de licencia con indicadores de color (nuevo estilo) o solo iconos de restricción (estilo clásico). Refleja el diseño actual de CivitAI."
+        },
         "misc": {
             "includeTriggerWords": "Incluir palabras clave en la sintaxis de LoRA",
-            "includeTriggerWordsHelp": "Incluir palabras clave entrenadas al copiar la sintaxis de LoRA al portapapeles"
+            "includeTriggerWordsHelp": "Incluir palabras clave entrenadas al copiar la sintaxis de LoRA al portapapeles",
+            "loraSyntaxFormat": "Formato de sintaxis LoRA",
+            "loraSyntaxFormatHelp": "Formato de sintaxis LoRA. El formato completo incluye la ruta de la subcarpeta (<lora:style/anime/x:1.0>) para una resolución de modelo sin pérdidas. El formato heredado usa solo el nombre del archivo (<lora:x:1.0>) — convención A1111, puede ser ambiguo con nombres de archivo duplicados entre carpetas.",
+            "loraSyntaxFormatOptions": {
+                "full": "Ruta completa (subcarpeta/nombre)",
+                "legacy": "A1111 heredado (solo nombre)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "Habilitar base de datos de archivo de metadatos",
@@ -619,6 +657,23 @@
             "proxyPassword": "Contraseña (opcional)",
             "proxyPasswordPlaceholder": "contraseña",
             "proxyPasswordHelp": "Contraseña para autenticación de proxy (si es necesario)"
+        },
+        "aiProvider": {
+            "title": "Proveedor de IA",
+            "provider": "Proveedor",
+            "providerHelp": "Elija su proveedor de LLM. OpenAI y Ollama usan endpoints predefinidos. Personalizado le permite especificar cualquier endpoint compatible con OpenAI.",
+            "custom": "Personalizado (compatible con OpenAI)",
+            "apiBase": "URL base de la API",
+            "apiBaseHelp": "La URL base para la API LLM (p.ej. https://api.openai.com/v1). Déjelo vacío para usar el valor predeterminado del proveedor.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "Clave de API",
+            "apiKeyHelp": "Su clave de API del proveedor LLM. Se almacena localmente y nunca se envía a ningún servidor excepto a su proveedor LLM elegido.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "No configurada",
+            "apiKeyConfigured": "Configurada",
+            "apiKeySet": "Configurar",
+            "model": "Modelo",
+            "modelHelp": "El nombre del modelo a usar (p.ej. deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). Consulte a su proveedor para ver los modelos disponibles."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "Menor",
                 "usage": "Número de usos",
                 "usageDesc": "Más",
-                "usageAsc": "Menos"
+                "usageAsc": "Menos",
+                "versionsCount": "Versiones locales",
+                "versionsCountDesc": "Más versiones primero",
+                "versionsCountAsc": "Menos versiones primero",
+                "versionIdDesc": "Versión más nueva primero"
             },
             "refresh": {
                 "title": "Actualizar lista de modelos",
-                "quick": "Sincronizar cambios",
-                "quickTooltip": "Busca archivos de modelo nuevos o faltantes para mantener la lista al día.",
                 "full": "Reconstruir caché",
                 "fullTooltip": "Vuelve a cargar todos los detalles desde los archivos de metadatos; úsalo si la biblioteca parece desactualizada o tras ediciones manuales."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "Establecer clasificación de contenido para todos",
             "copyAll": "Copiar toda la sintaxis",
             "refreshAll": "Actualizar todos los metadatos",
+            "repairMetadata": "Reparar metadatos de la selección",
+            "reimportMetadata": "Reimportar desde origen",
             "checkUpdates": "Comprobar actualizaciones para la selección",
             "moveAll": "Mover todos a carpeta",
             "autoOrganize": "Auto-organizar seleccionados",
@@ -692,9 +751,18 @@
             "unfavorite": "Quitar de favoritos",
             "deleteAll": "Eliminar seleccionados",
             "downloadMissingLoras": "Descargar LoRAs faltantes",
+            "downloadExamples": "Descargar imágenes de ejemplo",
             "clear": "Limpiar selección",
             "skipMetadataRefreshCount": "Omitir（{count} modelos）",
             "resumeMetadataRefreshCount": "Reanudar（{count} modelos）",
+            "sendToWorkflow": "Enviar al workflow",
+            "sections": {
+                "workflow": "Workflow",
+                "metadata": "Metadatos",
+                "attributes": "Atributos",
+                "organize": "Organizar",
+                "download": "Descargar"
+            },
             "autoOrganizeProgress": {
                 "initializing": "Inicializando auto-organización...",
                 "starting": "Iniciando auto-organización para {type}...",
@@ -703,7 +771,8 @@
                 "completed": "Completado: {success} movidos, {skipped} omitidos, {failures} fallidos",
                 "complete": "Auto-organización completada",
                 "error": "Error: {error}"
-            }
+            },
+            "enrichHfAgent": "Enriquecer metadatos (IA)"
         },
         "contextMenu": {
             "refreshMetadata": "Actualizar datos de Civitai",
@@ -720,13 +789,15 @@
             "setContentRating": "Establecer clasificación de contenido",
             "moveToFolder": "Mover a carpeta",
             "repairMetadata": "Reparar metadatos",
+            "reimportMetadata": "Reimportar desde origen",
             "excludeModel": "Excluir modelo",
             "restoreModel": "Restaurar modelo",
             "deleteModel": "Eliminar modelo",
             "shareRecipe": "Compartir receta",
             "viewAllLoras": "Ver todos los LoRAs",
             "downloadMissingLoras": "Descargar LoRAs faltantes",
-            "deleteRecipe": "Eliminar receta"
+            "deleteRecipe": "Eliminar receta",
+            "enrichHfAgent": "Enriquecer metadatos (IA)"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "Actualizar lista de recetas",
-                "quick": "Sincronizar cambios",
-                "quickTooltip": "Sincronizar cambios - actualización rápida sin reconstruir caché",
                 "full": "Reconstruir caché",
                 "fullTooltip": "Reconstruir caché - reescaneo completo de todos los archivos de recetas"
             },
@@ -849,6 +918,13 @@
                 "skipped": "La receta ya está en la última versión, no se necesita reparación",
                 "failed": "Error al reparar la receta: {message}",
                 "missingId": "No se puede reparar la receta: falta el ID de la receta"
+            },
+            "reimport": {
+                "starting": "Reimportando receta desde origen...",
+                "success": "Receta reimportada exitosamente",
+                "noSourceUrl": "La receta no tiene URL de origen, no se puede reimportar",
+                "failed": "Error al reimportar la receta: {message}",
+                "missingId": "No se puede reimportar la receta: falta el ID"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "Raíz",
         "collapseAll": "Colapsar todas las carpetas",
-        "pinSidebar": "Fijar barra lateral",
-        "unpinSidebar": "Desfijar barra lateral",
+        "hideOnThisPage": "Ocultar barra lateral en esta página",
+        "showSidebar": "Mostrar barra lateral",
+        "sidebarHiddenNotification": "Barra lateral oculta en la página {page}",
         "switchToListView": "Cambiar a vista de lista",
         "switchToTreeView": "Cambiar a vista de árbol",
         "recursiveOn": "Incluir subcarpetas",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "No se encontraron carpetas",
             "dragHint": "Arrastra elementos aquí para crear carpetas"
+        },
+        "folderUpdateCheck": {
+            "label": "Buscar actualizaciones en esta carpeta",
+            "loading": "Buscando actualizaciones de {type} en esta carpeta...",
+            "success": "Se encontraron {count} actualización(es) para {type}s en esta carpeta",
+            "none": "Todos los {type}s en esta carpeta están actualizados",
+            "error": "Error al buscar actualizaciones de {type} en la carpeta: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "Almacenamiento",
             "insights": "Perspectivas"
         },
+        "metrics": {
+            "totalModels": "Total de modelos",
+            "totalStorage": "Almacenamiento total",
+            "totalGenerations": "Generaciones totales",
+            "usageRate": "Tasa de uso",
+            "loras": "LoRAs",
+            "checkpoints": "Puntos de control",
+            "embeddings": "Embeddings",
+            "uniqueTags": "Etiquetas únicas",
+            "unusedModels": "Modelos no usados",
+            "avgUsesPerModel": "Prom. usos/modelo"
+        },
         "usage": {
             "mostUsedLoras": "LoRAs más utilizados",
             "mostUsedCheckpoints": "Checkpoints más utilizados",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "Perspectivas inteligentes",
-            "recommendations": "Recomendaciones"
+            "recommendations": "Recomendaciones",
+            "noInsights": "No hay información disponible",
+            "unusedLoras": {
+                "high": {
+                    "title": "Alta cantidad de LoRAs no utilizadas",
+                    "description": "El {percent}% de tus LoRAs ({count}/{total}) nunca se han utilizado.",
+                    "suggestion": "Considera organizar o archivar modelos no utilizados para liberar espacio."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "Puntos de control no utilizados detectados",
+                    "description": "El {percent}% de tus puntos de control ({count}/{total}) nunca se han utilizado.",
+                    "suggestion": "Revisa y considera eliminar los puntos de control que ya no necesites."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "Alta cantidad de Embeddings no utilizados",
+                    "description": "El {percent}% de tus embeddings ({count}/{total}) nunca se han utilizado.",
+                    "suggestion": "Considera organizar o archivar embeddings no utilizados para optimizar tu colección."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "Colección grande detectada",
+                    "description": "Tu colección de modelos está usando {size} de almacenamiento.",
+                    "suggestion": "Considera usar almacenamiento externo o soluciones en la nube para una mejor organización."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "Usuario activo",
+                    "description": "¡Has completado {count} generaciones hasta ahora!",
+                    "suggestion": "Sigue explorando y creando contenido increíble con tus modelos."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "Resumen de colección",
             "baseModelDistribution": "Distribución de modelo base",
             "usageTrends": "Tendencias de uso (Últimos 30 días)",
-            "usageDistribution": "Distribución de uso"
+            "usageDistribution": "Distribución de uso",
+            "date": "Fecha",
+            "usageCount": "Conteo de uso",
+            "fileSizeBytes": "Tamaño del archivo (bytes)",
+            "models": "Modelos",
+            "loraUsage": "Uso de LoRA",
+            "checkpointUsage": "Uso de Checkpoint",
+            "embeddingUsage": "Uso de Embedding"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Punto de control",
+            "diffusion_model": "Modelo de difusión",
+            "embedding": "Embeddings"
+        },
+        "placeholders": {
+            "loading": "Cargando...",
+            "noModels": "No se encontraron modelos",
+            "errorLoading": "Error al cargar datos",
+            "noStorageData": "No hay datos de almacenamiento disponibles",
+            "rootFolder": "Raíz",
+            "chartLibraryMissing": "El gráfico requiere la librería Chart.js"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} modelos",
+            "chartUsage": "{name}: {size}, {count} usos",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "Descargar modelo desde URL",
             "titleWithType": "Descargar {type} desde URL",
-            "url": "URL de Civitai",
             "civitaiUrl": "URL de Civitai:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "Ingrese una URL de CivitAI, CivArchive o Hugging Face por línea. Admite múltiples URLs para descarga por lotes.",
+            "selectHfFiles": "Seleccione el/los archivo(s) para descargar de este repositorio:",
+            "selectAll": "Seleccionar todo",
+            "fetchingRepoFiles": "Obteniendo archivos del repositorio...",
             "locationPreview": "Vista previa de ubicación de descarga",
             "useDefaultPath": "Usar ruta predeterminada",
             "useDefaultPathTooltip": "Cuando está habilitado, los archivos se organizan automáticamente usando plantillas de rutas configuradas",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "Descargado anteriormente, pero actualmente no está en tu biblioteca.",
             "alreadyInLibrary": "Ya en la biblioteca",
             "autoOrganizedPath": "[Auto-organizado por plantilla de ruta]",
+            "fileSelection": {
+                "title": "Seleccionar formato de archivo",
+                "files": "archivos",
+                "select": "Seleccionar archivo"
+            },
             "errors": {
                 "invalidUrl": "Formato de URL de Civitai inválido",
-                "noVersions": "No hay versiones disponibles para este modelo"
+                "noVersions": "No hay versiones disponibles para este modelo",
+                "mixedSources": "No se pueden mezclar URL de CivitAI y Hugging Face en el mismo lote.",
+                "noModelFiles": "No se encontraron archivos de modelo en este repositorio."
             },
             "status": {
                 "preparing": "Preparando descarga...",
@@ -1080,6 +1250,12 @@
             "countMessage": "modelos serán eliminados permanentemente.",
             "action": "Eliminar todo"
         },
+        "bulkDeleteRecipes": {
+            "title": "Eliminar múltiples recetas",
+            "message": "¿Estás seguro de que quieres eliminar todas las recetas seleccionadas y sus archivos asociados?",
+            "countMessage": "recetas serán eliminadas permanentemente.",
+            "action": "Eliminar todo"
+        },
         "checkUpdates": {
             "title": "¿Comprobar actualizaciones para todos los {typePlural}?",
             "message": "Esto comprobará las actualizaciones de todos los {typePlural} de tu biblioteca. En colecciones grandes puede tardar un poco más.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "Editar nombre del modelo",
                 "editFileName": "Editar nombre de archivo",
                 "editBaseModel": "Editar modelo base",
+                "editVersionName": "Editar nombre de versión",
                 "viewOnCivitai": "Ver en Civitai",
                 "viewOnCivitaiText": "Ver en Civitai",
+                "viewOnHuggingFace": "Ver en Hugging Face",
+                "viewOnHuggingFaceText": "Ver en Hugging Face",
                 "viewCreatorProfile": "Ver perfil del creador",
                 "openFileLocation": "Abrir ubicación del archivo",
                 "sendToWorkflow": "Enviar a ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "Notas adicionales",
                 "notesHint": "Presiona Enter para guardar, Shift+Enter para nueva línea",
                 "addNotesPlaceholder": "Añade tus notas aquí...",
-                "aboutThisVersion": "Acerca de esta versión"
+                "aboutThisVersion": "Acerca de esta versión",
+                "baseModelSearchPlaceholder": "Buscar modelo base…",
+                "baseModelSuggested": "Sugerido",
+                "baseModelNoMatch": "No hay modelos base que coincidan"
             },
             "notes": {
                 "saved": "Notas guardadas exitosamente",
-                "saveFailed": "Error al guardar notas"
+                "saveFailed": "Error al guardar notas",
+                "showMore": "Mostrar más",
+                "showLess": "Mostrar menos"
             },
             "usageTips": {
                 "addPresetParameter": "Añadir parámetro preestablecido...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "Versión eliminada"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "Resumen de obtención de metadatos",
+            "statSuccess": "Éxito",
+            "statFailed": "Fallido",
+            "statSkipped": "Omitido",
+            "statTotal": "Total escaneado",
+            "statDuration": "Duración",
+            "successMessage": "¡Todos los {count} {type}s actualizados correctamente!",
+            "failedItems": "Elementos fallidos ({count})",
+            "close": "Cerrar",
+            "copyReport": "Copiar informe",
+            "downloadCsv": "Descargar CSV",
+            "columnModelName": "Nombre del modelo",
+            "columnError": "Error"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "Esta etiqueta ya existe"
         }
     },
-    "keyboard": {
-        "navigation": "Navegación por teclado:",
-        "shortcuts": {
-            "pageUp": "Desplazar hacia arriba una página",
-            "pageDown": "Desplazar hacia abajo una página",
-            "home": "Saltar al inicio",
-            "end": "Saltar al final"
-        }
-    },
     "initialization": {
         "title": "Inicializando",
         "message": "Preparando tu espacio de trabajo...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "No hay nodos compatibles disponibles en el flujo de trabajo actual",
             "noTargetNodeSelected": "No se ha seleccionado ningún nodo de destino",
             "modelUpdated": "Modelo actualizado en el flujo de trabajo",
-            "modelFailed": "Error al actualizar nodo de modelo"
+            "modelFailed": "Error al actualizar nodo de modelo",
+            "embeddingAdded": "Embedding añadido al flujo de trabajo",
+            "embeddingFailed": "Error al añadir el embedding",
+            "promptSent": "Prompt enviado al flujo de trabajo",
+            "promptFailed": "Error al enviar el prompt"
         },
         "nodeSelector": {
             "recipe": "Receta",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "Prompt",
             "replace": "Reemplazar",
             "append": "Añadir",
             "selectTargetNode": "Seleccionar nodo de destino",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "No hay ID de receta disponible",
             "sendToWorkflowFailed": "Error al enviar la receta al flujo de trabajo: {message}",
             "copyFailed": "Error copiando sintaxis de receta: {message}",
+            "createError": "Error al crear la receta：{message}",
+            "createFailed": "Error al crear la receta：{error}",
+            "createMissingData": "Faltan datos necesarios para crear la receta",
+            "created": "Receta creada exitosamente",
             "noMissingLoras": "No hay LoRAs faltantes para descargar",
             "missingLorasInfoFailed": "Error al obtener información de LoRAs faltantes",
             "preparingForDownloadFailed": "Error preparando LoRAs para descarga",
             "enterLoraName": "Por favor introduce un nombre de LoRA o sintaxis",
             "reconnectedSuccessfully": "LoRA reconectado exitosamente",
             "reconnectFailed": "Error reconectando LoRA: {message}",
+            "noPromptToSend": "No hay prompt para enviar",
             "cannotSend": "No se puede enviar receta: Falta ID de receta",
             "sendFailed": "Error al enviar receta al flujo de trabajo",
             "sendError": "Error enviando receta al flujo de trabajo",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "No se han seleccionado recetas",
+            "repairBulkComplete": "Reparación completa: {repaired} reparadas, {skipped} omitidas (de {total})",
+            "repairBulkSkipped": "No se necesita reparación para ninguna de las {total} recetas seleccionadas",
+            "repairBulkFailed": "Error al reparar las recetas seleccionadas: {message}",
+            "reimporting": "Reimportando receta desde origen...",
+            "reimportSuccess": "Receta reimportada exitosamente",
+            "reimportBulkComplete": "Reimportación completa: {completed} reimportadas, {failed} fallidas (de {total})",
+            "reimportBulkFailed": "Error al reimportar algunas recetas",
             "noMissingLorasInSelection": "No se encontraron LoRAs faltantes en las recetas seleccionadas",
             "noLoraRootConfigured": "No se ha configurado el directorio raíz de LoRA. Por favor, establezca un directorio raíz de LoRA predeterminado en la configuración."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "Movidos exitosamente {successCount} {type}s",
             "exampleImagesDownloadSuccess": "¡Imágenes de ejemplo descargadas exitosamente!",
             "exampleImagesDownloadFailed": "Error al descargar imágenes de ejemplo: {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "Copiado al portapapeles",
+            "downloadStarted": "Descarga iniciada"
+        },
+        "agent": {
+            "llmNotConfigured": "Proveedor de IA no configurado. Actívelo en Configuración → Proveedor de IA.",
+            "enrichStarted": "Enriqueciendo metadatos con IA...",
+            "enrichComplete": "Enriquecimiento de metadatos completado: {{summary}}",
+            "enrichFailed": "Enriquecimiento de metadatos fallido: {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "Requiere atención",
             "error": "Se requiere acción"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API Key"
+            },
+            "cache_health": {
+                "title": "Model Cache Health"
+            },
+            "filename_conflicts": {
+                "title": "Duplicate Filename Conflicts"
+            },
+            "ui_version": {
+                "title": "UI Version"
+            }
+        },
         "actions": {
             "runAgain": "Ejecutar de nuevo",
-            "exportBundle": "Exportar paquete"
+            "exportBundle": "Exportar paquete",
+            "open-settings": "Open Settings",
+            "open-settings-syntax-format": "Switch to Full Path Syntax",
+            "repair-cache": "Rebuild Cache",
+            "resolve-filename-conflicts": "Resolve Conflicts",
+            "reload-page": "Reload UI"
+        },
+        "labels": {
+            "conflicts": "Conflicts",
+            "version": "Version"
         },
         "toast": {
             "loadFailed": "Error al cargar los diagnósticos: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "Error al resolver conflictos de nombre de archivo: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "Resolver conflictos de nombres de archivo",
+        "message": "Renombrar añadiendo un hash de 4 caracteres a cada nombre de archivo duplicado.",
+        "note": "Esta operación renombra archivos en el disco. Es posible que las referencias a modelos en flujos de trabajo existentes deban actualizarse si usas el formato de sintaxis A1111.",
+        "detail": "Ejemplo: <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "Renombrará <strong>{count}</strong> archivo(s) en <strong>{groups}</strong> grupo(s) de duplicados",
+        "confirm": "Renombrar archivos",
+        "cancel": "Cancelar"
+    },
     "banners": {
         "versionMismatch": {
             "title": "Actualización de la aplicación detectada",

locales/fr.json

@@ -16,10 +16,13 @@
             "help": "Aide",
             "add": "Ajouter",
             "close": "Fermer",
-            "menu": "Menu"
+            "menu": "Menu",
+            "remove": "Supprimer",
+            "change": "Modifier"
         },
         "status": {
             "loading": "Chargement...",
+            "cancelling": "Annulation...",
             "unknown": "Inconnu",
             "date": "Date",
             "version": "Version",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "Retirer des favoris",
             "viewOnCivitai": "Voir sur Civitai",
             "notAvailableFromCivitai": "Non disponible sur Civitai",
+            "viewOnHuggingFace": "Voir sur Hugging Face",
             "sendToWorkflow": "Envoyer vers ComfyUI (Clic: Ajouter, Maj+Clic: Remplacer)",
             "copyLoRASyntax": "Copier la syntaxe LoRA",
             "checkpointNameCopied": "Nom du checkpoint copié",
@@ -111,6 +115,7 @@
             "replacePreview": "Remplacer l'aperçu",
             "copyCheckpointName": "Copier le nom du checkpoint",
             "copyEmbeddingName": "Copier le nom de l'embedding",
+            "embeddingNameCopied": "Syntaxe dembedding copiée",
             "sendCheckpointToWorkflow": "Envoyer vers ComfyUI",
             "sendEmbeddingToWorkflow": "Envoyer vers ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "Nombre d'utilisations"
+        },
+        "footer": {
+            "versionCount": "{count} versions",
+            "viewAllVersions": "Voir toutes les versions locales"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "Gérer les modèles exclus"
+        },
+        "groupByModel": {
+            "label": "Grouper par modèle"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "Statistiques"
         },
         "search": {
-            "placeholder": "Rechercher...",
-            "placeholders": {
-                "loras": "Rechercher des LoRAs...",
-                "recipes": "Rechercher des recipes...",
-                "checkpoints": "Rechercher des checkpoints...",
-                "embeddings": "Rechercher des embeddings..."
-            },
+            "placeholder": "Rechercher",
             "options": "Options de recherche",
             "searchIn": "Rechercher dans :",
             "notAvailable": "Recherche non disponible sur la page de statistiques",
@@ -232,7 +238,10 @@
             "license": "Licence",
             "noCreditRequired": "Crédit non requis",
             "allowSellingGeneratedContent": "Vente autorisée",
+            "allowSellingGeneratedContentTooltip": "Autoriser la vente d\"images générées",
+            "noCreditRequiredTooltip": "Utiliser le modèle sans créditer le créateur",
             "noTags": "Aucun tag",
+            "autoTags": "Auto-Tags",
             "noBaseModelMatches": "Aucun modèle de base ne correspond à la recherche actuelle.",
             "clearAll": "Effacer tous les filtres",
             "any": "N'importe quel",
@@ -244,7 +253,18 @@
             "toggle": "Basculer le thème",
             "switchToLight": "Passer au thème clair",
             "switchToDark": "Passer au thème sombre",
-            "switchToAuto": "Passer au thème automatique"
+            "switchToAuto": "Passer au thème automatique",
+            "presets": "Préréglages de thème",
+            "default": "Par défaut",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "Mode",
+            "light": "Clair",
+            "dark": "Sombre",
+            "auto": "Auto"
         },
         "actions": {
             "checkUpdates": "Vérifier les mises à jour",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Clé API Civitai",
         "civitaiApiKeyPlaceholder": "Entrez votre clé API Civitai",
         "civitaiApiKeyHelp": "Utilisée pour l'authentification lors du téléchargement de modèles depuis Civitai",
+        "civitaiApiKeyConfigured": "Configuré",
+        "civitaiApiKeyNotConfigured": "Non configuré",
+        "civitaiApiKeySet": "Configurer",
         "civitaiHost": {
             "label": "Hôte Civitai",
             "help": "Choisissez quel site Civitai s'ouvre lorsque vous utilisez les liens « View on Civitai ».",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "Moteur de téléchargement",
-            "help": "Choisissez comment les fichiers de modèles sont téléchargés. Python utilise le téléchargeur intégré. aria2 utilise le processus externe expérimental de téléchargement.",
+            "help": "Choisissez comment les fichiers de modèles sont téléchargés. Python utilise le téléchargeur intégré. aria2 utilise le processus externe recommandé de téléchargement.",
             "options": {
                 "python": "Python (intégré)",
-                "aria2": "aria2 (expérimental)"
+                "aria2": "aria2 (recommandé)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "Téléchargements",
             "videoSettings": "Paramètres vidéo",
             "layoutSettings": "Paramètres d'affichage",
+            "licenseIcons": "Icônes de licence",
             "misc": "Divers",
             "backup": "Sauvegardes",
             "folderSettings": "Racines par défaut",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "Chemins de dossiers supplémentaires",
             "downloadPathTemplates": "Modèles de chemin de téléchargement",
             "priorityTags": "Étiquettes prioritaires",
-            "updateFlags": "Indicateurs de mise à jour",
+            "versionScope": "Indicateurs de mise à jour",
             "exampleImages": "Images d'exemple",
             "autoOrganize": "Organisation automatique",
             "metadata": "Métadonnées",
@@ -408,6 +432,8 @@
             "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": {
+            "groupByModel": "Grouper par modèle",
+            "groupByModelHelp": "Lorsque activé, seule la version la plus récente de chaque modèle Civitai s'affiche sous forme de carte unique. Les versions plus anciennes sont masquées.",
             "displayDensity": "Densité d'affichage",
             "displayDensityOptions": {
                 "default": "Par défaut",
@@ -442,7 +468,9 @@
                 "modelName": "Nom du modèle",
                 "fileName": "Nom du fichier"
             },
-            "modelNameDisplayHelp": "Choisissez ce qui doit être affiché dans le pied de page de la carte du modèle"
+            "modelNameDisplayHelp": "Choisissez ce qui doit être affiché dans le pied de page de la carte du modèle",
+            "cardBlurAmount": "Flou de superposition des cartes",
+            "cardBlurAmountHelp": "Ajustez l'intensité du flou des superpositions d'en-tête et de pied de page sur les cartes de modèles et de recettes (0 = aucun flou, 20 = flou maximal)."
         },
         "folderSettings": {
             "activeLibrary": "Bibliothèque active",
@@ -562,7 +590,7 @@
             "download": "Télécharger",
             "restartRequired": "Redémarrage requis"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "Stratégie des indicateurs de mise à jour",
             "help": "Choisissez si les badges de mise à jour doivent apparaître uniquement lorsqu’une nouvelle version partage le même modèle de base que vos fichiers locaux, ou dès qu’il existe une version plus récente pour ce modèle.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "Masquer les mises à jour en accès anticipé",
             "help": "Seulement les mises à jour en accès anticipé"
         },
+        "licenseIcons": {
+            "useNewStyle": "Utiliser les icônes de licence mises à jour",
+            "useNewStyleHelp": "Afficher les permissions de licence avec des indicateurs colorés (nouveau style) ou des icônes de restriction uniquement (style classique). Reprend le design actuel de CivitAI."
+        },
         "misc": {
             "includeTriggerWords": "Inclure les mots-clés dans la syntaxe LoRA",
-            "includeTriggerWordsHelp": "Inclure les mots-clés d'entraînement lors de la copie de la syntaxe LoRA dans le presse-papiers"
+            "includeTriggerWordsHelp": "Inclure les mots-clés d'entraînement lors de la copie de la syntaxe LoRA dans le presse-papiers",
+            "loraSyntaxFormat": "Format de syntaxe LoRA",
+            "loraSyntaxFormatHelp": "Format de syntaxe LoRA. Le format complet inclut le chemin du sous-dossier (<lora:style/anime/x:1.0>) pour une résolution de modèle sans perte. Le format hérité utilise uniquement le nom du fichier (<lora:x:1.0>) — convention A1111, peut être ambiguë en cas de noms de fichiers en double dans différents dossiers.",
+            "loraSyntaxFormatOptions": {
+                "full": "Chemin complet (sous-dossier/nom)",
+                "legacy": "A1111 hérité (nom uniquement)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "Activer la base de données d'archive des métadonnées",
@@ -619,6 +657,23 @@
             "proxyPassword": "Mot de passe (optionnel)",
             "proxyPasswordPlaceholder": "mot_de_passe",
             "proxyPasswordHelp": "Mot de passe pour l'authentification proxy (si nécessaire)"
+        },
+        "aiProvider": {
+            "title": "Fournisseur d'IA",
+            "provider": "Fournisseur",
+            "providerHelp": "Choisissez votre fournisseur LLM. OpenAI et Ollama utilisent des endpoints prédéfinis. Personnalisé vous permet de spécifier n'importe quel endpoint compatible OpenAI.",
+            "custom": "Personnalisé (compatible OpenAI)",
+            "apiBase": "URL de base de l'API",
+            "apiBaseHelp": "L'URL de base pour l'API LLM (ex. https://api.openai.com/v1). Laissez vide pour utiliser le fournisseur par défaut.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "Clé API",
+            "apiKeyHelp": "Votre clé API du fournisseur LLM. Stockée localement, jamais envoyée à un serveur autre que votre fournisseur LLM choisi.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "Non définie",
+            "apiKeyConfigured": "Configurée",
+            "apiKeySet": "Configurer",
+            "model": "Modèle",
+            "modelHelp": "Le nom du modèle à utiliser (ex. deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). Consultez votre fournisseur pour les modèles disponibles."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "Plus petit",
                 "usage": "Nombre d'utilisations",
                 "usageDesc": "Plus",
-                "usageAsc": "Moins"
+                "usageAsc": "Moins",
+                "versionsCount": "Versions locales",
+                "versionsCountDesc": "Plus de versions d'abord",
+                "versionsCountAsc": "Moins de versions d'abord",
+                "versionIdDesc": "Version la plus récente d'abord"
             },
             "refresh": {
                 "title": "Actualiser la liste des modèles",
-                "quick": "Synchroniser les changements",
-                "quickTooltip": "Analyse les nouveaux fichiers de modèle ou les fichiers manquants pour garder la liste à jour.",
                 "full": "Reconstruire le cache",
                 "fullTooltip": "Recharge tous les détails des modèles depuis les fichiers metadata — à utiliser si la bibliothèque paraît obsolète ou après des modifications manuelles."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "Définir la classification du contenu pour tous",
             "copyAll": "Copier toute la syntaxe",
             "refreshAll": "Actualiser toutes les métadonnées",
+            "repairMetadata": "Réparer les métadonnées de la sélection",
+            "reimportMetadata": "Ré-importer depuis la source",
             "checkUpdates": "Vérifier les mises à jour pour la sélection",
             "moveAll": "Déplacer tout vers un dossier",
             "autoOrganize": "Auto-organiser la sélection",
@@ -692,9 +751,18 @@
             "unfavorite": "Retirer des favoris",
             "deleteAll": "Supprimer la sélection",
             "downloadMissingLoras": "Télécharger les LoRAs manquants",
+            "downloadExamples": "Télécharger les images d'exemple",
             "clear": "Effacer la sélection",
             "skipMetadataRefreshCount": "Ignorer（{count} modèles）",
             "resumeMetadataRefreshCount": "Reprendre（{count} modèles）",
+            "sendToWorkflow": "Envoyer au workflow",
+            "sections": {
+                "workflow": "Workflow",
+                "metadata": "Métadonnées",
+                "attributes": "Attributs",
+                "organize": "Organiser",
+                "download": "Télécharger"
+            },
             "autoOrganizeProgress": {
                 "initializing": "Initialisation de l'auto-organisation...",
                 "starting": "Démarrage de l'auto-organisation pour {type}...",
@@ -703,7 +771,8 @@
                 "completed": "Terminé : {success} déplacés, {skipped} ignorés, {failures} échecs",
                 "complete": "Auto-organisation terminée",
                 "error": "Erreur : {error}"
-            }
+            },
+            "enrichHfAgent": "Enrichir les métadonnées (IA)"
         },
         "contextMenu": {
             "refreshMetadata": "Actualiser les données Civitai",
@@ -720,13 +789,15 @@
             "setContentRating": "Définir la classification du contenu",
             "moveToFolder": "Déplacer vers un dossier",
             "repairMetadata": "Réparer les métadonnées",
+            "reimportMetadata": "Ré-importer depuis la source",
             "excludeModel": "Exclure le modèle",
             "restoreModel": "Restaurer le modèle",
             "deleteModel": "Supprimer le modèle",
             "shareRecipe": "Partager la recipe",
             "viewAllLoras": "Voir tous les LoRAs",
             "downloadMissingLoras": "Télécharger les LoRAs manquants",
-            "deleteRecipe": "Supprimer la recipe"
+            "deleteRecipe": "Supprimer la recipe",
+            "enrichHfAgent": "Enrichir les métadonnées (IA)"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "Actualiser la liste des recipes",
-                "quick": "Synchroniser les changements",
-                "quickTooltip": "Synchroniser les changements - actualisation rapide sans reconstruire le cache",
                 "full": "Reconstruire le cache",
                 "fullTooltip": "Reconstruire le cache - rescan complet de tous les fichiers de recipes"
             },
@@ -849,6 +918,13 @@
                 "skipped": "Recette déjà à la version la plus récente, aucune réparation nécessaire",
                 "failed": "Échec de la réparation de la recette : {message}",
                 "missingId": "Impossible de réparer la recette : ID de recette manquant"
+            },
+            "reimport": {
+                "starting": "Ré-import de la recette depuis la source...",
+                "success": "Recette ré-importée avec succès",
+                "noSourceUrl": "La recette n'a pas d'URL source, ré-import impossible",
+                "failed": "Échec du ré-import de la recette : {message}",
+                "missingId": "Impossible de ré-importer la recette : ID de recette manquant"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "Racine",
         "collapseAll": "Réduire tous les dossiers",
-        "pinSidebar": "Épingler la barre latérale",
-        "unpinSidebar": "Désépingler la barre latérale",
+        "hideOnThisPage": "Masquer la barre latérale sur cette page",
+        "showSidebar": "Afficher la barre latérale",
+        "sidebarHiddenNotification": "Barre latérale masquée sur la page {page}",
         "switchToListView": "Passer en vue liste",
         "switchToTreeView": "Passer en vue arborescence",
         "recursiveOn": "Inclure les sous-dossiers",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "Aucun dossier trouvé",
             "dragHint": "Faites glisser des éléments ici pour créer des dossiers"
+        },
+        "folderUpdateCheck": {
+            "label": "Vérifier les mises à jour dans ce dossier",
+            "loading": "Vérification des mises à jour {type} dans ce dossier...",
+            "success": "{count} mise(s) à jour trouvée(s) pour les {type}s dans ce dossier",
+            "none": "Tous les {type}s dans ce dossier sont à jour",
+            "error": "Échec de la vérification des mises à jour {type} dans ce dossier : {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "Stockage",
             "insights": "Aperçus"
         },
+        "metrics": {
+            "totalModels": "Total des modèles",
+            "totalStorage": "Stockage total",
+            "totalGenerations": "Générations totales",
+            "usageRate": "Taux d'utilisation",
+            "loras": "LoRAs",
+            "checkpoints": "Points de contrôle",
+            "embeddings": "Embeddings",
+            "uniqueTags": "Tags uniques",
+            "unusedModels": "Modèles inutilisés",
+            "avgUsesPerModel": "Moy. utilisations/modèle"
+        },
         "usage": {
             "mostUsedLoras": "LoRAs les plus utilisés",
             "mostUsedCheckpoints": "Checkpoints les plus utilisés",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "Aperçus intelligents",
-            "recommendations": "Recommandations"
+            "recommendations": "Recommandations",
+            "noInsights": "Aucun aperçu disponible",
+            "unusedLoras": {
+                "high": {
+                    "title": "Nombre élevé de LoRAs inutilisées",
+                    "description": "{percent}% de vos LoRAs ({count}/{total}) n'ont jamais été utilisées.",
+                    "suggestion": "Envisagez d'organiser ou d'archiver les modèles inutilisés pour libérer de l'espace."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "Points de contrôle inutilisés détectés",
+                    "description": "{percent}% de vos points de contrôle ({count}/{total}) n'ont jamais été utilisés.",
+                    "suggestion": "Examinez et envisagez de supprimer les points de contrôle dont vous n'avez plus besoin."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "Nombre élevé d'Embeddings inutilisées",
+                    "description": "{percent}% de vos embeddings ({count}/{total}) n'ont jamais été utilisées.",
+                    "suggestion": "Envisagez d'organiser ou d'archiver les embeddings inutilisées pour optimiser votre collection."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "Grande collection détectée",
+                    "description": "Votre collection de modèles utilise {size} de stockage.",
+                    "suggestion": "Envisagez d'utiliser un stockage externe ou des solutions cloud pour une meilleure organisation."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "Utilisateur actif",
+                    "description": "Vous avez effectué {count} générations jusqu'à présent !",
+                    "suggestion": "Continuez à explorer et à créer du contenu formidable avec vos modèles."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "Aperçu de la collection",
             "baseModelDistribution": "Distribution des modèles de base",
             "usageTrends": "Tendances d'utilisation (30 derniers jours)",
-            "usageDistribution": "Distribution de l'utilisation"
+            "usageDistribution": "Distribution de l'utilisation",
+            "date": "Date",
+            "usageCount": "Nombre d'utilisations",
+            "fileSizeBytes": "Taille du fichier (octets)",
+            "models": "Modèles",
+            "loraUsage": "Utilisation LoRA",
+            "checkpointUsage": "Utilisation Checkpoint",
+            "embeddingUsage": "Utilisation Embedding"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Point de contrôle",
+            "diffusion_model": "Modèle de diffusion",
+            "embedding": "Embeddings"
+        },
+        "placeholders": {
+            "loading": "Chargement...",
+            "noModels": "Aucun modèle trouvé",
+            "errorLoading": "Erreur de chargement des données",
+            "noStorageData": "Aucune donnée de stockage disponible",
+            "rootFolder": "Racine",
+            "chartLibraryMissing": "Le graphique nécessite la bibliothèque Chart.js"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} modèles",
+            "chartUsage": "{name}: {size}, {count} utilisations",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "Télécharger un modèle depuis une URL",
             "titleWithType": "Télécharger {type} depuis une URL",
-            "url": "URL Civitai",
             "civitaiUrl": "URL Civitai :",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "Entrez une URL CivitAI, CivArchive ou Hugging Face par ligne. Prend en charge plusieurs URL pour le téléchargement par lot.",
+            "selectHfFiles": "Sélectionnez le(s) fichier(s) à télécharger depuis ce dépôt :",
+            "selectAll": "Tout sélectionner",
+            "fetchingRepoFiles": "Récupération des fichiers du dépôt...",
             "locationPreview": "Aperçu de l'emplacement de téléchargement",
             "useDefaultPath": "Utiliser le chemin par défaut",
             "useDefaultPathTooltip": "Lorsque activé, les fichiers sont automatiquement organisés selon les modèles de chemin configurés",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "Déjà téléchargé, mais il n'est actuellement pas dans votre bibliothèque.",
             "alreadyInLibrary": "Déjà dans la bibliothèque",
             "autoOrganizedPath": "[Auto-organisé par modèle de chemin]",
+            "fileSelection": {
+                "title": "Choisir le format de fichier",
+                "files": "fichiers",
+                "select": "Choisir le fichier"
+            },
             "errors": {
                 "invalidUrl": "Format d'URL Civitai invalide",
-                "noVersions": "Aucune version disponible pour ce modèle"
+                "noVersions": "Aucune version disponible pour ce modèle",
+                "mixedSources": "Impossible de mélanger les URL CivitAI et Hugging Face dans le même lot.",
+                "noModelFiles": "Aucun fichier de modèle trouvé dans ce dépôt."
             },
             "status": {
                 "preparing": "Préparation du téléchargement...",
@@ -1080,6 +1250,12 @@
             "countMessage": "modèles seront définitivement supprimés.",
             "action": "Tout supprimer"
         },
+        "bulkDeleteRecipes": {
+            "title": "Supprimer plusieurs recipes",
+            "message": "Êtes-vous sûr de vouloir supprimer toutes les recipes sélectionnées et leurs fichiers associés ?",
+            "countMessage": "recipes seront définitivement supprimées.",
+            "action": "Tout supprimer"
+        },
         "checkUpdates": {
             "title": "Vérifier les mises à jour pour tous les {typePlural} ?",
             "message": "Cette action vérifie les mises à jour pour tous les {typePlural} de votre bibliothèque. Les grandes collections peuvent prendre un peu plus de temps.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "Modifier le nom du modèle",
                 "editFileName": "Modifier le nom de fichier",
                 "editBaseModel": "Modifier le modèle de base",
+                "editVersionName": "Modifier le nom de la version",
                 "viewOnCivitai": "Voir sur Civitai",
                 "viewOnCivitaiText": "Voir sur Civitai",
+                "viewOnHuggingFace": "Voir sur Hugging Face",
+                "viewOnHuggingFaceText": "Voir sur Hugging Face",
                 "viewCreatorProfile": "Voir le profil du créateur",
                 "openFileLocation": "Ouvrir l'emplacement du fichier",
                 "sendToWorkflow": "Envoyer vers ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "Notes supplémentaires",
                 "notesHint": "Appuyez sur Entrée pour sauvegarder, Maj+Entrée pour nouvelle ligne",
                 "addNotesPlaceholder": "Ajoutez vos notes ici...",
-                "aboutThisVersion": "À propos de cette version"
+                "aboutThisVersion": "À propos de cette version",
+                "baseModelSearchPlaceholder": "Rechercher un modèle de base…",
+                "baseModelSuggested": "Suggéré",
+                "baseModelNoMatch": "Aucun modèle de base correspondant"
             },
             "notes": {
                 "saved": "Notes sauvegardées avec succès",
-                "saveFailed": "Échec de la sauvegarde des notes"
+                "saveFailed": "Échec de la sauvegarde des notes",
+                "showMore": "Afficher plus",
+                "showLess": "Afficher moins"
             },
             "usageTips": {
                 "addPresetParameter": "Ajouter un paramètre prédéfini...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "Version supprimée"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "Récapitulatif de la récupération des métadonnées",
+            "statSuccess": "Réussi",
+            "statFailed": "Échoué",
+            "statSkipped": "Ignoré",
+            "statTotal": "Total scanné",
+            "statDuration": "Durée",
+            "successMessage": "Tous les {count} {type}s mis à jour avec succès !",
+            "failedItems": "Éléments échoués ({count})",
+            "close": "Fermer",
+            "copyReport": "Copier le rapport",
+            "downloadCsv": "Télécharger CSV",
+            "columnModelName": "Nom du modèle",
+            "columnError": "Erreur"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "Ce tag existe déjà"
         }
     },
-    "keyboard": {
-        "navigation": "Navigation au clavier :",
-        "shortcuts": {
-            "pageUp": "Défiler d'une page vers le haut",
-            "pageDown": "Défiler d'une page vers le bas",
-            "home": "Aller en haut",
-            "end": "Aller en bas"
-        }
-    },
     "initialization": {
         "title": "Initialisation",
         "message": "Préparation de votre espace de travail...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "Aucun nœud compatible disponible dans le workflow actuel",
             "noTargetNodeSelected": "Aucun nœud cible sélectionné",
             "modelUpdated": "Modèle mis à jour dans le workflow",
-            "modelFailed": "Échec de la mise à jour du nœud modèle"
+            "modelFailed": "Échec de la mise à jour du nœud modèle",
+            "embeddingAdded": "Embedding ajouté au workflow",
+            "embeddingFailed": "Échec de l'ajout de l'embedding",
+            "promptSent": "Prompt envoyé au workflow",
+            "promptFailed": "Échec de l'envoi du prompt"
         },
         "nodeSelector": {
             "recipe": "Recipe",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "Prompt",
             "replace": "Remplacer",
             "append": "Ajouter",
             "selectTargetNode": "Sélectionner le nœud cible",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "Aucun ID de recipe disponible",
             "sendToWorkflowFailed": "Échec de l'envoi de la recette vers le workflow : {message}",
             "copyFailed": "Erreur lors de la copie de la syntaxe de la recipe : {message}",
+            "createError": "Erreur lors de la création du Recipe ：{message}",
+            "createFailed": "Échec de la création du Recipe ：{error}",
+            "createMissingData": "Données requises manquantes pour créer le Recipe",
+            "created": "Recipe créé avec succès",
             "noMissingLoras": "Aucun LoRA manquant à télécharger",
             "missingLorasInfoFailed": "Échec de l'obtention des informations pour les LoRAs manquants",
             "preparingForDownloadFailed": "Erreur lors de la préparation des LoRAs pour le téléchargement",
             "enterLoraName": "Veuillez entrer un nom ou une syntaxe LoRA",
             "reconnectedSuccessfully": "LoRA reconnecté avec succès",
             "reconnectFailed": "Erreur lors de la reconnexion du LoRA : {message}",
+            "noPromptToSend": "Aucun prompt à envoyer",
             "cannotSend": "Impossible d'envoyer la recipe : ID de recipe manquant",
             "sendFailed": "Échec de l'envoi de la recipe vers le workflow",
             "sendError": "Erreur lors de l'envoi de la recipe vers le workflow",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "Aucune recette sélectionnée",
+            "repairBulkComplete": "Réparation terminée : {repaired} réparée(s), {skipped} ignorée(s) (sur {total})",
+            "repairBulkSkipped": "Aucune réparation nécessaire parmi les {total} recettes sélectionnées",
+            "repairBulkFailed": "Échec de la réparation des recettes sélectionnées : {message}",
+            "reimporting": "Ré-import de la recette depuis la source...",
+            "reimportSuccess": "Recette ré-importée avec succès",
+            "reimportBulkComplete": "Ré-import terminé : {completed} ré-importé(s), {failed} échec(s) (sur {total})",
+            "reimportBulkFailed": "Échec du ré-import de certaines recettes",
             "noMissingLorasInSelection": "Aucun LoRA manquant trouvé dans les recettes sélectionnées",
             "noLoraRootConfigured": "Aucun répertoire racine LoRA configuré. Veuillez définir un répertoire racine LoRA par défaut dans les paramètres."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "{successCount} {type}s déplacés avec succès",
             "exampleImagesDownloadSuccess": "Images d'exemple téléchargées avec succès !",
             "exampleImagesDownloadFailed": "Échec du téléchargement des images d'exemple : {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "Copié dans le presse-papiers",
+            "downloadStarted": "Téléchargement démarré"
+        },
+        "agent": {
+            "llmNotConfigured": "Fournisseur d'IA non configuré. Activez-le dans Paramètres → Fournisseur d'IA.",
+            "enrichStarted": "Enrichissement des métadonnées par IA...",
+            "enrichComplete": "Enrichissement des métadonnées terminé : {{summary}}",
+            "enrichFailed": "Échec de l'enrichissement des métadonnées : {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "Nécessite une attention",
             "error": "Action requise"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API Key"
+            },
+            "cache_health": {
+                "title": "Model Cache Health"
+            },
+            "filename_conflicts": {
+                "title": "Duplicate Filename Conflicts"
+            },
+            "ui_version": {
+                "title": "UI Version"
+            }
+        },
         "actions": {
             "runAgain": "Relancer",
-            "exportBundle": "Exporter le lot"
+            "exportBundle": "Exporter le lot",
+            "open-settings": "Open Settings",
+            "open-settings-syntax-format": "Switch to Full Path Syntax",
+            "repair-cache": "Rebuild Cache",
+            "resolve-filename-conflicts": "Resolve Conflicts",
+            "reload-page": "Reload UI"
+        },
+        "labels": {
+            "conflicts": "Conflicts",
+            "version": "Version"
         },
         "toast": {
             "loadFailed": "Échec du chargement des diagnostics : {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "Échec de la résolution des conflits de nom de fichier : {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "Résoudre les conflits de noms de fichiers",
+        "message": "Renommer en ajoutant un hachage de 4 caractères à chaque nom de fichier en double.",
+        "note": "Cette opération renomme les fichiers sur le disque. Les références de modèle dans les workflows existants peuvent nécessiter une mise à jour si vous utilisez le format de syntaxe A1111.",
+        "detail": "Exemple : <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "Renommera <strong>{count}</strong> fichier(s) dans <strong>{groups}</strong> groupe(s) de doublons",
+        "confirm": "Renommer les fichiers",
+        "cancel": "Annuler"
+    },
     "banners": {
         "versionMismatch": {
             "title": "Mise à jour de l'application détectée",

locales/he.json

@@ -16,10 +16,13 @@
             "help": "עזרה",
             "add": "הוספה",
             "close": "סגור",
-            "menu": "תפריט"
+            "menu": "תפריט",
+            "remove": "הסר",
+            "change": "שנה"
         },
         "status": {
             "loading": "טוען...",
+            "cancelling": "מבטל...",
             "unknown": "לא ידוע",
             "date": "תאריך",
             "version": "גרסה",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "הסר מהמועדפים",
             "viewOnCivitai": "הצג ב-Civitai",
             "notAvailableFromCivitai": "לא זמין מ-Civitai",
+            "viewOnHuggingFace": "צפייה ב-Hugging Face",
             "sendToWorkflow": "שלח ל-ComfyUI (לחיצה: הוסף, Shift+לחיצה: החלף)",
             "copyLoRASyntax": "העתק תחביר LoRA",
             "checkpointNameCopied": "שם Checkpoint הועתק",
@@ -111,6 +115,7 @@
             "replacePreview": "החלף תצוגה מקדימה",
             "copyCheckpointName": "העתק שם Checkpoint",
             "copyEmbeddingName": "העתק שם Embedding",
+            "embeddingNameCopied": "תחביר Embedding הועתק",
             "sendCheckpointToWorkflow": "שלח ל-ComfyUI",
             "sendEmbeddingToWorkflow": "שלח ל-ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "מספר שימושים"
+        },
+        "footer": {
+            "versionCount": "{count} גרסאות",
+            "viewAllVersions": "הצג את כל הגרסאות המקומיות"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "ניהול מודלים מוחרגים"
+        },
+        "groupByModel": {
+            "label": "קיבוץ לפי דגם"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "סטטיסטיקה"
         },
         "search": {
-            "placeholder": "חפש...",
-            "placeholders": {
-                "loras": "חפש LoRAs...",
-                "recipes": "חפש מתכונים...",
-                "checkpoints": "חפש checkpoints...",
-                "embeddings": "חפש embeddings..."
-            },
+            "placeholder": "חיפוש",
             "options": "אפשרויות חיפוש",
             "searchIn": "חפש ב:",
             "notAvailable": "חיפוש לא זמין בדף הסטטיסטיקה",
@@ -232,7 +238,10 @@
             "license": "רישיון",
             "noCreditRequired": "ללא קרדיט נדרש",
             "allowSellingGeneratedContent": "אפשר מכירה",
+            "allowSellingGeneratedContentTooltip": "אפשר מכירת תמונות שנוצרו",
+            "noCreditRequiredTooltip": "שימוש במודל ללא מתן קרדיט ליוצר",
             "noTags": "ללא תגיות",
+            "autoTags": "תגיות אוטומטיות",
             "noBaseModelMatches": "אין מודלי בסיס התואמים לחיפוש הנוכחי.",
             "clearAll": "נקה את כל המסננים",
             "any": "כלשהו",
@@ -244,7 +253,18 @@
             "toggle": "החלף ערכת נושא",
             "switchToLight": "עבור לערכת נושא בהירה",
             "switchToDark": "עבור לערכת נושא כהה",
-            "switchToAuto": "עבור לערכת נושא אוטומטית"
+            "switchToAuto": "עבור לערכת נושא אוטומטית",
+            "presets": "ערכות נושא מוגדרות",
+            "default": "ברירת מחדל",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "מצב",
+            "light": "בהיר",
+            "dark": "כהה",
+            "auto": "אוטומטי"
         },
         "actions": {
             "checkUpdates": "בדוק עדכונים",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "מפתח API של Civitai",
         "civitaiApiKeyPlaceholder": "הזן את מפתח ה-API שלך מ-Civitai",
         "civitaiApiKeyHelp": "משמש לאימות בעת הורדת מודלים מ-Civitai",
+        "civitaiApiKeyConfigured": "מוגדר",
+        "civitaiApiKeyNotConfigured": "לא מוגדר",
+        "civitaiApiKeySet": "הגדר",
         "civitaiHost": {
             "label": "מארח Civitai",
             "help": "בחר איזה אתר של Civitai ייפתח בעת שימוש בקישורי \"View on Civitai\".",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "מנגנון הורדה",
-            "help": "בחר כיצד יורדים קבצי המודל. Python משתמש במוריד המובנה. aria2 משתמש בתהליך הורדה חיצוני ניסיוני.",
+            "help": "בחר כיצד יורדים קבצי המודל. Python משתמש במוריד המובנה. aria2 משתמש בתהליך הורדה חיצוני מומלץ.",
             "options": {
                 "python": "Python (מובנה)",
-                "aria2": "aria2 (ניסיוני)"
+                "aria2": "aria2 (מומלץ)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "הורדות",
             "videoSettings": "הגדרות וידאו",
             "layoutSettings": "הגדרות פריסה",
+            "licenseIcons": "סמלי רישיון",
             "misc": "שונות",
             "backup": "גיבויים",
             "folderSettings": "תיקיות ברירת מחדל",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "נתיבי תיקיות נוספים",
             "downloadPathTemplates": "תבניות נתיב הורדה",
             "priorityTags": "תגיות עדיפות",
-            "updateFlags": "תגי עדכון",
+            "versionScope": "תגי עדכון",
             "exampleImages": "תמונות דוגמה",
             "autoOrganize": "ארגון אוטומטי",
             "metadata": "מטא-נתונים",
@@ -408,6 +432,8 @@
             "help": "כאשר מופעל, LoRA Manager ידלג על הורדת גרסת מודל אם שירות היסטוריית ההורדות רושם את הגרסה המדויקת הזו ככבר שהורדה. חל על כל תהליכי ההורדה."
         },
         "layoutSettings": {
+            "groupByModel": "קיבוץ לפי דגם",
+            "groupByModelHelp": "כאשר מופעל, רק הגרסה העדכנית ביותר של כל דגם Civitai מוצגת ככרטיס בודד. גרסאות ישנות יותר מוסתרות.",
             "displayDensity": "צפיפות תצוגה",
             "displayDensityOptions": {
                 "default": "ברירת מחדל",
@@ -442,7 +468,9 @@
                 "modelName": "שם מודל",
                 "fileName": "שם קובץ"
             },
-            "modelNameDisplayHelp": "בחר מה להציג בכותרת התחתונה של כרטיס המודל"
+            "modelNameDisplayHelp": "בחר מה להציג בכותרת התחתונה של כרטיס המודל",
+            "cardBlurAmount": "עוצמת טשטוש שכבת-על בכרטיס",
+            "cardBlurAmountHelp": "כוונן את עוצמת הטשטוש של שכבת-העל בכותרת ובכותרות תחתונה בכרטיסי מודל ומתכונים (0 = ללא טשטוש, 20 = טשטוש מקסימלי)."
         },
         "folderSettings": {
             "activeLibrary": "ספרייה פעילה",
@@ -562,7 +590,7 @@
             "download": "הורד",
             "restartRequired": "דורש הפעלה מחדש"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "אסטרטגיית תגי עדכון",
             "help": "בחרו אם תוויות העדכון יוצגו רק כאשר גרסה חדשה חולקת את אותו דגם בסיס כמו הקבצים המקומיים שלכם או בכל מקרה שבו קיימת גרסה חדשה עבור אותו דגם.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "הסתר עדכוני גישה מוקדמת",
             "help": "רק עדכוני גישה מוקדמת"
         },
+        "licenseIcons": {
+            "useNewStyle": "השתמש בסמלי רישיון מעודכנים",
+            "useNewStyleHelp": "הצג הרשאות רישיון עם מחוונים צבעוניים (סגנון חדש) או סמלי הגבלה בלבד (סגנון קלאסי). משקף את העיצוב העדכני של CivitAI."
+        },
         "misc": {
             "includeTriggerWords": "כלול מילות טריגר בתחביר LoRA",
-            "includeTriggerWordsHelp": "כלול מילות טריגר מאומנות בעת העתקת תחביר LoRA ללוח"
+            "includeTriggerWordsHelp": "כלול מילות טריגר מאומנות בעת העתקת תחביר LoRA ללוח",
+            "loraSyntaxFormat": "פורמט תחביר LoRA",
+            "loraSyntaxFormatHelp": "פורמט תחביר LoRA. נתיב מלא כולל תת-תיקייה (<lora:style/anime/x:1.0>) לפתרון מודל ללא אובדן. גרסה ישנה משתמשת בשם קובץ בלבד (<lora:x:1.0>) — מוסכמת A1111, עלולה להיות לא חד משמעית עם שמות קבצים כפולים בתיקיות שונות.",
+            "loraSyntaxFormatOptions": {
+                "full": "נתיב מלא (תת-תיקייה/שם)",
+                "legacy": "A1111 ישן (שם בלבד)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "הפעל מסד נתונים של ארכיון מטא-דאטה",
@@ -619,6 +657,23 @@
             "proxyPassword": "סיסמה (אופציונלי)",
             "proxyPasswordPlaceholder": "password",
             "proxyPasswordHelp": "סיסמה לאימות מול הפרוקסי (אם נדרש)"
+        },
+        "aiProvider": {
+            "title": "ספק AI",
+            "provider": "ספק",
+            "providerHelp": "בחר את ספק ה-LLM שלך. OpenAI ו-Ollama משתמשים בנקודות קצה מוגדרות מראש. מותאם אישית מאפשר לך לציין כל נקודת קצה תואמת OpenAI.",
+            "custom": "מותאם אישית (תואם OpenAI)",
+            "apiBase": "כתובת בסיס API",
+            "apiBaseHelp": "כתובת ה-URL הבסיסית ל-API של LLM (לדוגמה https://api.openai.com/v1). השאר ריק לשימוש בברירת המחדל של הספק.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "מפתח API",
+            "apiKeyHelp": "מפתח ה-API של ספק ה-LLM שלך. נשמר מקומית, לעולם לא נשלח לשרת כלשהו מלבד ספק ה-LLM שבחרת.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "לא הוגדר",
+            "apiKeyConfigured": "הוגדר",
+            "apiKeySet": "הגדר",
+            "model": "מודל",
+            "modelHelp": "שם המודל לשימוש (לדוגמה deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). בדוק אצל הספק שלך אילו מודלים זמינים."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "הקטן ביותר",
                 "usage": "מספר שימושים",
                 "usageDesc": "הכי הרבה",
-                "usageAsc": "הכי פחות"
+                "usageAsc": "הכי פחות",
+                "versionsCount": "גרסאות מקומיות",
+                "versionsCountDesc": "הכי הרבה גרסאות ראשונות",
+                "versionsCountAsc": "הכי מעט גרסאות ראשונות",
+                "versionIdDesc": "גרסה חדשה ביותר ראשונה"
             },
             "refresh": {
                 "title": "רענן רשימת מודלים",
-                "quick": "סנכרון שינויים",
-                "quickTooltip": "סריקה לאיתור קבצי מודל חדשים או חסרים כדי לשמור את הרשימה מעודכנת.",
                 "full": "בניית מטמון מחדש",
                 "fullTooltip": "טוען מחדש את כל פרטי המודלים מקבצי המטא-דאטה – לשימוש אם הספרייה נראית לא מעודכנת או לאחר עריכות ידניות."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "הגדר דירוג תוכן לכל המודלים",
             "copyAll": "העתק את כל התחבירים",
             "refreshAll": "רענן את כל המטא-דאטה",
+            "repairMetadata": "תקן מטא-דאטה עבור הנבחרים",
+            "reimportMetadata": "ייבא מחדש ממקור",
             "checkUpdates": "בדוק עדכונים לבחירה",
             "moveAll": "העבר הכל לתיקייה",
             "autoOrganize": "ארגן אוטומטית נבחרים",
@@ -692,9 +751,18 @@
             "unfavorite": "הסר ממועדפים",
             "deleteAll": "מחק נבחרים",
             "downloadMissingLoras": "הורדת LoRAs חסרים",
+            "downloadExamples": "הורד תמונות דוגמה",
             "clear": "נקה בחירה",
             "skipMetadataRefreshCount": "דילוג（{count} מודלים）",
             "resumeMetadataRefreshCount": "המשך（{count} מודלים）",
+            "sendToWorkflow": "שלח ל-Workflow",
+            "sections": {
+                "workflow": "Workflow",
+                "metadata": "מטא-נתונים",
+                "attributes": "מאפיינים",
+                "organize": "ארגן",
+                "download": "הורדה"
+            },
             "autoOrganizeProgress": {
                 "initializing": "מאתחל ארגון אוטומטי...",
                 "starting": "מתחיל ארגון אוטומטי עבור {type}...",
@@ -703,7 +771,8 @@
                 "completed": "הושלם: {success} הועברו, {skipped} דולגו, {failures} נכשלו",
                 "complete": "ארגון אוטומטי הושלם",
                 "error": "שגיאה: {error}"
-            }
+            },
+            "enrichHfAgent": "העשרת מטא-דאטה (AI)"
         },
         "contextMenu": {
             "refreshMetadata": "רענן נתוני Civitai",
@@ -720,13 +789,15 @@
             "setContentRating": "הגדר דירוג תוכן",
             "moveToFolder": "העבר לתיקייה",
             "repairMetadata": "תיקון מטא-דאטה",
+            "reimportMetadata": "ייבא מחדש ממקור",
             "excludeModel": "החרג מודל",
             "restoreModel": "שחזור מודל",
             "deleteModel": "מחק מודל",
             "shareRecipe": "שתף מתכון",
             "viewAllLoras": "הצג את כל ה-LoRAs",
             "downloadMissingLoras": "הורד LoRAs חסרים",
-            "deleteRecipe": "מחק מתכון"
+            "deleteRecipe": "מחק מתכון",
+            "enrichHfAgent": "העשרת מטא-דאטה (AI)"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "רענן רשימת מתכונים",
-                "quick": "סנכרן שינויים",
-                "quickTooltip": "סנכרן שינויים - רענון מהיר ללא בניית מטמון מחדש",
                 "full": "בנה מטמון מחדש",
                 "fullTooltip": "בנה מטמון מחדש - סריקה מחדש מלאה של כל קבצי המתכונים"
             },
@@ -849,6 +918,13 @@
                 "skipped": "המתכון כבר בגרסה העדכנית ביותר, אין צורך בתיקון",
                 "failed": "תיקון המתכון נכשל: {message}",
                 "missingId": "לא ניתן לתקן את המתכון: חסר מזהה מתכון"
+            },
+            "reimport": {
+                "starting": "מייבא מתכון מחדש מהמקור...",
+                "success": "המתכון יובא מחדש בהצלחה",
+                "noSourceUrl": "למתכון אין כתובת מקור, לא ניתן לייבא מחדש",
+                "failed": "ייבוא המתכון מחדש נכשל: {message}",
+                "missingId": "לא ניתן לייבא מחדש: חסר מזהה מתכון"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "שורש",
         "collapseAll": "כווץ את כל התיקיות",
-        "pinSidebar": "נעל סרגל צד",
-        "unpinSidebar": "שחרר סרגל צד",
+        "hideOnThisPage": "הסתר סרגל צד בדף זה",
+        "showSidebar": "הצג סרגל צד",
+        "sidebarHiddenNotification": "סרגל הצד מוסתר בדף {page}",
         "switchToListView": "עבור לתצוגת רשימה",
         "switchToTreeView": "תצוגת עץ",
         "recursiveOn": "כלול תיקיות משנה",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "לא נמצאו תיקיות",
             "dragHint": "גרור פריטים לכאן כדי ליצור תיקיות"
+        },
+        "folderUpdateCheck": {
+            "label": "בדוק עדכונים בתיקייה זו",
+            "loading": "בודק עדכוני {type} בתיקייה זו...",
+            "success": "נמצאו {count} עדכון/ים עבור {type}s בתיקייה זו",
+            "none": "כל ה-{type}s בתיקייה זו מעודכנים",
+            "error": "נכשל בבדיקת עדכוני {type} בתיקייה: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "אחסון",
             "insights": "תובנות"
         },
+        "metrics": {
+            "totalModels": "סה\"כ דגמים",
+            "totalStorage": "סה\"כ אחסון",
+            "totalGenerations": "סה\"כ יצירות",
+            "usageRate": "שיעור שימוש",
+            "loras": "LoRA",
+            "checkpoints": "נקודות ביקורת",
+            "embeddings": "הטמעות",
+            "uniqueTags": "תגיות ייחודיות",
+            "unusedModels": "דגמים שאינם בשימוש",
+            "avgUsesPerModel": "ממוצע שימושים/דגם"
+        },
         "usage": {
             "mostUsedLoras": "LoRAs הנפוצים ביותר",
             "mostUsedCheckpoints": "Checkpoints הנפוצים ביותר",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "תובנות חכמות",
-            "recommendations": "המלצות"
+            "recommendations": "המלצות",
+            "noInsights": "אין תובנות זמינות",
+            "unusedLoras": {
+                "high": {
+                    "title": "כמות גבוהה של LoRAs שאינן בשימוש",
+                    "description": "{percent}% מה-LoRAs שלך ({count}/{total}) מעולם לא נעשה בהם שימוש.",
+                    "suggestion": "שקול לארגן או לאחסן בארכיון מודלים שאינם בשימוש כדי לפנות שטח אחסון."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "התגלו נקודות ביקורת שאינן בשימוש",
+                    "description": "{percent}% מנקודות הביקורת שלך ({count}/{total}) מעולם לא נעשה בהן שימוש.",
+                    "suggestion": "בדוק ושקול להסיר נקודות ביקורת שאינך צריך עוד."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "כמות גבוהה של Embeddings שאינם בשימוש",
+                    "description": "{percent}% מה-Embeddings שלך ({count}/{total}) מעולם לא נעשה בהם שימוש.",
+                    "suggestion": "שקול לארגן או לאחסן בארכיון Embeddings שאינם בשימוש כדי לייעל את האוסף."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "התגלה אוסף גדול",
+                    "description": "אוסף המודלים שלך משתמש ב-{size} של אחסון.",
+                    "suggestion": "שקול להשתמש באחסון חיצוני או בפתרונות ענן לארגון טוב יותר."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "משתמש פעיל",
+                    "description": "השלמת {count} יצירות עד כה!",
+                    "suggestion": "המשך לחקור וליצור תוכן מדהים עם המודלים שלך."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "סקירת אוסף",
             "baseModelDistribution": "התפלגות מודלי בסיס",
             "usageTrends": "מגמות שימוש (30 יום אחרונים)",
-            "usageDistribution": "התפלגות שימוש"
+            "usageDistribution": "התפלגות שימוש",
+            "date": "תאריך",
+            "usageCount": "מספר שימושים",
+            "fileSizeBytes": "גודל קובץ (בתים)",
+            "models": "דגמים",
+            "loraUsage": "שימוש ב-LoRA",
+            "checkpointUsage": "שימוש ב-Checkpoint",
+            "embeddingUsage": "שימוש ב-Embedding"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "נקודת ביקורת",
+            "diffusion_model": "מודל דיפוזיה",
+            "embedding": "הטמעות"
+        },
+        "placeholders": {
+            "loading": "טוען...",
+            "noModels": "לא נמצאו דגמים",
+            "errorLoading": "שגיאה בטעינת נתונים",
+            "noStorageData": "אין נתוני אחסון זמינים",
+            "rootFolder": "שורש",
+            "chartLibraryMissing": "הגרף דורש את ספריית Chart.js"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} דגמים",
+            "chartUsage": "{name}: {size}, {count} שימושים",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "הורד מודל מכתובת URL",
             "titleWithType": "הורד {type} מכתובת URL",
-            "url": "כתובת URL של Civitai",
             "civitaiUrl": "כתובת URL של Civitai:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "יש להזין כתובת URL אחת של CivitAI, CivArchive או Hugging Face בכל שורה. תומך במספר כתובות URL להורדה בקבוצה.",
+            "selectHfFiles": "בחר קבצים להורדה ממאגר זה:",
+            "selectAll": "בחר הכל",
+            "fetchingRepoFiles": "מביא קבצים מהמאגר...",
             "locationPreview": "תצוגה מקדימה של מיקום ההורדה",
             "useDefaultPath": "השתמש בנתיב ברירת מחדל",
             "useDefaultPathTooltip": "כאשר מופעל, קבצים מאורגנים אוטומטית באמצעות תבניות נתיב מוגדרות",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "הורד בעבר, אך הוא אינו נמצא כרגע בספרייה שלך.",
             "alreadyInLibrary": "כבר בספרייה",
             "autoOrganizedPath": "[מאורגן אוטומטית לפי תבנית נתיב]",
+            "fileSelection": {
+                "title": "בחר פורמט קובץ",
+                "files": "קבצים",
+                "select": "בחר קובץ"
+            },
             "errors": {
                 "invalidUrl": "פורמט URL של Civitai לא חוקי",
-                "noVersions": "אין גרסאות זמינות למודל זה"
+                "noVersions": "אין גרסאות זמינות למודל זה",
+                "mixedSources": "לא ניתן לערבב כתובות URL של CivitAI ו-Hugging Face באותה קבוצה.",
+                "noModelFiles": "לא נמצאו קבצי מודל במאגר זה."
             },
             "status": {
                 "preparing": "מכין הורדה...",
@@ -1080,6 +1250,12 @@
             "countMessage": "מודלים יימחקו לצמיתות.",
             "action": "מחק הכל"
         },
+        "bulkDeleteRecipes": {
+            "title": "מחק מספר מתכונים",
+            "message": "האם אתה בטוח שברצונך למחוק את כל המתכונים שנבחרו ואת הקבצים הנלווים אליהם?",
+            "countMessage": "מתכונים יימחקו לצמיתות.",
+            "action": "מחק הכל"
+        },
         "checkUpdates": {
             "title": "לבדוק עדכונים לכל ה-{typePlural}?",
             "message": "הפעולה תבדוק עדכונים עבור כל ה-{typePlural} בספרייה שלך. באוספים גדולים זה עלול לקחת מעט יותר זמן.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "ערוך שם מודל",
                 "editFileName": "ערוך שם קובץ",
                 "editBaseModel": "ערוך מודל בסיס",
+                "editVersionName": "ערוך שם גרסה",
                 "viewOnCivitai": "הצג ב-Civitai",
                 "viewOnCivitaiText": "הצג ב-Civitai",
+                "viewOnHuggingFace": "צפייה ב-Hugging Face",
+                "viewOnHuggingFaceText": "צפייה ב-Hugging Face",
                 "viewCreatorProfile": "הצג פרופיל יוצר",
                 "openFileLocation": "פתח מיקום קובץ",
                 "sendToWorkflow": "שלח ל-ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "הערות נוספות",
                 "notesHint": "לחץ Enter לשמירה, Shift+Enter לשורה חדשה",
                 "addNotesPlaceholder": "הוסף את ההערות שלך כאן...",
-                "aboutThisVersion": "אודות גרסה זו"
+                "aboutThisVersion": "אודות גרסה זו",
+                "baseModelSearchPlaceholder": "חפש מודל בסיס…",
+                "baseModelSuggested": "מוצע",
+                "baseModelNoMatch": "אין מודלי בסיס תואמים"
             },
             "notes": {
                 "saved": "הערות נשמרו בהצלחה",
-                "saveFailed": "שמירת ההערות נכשלה"
+                "saveFailed": "שמירת ההערות נכשלה",
+                "showMore": "הצג עוד",
+                "showLess": "הצג פחות"
             },
             "usageTips": {
                 "addPresetParameter": "הוסף פרמטר קבוע מראש...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "הגרסה נמחקה"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "סיכום שליפת מטא-דאטה",
+            "statSuccess": "הצלחה",
+            "statFailed": "נכשל",
+            "statSkipped": "דולג",
+            "statTotal": "סה\"כ נסרק",
+            "statDuration": "משך",
+            "successMessage": "כל {count} {type}s עודכנו בהצלחה!",
+            "failedItems": "פריטים נכשלים ({count})",
+            "close": "סגור",
+            "copyReport": "העתק דוח",
+            "downloadCsv": "הורד CSV",
+            "columnModelName": "שם המודל",
+            "columnError": "שגיאה"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "תגית זו כבר קיימת"
         }
     },
-    "keyboard": {
-        "navigation": "ניווט במקלדת:",
-        "shortcuts": {
-            "pageUp": "גלול עמוד אחד למעלה",
-            "pageDown": "גלול עמוד אחד למטה",
-            "home": "קפוץ להתחלה",
-            "end": "קפוץ לסוף"
-        }
-    },
     "initialization": {
         "title": "מאתחל",
         "message": "מכין את סביבת העבודה שלך...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "אין צמתים תואמים זמינים ב-workflow הנוכחי",
             "noTargetNodeSelected": "לא נבחר צומת יעד",
             "modelUpdated": "מודל עודכן ב-workflow",
-            "modelFailed": "עדכון צומת המודל נכשל"
+            "modelFailed": "עדכון צומת המודל נכשל",
+            "embeddingAdded": "Embedding נוסף ל-workflow",
+            "embeddingFailed": "הוספת Embedding נכשלה",
+            "promptSent": "הנחיה נשלחה ל-workflow",
+            "promptFailed": "שליחת ההנחיה נכשלה"
         },
         "nodeSelector": {
             "recipe": "מתכון",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "הנחיה",
             "replace": "החלף",
             "append": "הוסף",
             "selectTargetNode": "בחר צומת יעד",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "אין מזהה מתכון זמין",
             "sendToWorkflowFailed": "נכשל שליחת המתכון ל-workflow: {message}",
             "copyFailed": "שגיאה בהעתקת תחביר המתכון: {message}",
+            "createError": "שגיאה ביצירת המתכון：{message}",
+            "createFailed": "יצירת המתכון נכשלה：{error}",
+            "createMissingData": "חסרים נתונים נדרשים ליצירת המתכון",
+            "created": "המתכון נוצר בהצלחה",
             "noMissingLoras": "אין LoRAs חסרים להורדה",
             "missingLorasInfoFailed": "קבלת מידע עבור LoRAs חסרים נכשלה",
             "preparingForDownloadFailed": "שגיאה בהכנת LoRAs להורדה",
             "enterLoraName": "אנא הזן שם LoRA או תחביר",
             "reconnectedSuccessfully": "LoRA קושר מחדש בהצלחה",
             "reconnectFailed": "שגיאה בקישור מחדש של LoRA: {message}",
+            "noPromptToSend": "אין הנחיה לשליחה",
             "cannotSend": "לא ניתן לשלוח מתכון: חסר מזהה מתכון",
             "sendFailed": "שליחת המתכון ל-workflow נכשלה",
             "sendError": "שגיאה בשליחת המתכון ל-workflow",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "לא נבחרו מתכונים",
+            "repairBulkComplete": "התיקון הושלם: {repaired} תוקנו, {skipped} דולגו (מתוך {total})",
+            "repairBulkSkipped": "אין צורך בתיקון עבור {total} המתכונים הנבחרים",
+            "repairBulkFailed": "תיקון המתכונים הנבחרים נכשל: {message}",
+            "reimporting": "מייבא מתכון מחדש מהמקור...",
+            "reimportSuccess": "המתכון יובא מחדש בהצלחה",
+            "reimportBulkComplete": "ייבוא מחדש הושלם: {completed} יובאו, {failed} נכשלו (מתוך {total})",
+            "reimportBulkFailed": "ייבוא מחדש של חלק מהמתכונים נכשל",
             "noMissingLorasInSelection": "לא נמצאו LoRAs חסרים במתכונים שנבחרו",
             "noLoraRootConfigured": "תיקיית השורש של LoRA לא מוגדרת. אנא הגדר תיקיית שורש LoRA ברירת מחדל בהגדרות."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "הועברו בהצלחה {successCount} {type}s",
             "exampleImagesDownloadSuccess": "תמונות הדוגמה הורדו בהצלחה!",
             "exampleImagesDownloadFailed": "הורדת תמונות הדוגמה נכשלה: {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "הועתק ללוח",
+            "downloadStarted": "ההורדה החלה"
+        },
+        "agent": {
+            "llmNotConfigured": "ספק AI לא הוגדר. הפעל אותו בהגדרות → ספק AI.",
+            "enrichStarted": "מעשיר מטא-דאטה באמצעות AI...",
+            "enrichComplete": "העשרת מטא-דאטה הושלמה: {{summary}}",
+            "enrichFailed": "העשרת מטא-דאטה נכשלה: {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "דורש תשומת לב",
             "error": "נדרשת פעולה"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API Key"
+            },
+            "cache_health": {
+                "title": "Model Cache Health"
+            },
+            "filename_conflicts": {
+                "title": "Duplicate Filename Conflicts"
+            },
+            "ui_version": {
+                "title": "UI Version"
+            }
+        },
         "actions": {
             "runAgain": "הפעל שוב",
-            "exportBundle": "ייצוא חבילה"
+            "exportBundle": "ייצוא חבילה",
+            "open-settings": "Open Settings",
+            "open-settings-syntax-format": "Switch to Full Path Syntax",
+            "repair-cache": "Rebuild Cache",
+            "resolve-filename-conflicts": "Resolve Conflicts",
+            "reload-page": "Reload UI"
+        },
+        "labels": {
+            "conflicts": "Conflicts",
+            "version": "Version"
         },
         "toast": {
             "loadFailed": "טעינת האבחון נכשלה: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "פתרון התנגשויות שמות קבצים נכשל: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "פתור התנגשויות בשמות קבצים",
+        "message": "שינוי שם על ידי הוספת האש באורך 4 תווים לכל שם קובץ כפול.",
+        "note": "פעולה זו משנה שמות של קבצים בדיסק. ייתכן שיהיה צורך לעדכן הפניות למודלים בזרימות עבודה קיימות אם אתה משתמש בפורמט התחביר A1111.",
+        "detail": "דוגמה: <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "ישנה שם של <strong>{count}</strong> קבצים ב-<strong>{groups}</strong> קבוצות כפולות",
+        "confirm": "שנה שמות קבצים",
+        "cancel": "ביטול"
+    },
     "banners": {
         "versionMismatch": {
             "title": "זוהה עדכון יישום",

locales/ja.json

@@ -16,10 +16,13 @@
             "help": "ヘルプ",
             "add": "追加",
             "close": "閉じる",
-            "menu": "メニュー"
+            "menu": "メニュー",
+            "remove": "削除",
+            "change": "変更"
         },
         "status": {
             "loading": "読み込み中...",
+            "cancelling": "キャンセル中...",
             "unknown": "不明",
             "date": "日付",
             "version": "バージョン",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "お気に入りから削除",
             "viewOnCivitai": "Civitaiで表示",
             "notAvailableFromCivitai": "Civitaiでは利用できません",
+            "viewOnHuggingFace": "Hugging Face で見る",
             "sendToWorkflow": "ComfyUIに送信（クリック：追加、Shift+クリック：置換）",
             "copyLoRASyntax": "LoRA構文をコピー",
             "checkpointNameCopied": "checkpointの名前をコピーしました",
@@ -111,6 +115,7 @@
             "replacePreview": "プレビューを置換",
             "copyCheckpointName": "checkpoint名をコピー",
             "copyEmbeddingName": "embedding名をコピー",
+            "embeddingNameCopied": "Embedding構文をコピーしました",
             "sendCheckpointToWorkflow": "ComfyUIに送信",
             "sendEmbeddingToWorkflow": "ComfyUIに送信"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "使用回数"
+        },
+        "footer": {
+            "versionCount": "{count} バージョン",
+            "viewAllVersions": "ローカルの全バージョンを表示"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "除外モデルを管理"
+        },
+        "groupByModel": {
+            "label": "モデルでグループ化"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "統計"
         },
         "search": {
-            "placeholder": "検索...",
-            "placeholders": {
-                "loras": "LoRAを検索...",
-                "recipes": "レシピを検索...",
-                "checkpoints": "checkpointを検索...",
-                "embeddings": "embeddingを検索..."
-            },
+            "placeholder": "検索",
             "options": "検索オプション",
             "searchIn": "検索対象：",
             "notAvailable": "統計ページでは検索は利用できません",
@@ -232,7 +238,10 @@
             "license": "ライセンス",
             "noCreditRequired": "クレジット不要",
             "allowSellingGeneratedContent": "販売許可",
+            "allowSellingGeneratedContentTooltip": "生成した画像の販売を許可",
+            "noCreditRequiredTooltip": "クレジット表記なしでモデルを使用可能",
             "noTags": "タグなし",
+            "autoTags": "自動タグ",
             "noBaseModelMatches": "現在の検索に一致するベースモデルはありません。",
             "clearAll": "すべてのフィルタをクリア",
             "any": "いずれか",
@@ -244,7 +253,18 @@
             "toggle": "テーマの切り替え",
             "switchToLight": "ライトテーマに切り替え",
             "switchToDark": "ダークテーマに切り替え",
-            "switchToAuto": "自動テーマに切り替え"
+            "switchToAuto": "自動テーマに切り替え",
+            "presets": "テーマプリセット",
+            "default": "デフォルト",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "モード",
+            "light": "ライト",
+            "dark": "ダーク",
+            "auto": "自動"
         },
         "actions": {
             "checkUpdates": "更新確認",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Civitai APIキー",
         "civitaiApiKeyPlaceholder": "Civitai APIキーを入力してください",
         "civitaiApiKeyHelp": "Civitaiからモデルをダウンロードするときの認証に使用されます",
+        "civitaiApiKeyConfigured": "設定済み",
+        "civitaiApiKeyNotConfigured": "未設定",
+        "civitaiApiKeySet": "設定",
         "civitaiHost": {
             "label": "Civitai ホスト",
             "help": "「View on Civitai」リンクを使うときに開く Civitai サイトを選択します。",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "ダウンロードバックエンド",
-            "help": "モデルファイルのダウンロード方法を選択します。Python は内蔵ダウンローダーを使用し、aria2 は実験的な外部ダウンローダープロセスを使用します。",
+            "help": "モデルファイルのダウンロード方法を選択します。Python は内蔵ダウンローダーを使用し、aria2 は推奨の外部ダウンローダープロセスを使用します。",
             "options": {
                 "python": "Python（内蔵）",
-                "aria2": "aria2（実験的）"
+                "aria2": "aria2（推奨）"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "ダウンロード",
             "videoSettings": "動画設定",
             "layoutSettings": "レイアウト設定",
+            "licenseIcons": "ライセンスアイコン",
             "misc": "その他",
             "backup": "バックアップ",
             "folderSettings": "デフォルトルート",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "追加フォルダーパス",
             "downloadPathTemplates": "ダウンロードパステンプレート",
             "priorityTags": "優先タグ",
-            "updateFlags": "アップデートフラグ",
+            "versionScope": "アップデートフラグ",
             "exampleImages": "例画像",
             "autoOrganize": "自動整理",
             "metadata": "メタデータ",
@@ -408,6 +432,8 @@
             "help": "有効にすると、ダウンロード履歴サービスがそのバージョンが既にダウンロード済みと記録している場合、LoRA Managerはそのモデルバージョンのダウンロードをスキップします。すべてのダウンロードフローに適用されます。"
         },
         "layoutSettings": {
+            "groupByModel": "モデルでグループ化",
+            "groupByModelHelp": "有効にすると、各Civitaiモデルの最新バージョンのみが1枚のカードとして表示され、古いバージョンは非表示になります。",
             "displayDensity": "表示密度",
             "displayDensityOptions": {
                 "default": "デフォルト",
@@ -442,7 +468,9 @@
                 "modelName": "モデル名",
                 "fileName": "ファイル名"
             },
-            "modelNameDisplayHelp": "モデルカードのフッターに表示する内容を選択"
+            "modelNameDisplayHelp": "モデルカードのフッターに表示する内容を選択",
+            "cardBlurAmount": "カードオーバーレイのぼかし",
+            "cardBlurAmountHelp": "モデルカードとレシピカードのヘッダー・フッターオーバーレイのぼかし強度を調整します（0 = ぼかしなし、20 = 最大ぼかし）。"
         },
         "folderSettings": {
             "activeLibrary": "アクティブライブラリ",
@@ -562,7 +590,7 @@
             "download": "ダウンロード",
             "restartRequired": "再起動が必要"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "アップデートフラグの表示戦略",
             "help": "新リリースがローカルファイルと同じベースモデルを共有する場合にのみ更新バッジを表示するか、そのモデルに新しいバージョンがあれば常に表示するかを決めます。",
             "options": {
@@ -574,9 +602,19 @@
             "label": "早期アクセス更新を非表示",
             "help": "早期アクセスのみの更新"
         },
+        "licenseIcons": {
+            "useNewStyle": "更新されたライセンスアイコンを使用",
+            "useNewStyleHelp": "カラーインジケーター付きでライセンス許可を表示（新スタイル）するか、制限のみのアイコンを表示（クラシックスタイル）します。現在のCivitAIデザインを反映しています。"
+        },
         "misc": {
             "includeTriggerWords": "LoRA構文にトリガーワードを含める",
-            "includeTriggerWordsHelp": "LoRA構文をクリップボードにコピーする際、学習済みトリガーワードを含めます"
+            "includeTriggerWordsHelp": "LoRA構文をクリップボードにコピーする際、学習済みトリガーワードを含めます",
+            "loraSyntaxFormat": "LoRA構文形式",
+            "loraSyntaxFormatHelp": "LoRA構文形式。フルパスはサブフォルダパスを含み（<lora:style/anime/x:1.0>）、モデルをロスレスで解決します。レガシーはファイル名のみ（<lora:x:1.0>）— A1111規約ですが、フォルダ間でファイル名が重複する場合に曖昧になる可能性があります。",
+            "loraSyntaxFormatOptions": {
+                "full": "フルパス（サブフォルダ/名前）",
+                "legacy": "レガシーA1111（名前のみ）"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "メタデータアーカイブデータベースを有効化",
@@ -619,6 +657,23 @@
             "proxyPassword": "パスワード（任意）",
             "proxyPasswordPlaceholder": "パスワード",
             "proxyPasswordHelp": "プロキシ認証用のパスワード（必要な場合）"
+        },
+        "aiProvider": {
+            "title": "AIプロバイダー",
+            "provider": "プロバイダー",
+            "providerHelp": "LLMプロバイダーを選択してください。OpenAIとOllamaはプリセットのAPIエンドポイントを使用します。カスタムでは任意のOpenAI互換エンドポイントを指定できます。",
+            "custom": "カスタム（OpenAI互換）",
+            "apiBase": "APIベースURL",
+            "apiBaseHelp": "LLM APIのベースURL（例：https://api.openai.com/v1）。空の場合はプロバイダーのデフォルトが使用されます。",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "APIキー",
+            "apiKeyHelp": "LLMプロバイダーのAPIキー。ローカルに保存され、選択したLLMプロバイダー以外のサーバーに送信されることはありません。",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "未設定",
+            "apiKeyConfigured": "設定済み",
+            "apiKeySet": "設定",
+            "model": "モデル",
+            "modelHelp": "使用するモデル名（例：deepseek-v4-flash, gemini-2.5-flash, gemma4:12b）。プロバイダーで利用可能なモデルをご確認ください。"
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "小さい順",
                 "usage": "使用回数",
                 "usageDesc": "多い",
-                "usageAsc": "少ない"
+                "usageAsc": "少ない",
+                "versionsCount": "ローカルバージョン数",
+                "versionsCountDesc": "バージョン数の多い順",
+                "versionsCountAsc": "バージョン数の少ない順",
+                "versionIdDesc": "最新バージョン順"
             },
             "refresh": {
                 "title": "モデルリストを更新",
-                "quick": "変更を同期",
-                "quickTooltip": "新しいモデルファイルや欠けているファイルをスキャンして一覧を最新に保ちます。",
                 "full": "キャッシュを再構築",
                 "fullTooltip": "メタデータファイルから全モデル情報を再読み込みします。リストが古いと感じるときや手動編集後に使用してください。"
             },
@@ -682,6 +739,8 @@
             "setContentRating": "すべてのモデルのコンテンツレーティングを設定",
             "copyAll": "すべての構文をコピー",
             "refreshAll": "すべてのメタデータを更新",
+            "repairMetadata": "選択したレシピのメタデータを修復",
+            "reimportMetadata": "ソースから再インポート",
             "checkUpdates": "選択項目の更新を確認",
             "moveAll": "すべてをフォルダに移動",
             "autoOrganize": "自動整理を実行",
@@ -692,9 +751,18 @@
             "unfavorite": "お気に入りから削除",
             "deleteAll": "選択したものを削除",
             "downloadMissingLoras": "不足している LoRA をダウンロード",
+            "downloadExamples": "例画像をダウンロード",
             "clear": "選択をクリア",
             "skipMetadataRefreshCount": "スキップ（{count}モデル）",
             "resumeMetadataRefreshCount": "再開（{count}モデル）",
+            "sendToWorkflow": "ワークフローに送信",
+            "sections": {
+                "workflow": "ワークフロー",
+                "metadata": "メタデータ",
+                "attributes": "属性",
+                "organize": "整理",
+                "download": "ダウンロード"
+            },
             "autoOrganizeProgress": {
                 "initializing": "自動整理を初期化中...",
                 "starting": "{type}の自動整理を開始中...",
@@ -703,7 +771,8 @@
                 "completed": "完了：{success} 移動、{skipped} スキップ、{failures} 失敗",
                 "complete": "自動整理が完了しました",
                 "error": "エラー：{error}"
-            }
+            },
+            "enrichHfAgent": "メタデータをAIで補完"
         },
         "contextMenu": {
             "refreshMetadata": "Civitaiデータを更新",
@@ -720,13 +789,15 @@
             "setContentRating": "コンテンツレーティングを設定",
             "moveToFolder": "フォルダに移動",
             "repairMetadata": "メタデータを修復",
+            "reimportMetadata": "ソースから再インポート",
             "excludeModel": "モデルを除外",
             "restoreModel": "モデルを復元",
             "deleteModel": "モデルを削除",
             "shareRecipe": "レシピを共有",
             "viewAllLoras": "すべてのLoRAを表示",
             "downloadMissingLoras": "不足しているLoRAをダウンロード",
-            "deleteRecipe": "レシピを削除"
+            "deleteRecipe": "レシピを削除",
+            "enrichHfAgent": "メタデータをAIで補完"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "レシピリストを更新",
-                "quick": "変更を同期",
-                "quickTooltip": "変更を同期 - キャッシュを再構築せずにクイック更新",
                 "full": "キャッシュを再構築",
                 "fullTooltip": "キャッシュを再構築 - すべてのレシピファイルを完全に再スキャン"
             },
@@ -849,6 +918,13 @@
                 "skipped": "レシピはすでに最新バージョンです。修復は不要です",
                 "failed": "レシピの修復に失敗しました: {message}",
                 "missingId": "レシピを修復できません: レシピIDがありません"
+            },
+            "reimport": {
+                "starting": "ソースからレシピを再インポート中...",
+                "success": "レシピの再インポートが完了しました",
+                "noSourceUrl": "レシピにソースURLがありません。再インポートできません",
+                "failed": "レシピの再インポートに失敗しました: {message}",
+                "missingId": "レシピを再インポートできません: レシピIDがありません"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "ルート",
         "collapseAll": "すべてのフォルダを折りたたむ",
-        "pinSidebar": "サイドバーを固定",
-        "unpinSidebar": "サイドバーの固定を解除",
+        "hideOnThisPage": "このページでサイドバーを非表示",
+        "showSidebar": "サイドバーを表示",
+        "sidebarHiddenNotification": "{page}ページでサイドバーが非表示になっています",
         "switchToListView": "リストビューに切り替え",
         "switchToTreeView": "ツリー表示に切り替え",
         "recursiveOn": "サブフォルダーを含める",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "フォルダが見つかりません",
             "dragHint": "ここへアイテムをドラッグしてフォルダを作成します"
+        },
+        "folderUpdateCheck": {
+            "label": "このフォルダのアップデートを確認",
+            "loading": "このフォルダの{type}アップデートを確認中...",
+            "success": "このフォルダの{type}sに{count}件のアップデートが見つかりました",
+            "none": "このフォルダのすべての{type}sは最新です",
+            "error": "フォルダの{type}アップデート確認に失敗しました: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "ストレージ",
             "insights": "インサイト"
         },
+        "metrics": {
+            "totalModels": "モデル総数",
+            "totalStorage": "ストレージ合計",
+            "totalGenerations": "生成回数合計",
+            "usageRate": "使用率",
+            "loras": "LoRA",
+            "checkpoints": "Checkpoint",
+            "embeddings": "Embedding",
+            "uniqueTags": "ユニークタグ",
+            "unusedModels": "未使用モデル",
+            "avgUsesPerModel": "平均使用回数/モデル"
+        },
         "usage": {
             "mostUsedLoras": "最も使用されているLoRA",
             "mostUsedCheckpoints": "最も使用されているCheckpoint",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "スマートインサイト",
-            "recommendations": "推奨事項"
+            "recommendations": "推奨事項",
+            "noInsights": "インサイトはありません",
+            "unusedLoras": {
+                "high": {
+                    "title": "未使用のLoRAが多数あります",
+                    "description": "LoRAの{percent}%（{count}/{total}）が一度も使用されていません。",
+                    "suggestion": "未使用のモデルを整理またはアーカイブしてストレージを解放してください。"
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "未使用のCheckpointを検出",
+                    "description": "Checkpointの{percent}%（{count}/{total}）が一度も使用されていません。",
+                    "suggestion": "不要なCheckpointを確認して削除を検討してください。"
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "未使用のEmbeddingが多数あります",
+                    "description": "Embeddingの{percent}%（{count}/{total}）が一度も使用されていません。",
+                    "suggestion": "未使用のEmbeddingを整理またはアーカイブしてコレクションを最適化してください。"
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "大規模コレクションを検出",
+                    "description": "モデルコレクションが{size}のストレージを使用しています。",
+                    "suggestion": "外部ストレージやクラウドソリューションの使用を検討してください。"
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "アクティブユーザー",
+                    "description": "これまでに{count}回の生成を完了しました！",
+                    "suggestion": "モデルを使って素晴らしいコンテンツを作り続けてください。"
+                }
+            }
         },
         "charts": {
             "collectionOverview": "コレクション概要",
             "baseModelDistribution": "ベースモデル分布",
             "usageTrends": "使用傾向（過去30日）",
-            "usageDistribution": "使用分布"
+            "usageDistribution": "使用分布",
+            "date": "日付",
+            "usageCount": "使用回数",
+            "fileSizeBytes": "ファイルサイズ（バイト）",
+            "models": "モデル",
+            "loraUsage": "LoRA 使用量",
+            "checkpointUsage": "Checkpoint 使用量",
+            "embeddingUsage": "Embedding 使用量"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "拡散モデル",
+            "embedding": "Embedding"
+        },
+        "placeholders": {
+            "loading": "読み込み中...",
+            "noModels": "モデルが見つかりません",
+            "errorLoading": "データ読み込みエラー",
+            "noStorageData": "ストレージデータがありません",
+            "rootFolder": "ルート",
+            "chartLibraryMissing": "Chart.js ライブラリが必要です"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} モデル",
+            "chartUsage": "{name}: {size}, {count} 回使用",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "URLからモデルをダウンロード",
             "titleWithType": "URLから{type}をダウンロード",
-            "url": "Civitai URL",
             "civitaiUrl": "Civitai URL：",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "1行に1つのCivitAI、CivArchive、またはHugging Face URLを入力してください。複数のURLを一括ダウンロードできます。",
+            "selectHfFiles": "このリポジトリからダウンロードするファイルを選択してください：",
+            "selectAll": "すべて選択",
+            "fetchingRepoFiles": "リポジトリのファイルを取得中...",
             "locationPreview": "ダウンロード場所プレビュー",
             "useDefaultPath": "デフォルトパスを使用",
             "useDefaultPathTooltip": "有効にすると、設定されたパステンプレートを使用してファイルが自動的に整理されます",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "以前にダウンロード済みですが、現在はライブラリにありません。",
             "alreadyInLibrary": "既にライブラリ内",
             "autoOrganizedPath": "[パステンプレートによる自動整理]",
+            "fileSelection": {
+                "title": "ファイル形式を選択",
+                "files": "ファイル",
+                "select": "ファイルを選択"
+            },
             "errors": {
                 "invalidUrl": "無効なCivitai URL形式",
-                "noVersions": "このモデルの利用可能なバージョンがありません"
+                "noVersions": "このモデルの利用可能なバージョンがありません",
+                "mixedSources": "同じバッチ内でCivitAIとHugging FaceのURLを混在させることはできません。",
+                "noModelFiles": "このリポジトリにモデルファイルが見つかりませんでした。"
             },
             "status": {
                 "preparing": "ダウンロードを準備中...",
@@ -1080,6 +1250,12 @@
             "countMessage": "モデルが完全に削除されます。",
             "action": "すべて削除"
         },
+        "bulkDeleteRecipes": {
+            "title": "複数のレシピを削除",
+            "message": "選択したすべてのレシピと関連ファイルを削除してもよろしいですか？",
+            "countMessage": "レシピが完全に削除されます。",
+            "action": "すべて削除"
+        },
         "checkUpdates": {
             "title": "すべての{type}の更新を確認しますか？",
             "message": "ライブラリ内のすべての{type}で更新を確認します。コレクションが大きい場合は時間がかかることがあります。",
@@ -1160,8 +1336,11 @@
                 "editModelName": "モデル名を編集",
                 "editFileName": "ファイル名を編集",
                 "editBaseModel": "ベースモデルを編集",
+                "editVersionName": "バージョン名を編集",
                 "viewOnCivitai": "Civitaiで表示",
                 "viewOnCivitaiText": "Civitaiで表示",
+                "viewOnHuggingFace": "Hugging Face で見る",
+                "viewOnHuggingFaceText": "Hugging Face で見る",
                 "viewCreatorProfile": "作成者プロフィールを表示",
                 "openFileLocation": "ファイルの場所を開く",
                 "sendToWorkflow": "ComfyUI に送信",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "追加メモ",
                 "notesHint": "Enterで保存、Shift+Enterで改行",
                 "addNotesPlaceholder": "メモをここに追加...",
-                "aboutThisVersion": "このバージョンについて"
+                "aboutThisVersion": "このバージョンについて",
+                "baseModelSearchPlaceholder": "ベースモデルを検索…",
+                "baseModelSuggested": "おすすめ",
+                "baseModelNoMatch": "該当するベースモデルがありません"
             },
             "notes": {
                 "saved": "メモが正常に保存されました",
-                "saveFailed": "メモの保存に失敗しました"
+                "saveFailed": "メモの保存に失敗しました",
+                "showMore": "もっと見る",
+                "showLess": "折りたたむ"
             },
             "usageTips": {
                 "addPresetParameter": "プリセットパラメータを追加...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "バージョンを削除しました"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "メタデータ取得サマリー",
+            "statSuccess": "成功",
+            "statFailed": "失敗",
+            "statSkipped": "スキップ",
+            "statTotal": "スキャン合計",
+            "statDuration": "所要時間",
+            "successMessage": "すべての{count}件の{type}を正常に更新しました",
+            "failedItems": "失敗したアイテム ({count})",
+            "close": "閉じる",
+            "copyReport": "レポートをコピー",
+            "downloadCsv": "CSVをダウンロード",
+            "columnModelName": "モデル名",
+            "columnError": "エラー"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "このタグは既に存在します"
         }
     },
-    "keyboard": {
-        "navigation": "キーボードナビゲーション：",
-        "shortcuts": {
-            "pageUp": "1ページ上にスクロール",
-            "pageDown": "1ページ下にスクロール",
-            "home": "トップにジャンプ",
-            "end": "ボトムにジャンプ"
-        }
-    },
     "initialization": {
         "title": "初期化中",
         "message": "ワークスペースを準備中...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "現在のワークフローには互換性のあるノードがありません",
             "noTargetNodeSelected": "ターゲットノードが選択されていません",
             "modelUpdated": "モデルがワークフローで更新されました",
-            "modelFailed": "モデルノードの更新に失敗しました"
+            "modelFailed": "モデルノードの更新に失敗しました",
+            "embeddingAdded": "Embeddingをワークフローに追加しました",
+            "embeddingFailed": "Embeddingの追加に失敗しました",
+            "promptSent": "プロンプトをワークフローに送信しました",
+            "promptFailed": "プロンプトの送信に失敗しました"
         },
         "nodeSelector": {
             "recipe": "レシピ",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "プロンプト",
             "replace": "置換",
             "append": "追加",
             "selectTargetNode": "ターゲットノードを選択",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "レシピIDが利用できません",
             "sendToWorkflowFailed": "ワークフローへのレシピ送信に失敗しました：{message}",
             "copyFailed": "レシピ構文のコピーエラー：{message}",
+            "createError": "レシピ作成中にエラーが発生しました：{message}",
+            "createFailed": "レシピの作成に失敗しました：{error}",
+            "createMissingData": "レシピ作成に必要なデータが不足しています",
+            "created": "レシピを作成しました",
             "noMissingLoras": "ダウンロードする不足LoRAがありません",
             "missingLorasInfoFailed": "不足LoRAの情報取得に失敗しました",
             "preparingForDownloadFailed": "ダウンロード用LoRAの準備中にエラーが発生しました",
             "enterLoraName": "LoRA名または構文を入力してください",
             "reconnectedSuccessfully": "LoRAが正常に再接続されました",
             "reconnectFailed": "LoRA再接続エラー：{message}",
+            "noPromptToSend": "送信するプロンプトがありません",
             "cannotSend": "レシピを送信できません：レシピIDがありません",
             "sendFailed": "レシピのワークフローへの送信に失敗しました",
             "sendError": "レシピのワークフロー送信エラー",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "レシピが選択されていません",
+            "repairBulkComplete": "修復完了：{repaired} 件修復、{skipped} 件スキップ（合計 {total} 件）",
+            "repairBulkSkipped": "選択した {total} 件のレシピは修復不要です",
+            "repairBulkFailed": "選択したレシピの修復に失敗しました：{message}",
+            "reimporting": "ソースからレシピを再インポート中...",
+            "reimportSuccess": "レシピの再インポートが完了しました",
+            "reimportBulkComplete": "再インポート完了：{completed} 件成功、{failed} 件失敗（合計 {total} 件）",
+            "reimportBulkFailed": "一部のレシピの再インポートに失敗しました",
             "noMissingLorasInSelection": "選択したレシピに不足している LoRA が見つかりませんでした",
             "noLoraRootConfigured": "LoRA ルートディレクトリが設定されていません。設定でデフォルトの LoRA ルートを設定してください。"
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "{successCount} {type}が正常に移動されました",
             "exampleImagesDownloadSuccess": "例画像が正常にダウンロードされました！",
             "exampleImagesDownloadFailed": "例画像のダウンロードに失敗しました：{message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "クリップボードにコピーしました",
+            "downloadStarted": "ダウンロードを開始しました"
+        },
+        "agent": {
+            "llmNotConfigured": "AIプロバイダーが設定されていません。設定 → AIプロバイダーで有効にしてください。",
+            "enrichStarted": "AIでメタデータを補完中...",
+            "enrichComplete": "メタデータの補完が完了しました：{{summary}}",
+            "enrichFailed": "メタデータの補完に失敗しました：{{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "要注意",
             "error": "対応が必要"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API キー"
+            },
+            "cache_health": {
+                "title": "モデルキャッシュの健全性"
+            },
+            "filename_conflicts": {
+                "title": "ファイル名重複競合"
+            },
+            "ui_version": {
+                "title": "UI バージョン"
+            }
+        },
         "actions": {
             "runAgain": "再実行",
-            "exportBundle": "パッケージをエクスポート"
+            "exportBundle": "パッケージをエクスポート",
+            "open-settings": "設定を開く",
+            "open-settings-syntax-format": "フルパス構文に切り替え",
+            "repair-cache": "キャッシュを再構築",
+            "resolve-filename-conflicts": "競合を解決",
+            "reload-page": "UI をリロード"
+        },
+        "labels": {
+            "conflicts": "競合",
+            "version": "バージョン"
         },
         "toast": {
             "loadFailed": "診断の読み込みに失敗しました: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "ファイル名競合の解決に失敗しました: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "ファイル名の競合を解決",
+        "message": "重複したファイル名に4文字のハッシュを追加してリネームします。",
+        "note": "この操作はディスク上のファイルをリネームします。A1111 構文形式を使用している場合、既存のワークフロー内のモデル参照を更新する必要があるかもしれません。",
+        "detail": "例：<code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "<strong>{groups}</strong> 組の重複にわたって <strong>{count}</strong> 個のファイルをリネームします",
+        "confirm": "ファイルをリネーム",
+        "cancel": "キャンセル"
+    },
     "banners": {
         "versionMismatch": {
             "title": "アプリケーション更新が検出されました",

locales/ko.json

@@ -16,10 +16,13 @@
             "help": "도움말",
             "add": "추가",
             "close": "닫기",
-            "menu": "메뉴"
+            "menu": "메뉴",
+            "remove": "제거",
+            "change": "변경"
         },
         "status": {
             "loading": "로딩 중...",
+            "cancelling": "취소 중...",
             "unknown": "알 수 없음",
             "date": "날짜",
             "version": "버전",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "즐겨찾기에서 제거",
             "viewOnCivitai": "Civitai에서 보기",
             "notAvailableFromCivitai": "Civitai에서 사용할 수 없음",
+            "viewOnHuggingFace": "Hugging Face에서 보기",
             "sendToWorkflow": "ComfyUI로 전송 (클릭: 추가, Shift+클릭: 교체)",
             "copyLoRASyntax": "LoRA 문법 복사",
             "checkpointNameCopied": "Checkpoint 이름 복사됨",
@@ -111,6 +115,7 @@
             "replacePreview": "미리보기 교체",
             "copyCheckpointName": "Checkpoint 이름 복사",
             "copyEmbeddingName": "Embedding 이름 복사",
+            "embeddingNameCopied": "Embedding 구문 복사됨",
             "sendCheckpointToWorkflow": "ComfyUI로 전송",
             "sendEmbeddingToWorkflow": "ComfyUI로 전송"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "사용 횟수"
+        },
+        "footer": {
+            "versionCount": "{count}개 버전",
+            "viewAllVersions": "모든 로컬 버전 보기"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "제외된 모델 관리"
+        },
+        "groupByModel": {
+            "label": "모델별 그룹화"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "통계"
         },
         "search": {
-            "placeholder": "검색...",
-            "placeholders": {
-                "loras": "LoRA 검색...",
-                "recipes": "레시피 검색...",
-                "checkpoints": "Checkpoint 검색...",
-                "embeddings": "Embedding 검색..."
-            },
+            "placeholder": "검색",
             "options": "검색 옵션",
             "searchIn": "검색 범위:",
             "notAvailable": "통계 페이지에서는 검색을 사용할 수 없습니다",
@@ -232,7 +238,10 @@
             "license": "라이선스",
             "noCreditRequired": "크레딧 표기 없음",
             "allowSellingGeneratedContent": "판매 허용",
+            "allowSellingGeneratedContentTooltip": "생성된 이미지 판매 허용",
+            "noCreditRequiredTooltip": "크리에이터 저작자 표시 없이 모델 사용 가능",
             "noTags": "태그 없음",
+            "autoTags": "자동 태그",
             "noBaseModelMatches": "현재 검색과 일치하는 베이스 모델이 없습니다.",
             "clearAll": "모든 필터 지우기",
             "any": "아무",
@@ -244,7 +253,18 @@
             "toggle": "테마 토글",
             "switchToLight": "라이트 테마로 전환",
             "switchToDark": "다크 테마로 전환",
-            "switchToAuto": "자동 테마로 전환"
+            "switchToAuto": "자동 테마로 전환",
+            "presets": "테마 프리셋",
+            "default": "기본",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "모드",
+            "light": "라이트",
+            "dark": "다크",
+            "auto": "자동"
         },
         "actions": {
             "checkUpdates": "업데이트 확인",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Civitai API 키",
         "civitaiApiKeyPlaceholder": "Civitai API 키를 입력하세요",
         "civitaiApiKeyHelp": "Civitai에서 모델을 다운로드할 때 인증에 사용됩니다",
+        "civitaiApiKeyConfigured": "설정됨",
+        "civitaiApiKeyNotConfigured": "설정되지 않음",
+        "civitaiApiKeySet": "설정",
         "civitaiHost": {
             "label": "Civitai 호스트",
             "help": "\"View on Civitai\" 링크를 사용할 때 어떤 Civitai 사이트를 열지 선택합니다.",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "다운로드 백엔드",
-            "help": "모델 파일을 다운로드하는 방식을 선택합니다. Python은 내장 다운로더를 사용하고, aria2는 실험적인 외부 다운로더 프로세스를 사용합니다.",
+            "help": "모델 파일을 다운로드하는 방식을 선택합니다. Python은 내장 다운로더를 사용하고, aria2는 권장되는 외부 다운로더 프로세스를 사용합니다.",
             "options": {
                 "python": "Python(내장)",
-                "aria2": "aria2(실험적)"
+                "aria2": "aria2(권장)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "다운로드",
             "videoSettings": "비디오 설정",
             "layoutSettings": "레이아웃 설정",
+            "licenseIcons": "라이선스 아이콘",
             "misc": "기타",
             "backup": "백업",
             "folderSettings": "기본 루트",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "추가 폴다 경로",
             "downloadPathTemplates": "다운로드 경로 템플릿",
             "priorityTags": "우선순위 태그",
-            "updateFlags": "업데이트 표시",
+            "versionScope": "업데이트 표시",
             "exampleImages": "예시 이미지",
             "autoOrganize": "자동 정리",
             "metadata": "메타데이터",
@@ -408,6 +432,8 @@
             "help": "활성화하면 다운로드 기록 서비스가 해당 버전이 이미 다운로드되었음을 기록한 경우 LoRA Manager는 해당 모델 버전 다운로드를 건너뜁니다. 모든 다운로드 플로우에 적용됩니다."
         },
         "layoutSettings": {
+            "groupByModel": "모델별 그룹화",
+            "groupByModelHelp": "활성화하면 각 Civitai 모델의 최신 버전만 단일 카드로 표시되며, 이전 버전은 숨겨집니다.",
             "displayDensity": "표시 밀도",
             "displayDensityOptions": {
                 "default": "기본",
@@ -442,7 +468,9 @@
                 "modelName": "모델명",
                 "fileName": "파일명"
             },
-            "modelNameDisplayHelp": "모델 카드 하단에 표시할 내용을 선택하세요"
+            "modelNameDisplayHelp": "모델 카드 하단에 표시할 내용을 선택하세요",
+            "cardBlurAmount": "카드 오버레이 흐림 강도",
+            "cardBlurAmountHelp": "모델 및 레시피 카드의 헤더와 푸터 오버레이 흐림 강도를 조정합니다 (0 = 흐림 없음, 20 = 최대 흐림)."
         },
         "folderSettings": {
             "activeLibrary": "활성 라이브러리",
@@ -562,7 +590,7 @@
             "download": "다운로드",
             "restartRequired": "재시작 필요"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "업데이트 표시 전략",
             "help": "새 릴리스가 로컬 파일과 동일한 베이스 모델을 공유할 때만 업데이트 배지를 표시할지, 또는 해당 모델에 사용 가능한 새 버전이 있으면 항상 표시할지 결정합니다.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "얼리 액세스 업데이트 숨기기",
             "help": "얼리 액세스 업데이트만"
         },
+        "licenseIcons": {
+            "useNewStyle": "업데이트된 라이선스 아이콘 사용",
+            "useNewStyleHelp": "색상 표시기가 있는 라이선스 권한(새 스타일) 또는 제한 전용 아이콘(클래식 스타일)을 표시합니다. 현재 CivitAI 디자인을 반영합니다."
+        },
         "misc": {
             "includeTriggerWords": "LoRA 문법에 트리거 단어 포함",
-            "includeTriggerWordsHelp": "LoRA 문법을 클립보드에 복사할 때 학습된 트리거 단어를 포함합니다"
+            "includeTriggerWordsHelp": "LoRA 문법을 클립보드에 복사할 때 학습된 트리거 단어를 포함합니다",
+            "loraSyntaxFormat": "LoRA 구문 형식",
+            "loraSyntaxFormatHelp": "LoRA 구문 형식. 전체 경로는 하위 폴더 경로(<lora:style/anime/x:1.0>)를 포함하여 손실 없는 모델 해상도를 제공합니다. 레거시는 파일 이름만(<lora:x:1.0>) 사용 — A1111 규칙이지만, 폴더 간 파일명 중복 시 모호할 수 있습니다.",
+            "loraSyntaxFormatOptions": {
+                "full": "전체 경로(하위 폴더/이름)",
+                "legacy": "레거시 A1111(이름만)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "메타데이터 아카이브 데이터베이스 활성화",
@@ -619,6 +657,23 @@
             "proxyPassword": "비밀번호 (선택사항)",
             "proxyPasswordPlaceholder": "password",
             "proxyPasswordHelp": "프록시 인증에 필요한 비밀번호 (필요한 경우)"
+        },
+        "aiProvider": {
+            "title": "AI 제공자",
+            "provider": "제공자",
+            "providerHelp": "LLM 제공자를 선택하세요. OpenAI와 Ollama는 사전 설정된 API 엔드포인트를 사용합니다. 사용자 정의를 선택하면 모든 OpenAI 호환 엔드포인트를 지정할 수 있습니다.",
+            "custom": "사용자 정의 (OpenAI 호환)",
+            "apiBase": "API 기본 URL",
+            "apiBaseHelp": "LLM API의 기본 URL입니다 (예: https://api.openai.com/v1). 비워두면 제공자 기본값이 사용됩니다.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "API 키",
+            "apiKeyHelp": "LLM 제공자의 API 키입니다. 로컬에 저장되며 선택한 LLM 제공자 외의 서버로 전송되지 않습니다.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "설정되지 않음",
+            "apiKeyConfigured": "설정됨",
+            "apiKeySet": "설정",
+            "model": "모델",
+            "modelHelp": "사용할 모델 이름 (예: deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). 제공자에서 사용 가능한 모델을 확인하세요."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "작은 순서",
                 "usage": "사용 횟수",
                 "usageDesc": "많은 순",
-                "usageAsc": "적은 순"
+                "usageAsc": "적은 순",
+                "versionsCount": "로컬 버전 수",
+                "versionsCountDesc": "버전 수 많은 순",
+                "versionsCountAsc": "버전 수 적은 순",
+                "versionIdDesc": "최신 버전순"
             },
             "refresh": {
                 "title": "모델 목록 새로고침",
-                "quick": "변경 사항 동기화",
-                "quickTooltip": "새로운 모델 파일이나 누락된 파일을 찾아 목록을 최신 상태로 유지합니다.",
                 "full": "캐시 재구성",
                 "fullTooltip": "메타데이터 파일에서 모든 모델 정보를 다시 불러옵니다. 라이브러리가 오래되어 보이거나 수동 수정 후에 사용하세요."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "모든 모델에 콘텐츠 등급 설정",
             "copyAll": "모든 문법 복사",
             "refreshAll": "모든 메타데이터 새로고침",
+            "repairMetadata": "선택한 레시피 메타데이터 복구",
+            "reimportMetadata": "소스에서 다시 가져오기",
             "checkUpdates": "선택 항목 업데이트 확인",
             "moveAll": "모두 폴더로 이동",
             "autoOrganize": "자동 정리 선택",
@@ -692,9 +751,18 @@
             "unfavorite": "즐겨찾기 해제",
             "deleteAll": "선택된 항목 삭제",
             "downloadMissingLoras": "누락된 LoRA 다운로드",
+            "downloadExamples": "예시 이미지 다운로드",
             "clear": "선택 지우기",
             "skipMetadataRefreshCount": "건너뛰기（{count}개 모델）",
             "resumeMetadataRefreshCount": "재개（{count}개 모델）",
+            "sendToWorkflow": "워크플로우로 보내기",
+            "sections": {
+                "workflow": "워크플로우",
+                "metadata": "메타데이터",
+                "attributes": "속성",
+                "organize": "정리",
+                "download": "다운로드"
+            },
             "autoOrganizeProgress": {
                 "initializing": "자동 정리 초기화 중...",
                 "starting": "{type}에 대한 자동 정리 시작...",
@@ -703,7 +771,8 @@
                 "completed": "완료: {success}개 이동, {skipped}개 건너뜀, {failures}개 실패",
                 "complete": "자동 정리 완료",
                 "error": "오류: {error}"
-            }
+            },
+            "enrichHfAgent": "AI로 메타데이터 보강"
         },
         "contextMenu": {
             "refreshMetadata": "Civitai 데이터 새로고침",
@@ -720,13 +789,15 @@
             "setContentRating": "콘텐츠 등급 설정",
             "moveToFolder": "폴더로 이동",
             "repairMetadata": "메타데이터 복구",
+            "reimportMetadata": "소스에서 다시 가져오기",
             "excludeModel": "모델 제외",
             "restoreModel": "모델 복원",
             "deleteModel": "모델 삭제",
             "shareRecipe": "레시피 공유",
             "viewAllLoras": "모든 LoRA 보기",
             "downloadMissingLoras": "누락된 LoRA 다운로드",
-            "deleteRecipe": "레시피 삭제"
+            "deleteRecipe": "레시피 삭제",
+            "enrichHfAgent": "AI로 메타데이터 보강"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "레시피 목록 새로고침",
-                "quick": "변경 사항 동기화",
-                "quickTooltip": "변경 사항 동기화 - 캐시를 재구성하지 않고 빠른 새로고침",
                 "full": "캐시 재구성",
                 "fullTooltip": "캐시 재구성 - 모든 레시피 파일을 완전히 다시 스캔"
             },
@@ -849,6 +918,13 @@
                 "skipped": "레시피가 이미 최신 버전입니다. 복구가 필요하지 않습니다",
                 "failed": "레시피 복구 실패: {message}",
                 "missingId": "레시피를 복구할 수 없음: 레시피 ID 누락"
+            },
+            "reimport": {
+                "starting": "소스에서 레시피를 다시 가져오는 중...",
+                "success": "레시피를 다시 가져왔습니다",
+                "noSourceUrl": "레시피에 소스 URL이 없어 다시 가져올 수 없습니다",
+                "failed": "레시피 다시 가져오기 실패: {message}",
+                "missingId": "레시피를 다시 가져올 수 없음: 레시피 ID 누락"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "루트",
         "collapseAll": "모든 폴더 접기",
-        "pinSidebar": "사이드바 고정",
-        "unpinSidebar": "사이드바 고정 해제",
+        "hideOnThisPage": "이 페이지에서 사이드바 숨기기",
+        "showSidebar": "사이드바 표시",
+        "sidebarHiddenNotification": "{page} 페이지에서 사이드바가 숨겨져 있습니다",
         "switchToListView": "목록 보기로 전환",
         "switchToTreeView": "트리 보기로 전환",
         "recursiveOn": "하위 폴더 포함",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "폴더를 찾을 수 없습니다",
             "dragHint": "항목을 여기로 드래그하여 폴더를 만듭니다"
+        },
+        "folderUpdateCheck": {
+            "label": "이 폴더의 업데이트 확인",
+            "loading": "이 폴더의 {type} 업데이트를 확인하는 중...",
+            "success": "이 폴더에서 {type}s에 대한 {count}개 업데이트를 찾았습니다",
+            "none": "이 폴더의 모든 {type}s가 최신 상태입니다",
+            "error": "폴더의 {type} 업데이트 확인 실패: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "저장소",
             "insights": "인사이트"
         },
+        "metrics": {
+            "totalModels": "모델 총계",
+            "totalStorage": "총 저장 공간",
+            "totalGenerations": "총 생성 횟수",
+            "usageRate": "사용률",
+            "loras": "LoRA",
+            "checkpoints": "Checkpoint",
+            "embeddings": "Embedding",
+            "uniqueTags": "고유 태그",
+            "unusedModels": "미사용 모델",
+            "avgUsesPerModel": "모델당 평균 사용"
+        },
         "usage": {
             "mostUsedLoras": "가장 많이 사용된 LoRA",
             "mostUsedCheckpoints": "가장 많이 사용된 Checkpoint",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "스마트 인사이트",
-            "recommendations": "추천"
+            "recommendations": "추천",
+            "noInsights": "인사이트 없음",
+            "unusedLoras": {
+                "high": {
+                    "title": "사용하지 않은 LoRA가 많음",
+                    "description": "LoRA의 {percent}%({count}/{total})가 한 번도 사용되지 않았습니다.",
+                    "suggestion": "사용하지 않는 모델을 정리하거나 보관하여 저장 공간을 확보하세요."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "사용하지 않은 Checkpoint 감지",
+                    "description": "Checkpoint의 {percent}%({count}/{total})가 한 번도 사용되지 않았습니다.",
+                    "suggestion": "더 이상 필요하지 않은 Checkpoint를 검토하고 제거하세요."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "사용하지 않은 Embedding이 많음",
+                    "description": "Embedding의 {percent}%({count}/{total})가 한 번도 사용되지 않았습니다.",
+                    "suggestion": "사용하지 않는 Embedding을 정리하여 컬렉션을 최적화하세요."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "대규모 컬렉션 감지",
+                    "description": "모델 컬렉션이 {size}의 저장 공간을 사용 중입니다.",
+                    "suggestion": "더 나은 관리를 위해 외부 저장소나 클라우드 솔루션을 고려하세요."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "활성 사용자",
+                    "description": "지금까지 {count}번의 생성을 완료했습니다!",
+                    "suggestion": "모델로 계속해서 멋진 콘텐츠를 탐색하고 만들어보세요."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "컬렉션 개요",
             "baseModelDistribution": "베이스 모델 분포",
             "usageTrends": "사용량 트렌드 (최근 30일)",
-            "usageDistribution": "사용량 분포"
+            "usageDistribution": "사용량 분포",
+            "date": "날짜",
+            "usageCount": "사용 횟수",
+            "fileSizeBytes": "파일 크기(바이트)",
+            "models": "모델",
+            "loraUsage": "LoRA 사용량",
+            "checkpointUsage": "Checkpoint 사용량",
+            "embeddingUsage": "Embedding 사용량"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "확산 모델",
+            "embedding": "Embedding"
+        },
+        "placeholders": {
+            "loading": "로딩 중...",
+            "noModels": "모델을 찾을 수 없음",
+            "errorLoading": "데이터 로딩 오류",
+            "noStorageData": "저장 데이터 없음",
+            "rootFolder": "루트",
+            "chartLibraryMissing": "Chart.js 라이브러리가 필요합니다"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count}개 모델",
+            "chartUsage": "{name}: {size}, {count}회 사용",
+            "chartPercentage": "{label}: {value}({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "URL에서 모델 다운로드",
             "titleWithType": "URL에서 {type} 다운로드",
-            "url": "Civitai URL",
             "civitaiUrl": "Civitai URL:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "한 줄에 하나의 CivitAI, CivArchive 또는 Hugging Face URL을 입력하세요. 여러 URL을 일괄 다운로드할 수 있습니다.",
+            "selectHfFiles": "이 저장소에서 다운로드할 파일을 선택하세요：",
+            "selectAll": "모두 선택",
+            "fetchingRepoFiles": "저장소 파일을 가져오는 중...",
             "locationPreview": "다운로드 위치 미리보기",
             "useDefaultPath": "기본 경로 사용",
             "useDefaultPathTooltip": "활성화하면 구성된 경로 템플릿을 사용하여 파일이 자동으로 정리됩니다",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "이전에 다운로드했지만 현재 라이브러리에 없습니다.",
             "alreadyInLibrary": "이미 라이브러리에 있음",
             "autoOrganizedPath": "[경로 템플릿으로 자동 정리됨]",
+            "fileSelection": {
+                "title": "파일 형식 선택",
+                "files": "개 파일",
+                "select": "파일 선택"
+            },
             "errors": {
                 "invalidUrl": "잘못된 Civitai URL 형식",
-                "noVersions": "이 모델에 사용 가능한 버전이 없습니다"
+                "noVersions": "이 모델에 사용 가능한 버전이 없습니다",
+                "mixedSources": "동일한 배치에서 CivitAI와 Hugging Face URL을 혼합할 수 없습니다.",
+                "noModelFiles": "이 저장소에서 모델 파일을 찾을 수 없습니다."
             },
             "status": {
                 "preparing": "다운로드 준비 중...",
@@ -1080,6 +1250,12 @@
             "countMessage": "개의 모델이 영구적으로 삭제됩니다.",
             "action": "모두 삭제"
         },
+        "bulkDeleteRecipes": {
+            "title": "여러 레시피 삭제",
+            "message": "선택된 모든 레시피와 관련 파일을 삭제하시겠습니까?",
+            "countMessage": "개의 레시피가 영구적으로 삭제됩니다.",
+            "action": "모두 삭제"
+        },
         "checkUpdates": {
             "title": "{type} 전체 업데이트를 확인할까요?",
             "message": "라이브러리에 있는 모든 {type}의 업데이트를 확인합니다. 컬렉션이 클수록 시간이 조금 더 걸릴 수 있습니다.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "모델명 편집",
                 "editFileName": "파일명 편집",
                 "editBaseModel": "베이스 모델 편집",
+                "editVersionName": "버전명 편집",
                 "viewOnCivitai": "Civitai에서 보기",
                 "viewOnCivitaiText": "Civitai에서 보기",
+                "viewOnHuggingFace": "Hugging Face에서 보기",
+                "viewOnHuggingFaceText": "Hugging Face에서 보기",
                 "viewCreatorProfile": "제작자 프로필 보기",
                 "openFileLocation": "파일 위치 열기",
                 "sendToWorkflow": "ComfyUI로 보내기",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "추가 메모",
                 "notesHint": "Enter로 저장, Shift+Enter로 줄바꿈",
                 "addNotesPlaceholder": "메모를 여기에 추가하세요...",
-                "aboutThisVersion": "이 버전에 대해"
+                "aboutThisVersion": "이 버전에 대해",
+                "baseModelSearchPlaceholder": "베이스 모델 검색…",
+                "baseModelSuggested": "추천",
+                "baseModelNoMatch": "일치하는 베이스 모델 없음"
             },
             "notes": {
                 "saved": "메모가 성공적으로 저장됨",
-                "saveFailed": "메모 저장 실패"
+                "saveFailed": "메모 저장 실패",
+                "showMore": "더 보기",
+                "showLess": "접기"
             },
             "usageTips": {
                 "addPresetParameter": "프리셋 매개변수 추가...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "버전이 삭제되었습니다"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "메타데이터 가져오기 요약",
+            "statSuccess": "성공",
+            "statFailed": "실패",
+            "statSkipped": "건너뜀",
+            "statTotal": "총 스캔",
+            "statDuration": "소요 시간",
+            "successMessage": "모든 {count}개 {type}이(가) 성공적으로 업데이트되었습니다",
+            "failedItems": "실패한 항목 ({count})",
+            "close": "닫기",
+            "copyReport": "보고서 복사",
+            "downloadCsv": "CSV 다운로드",
+            "columnModelName": "모델 이름",
+            "columnError": "오류"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "이 태그는 이미 존재합니다"
         }
     },
-    "keyboard": {
-        "navigation": "키보드 내비게이션:",
-        "shortcuts": {
-            "pageUp": "한 페이지 위로 스크롤",
-            "pageDown": "한 페이지 아래로 스크롤",
-            "home": "맨 위로 이동",
-            "end": "맨 아래로 이동"
-        }
-    },
     "initialization": {
         "title": "초기화 중",
         "message": "작업공간을 준비하고 있습니다...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "현재 워크플로에서 호환되는 노드가 없습니다",
             "noTargetNodeSelected": "대상 노드가 선택되지 않았습니다",
             "modelUpdated": "모델이 워크플로에서 업데이트되었습니다",
-            "modelFailed": "모델 노드 업데이트 실패"
+            "modelFailed": "모델 노드 업데이트 실패",
+            "embeddingAdded": "Embedding을 워크플로에 추가했습니다",
+            "embeddingFailed": "Embedding 추가 실패",
+            "promptSent": "프롬프트를 워크플로에 보냈습니다",
+            "promptFailed": "프롬프트 보내기 실패"
         },
         "nodeSelector": {
             "recipe": "레시피",
             "lora": "LoRA",
+            "embedding": "임베딩",
+            "prompt": "프롬프트",
             "replace": "교체",
             "append": "추가",
             "selectTargetNode": "대상 노드 선택",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "사용 가능한 레시피 ID가 없습니다",
             "sendToWorkflowFailed": "워크플로우에 레시피 보내기 실패: {message}",
             "copyFailed": "레시피 문법 복사 오류: {message}",
+            "createError": "레시피 생성 중 오류 발생：{message}",
+            "createFailed": "레시피 생성 실패：{error}",
+            "createMissingData": "레시피 생성에 필요한 데이터가 없습니다",
+            "created": "레시피가 생성되었습니다",
             "noMissingLoras": "다운로드할 누락된 LoRA가 없습니다",
             "missingLorasInfoFailed": "누락된 LoRA 정보를 가져오는데 실패했습니다",
             "preparingForDownloadFailed": "LoRA 다운로드 준비 오류",
             "enterLoraName": "LoRA 이름 또는 문법을 입력해주세요",
             "reconnectedSuccessfully": "LoRA가 성공적으로 다시 연결되었습니다",
             "reconnectFailed": "LoRA 다시 연결 오류: {message}",
+            "noPromptToSend": "보낼 프롬프트가 없습니다",
             "cannotSend": "레시피를 전송할 수 없습니다: 레시피 ID 누락",
             "sendFailed": "레시피를 워크플로로 전송하는데 실패했습니다",
             "sendError": "레시피를 워크플로로 전송하는 중 오류",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "선택한 레시피가 없습니다",
+            "repairBulkComplete": "복구 완료: {repaired}개 복구, {skipped}개 건너뜀 (총 {total}개)",
+            "repairBulkSkipped": "선택한 {total}개 레시피는 복구가 필요하지 않습니다",
+            "repairBulkFailed": "선택한 레시피 복구 실패: {message}",
+            "reimporting": "소스에서 레시피를 다시 가져오는 중...",
+            "reimportSuccess": "레시피를 다시 가져왔습니다",
+            "reimportBulkComplete": "다시 가져오기 완료: {completed}개 성공, {failed}개 실패 (총 {total}개)",
+            "reimportBulkFailed": "일부 레시피를 다시 가져오지 못했습니다",
             "noMissingLorasInSelection": "선택한 레시피에서 누락된 LoRA를 찾을 수 없습니다",
             "noLoraRootConfigured": "LoRA 루트 디렉토리가 구성되지 않았습니다. 설정에서 기본 LoRA 루트를 설정하세요."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "{successCount}개 {type}이(가) 성공적으로 이동되었습니다",
             "exampleImagesDownloadSuccess": "예시 이미지가 성공적으로 다운로드되었습니다!",
             "exampleImagesDownloadFailed": "예시 이미지 다운로드 실패: {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "클립보드에 복사됨",
+            "downloadStarted": "다운로드 시작됨"
+        },
+        "agent": {
+            "llmNotConfigured": "AI 제공자가 설정되지 않았습니다. 설정 → AI 제공자에서 활성화하세요.",
+            "enrichStarted": "AI로 메타데이터 보강 중...",
+            "enrichComplete": "메타데이터 보강 완료: {{summary}}",
+            "enrichFailed": "메타데이터 보강 실패: {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "주의 필요",
             "error": "조치 필요"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API 키"
+            },
+            "cache_health": {
+                "title": "모델 캐시 상태"
+            },
+            "filename_conflicts": {
+                "title": "파일명 중복 충돌"
+            },
+            "ui_version": {
+                "title": "UI 버전"
+            }
+        },
         "actions": {
             "runAgain": "다시 실행",
-            "exportBundle": "번들 내보내기"
+            "exportBundle": "번들 내보내기",
+            "open-settings": "설정 열기",
+            "open-settings-syntax-format": "전체 경로 구문으로 전환",
+            "repair-cache": "캐시 재구축",
+            "resolve-filename-conflicts": "충돌 해결",
+            "reload-page": "UI 새로고침"
+        },
+        "labels": {
+            "conflicts": "충돌",
+            "version": "버전"
         },
         "toast": {
             "loadFailed": "진단 로드 실패: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "파일명 충돌 해결 실패: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "파일명 충돌 해결",
+        "message": "중복 파일명에 4자리 해시를 추가하여 이름을 변경합니다.",
+        "note": "이 작업은 디스크에 있는 파일의 이름을 변경합니다. A1111 구문 형식을 사용하는 경우 기존 워크플로우의 모델 참조를 업데이트해야 할 수 있습니다.",
+        "detail": "예시: <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "<strong>{groups}</strong>개 중복 그룹에서 <strong>{count}</strong>개 파일 이름을 변경합니다",
+        "confirm": "파일 이름 변경",
+        "cancel": "취소"
+    },
     "banners": {
         "versionMismatch": {
             "title": "애플리케이션 업데이트 감지",

locales/ru.json

@@ -16,10 +16,13 @@
             "help": "Справка",
             "add": "Добавить",
             "close": "Закрыть",
-            "menu": "Меню"
+            "menu": "Меню",
+            "remove": "Удалить",
+            "change": "Изменить"
         },
         "status": {
             "loading": "Загрузка...",
+            "cancelling": "Отмена...",
             "unknown": "Неизвестно",
             "date": "Дата",
             "version": "Версия",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "Удалить из избранного",
             "viewOnCivitai": "Посмотреть на Civitai",
             "notAvailableFromCivitai": "Недоступно на Civitai",
+            "viewOnHuggingFace": "Открыть Hugging Face",
             "sendToWorkflow": "Отправить в ComfyUI (Клик: Добавить, Shift+Клик: Заменить)",
             "copyLoRASyntax": "Копировать синтаксис LoRA",
             "checkpointNameCopied": "Имя checkpoint скопировано",
@@ -111,6 +115,7 @@
             "replacePreview": "Заменить превью",
             "copyCheckpointName": "Копировать имя checkpoint",
             "copyEmbeddingName": "Копировать имя embedding",
+            "embeddingNameCopied": "Синтаксис embedding скопирован",
             "sendCheckpointToWorkflow": "Отправить в ComfyUI",
             "sendEmbeddingToWorkflow": "Отправить в ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "Количество использований"
+        },
+        "footer": {
+            "versionCount": "{count} версий",
+            "viewAllVersions": "Показать все локальные версии"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "Управление исключёнными моделями"
+        },
+        "groupByModel": {
+            "label": "Группировать по модели"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "Статистика"
         },
         "search": {
-            "placeholder": "Поиск...",
-            "placeholders": {
-                "loras": "Поиск LoRAs...",
-                "recipes": "Поиск рецептов...",
-                "checkpoints": "Поиск checkpoints...",
-                "embeddings": "Поиск embeddings..."
-            },
+            "placeholder": "Поиск",
             "options": "Опции поиска",
             "searchIn": "Искать в:",
             "notAvailable": "Поиск недоступен на странице статистики",
@@ -232,7 +238,10 @@
             "license": "Лицензия",
             "noCreditRequired": "Без указания авторства",
             "allowSellingGeneratedContent": "Продажа разрешена",
+            "allowSellingGeneratedContentTooltip": "Разрешить продажу сгенерированных изображений",
+            "noCreditRequiredTooltip": "Использование модели без указания автора",
             "noTags": "Без тегов",
+            "autoTags": "Авто-теги",
             "noBaseModelMatches": "Нет базовых моделей, соответствующих текущему поиску.",
             "clearAll": "Очистить все фильтры",
             "any": "Любой",
@@ -244,7 +253,18 @@
             "toggle": "Переключить тему",
             "switchToLight": "Переключить на светлую тему",
             "switchToDark": "Переключить на тёмную тему",
-            "switchToAuto": "Переключить на автоматическую тему"
+            "switchToAuto": "Переключить на автоматическую тему",
+            "presets": "Предустановки тем",
+            "default": "По умолчанию",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "Режим",
+            "light": "Светлый",
+            "dark": "Тёмный",
+            "auto": "Авто"
         },
         "actions": {
             "checkUpdates": "Проверить обновления",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Ключ API Civitai",
         "civitaiApiKeyPlaceholder": "Введите ваш ключ API Civitai",
         "civitaiApiKeyHelp": "Используется для аутентификации при загрузке моделей с Civitai",
+        "civitaiApiKeyConfigured": "Настроен",
+        "civitaiApiKeyNotConfigured": "Не настроен",
+        "civitaiApiKeySet": "Настроить",
         "civitaiHost": {
             "label": "Хост Civitai",
             "help": "Выберите, какой сайт Civitai будет открываться при использовании ссылок «View on Civitai».",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "Бэкенд загрузки",
-            "help": "Выберите способ загрузки файлов моделей. Python использует встроенный загрузчик. aria2 использует экспериментальный внешний процесс загрузки.",
+            "help": "Выберите способ загрузки файлов моделей. Python использует встроенный загрузчик. aria2 использует рекомендуемый внешний процесс загрузки.",
             "options": {
                 "python": "Python (встроенный)",
-                "aria2": "aria2 (экспериментальный)"
+                "aria2": "aria2 (рекомендуемый)"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "Загрузки",
             "videoSettings": "Настройки видео",
             "layoutSettings": "Настройки макета",
+            "licenseIcons": "Значки лицензии",
             "misc": "Разное",
             "backup": "Резервные копии",
             "folderSettings": "Корневые папки",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "Дополнительные пути к папкам",
             "downloadPathTemplates": "Шаблоны путей загрузки",
             "priorityTags": "Приоритетные теги",
-            "updateFlags": "Метки обновлений",
+            "versionScope": "Метки обновлений",
             "exampleImages": "Примеры изображений",
             "autoOrganize": "Автоорганизация",
             "metadata": "Метаданные",
@@ -408,6 +432,8 @@
             "help": "Если включено, LoRA Manager будет пропускать загрузку версии модели, если сервис истории загрузок записал, что эта конкретная версия уже загружена. Применяется ко всем потокам загрузки."
         },
         "layoutSettings": {
+            "groupByModel": "Группировать по модели",
+            "groupByModelHelp": "При включении отображается только последняя версия каждой модели Civitai в виде одной карточки. Старые версии скрыты.",
             "displayDensity": "Плотность отображения",
             "displayDensityOptions": {
                 "default": "По умолчанию",
@@ -442,7 +468,9 @@
                 "modelName": "Название модели",
                 "fileName": "Имя файла"
             },
-            "modelNameDisplayHelp": "Выберите, что отображать в нижней части карточки модели"
+            "modelNameDisplayHelp": "Выберите, что отображать в нижней части карточки модели",
+            "cardBlurAmount": "Размытие наложения карточек",
+            "cardBlurAmountHelp": "Настройте интенсивность размытия наложений верхнего и нижнего колонтитулов на карточках моделей и рецептов (0 = без размытия, 20 = максимальное размытие)."
         },
         "folderSettings": {
             "activeLibrary": "Активная библиотека",
@@ -562,7 +590,7 @@
             "download": "Загрузить",
             "restartRequired": "Требует перезапуска"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "Стратегия меток обновлений",
             "help": "Выберите, отображать ли значки обновления только когда новая версия имеет тот же базовый модель, что и локальные файлы, или всегда при наличии любого нового релиза для этой модели.",
             "options": {
@@ -574,9 +602,19 @@
             "label": "Скрыть обновления раннего доступа",
             "help": "Только обновления раннего доступа"
         },
+        "licenseIcons": {
+            "useNewStyle": "Использовать обновлённые значки лицензии",
+            "useNewStyleHelp": "Отображать разрешения лицензии с цветными индикаторами (новый стиль) или только значки ограничений (классический стиль). Соответствует текущему дизайну CivitAI."
+        },
         "misc": {
             "includeTriggerWords": "Включать триггерные слова в синтаксис LoRA",
-            "includeTriggerWordsHelp": "Включать обученные триггерные слова при копировании синтаксиса LoRA в буфер обмена"
+            "includeTriggerWordsHelp": "Включать обученные триггерные слова при копировании синтаксиса LoRA в буфер обмена",
+            "loraSyntaxFormat": "Формат синтаксиса LoRA",
+            "loraSyntaxFormatHelp": "Формат синтаксиса LoRA. Полный путь включает подпапку (<lora:style/anime/x:1.0>) для безпотерьного разрешения модели. Устаревший использует только имя файла (<lora:x:1.0>) — соглашение A1111, может быть неоднозначным при дублировании имён файлов в разных папках.",
+            "loraSyntaxFormatOptions": {
+                "full": "Полный путь (подпапка/имя)",
+                "legacy": "Устаревший A1111 (только имя)"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "Включить архив метаданных",
@@ -619,6 +657,23 @@
             "proxyPassword": "Пароль (необязательно)",
             "proxyPasswordPlaceholder": "пароль",
             "proxyPasswordHelp": "Пароль для аутентификации на прокси (если требуется)"
+        },
+        "aiProvider": {
+            "title": "Поставщик ИИ",
+            "provider": "Поставщик",
+            "providerHelp": "Выберите поставщика LLM. OpenAI и Ollama используют предустановленные API-эндпоинты. Пользовательский позволяет указать любой совместимый с OpenAI эндпоинт.",
+            "custom": "Пользовательский (совместимый с OpenAI)",
+            "apiBase": "Базовый URL API",
+            "apiBaseHelp": "Базовый URL для LLM API (например, https://api.openai.com/v1). Оставьте пустым, чтобы использовать значение по умолчанию.",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "API-ключ",
+            "apiKeyHelp": "Ваш API-ключ поставщика LLM. Хранится локально и никогда не отправляется на другие серверы, кроме выбранного поставщика LLM.",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "Не задан",
+            "apiKeyConfigured": "Настроен",
+            "apiKeySet": "Настроить",
+            "model": "Модель",
+            "modelHelp": "Имя модели для использования (например, deepseek-v4-flash, gemini-2.5-flash, gemma4:12b). Проверьте доступные модели у вашего поставщика."
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "Наименьшим",
                 "usage": "Число использований",
                 "usageDesc": "Больше",
-                "usageAsc": "Меньше"
+                "usageAsc": "Меньше",
+                "versionsCount": "Локальные версии",
+                "versionsCountDesc": "Сначала больше версий",
+                "versionsCountAsc": "Сначала меньше версий",
+                "versionIdDesc": "Сначала новые версии"
             },
             "refresh": {
                 "title": "Обновить список моделей",
-                "quick": "Синхронизировать изменения",
-                "quickTooltip": "Находит новые или отсутствующие файлы моделей, чтобы список оставался актуальным.",
                 "full": "Перестроить кэш",
                 "fullTooltip": "Перечитывает все данные моделей из файлов метаданных — используйте, если библиотека выглядит устаревшей или после ручных правок."
             },
@@ -682,6 +739,8 @@
             "setContentRating": "Установить рейтинг контента для всех",
             "copyAll": "Копировать весь синтаксис",
             "refreshAll": "Обновить все метаданные",
+            "repairMetadata": "Восстановить метаданные для выбранных",
+            "reimportMetadata": "Переимпортировать из источника",
             "checkUpdates": "Проверить обновления для выбранных",
             "moveAll": "Переместить все в папку",
             "autoOrganize": "Автоматически организовать выбранные",
@@ -692,9 +751,18 @@
             "unfavorite": "Удалить из избранного",
             "deleteAll": "Удалить выбранные",
             "downloadMissingLoras": "Скачать отсутствующие LoRAs",
+            "downloadExamples": "Загрузить примеры изображений",
             "clear": "Очистить выбор",
             "skipMetadataRefreshCount": "Пропустить（{count} моделей）",
             "resumeMetadataRefreshCount": "Возобновить（{count} моделей）",
+            "sendToWorkflow": "Отправить в Workflow",
+            "sections": {
+                "workflow": "Workflow",
+                "metadata": "Метаданные",
+                "attributes": "Атрибуты",
+                "organize": "Организовать",
+                "download": "Скачать"
+            },
             "autoOrganizeProgress": {
                 "initializing": "Инициализация автоматической организации...",
                 "starting": "Запуск автоматической организации для {type}...",
@@ -703,7 +771,8 @@
                 "completed": "Завершено: {success} перемещено, {skipped} пропущено, {failures} не удалось",
                 "complete": "Автоматическая организация завершена",
                 "error": "Ошибка: {error}"
-            }
+            },
+            "enrichHfAgent": "Обогатить метаданные (ИИ)"
         },
         "contextMenu": {
             "refreshMetadata": "Обновить данные Civitai",
@@ -720,13 +789,15 @@
             "setContentRating": "Установить рейтинг контента",
             "moveToFolder": "Переместить в папку",
             "repairMetadata": "Восстановить метаданные",
+            "reimportMetadata": "Переимпортировать из источника",
             "excludeModel": "Исключить модель",
             "restoreModel": "Восстановить модель",
             "deleteModel": "Удалить модель",
             "shareRecipe": "Поделиться рецептом",
             "viewAllLoras": "Посмотреть все LoRAs",
             "downloadMissingLoras": "Загрузить отсутствующие LoRAs",
-            "deleteRecipe": "Удалить рецепт"
+            "deleteRecipe": "Удалить рецепт",
+            "enrichHfAgent": "Обогатить метаданные (ИИ)"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "Обновить список рецептов",
-                "quick": "Синхронизировать изменения",
-                "quickTooltip": "Синхронизировать изменения - быстрое обновление без перестроения кэша",
                 "full": "Перестроить кэш",
                 "fullTooltip": "Перестроить кэш - полное повторное сканирование всех файлов рецептов"
             },
@@ -849,6 +918,13 @@
                 "skipped": "Рецепт уже последней версии, восстановление не требуется",
                 "failed": "Не удалось восстановить рецепт: {message}",
                 "missingId": "Не удалось восстановить рецепт: отсутствует ID рецепта"
+            },
+            "reimport": {
+                "starting": "Переимпорт рецепта из источника...",
+                "success": "Рецепт успешно переимпортирован",
+                "noSourceUrl": "У рецепта нет URL источника, переимпорт невозможен",
+                "failed": "Не удалось переимпортировать рецепт: {message}",
+                "missingId": "Невозможно переимпортировать рецепт: отсутствует ID"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "Корень",
         "collapseAll": "Свернуть все папки",
-        "pinSidebar": "Закрепить боковую панель",
-        "unpinSidebar": "Открепить боковую панель",
+        "hideOnThisPage": "Скрыть боковую панель на этой странице",
+        "showSidebar": "Показать боковую панель",
+        "sidebarHiddenNotification": "Боковая панель скрыта на странице {page}",
         "switchToListView": "Переключить на вид списка",
         "switchToTreeView": "Переключить на древовидный вид",
         "recursiveOn": "Включать вложенные папки",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "Папки не найдены",
             "dragHint": "Перетащите элементы сюда, чтобы создать папки"
+        },
+        "folderUpdateCheck": {
+            "label": "Проверить обновления в этой папке",
+            "loading": "Проверка обновлений {type} в этой папке...",
+            "success": "Найдено {count} обновление(й) для {type}s в этой папке",
+            "none": "Все {type}s в этой папке актуальны",
+            "error": "Не удалось проверить папку на наличие обновлений {type}: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "Хранение",
             "insights": "Аналитика"
         },
+        "metrics": {
+            "totalModels": "Всего моделей",
+            "totalStorage": "Всего хранилища",
+            "totalGenerations": "Всего генераций",
+            "usageRate": "Коэффициент использования",
+            "loras": "LoRA",
+            "checkpoints": "Контрольные точки",
+            "embeddings": "Эмбеддинги",
+            "uniqueTags": "Уникальные теги",
+            "unusedModels": "Неиспользуемые модели",
+            "avgUsesPerModel": "Сред. использований/модель"
+        },
         "usage": {
             "mostUsedLoras": "Наиболее используемые LoRAs",
             "mostUsedCheckpoints": "Наиболее используемые Checkpoints",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "Умная аналитика",
-            "recommendations": "Рекомендации"
+            "recommendations": "Рекомендации",
+            "noInsights": "Нет доступных данных",
+            "unusedLoras": {
+                "high": {
+                    "title": "Большое количество неиспользуемых LoRA",
+                    "description": "{percent}% ваших LoRA ({count}/{total}) никогда не использовались.",
+                    "suggestion": "Рассмотрите возможность организации или архивирования неиспользуемых моделей для освобождения места."
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "Обнаружены неиспользуемые контрольные точки",
+                    "description": "{percent}% ваших контрольных точек ({count}/{total}) никогда не использовались.",
+                    "suggestion": "Проверьте и удалите ненужные контрольные точки."
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "Большое количество неиспользуемых эмбеддингов",
+                    "description": "{percent}% ваших эмбеддингов ({count}/{total}) никогда не использовались.",
+                    "suggestion": "Организуйте или архивируйте неиспользуемые эмбеддинги для оптимизации коллекции."
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "Обнаружена большая коллекция",
+                    "description": "Ваша коллекция моделей использует {size} хранилища.",
+                    "suggestion": "Рассмотрите внешнее хранилище или облачные решения для лучшей организации."
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "Активный пользователь",
+                    "description": "Вы завершили {count} генераций!",
+                    "suggestion": "Продолжайте исследовать и создавать удивительный контент с вашими моделями."
+                }
+            }
         },
         "charts": {
             "collectionOverview": "Обзор коллекции",
             "baseModelDistribution": "Распределение базовых моделей",
             "usageTrends": "Тенденции использования (за последние 30 дней)",
-            "usageDistribution": "Распределение использования"
+            "usageDistribution": "Распределение использования",
+            "date": "Дата",
+            "usageCount": "Количество использований",
+            "fileSizeBytes": "Размер файла (байты)",
+            "models": "Модели",
+            "loraUsage": "Использование LoRA",
+            "checkpointUsage": "Использование Checkpoint",
+            "embeddingUsage": "Использование Embedding"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Контрольная точка",
+            "diffusion_model": "Диффузионная модель",
+            "embedding": "Эмбеддинги"
+        },
+        "placeholders": {
+            "loading": "Загрузка...",
+            "noModels": "Модели не найдены",
+            "errorLoading": "Ошибка загрузки данных",
+            "noStorageData": "Нет данных о хранилище",
+            "rootFolder": "Корень",
+            "chartLibraryMissing": "Для графика требуется библиотека Chart.js"
+        },
+        "tooltips": {
+            "tagCount": "{tag}: {count} моделей",
+            "chartUsage": "{name}: {size}, {count} использований",
+            "chartPercentage": "{label}: {value} ({pct}%)"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "Скачать модель по URL",
             "titleWithType": "Скачать {type} по URL",
-            "url": "Civitai URL",
             "civitaiUrl": "Civitai URL:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "Введите один URL CivitAI, CivArchive или Hugging Face в каждой строке. Поддерживает несколько URL для пакетной загрузки.",
+            "selectHfFiles": "Выберите файл(ы) для загрузки из этого репозитория：",
+            "selectAll": "Выбрать все",
+            "fetchingRepoFiles": "Получение файлов репозитория...",
             "locationPreview": "Предпросмотр места загрузки",
             "useDefaultPath": "Использовать путь по умолчанию",
             "useDefaultPathTooltip": "При включении файлы автоматически организуются с использованием настроенных шаблонов путей",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "Ранее загружено, но сейчас этого нет в вашей библиотеке.",
             "alreadyInLibrary": "Уже в библиотеке",
             "autoOrganizedPath": "[Автоматически организовано по шаблону пути]",
+            "fileSelection": {
+                "title": "Выбрать формат файла",
+                "files": "файлов",
+                "select": "Выбрать файл"
+            },
             "errors": {
                 "invalidUrl": "Неверный формат URL Civitai",
-                "noVersions": "Нет доступных версий для этой модели"
+                "noVersions": "Нет доступных версий для этой модели",
+                "mixedSources": "Нельзя смешивать URL-адреса CivitAI и Hugging Face в одном пакете.",
+                "noModelFiles": "В этом репозитории не найдено файлов моделей."
             },
             "status": {
                 "preparing": "Подготовка загрузки...",
@@ -1080,6 +1250,12 @@
             "countMessage": "моделей будут удалены навсегда.",
             "action": "Удалить все"
         },
+        "bulkDeleteRecipes": {
+            "title": "Удалить несколько рецептов",
+            "message": "Вы уверены, что хотите удалить все выбранные рецепты и связанные с ними файлы?",
+            "countMessage": "рецептов будут удалены навсегда.",
+            "action": "Удалить все"
+        },
         "checkUpdates": {
             "title": "Проверить обновления для всех {typePlural}?",
             "message": "Будут проверены обновления для всех {typePlural} в вашей библиотеке. Для больших коллекций это может занять немного больше времени.",
@@ -1160,8 +1336,11 @@
                 "editModelName": "Редактировать название модели",
                 "editFileName": "Редактировать имя файла",
                 "editBaseModel": "Редактировать базовую модель",
+                "editVersionName": "Редактировать название версии",
                 "viewOnCivitai": "Посмотреть на Civitai",
                 "viewOnCivitaiText": "Посмотреть на Civitai",
+                "viewOnHuggingFace": "Открыть Hugging Face",
+                "viewOnHuggingFaceText": "Открыть Hugging Face",
                 "viewCreatorProfile": "Посмотреть профиль создателя",
                 "openFileLocation": "Открыть расположение файла",
                 "sendToWorkflow": "Отправить в ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "Дополнительные заметки",
                 "notesHint": "Нажмите Enter для сохранения, Shift+Enter для новой строки",
                 "addNotesPlaceholder": "Добавьте ваши заметки здесь...",
-                "aboutThisVersion": "Об этой версии"
+                "aboutThisVersion": "Об этой версии",
+                "baseModelSearchPlaceholder": "Поиск базовой модели…",
+                "baseModelSuggested": "Предполагаемые",
+                "baseModelNoMatch": "Нет подходящих базовых моделей"
             },
             "notes": {
                 "saved": "Заметки успешно сохранены",
-                "saveFailed": "Не удалось сохранить заметки"
+                "saveFailed": "Не удалось сохранить заметки",
+                "showMore": "Показать больше",
+                "showLess": "Свернуть"
             },
             "usageTips": {
                 "addPresetParameter": "Добавить предустановленный параметр...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "Версия удалена"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "Сводка получения метаданных",
+            "statSuccess": "Успешно",
+            "statFailed": "Ошибка",
+            "statSkipped": "Пропущено",
+            "statTotal": "Всего проверено",
+            "statDuration": "Длительность",
+            "successMessage": "Все {count} {type}s успешно обновлены",
+            "failedItems": "Ошибочные элементы ({count})",
+            "close": "Закрыть",
+            "copyReport": "Копировать отчет",
+            "downloadCsv": "Скачать CSV",
+            "columnModelName": "Имя модели",
+            "columnError": "Ошибка"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "Этот тег уже существует"
         }
     },
-    "keyboard": {
-        "navigation": "Навигация с клавиатуры:",
-        "shortcuts": {
-            "pageUp": "Прокрутить на страницу вверх",
-            "pageDown": "Прокрутить на страницу вниз",
-            "home": "Перейти к началу",
-            "end": "Перейти к концу"
-        }
-    },
     "initialization": {
         "title": "Инициализация",
         "message": "Подготовка вашего рабочего пространства...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "В текущем workflow нет совместимых узлов",
             "noTargetNodeSelected": "Целевой узел не выбран",
             "modelUpdated": "Модель обновлена в workflow",
-            "modelFailed": "Не удалось обновить узел модели"
+            "modelFailed": "Не удалось обновить узел модели",
+            "embeddingAdded": "Embedding добавлен в workflow",
+            "embeddingFailed": "Не удалось добавить embedding",
+            "promptSent": "Запрос отправлен в workflow",
+            "promptFailed": "Не удалось отправить запрос"
         },
         "nodeSelector": {
             "recipe": "Рецепт",
             "lora": "LoRA",
+            "embedding": "Эмбеддинг",
+            "prompt": "Запрос",
             "replace": "Заменить",
             "append": "Добавить",
             "selectTargetNode": "Выберите целевой узел",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "ID рецепта недоступен",
             "sendToWorkflowFailed": "Не удалось отправить рецепт в рабочий процесс: {message}",
             "copyFailed": "Ошибка копирования синтаксиса рецепта: {message}",
+            "createError": "Ошибка при создании рецепта：{message}",
+            "createFailed": "Не удалось создать рецепт：{error}",
+            "createMissingData": "Отсутствуют необходимые данные для создания рецепта",
+            "created": "Рецепт успешно создан",
             "noMissingLoras": "Нет отсутствующих LoRAs для загрузки",
             "missingLorasInfoFailed": "Не удалось получить информацию для отсутствующих LoRAs",
             "preparingForDownloadFailed": "Ошибка подготовки LoRAs для загрузки",
             "enterLoraName": "Пожалуйста, введите название LoRA или синтаксис",
             "reconnectedSuccessfully": "LoRA успешно переподключена",
             "reconnectFailed": "Ошибка переподключения LoRA: {message}",
+            "noPromptToSend": "Нет запроса для отправки",
             "cannotSend": "Невозможно отправить рецепт: отсутствует ID рецепта",
             "sendFailed": "Не удалось отправить рецепт в workflow",
             "sendError": "Ошибка отправки рецепта в workflow",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "Failed to browse directory: {message}",
             "batchImportDirectorySelected": "Directory selected: {path}",
             "noRecipesSelected": "Рецепты не выбраны",
+            "repairBulkComplete": "Восстановление завершено: {repaired} восстановлено, {skipped} пропущено (из {total})",
+            "repairBulkSkipped": "Ни один из {total} выбранных рецептов не требует восстановления",
+            "repairBulkFailed": "Не удалось восстановить выбранные рецепты: {message}",
+            "reimporting": "Переимпорт рецепта из источника...",
+            "reimportSuccess": "Рецепт успешно переимпортирован",
+            "reimportBulkComplete": "Переимпорт завершён: {completed} переимпортировано, {failed} ошибок (из {total})",
+            "reimportBulkFailed": "Не удалось переимпортировать некоторые рецепты",
             "noMissingLorasInSelection": "В выбранных рецептах не найдены отсутствующие LoRAs",
             "noLoraRootConfigured": "Корневой каталог LoRA не настроен. Пожалуйста, установите корневой каталог LoRA по умолчанию в настройках."
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "Успешно перемещено {successCount} {type}s",
             "exampleImagesDownloadSuccess": "Примеры изображений успешно загружены!",
             "exampleImagesDownloadFailed": "Не удалось загрузить примеры изображений: {message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "Скопировано в буфер обмена",
+            "downloadStarted": "Загрузка начата"
+        },
+        "agent": {
+            "llmNotConfigured": "Поставщик ИИ не настроен. Включите его в Настройки → Поставщик ИИ.",
+            "enrichStarted": "Обогащение метаданных с помощью ИИ...",
+            "enrichComplete": "Обогащение метаданных завершено: {{summary}}",
+            "enrichFailed": "Ошибка обогащения метаданных: {{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "Требует внимания",
             "error": "Требуется действие"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API Key"
+            },
+            "cache_health": {
+                "title": "Model Cache Health"
+            },
+            "filename_conflicts": {
+                "title": "Duplicate Filename Conflicts"
+            },
+            "ui_version": {
+                "title": "UI Version"
+            }
+        },
         "actions": {
             "runAgain": "Запустить снова",
-            "exportBundle": "Экспортировать пакет"
+            "exportBundle": "Экспортировать пакет",
+            "open-settings": "Open Settings",
+            "open-settings-syntax-format": "Switch to Full Path Syntax",
+            "repair-cache": "Rebuild Cache",
+            "resolve-filename-conflicts": "Resolve Conflicts",
+            "reload-page": "Reload UI"
+        },
+        "labels": {
+            "conflicts": "Conflicts",
+            "version": "Version"
         },
         "toast": {
             "loadFailed": "Не удалось загрузить диагностику: {message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "Не удалось разрешить конфликты имён файлов: {message}"
         }
     },
+    "conflictConfirm": {
+        "title": "Разрешить конфликты имён файлов",
+        "message": "Переименование с добавлением 4-символьного хеша к каждому дублирующемуся имени файла.",
+        "note": "Эта операция переименовывает файлы на диске. Если вы используете синтаксис A1111, ссылки на модели в существующих рабочих процессах могут потребовать обновления.",
+        "detail": "Пример: <code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "Будет переименовано <strong>{count}</strong> файл(ов) в <strong>{groups}</strong> группе(ах) дубликатов",
+        "confirm": "Переименовать файлы",
+        "cancel": "Отмена"
+    },
     "banners": {
         "versionMismatch": {
             "title": "Обнаружено обновление приложения",

locales/zh-CN.json

@@ -16,10 +16,13 @@
             "help": "帮助",
             "add": "添加",
             "close": "关闭",
-            "menu": "菜单"
+            "menu": "菜单",
+            "remove": "移除",
+            "change": "更换"
         },
         "status": {
             "loading": "加载中...",
+            "cancelling": "取消中...",
             "unknown": "未知",
             "date": "日期",
             "version": "版本",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "从收藏移除",
             "viewOnCivitai": "在 Civitai 查看",
             "notAvailableFromCivitai": "Civitai 上不可用",
+            "viewOnHuggingFace": "在 Hugging Face 查看",
             "sendToWorkflow": "发送到 ComfyUI（点击：追加，Shift+点击：替换）",
             "copyLoRASyntax": "复制 LoRA 语法",
             "checkpointNameCopied": "检查点名称已复制",
@@ -111,6 +115,7 @@
             "replacePreview": "替换预览",
             "copyCheckpointName": "复制 Checkpoint 名称",
             "copyEmbeddingName": "复制 Embedding 名称",
+            "embeddingNameCopied": "已复制 Embedding 语法",
             "sendCheckpointToWorkflow": "发送到 ComfyUI",
             "sendEmbeddingToWorkflow": "发送到 ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "使用次数"
+        },
+        "footer": {
+            "versionCount": "{count} 个版本",
+            "viewAllVersions": "查看所有本地版本"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "管理已排除的模型"
+        },
+        "groupByModel": {
+            "label": "按模型分组"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "统计"
         },
         "search": {
-            "placeholder": "搜索...",
-            "placeholders": {
-                "loras": "搜索 LoRA...",
-                "recipes": "搜索配方...",
-                "checkpoints": "搜索 Checkpoint...",
-                "embeddings": "搜索 Embedding..."
-            },
+            "placeholder": "搜索",
             "options": "搜索选项",
             "searchIn": "搜索范围：",
             "notAvailable": "统计页面不可用搜索",
@@ -232,7 +238,10 @@
             "license": "许可证",
             "noCreditRequired": "无需署名",
             "allowSellingGeneratedContent": "允许销售",
+            "allowSellingGeneratedContentTooltip": "允许出售生成的图片",
+            "noCreditRequiredTooltip": "使用模型时无需注明原作者",
             "noTags": "无标签",
+            "autoTags": "自动标签",
             "noBaseModelMatches": "没有基础模型符合当前搜索。",
             "clearAll": "清除所有筛选",
             "any": "任一",
@@ -244,7 +253,18 @@
             "toggle": "切换主题",
             "switchToLight": "切换到浅色主题",
             "switchToDark": "切换到深色主题",
-            "switchToAuto": "切换到自动主题"
+            "switchToAuto": "切换到自动主题",
+            "presets": "主题预设",
+            "default": "默认",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "模式",
+            "light": "浅色",
+            "dark": "深色",
+            "auto": "自动"
         },
         "actions": {
             "checkUpdates": "检查更新",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Civitai API 密钥",
         "civitaiApiKeyPlaceholder": "请输入你的 Civitai API 密钥",
         "civitaiApiKeyHelp": "用于从 Civitai 下载模型时的身份验证",
+        "civitaiApiKeyConfigured": "已配置",
+        "civitaiApiKeyNotConfigured": "未配置",
+        "civitaiApiKeySet": "设置",
         "civitaiHost": {
             "label": "Civitai 站点",
             "help": "选择使用“在 Civitai 中查看”时默认打开的 Civitai 站点。",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "下载后端",
-            "help": "选择模型文件的下载方式。Python 使用内置下载器。aria2 使用实验性的外部下载进程。",
+            "help": "选择模型文件的下载方式。Python 使用内置下载器。aria2 使用推荐的外部下载进程。",
             "options": {
                 "python": "Python（内置）",
-                "aria2": "aria2（实验性）"
+                "aria2": "aria2（推荐）"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "下载",
             "videoSettings": "视频设置",
             "layoutSettings": "布局设置",
+            "licenseIcons": "许可协议图标",
             "misc": "其他",
             "backup": "备份",
             "folderSettings": "默认根目录",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "额外文件夹路径",
             "downloadPathTemplates": "下载路径模板",
             "priorityTags": "优先标签",
-            "updateFlags": "更新标记",
+            "versionScope": "版本范围",
             "exampleImages": "示例图片",
             "autoOrganize": "自动整理",
             "metadata": "元数据",
@@ -408,6 +432,8 @@
             "help": "启用后，如果下载历史服务记录显示该版本已下载，LoRA Manager 将跳过下载该模型版本。适用于所有下载流程。"
         },
         "layoutSettings": {
+            "groupByModel": "按模型分组",
+            "groupByModelHelp": "开启后，每个 Civitai 模型仅显示最新版本的单张卡片，旧版本将被隐藏。",
             "displayDensity": "显示密度",
             "displayDensityOptions": {
                 "default": "默认",
@@ -442,7 +468,9 @@
                 "modelName": "模型名称",
                 "fileName": "文件名"
             },
-            "modelNameDisplayHelp": "选择在模型卡片底部显示的内容"
+            "modelNameDisplayHelp": "选择在模型卡片底部显示的内容",
+            "cardBlurAmount": "卡片叠加模糊强度",
+            "cardBlurAmountHelp": "调整模型和配方卡片上页眉和页脚叠加层的模糊强度（0 = 无模糊，20 = 最大模糊）。"
         },
         "folderSettings": {
             "activeLibrary": "活动库",
@@ -562,21 +590,31 @@
             "download": "下载",
             "restartRequired": "需要重启"
         },
-        "updateFlagStrategy": {
-            "label": "更新标记策略",
-            "help": "决定更新徽章是否仅在新版本与本地文件共享相同基础模型时显示，或只要该模型有任何更新版本就显示。",
+        "versionGrouping": {
+            "label": "版本分组",
+            "help": "控制版本在 UI 中的分组方式：按基础模型分组或合并显示。同时影响更新徽章逻辑和版本列表的筛选行为。",
             "options": {
-                "sameBase": "按基础模型匹配更新",
-                "any": "显示任何可用更新"
+                "sameBase": "按基础模型分组",
+                "any": "显示所有版本"
             }
         },
         "hideEarlyAccessUpdates": {
             "label": "隐藏抢先体验更新",
             "help": "抢先体验更新"
         },
+        "licenseIcons": {
+            "useNewStyle": "使用新版许可协议图标",
+            "useNewStyleHelp": "以彩色指示器显示许可权限（新样式），或仅显示限制图标（经典样式）。与当前 CivitAI 设计保持一致。"
+        },
         "misc": {
             "includeTriggerWords": "复制 LoRA 语法时包含触发词",
-            "includeTriggerWordsHelp": "复制 LoRA 语法到剪贴板时包含训练触发词"
+            "includeTriggerWordsHelp": "复制 LoRA 语法到剪贴板时包含训练触发词",
+            "loraSyntaxFormat": "LoRA 语法格式",
+            "loraSyntaxFormatHelp": "LoRA 语法格式。完整路径（Full）包含子文件夹路径 (<lora:style/anime/x:1.0>)，解析精确无歧义。旧版（Legacy）仅使用文件名 (<lora:x:1.0>)——A1111 原始约定，同名文件跨文件夹时可能产生歧义。",
+            "loraSyntaxFormatOptions": {
+                "full": "完整路径（子文件夹/名称）",
+                "legacy": "旧版 A1111（仅名称）"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "启用元数据归档数据库",
@@ -619,6 +657,23 @@
             "proxyPassword": "密码 (可选)",
             "proxyPasswordPlaceholder": "密码",
             "proxyPasswordHelp": "代理认证的密码 (如果需要)"
+        },
+        "aiProvider": {
+            "title": "AI 提供商",
+            "provider": "提供商",
+            "providerHelp": "选择您的 LLM 提供商。OpenAI 和 Ollama 使用预设的 API 端点。自定义允许您指定任何兼容 OpenAI 的端点。",
+            "custom": "自定义（兼容 OpenAI）",
+            "apiBase": "API 基础地址",
+            "apiBaseHelp": "LLM API 的基础 URL（例如 https://api.openai.com/v1）。留空则使用提供商默认地址。",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "API 密钥",
+            "apiKeyHelp": "您的 LLM 提供商 API 密钥。仅本地存储，不会发送到您选择的 LLM 提供商之外的任何服务器。",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "未设置",
+            "apiKeyConfigured": "已配置",
+            "apiKeySet": "设置",
+            "model": "模型",
+            "modelHelp": "要使用的模型名称（例如 deepseek-v4-flash, gemini-2.5-flash, gemma4:12b）。请查看您的提供商支持的可用模型列表。"
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "最小",
                 "usage": "使用次数",
                 "usageDesc": "最多",
-                "usageAsc": "最少"
+                "usageAsc": "最少",
+                "versionsCount": "本地版本数",
+                "versionsCountDesc": "版本数从多到少",
+                "versionsCountAsc": "版本数从少到多",
+                "versionIdDesc": "最新版本优先"
             },
             "refresh": {
                 "title": "刷新模型列表",
-                "quick": "同步变更",
-                "quickTooltip": "扫描新的或缺失的模型文件，保持列表最新。",
                 "full": "重建缓存",
                 "fullTooltip": "从元数据文件重新加载所有模型信息；用于列表过时或手动编辑后。"
             },
@@ -682,6 +739,8 @@
             "setContentRating": "为所选中设置内容评级",
             "copyAll": "复制所选中语法",
             "refreshAll": "刷新所选中元数据",
+            "repairMetadata": "修复所选中元数据",
+            "reimportMetadata": "从源重新导入",
             "checkUpdates": "检查所选更新",
             "moveAll": "移动所选中到文件夹",
             "autoOrganize": "自动整理所选模型",
@@ -692,9 +751,18 @@
             "unfavorite": "取消收藏",
             "deleteAll": "删除已选",
             "downloadMissingLoras": "下载缺失的 LoRAs",
+            "downloadExamples": "下载示例图片",
             "clear": "清除选择",
             "skipMetadataRefreshCount": "跳过（{count} 个模型）",
             "resumeMetadataRefreshCount": "恢复（{count} 个模型）",
+            "sendToWorkflow": "发送到工作流",
+            "sections": {
+                "workflow": "工作流",
+                "metadata": "元数据",
+                "attributes": "属性",
+                "organize": "整理",
+                "download": "下载"
+            },
             "autoOrganizeProgress": {
                 "initializing": "正在初始化自动整理...",
                 "starting": "正在为 {type} 启动自动整理...",
@@ -703,7 +771,8 @@
                 "completed": "完成：已移动 {success} 个，跳过 {skipped} 个，失败 {failures} 个",
                 "complete": "自动整理已完成",
                 "error": "错误：{error}"
-            }
+            },
+            "enrichHfAgent": "AI 元数据增强"
         },
         "contextMenu": {
             "refreshMetadata": "刷新 Civitai 数据",
@@ -720,13 +789,15 @@
             "setContentRating": "设置内容评级",
             "moveToFolder": "移动到文件夹",
             "repairMetadata": "修复元数据",
+            "reimportMetadata": "从源重新导入",
             "excludeModel": "排除模型",
             "restoreModel": "恢复模型",
             "deleteModel": "删除模型",
             "shareRecipe": "分享配方",
             "viewAllLoras": "查看所有 LoRA",
             "downloadMissingLoras": "下载缺失的 LoRA",
-            "deleteRecipe": "删除配方"
+            "deleteRecipe": "删除配方",
+            "enrichHfAgent": "AI 元数据增强"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "刷新配方列表",
-                "quick": "同步变更",
-                "quickTooltip": "同步变更 - 快速刷新而不重建缓存",
                 "full": "重建缓存",
                 "fullTooltip": "重建缓存 - 重新扫描所有配方文件"
             },
@@ -849,6 +918,13 @@
                 "skipped": "配方已是最新版本，无需修复",
                 "failed": "修复配方失败：{message}",
                 "missingId": "无法修复配方：缺少配方 ID"
+            },
+            "reimport": {
+                "starting": "正在从源重新导入配方...",
+                "success": "配方已从源重新导入成功",
+                "noSourceUrl": "配方没有源URL，无法重新导入",
+                "failed": "重新导入配方失败：{message}",
+                "missingId": "无法重新导入配方：缺少配方ID"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "根目录",
         "collapseAll": "折叠所有文件夹",
-        "pinSidebar": "固定侧边栏",
-        "unpinSidebar": "取消固定侧边栏",
+        "hideOnThisPage": "隐藏此页面侧边栏",
+        "showSidebar": "显示侧边栏",
+        "sidebarHiddenNotification": "{page}页面的文件夹侧边栏已隐藏",
         "switchToListView": "切换到列表视图",
         "switchToTreeView": "切换到树状视图",
         "recursiveOn": "包含子文件夹",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "未找到文件夹",
             "dragHint": "拖拽项目到此处以创建文件夹"
+        },
+        "folderUpdateCheck": {
+            "label": "检查此文件夹的更新",
+            "loading": "正在检查此文件夹中的{type}更新...",
+            "success": "在此文件夹中找到 {count} 个{type}更新",
+            "none": "此文件夹中的所有{type}都是最新版本",
+            "error": "检查文件夹{type}更新失败: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "存储",
             "insights": "洞察"
         },
+        "metrics": {
+            "totalModels": "模型总数",
+            "totalStorage": "总存储空间",
+            "totalGenerations": "总生成次数",
+            "usageRate": "使用率",
+            "loras": "LoRA",
+            "checkpoints": "Checkpoint",
+            "embeddings": "Embedding",
+            "uniqueTags": "唯一标签",
+            "unusedModels": "未使用模型",
+            "avgUsesPerModel": "平均使用次数/模型"
+        },
         "usage": {
             "mostUsedLoras": "最常用 LoRA",
             "mostUsedCheckpoints": "最常用 Checkpoint",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "智能洞察",
-            "recommendations": "推荐"
+            "recommendations": "推荐",
+            "noInsights": "暂无可用洞察",
+            "unusedLoras": {
+                "high": {
+                    "title": "大量未使用的 LoRA",
+                    "description": "你的 LoRA 中有 {percent}%（{count}/{total}）从未被使用过。",
+                    "suggestion": "考虑整理或归档未使用的模型以释放存储空间。"
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "检测到未使用的 Checkpoint",
+                    "description": "你的 Checkpoint 中有 {percent}%（{count}/{total}）从未被使用过。",
+                    "suggestion": "审查并考虑删除不再需要的 Checkpoint。"
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "大量未使用的 Embedding",
+                    "description": "你的 Embedding 中有 {percent}%（{count}/{total}）从未被使用过。",
+                    "suggestion": "考虑整理或归档未使用的 Embedding 以优化你的收藏。"
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "检测到大型收藏",
+                    "description": "你的模型收藏正在使用 {size} 的存储空间。",
+                    "suggestion": "考虑使用外部存储或云解决方案以获得更好的组织。"
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "活跃用户",
+                    "description": "你已经完成了 {count} 次生成！",
+                    "suggestion": "继续探索并用你的模型创作精彩内容。"
+                }
+            }
         },
         "charts": {
             "collectionOverview": "收藏概览",
             "baseModelDistribution": "基础模型分布",
             "usageTrends": "使用趋势（最近30天）",
-            "usageDistribution": "使用分布"
+            "usageDistribution": "使用分布",
+            "date": "日期",
+            "usageCount": "使用次数",
+            "fileSizeBytes": "文件大小（字节）",
+            "models": "模型",
+            "loraUsage": "LoRA 使用量",
+            "checkpointUsage": "Checkpoint 使用量",
+            "embeddingUsage": "Embedding 使用量"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "扩散模型",
+            "embedding": "Embedding"
+        },
+        "placeholders": {
+            "loading": "加载中...",
+            "noModels": "未找到模型",
+            "errorLoading": "数据加载失败",
+            "noStorageData": "暂无存储数据",
+            "rootFolder": "根目录",
+            "chartLibraryMissing": "需要 Chart.js 库来显示图表"
+        },
+        "tooltips": {
+            "tagCount": "{tag}：{count} 个模型",
+            "chartUsage": "{name}：{size}，{count} 次使用",
+            "chartPercentage": "{label}：{value}（{pct}%）"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "从 URL 下载模型",
             "titleWithType": "从 URL 下载 {type}",
-            "url": "Civitai URL",
             "civitaiUrl": "Civitai URL:",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "每行输入一个 CivitAI、CivArchive 或 Hugging Face URL。支持批量下载多个 URL。",
+            "selectHfFiles": "选择从此仓库下载的文件：",
+            "selectAll": "全选",
+            "fetchingRepoFiles": "正在获取仓库文件...",
             "locationPreview": "下载位置预览",
             "useDefaultPath": "使用默认路径",
             "useDefaultPathTooltip": "启用后，文件将自动按配置的路径模板进行整理",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "之前已下载，但当前不在你的库中。",
             "alreadyInLibrary": "已存在于库中",
             "autoOrganizedPath": "【已按路径模板自动整理】",
+            "fileSelection": {
+                "title": "选择文件格式",
+                "files": "个文件",
+                "select": "选择文件"
+            },
             "errors": {
                 "invalidUrl": "无效的 Civitai URL 格式",
-                "noVersions": "此模型没有可用版本"
+                "noVersions": "此模型没有可用版本",
+                "mixedSources": "无法在同一批次中混合使用 CivitAI 和 Hugging Face URL。",
+                "noModelFiles": "在此仓库中未找到模型文件。"
             },
             "status": {
                 "preparing": "正在准备下载...",
@@ -1080,6 +1250,12 @@
             "countMessage": "模型将被永久删除。",
             "action": "全部删除"
         },
+        "bulkDeleteRecipes": {
+            "title": "删除多个配方",
+            "message": "你确定要删除所有选中的配方及其相关文件吗？",
+            "countMessage": "配方将被永久删除。",
+            "action": "全部删除"
+        },
         "checkUpdates": {
             "title": "检查所有 {type} 的更新？",
             "message": "这会为库中的每个 {type} 检查更新，大型集合可能需要一些时间。",
@@ -1160,8 +1336,11 @@
                 "editModelName": "编辑模型名称",
                 "editFileName": "编辑文件名",
                 "editBaseModel": "编辑基础模型",
+                "editVersionName": "编辑版本名称",
                 "viewOnCivitai": "在 Civitai 查看",
                 "viewOnCivitaiText": "在 Civitai 查看",
+                "viewOnHuggingFace": "在 Hugging Face 查看",
+                "viewOnHuggingFaceText": "在 Hugging Face 查看",
                 "viewCreatorProfile": "查看创作者主页",
                 "openFileLocation": "打开文件位置",
                 "sendToWorkflow": "发送到 ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "附加备注",
                 "notesHint": "回车保存，Shift+回车换行",
                 "addNotesPlaceholder": "在此添加你的备注...",
-                "aboutThisVersion": "关于此版本"
+                "aboutThisVersion": "关于此版本",
+                "baseModelSearchPlaceholder": "搜索基础模型…",
+                "baseModelSuggested": "推荐",
+                "baseModelNoMatch": "没有匹配的基础模型"
             },
             "notes": {
                 "saved": "备注保存成功",
-                "saveFailed": "备注保存失败"
+                "saveFailed": "备注保存失败",
+                "showMore": "展开",
+                "showLess": "收起"
             },
             "usageTips": {
                 "addPresetParameter": "添加预设参数...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "版本已删除"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "元数据获取摘要",
+            "statSuccess": "成功",
+            "statFailed": "失败",
+            "statSkipped": "已跳过",
+            "statTotal": "总计扫描",
+            "statDuration": "耗时",
+            "successMessage": "全部 {count} 个 {type} 更新成功！",
+            "failedItems": "失败项目 ({count})",
+            "close": "关闭",
+            "copyReport": "复制报告",
+            "downloadCsv": "下载 CSV",
+            "columnModelName": "模型名称",
+            "columnError": "错误"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "该标签已存在"
         }
     },
-    "keyboard": {
-        "navigation": "键盘导航：",
-        "shortcuts": {
-            "pageUp": "向上一页滚动",
-            "pageDown": "向下一页滚动",
-            "home": "跳到顶部",
-            "end": "跳到底部"
-        }
-    },
     "initialization": {
         "title": "初始化",
         "message": "正在准备你的工作空间...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "当前工作流中没有兼容的节点",
             "noTargetNodeSelected": "未选择目标节点",
             "modelUpdated": "模型已更新到工作流",
-            "modelFailed": "更新模型节点失败"
+            "modelFailed": "更新模型节点失败",
+            "embeddingAdded": "Embedding 已追加到工作流",
+            "embeddingFailed": "添加 Embedding 失败",
+            "promptSent": "提示词已发送到工作流",
+            "promptFailed": "提示词发送失败"
         },
         "nodeSelector": {
             "recipe": "配方",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "提示词",
             "replace": "替换",
             "append": "追加",
             "selectTargetNode": "选择目标节点",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "无配方 ID",
             "sendToWorkflowFailed": "发送配方到工作流失败：{message}",
             "copyFailed": "复制配方语法出错：{message}",
+            "createError": "创建配方时出错：{message}",
+            "createFailed": "创建配方失败：{error}",
+            "createMissingData": "缺少创建配方所需的数据",
+            "created": "配方创建成功",
             "noMissingLoras": "没有缺失的 LoRA 可下载",
             "missingLorasInfoFailed": "获取缺失 LoRA 信息失败",
             "preparingForDownloadFailed": "准备下载 LoRA 时出错",
             "enterLoraName": "请输入 LoRA 名称或语法",
             "reconnectedSuccessfully": "LoRA 重新连接成功",
             "reconnectFailed": "LoRA 重新连接出错：{message}",
+            "noPromptToSend": "没有可发送的提示词",
             "cannotSend": "无法发送配方：缺少配方 ID",
             "sendFailed": "发送配方到工作流失败",
             "sendError": "发送配方到工作流出错",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "浏览目录失败：{message}",
             "batchImportDirectorySelected": "已选择目录：{path}",
             "noRecipesSelected": "未选择任何配方",
+            "repairBulkComplete": "修复完成：{repaired} 个已修复，{skipped} 个已跳过（共 {total} 个）",
+            "repairBulkSkipped": "所选 {total} 个配方无需修复",
+            "repairBulkFailed": "修复所选配方失败：{message}",
+            "reimporting": "正在从源重新导入配方...",
+            "reimportSuccess": "配方已从源重新导入成功",
+            "reimportBulkComplete": "重新导入完成：{completed} 个已导入，{failed} 个失败（共 {total} 个）",
+            "reimportBulkFailed": "重新导入某些配方失败",
             "noMissingLorasInSelection": "在选定的配方中未找到缺失的 LoRAs",
             "noLoraRootConfigured": "未配置 LoRA 根目录。请在设置中设置默认的 LoRA 根目录。"
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "成功移动 {successCount} 个 {type}",
             "exampleImagesDownloadSuccess": "示例图片下载成功！",
             "exampleImagesDownloadFailed": "示例图片下载失败：{message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "已复制到剪贴板",
+            "downloadStarted": "下载已开始"
+        },
+        "agent": {
+            "llmNotConfigured": "AI 提供商未配置。请在 设置 → AI 提供商 中进行配置。",
+            "enrichStarted": "正在使用 AI 增强元数据...",
+            "enrichComplete": "元数据增强完成：{{summary}}",
+            "enrichFailed": "元数据增强失败：{{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "需要关注",
             "error": "需要处理"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API 密钥"
+            },
+            "cache_health": {
+                "title": "模型缓存健康状态"
+            },
+            "filename_conflicts": {
+                "title": "文件名重复冲突"
+            },
+            "ui_version": {
+                "title": "UI 版本"
+            }
+        },
         "actions": {
             "runAgain": "重新检查",
-            "exportBundle": "导出诊断包"
+            "exportBundle": "导出诊断包",
+            "open-settings": "打开设置",
+            "open-settings-syntax-format": "切换为完整路径语法",
+            "repair-cache": "重建缓存",
+            "resolve-filename-conflicts": "解决冲突",
+            "reload-page": "刷新 UI"
+        },
+        "labels": {
+            "conflicts": "冲突详情",
+            "version": "版本信息"
         },
         "toast": {
             "loadFailed": "加载诊断结果失败：{message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "解决文件名冲突失败：{message}"
         }
     },
+    "conflictConfirm": {
+        "title": "解决文件名冲突",
+        "message": "通过在每个重复文件名后附加 4 位哈希值来重命名文件。",
+        "note": "此操作会重命名磁盘上的文件。如果使用 A1111 语法格式，现有工作流中的模型引用可能需要更新。",
+        "detail": "示例：<code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "将重命名 <strong>{count}</strong> 个文件（共 <strong>{groups}</strong> 组重复）",
+        "confirm": "重命名文件",
+        "cancel": "取消"
+    },
     "banners": {
         "versionMismatch": {
             "title": "检测到应用更新",

locales/zh-TW.json

@@ -16,10 +16,13 @@
             "help": "說明",
             "add": "新增",
             "close": "關閉",
-            "menu": "選單"
+            "menu": "選單",
+            "remove": "移除",
+            "change": "更換"
         },
         "status": {
             "loading": "載入中...",
+            "cancelling": "取消中...",
             "unknown": "未知",
             "date": "日期",
             "version": "版本",
@@ -102,6 +105,7 @@
             "removeFromFavorites": "移除收藏",
             "viewOnCivitai": "在 Civitai 查看",
             "notAvailableFromCivitai": "Civitai 不提供",
+            "viewOnHuggingFace": "在 Hugging Face 查看",
             "sendToWorkflow": "傳送到 ComfyUI（點擊：附加，Shift+點擊：取代）",
             "copyLoRASyntax": "複製 LoRA 語法",
             "checkpointNameCopied": "Checkpoint 名稱已複製",
@@ -111,6 +115,7 @@
             "replacePreview": "更換預覽圖",
             "copyCheckpointName": "複製檢查點名稱",
             "copyEmbeddingName": "複製嵌入名稱",
+            "embeddingNameCopied": "已複製 Embedding 語法",
             "sendCheckpointToWorkflow": "傳送到 ComfyUI",
             "sendEmbeddingToWorkflow": "傳送到 ComfyUI"
         },
@@ -141,6 +146,10 @@
         },
         "usage": {
             "timesUsed": "使用次數"
+        },
+        "footer": {
+            "versionCount": "{count} 個版本",
+            "viewAllVersions": "檢視所有本地版本"
         }
     },
     "globalContextMenu": {
@@ -179,6 +188,9 @@
         },
         "manageExcludedModels": {
             "label": "管理已排除的模型"
+        },
+        "groupByModel": {
+            "label": "按模型分組"
         }
     },
     "header": {
@@ -191,13 +203,7 @@
             "statistics": "統計"
         },
         "search": {
-            "placeholder": "搜尋...",
-            "placeholders": {
-                "loras": "搜尋 LoRA...",
-                "recipes": "搜尋配方...",
-                "checkpoints": "搜尋 checkpoint...",
-                "embeddings": "搜尋 embedding..."
-            },
+            "placeholder": "搜尋",
             "options": "搜尋選項",
             "searchIn": "搜尋範圍：",
             "notAvailable": "統計頁面無法搜尋",
@@ -232,7 +238,10 @@
             "license": "授權",
             "noCreditRequired": "無需署名",
             "allowSellingGeneratedContent": "允許銷售",
+            "allowSellingGeneratedContentTooltip": "允許出售生成的圖片",
+            "noCreditRequiredTooltip": "使用模型時無需註明原作者",
             "noTags": "無標籤",
+            "autoTags": "自動標籤",
             "noBaseModelMatches": "沒有基礎模型符合目前的搜尋。",
             "clearAll": "清除所有篩選",
             "any": "任一",
@@ -244,7 +253,18 @@
             "toggle": "切換主題",
             "switchToLight": "切換至淺色主題",
             "switchToDark": "切換至深色主題",
-            "switchToAuto": "自動主題"
+            "switchToAuto": "自動主題",
+            "presets": "主題預設",
+            "default": "預設",
+            "nord": "Nord",
+            "midnight": "Midnight",
+            "monokai": "Monokai",
+            "dracula": "Dracula",
+            "solarized": "Solarized",
+            "mode": "模式",
+            "light": "淺色",
+            "dark": "深色",
+            "auto": "自動"
         },
         "actions": {
             "checkUpdates": "檢查更新",
@@ -256,6 +276,9 @@
         "civitaiApiKey": "Civitai API 金鑰",
         "civitaiApiKeyPlaceholder": "請輸入您的 Civitai API 金鑰",
         "civitaiApiKeyHelp": "用於從 Civitai 下載模型時的身份驗證",
+        "civitaiApiKeyConfigured": "已設定",
+        "civitaiApiKeyNotConfigured": "未設定",
+        "civitaiApiKeySet": "設定",
         "civitaiHost": {
             "label": "Civitai 站點",
             "help": "選擇使用「在 Civitai 中查看」時預設開啟的 Civitai 站點。",
@@ -266,10 +289,10 @@
         },
         "downloadBackend": {
             "label": "下載後端",
-            "help": "選擇模型檔案的下載方式。Python 使用內建下載器。aria2 使用實驗性的外部下載程序。",
+            "help": "選擇模型檔案的下載方式。Python 使用內建下載器。aria2 使用推薦的外部下載程序。",
             "options": {
                 "python": "Python（內建）",
-                "aria2": "aria2（實驗性）"
+                "aria2": "aria2（推薦）"
             }
         },
         "aria2cPath": {
@@ -296,6 +319,7 @@
             "downloads": "下載",
             "videoSettings": "影片設定",
             "layoutSettings": "版面設定",
+            "licenseIcons": "許可協議圖標",
             "misc": "其他",
             "backup": "備份",
             "folderSettings": "預設根目錄",
@@ -303,7 +327,7 @@
             "extraFolderPaths": "額外資料夾路徑",
             "downloadPathTemplates": "下載路徑範本",
             "priorityTags": "優先標籤",
-            "updateFlags": "更新標記",
+            "versionScope": "版本範圍",
             "exampleImages": "範例圖片",
             "autoOrganize": "自動整理",
             "metadata": "中繼資料",
@@ -408,6 +432,8 @@
             "help": "啟用後，如果下載歷史服務記錄顯示該版本已下載，LoRA Manager 將跳過下載該模型版本。適用於所有下載流程。"
         },
         "layoutSettings": {
+            "groupByModel": "按模型分組",
+            "groupByModelHelp": "啟用後，每個 Civitai 模型僅顯示最新版本的單張卡片，舊版本將被隱藏。",
             "displayDensity": "顯示密度",
             "displayDensityOptions": {
                 "default": "預設",
@@ -442,7 +468,9 @@
                 "modelName": "模型名稱",
                 "fileName": "檔案名稱"
             },
-            "modelNameDisplayHelp": "選擇在模型卡片底部顯示的內容"
+            "modelNameDisplayHelp": "選擇在模型卡片底部顯示的內容",
+            "cardBlurAmount": "卡片疊加模糊強度",
+            "cardBlurAmountHelp": "調整模型和配方卡片上頁首和頁尾疊加層的模糊強度（0 = 無模糊，20 = 最大模糊）。"
         },
         "folderSettings": {
             "activeLibrary": "使用中的資料庫",
@@ -562,7 +590,7 @@
             "download": "下載",
             "restartRequired": "需要重新啟動"
         },
-        "updateFlagStrategy": {
+        "versionGrouping": {
             "label": "更新標記策略",
             "help": "決定更新徽章是否僅在新版本與本地檔案共享相同基礎模型時顯示，或只要該模型有任何更新版本就顯示。",
             "options": {
@@ -574,9 +602,19 @@
             "label": "隱藏搶先體驗更新",
             "help": "搶先體驗更新"
         },
+        "licenseIcons": {
+            "useNewStyle": "使用新版許可協議圖標",
+            "useNewStyleHelp": "以彩色指示器顯示許可權限（新樣式），或僅顯示限制圖標（經典樣式）。與當前 CivitAI 設計保持一致。"
+        },
         "misc": {
             "includeTriggerWords": "在 LoRA 語法中包含觸發詞",
-            "includeTriggerWordsHelp": "複製 LoRA 語法到剪貼簿時包含訓練觸發詞"
+            "includeTriggerWordsHelp": "複製 LoRA 語法到剪貼簿時包含訓練觸發詞",
+            "loraSyntaxFormat": "LoRA 語法格式",
+            "loraSyntaxFormatHelp": "LoRA 語法格式。完整路徑（Full）包含子資料夾路徑 (<lora:style/anime/x:1.0>)，解析精確無歧義。舊版（Legacy）僅使用檔名 (<lora:x:1.0>)——A1111 原始約定，同名檔案跨資料夾時可能產生歧義。",
+            "loraSyntaxFormatOptions": {
+                "full": "完整路徑（子資料夾/名稱）",
+                "legacy": "舊版 A1111（僅名稱）"
+            }
         },
         "metadataArchive": {
             "enableArchiveDb": "啟用中繼資料封存資料庫",
@@ -619,6 +657,23 @@
             "proxyPassword": "密碼（選填）",
             "proxyPasswordPlaceholder": "password",
             "proxyPasswordHelp": "代理驗證所需的密碼（如有需要）"
+        },
+        "aiProvider": {
+            "title": "AI 提供者",
+            "provider": "提供者",
+            "providerHelp": "選擇您的 LLM 提供者。OpenAI 和 Ollama 使用預設 API 端點。自訂允許您指定任何相容 OpenAI 的端點。",
+            "custom": "自訂（相容 OpenAI）",
+            "apiBase": "API 基礎位址",
+            "apiBaseHelp": "LLM API 的基礎 URL（例如 https://api.openai.com/v1）。留空則使用提供者預設位址。",
+            "apiBasePlaceholder": "https://api.openai.com/v1",
+            "apiKey": "API 金鑰",
+            "apiKeyHelp": "您的 LLM 提供者 API 金鑰。僅儲存在本地，除了您選擇的 LLM 提供者外，不會發送到任何伺服器。",
+            "apiKeyPlaceholder": "sk-...",
+            "apiKeyNotSet": "未設定",
+            "apiKeyConfigured": "已設定",
+            "apiKeySet": "設定",
+            "model": "模型",
+            "modelHelp": "要使用的模型名稱（例如 deepseek-v4-flash, gemini-2.5-flash, gemma4:12b）。請查看您的提供者支援的可用模型列表。"
         }
     },
     "loras": {
@@ -636,12 +691,14 @@
                 "sizeAsc": "最小",
                 "usage": "使用次數",
                 "usageDesc": "最多",
-                "usageAsc": "最少"
+                "usageAsc": "最少",
+                "versionsCount": "本地版本數",
+                "versionsCountDesc": "版本數從多到少",
+                "versionsCountAsc": "版本數從少到多",
+                "versionIdDesc": "最新版本優先"
             },
             "refresh": {
                 "title": "重新整理模型列表",
-                "quick": "同步變更",
-                "quickTooltip": "掃描新的或缺少的模型檔案，讓清單保持最新。",
                 "full": "重建快取",
                 "fullTooltip": "從中繼資料檔重新載入所有模型資訊；適用於清單過時或手動編輯後。"
             },
@@ -682,6 +739,8 @@
             "setContentRating": "為全部設定內容分級",
             "copyAll": "複製全部語法",
             "refreshAll": "刷新全部 metadata",
+            "repairMetadata": "修復所選中元數據",
+            "reimportMetadata": "從來源重新匯入",
             "checkUpdates": "檢查所選更新",
             "moveAll": "全部移動到資料夾",
             "autoOrganize": "自動整理所選模型",
@@ -692,9 +751,18 @@
             "unfavorite": "取消收藏",
             "deleteAll": "刪除所選",
             "downloadMissingLoras": "下載缺失的 LoRAs",
+            "downloadExamples": "下載範例圖片",
             "clear": "清除選取",
             "skipMetadataRefreshCount": "跳過（{count} 個模型）",
             "resumeMetadataRefreshCount": "恢復（{count} 個模型）",
+            "sendToWorkflow": "發送到工作流",
+            "sections": {
+                "workflow": "工作流",
+                "metadata": "元數據",
+                "attributes": "屬性",
+                "organize": "整理",
+                "download": "下載"
+            },
             "autoOrganizeProgress": {
                 "initializing": "正在初始化自動整理...",
                 "starting": "正在開始自動整理 {type}...",
@@ -703,7 +771,8 @@
                 "completed": "完成：已移動 {success}，已略過 {skipped}，失敗 {failures}",
                 "complete": "自動整理完成",
                 "error": "錯誤：{error}"
-            }
+            },
+            "enrichHfAgent": "AI 中繼資料增強"
         },
         "contextMenu": {
             "refreshMetadata": "刷新 Civitai 資料",
@@ -720,13 +789,15 @@
             "setContentRating": "設定內容分級",
             "moveToFolder": "移動到資料夾",
             "repairMetadata": "修復元數據",
+            "reimportMetadata": "從來源重新匯入",
             "excludeModel": "排除模型",
             "restoreModel": "還原模型",
             "deleteModel": "刪除模型",
             "shareRecipe": "分享配方",
             "viewAllLoras": "檢視全部 LoRA",
             "downloadMissingLoras": "下載缺少的 LoRA",
-            "deleteRecipe": "刪除配方"
+            "deleteRecipe": "刪除配方",
+            "enrichHfAgent": "AI 中繼資料增強"
         }
     },
     "recipes": {
@@ -807,8 +878,6 @@
             },
             "refresh": {
                 "title": "重新整理配方列表",
-                "quick": "同步變更",
-                "quickTooltip": "同步變更 - 快速重新整理而不重建快取",
                 "full": "重建快取",
                 "fullTooltip": "重建快取 - 重新掃描所有配方檔案"
             },
@@ -849,6 +918,13 @@
                 "skipped": "配方已是最新版本，無需修復",
                 "failed": "修復配方失敗：{message}",
                 "missingId": "無法修復配方：缺少配方 ID"
+            },
+            "reimport": {
+                "starting": "正在從來源重新匯入配方...",
+                "success": "配方已從來源重新匯入成功",
+                "noSourceUrl": "配方沒有來源URL，無法重新匯入",
+                "failed": "重新匯入配方失敗：{message}",
+                "missingId": "無法重新匯入配方：缺少配方ID"
             }
         },
         "batchImport": {
@@ -927,8 +1003,9 @@
     "sidebar": {
         "modelRoot": "根目錄",
         "collapseAll": "全部摺疊資料夾",
-        "pinSidebar": "固定側邊欄",
-        "unpinSidebar": "取消固定側邊欄",
+        "hideOnThisPage": "隱藏此頁面側邊欄",
+        "showSidebar": "顯示側邊欄",
+        "sidebarHiddenNotification": "{page}頁面的資料夾側邊欄已隱藏",
         "switchToListView": "切換至列表檢視",
         "switchToTreeView": "切換到樹狀檢視",
         "recursiveOn": "包含子資料夾",
@@ -948,6 +1025,13 @@
         "empty": {
             "noFolders": "未找到資料夾",
             "dragHint": "將項目拖到此處以建立資料夾"
+        },
+        "folderUpdateCheck": {
+            "label": "檢查此資料夾的更新",
+            "loading": "正在檢查此資料夾中的{type}更新...",
+            "success": "在此資料夾中找到 {count} 個{type}更新",
+            "none": "此資料夾中的所有{type}都是最新版本",
+            "error": "檢查資料夾{type}更新失敗: {message}"
         }
     },
     "statistics": {
@@ -959,6 +1043,18 @@
             "storage": "儲存空間",
             "insights": "洞察"
         },
+        "metrics": {
+            "totalModels": "模型總數",
+            "totalStorage": "總儲存空間",
+            "totalGenerations": "總生成次數",
+            "usageRate": "使用率",
+            "loras": "LoRA",
+            "checkpoints": "Checkpoint",
+            "embeddings": "Embedding",
+            "uniqueTags": "唯一標籤",
+            "unusedModels": "未使用模型",
+            "avgUsesPerModel": "平均使用次數/模型"
+        },
         "usage": {
             "mostUsedLoras": "最常用的 LoRA",
             "mostUsedCheckpoints": "最常用的 Checkpoint",
@@ -976,13 +1072,77 @@
         },
         "insights": {
             "smartInsights": "智慧洞察",
-            "recommendations": "推薦"
+            "recommendations": "推薦",
+            "noInsights": "暫無可用洞察",
+            "unusedLoras": {
+                "high": {
+                    "title": "大量未使用的 LoRA",
+                    "description": "你的 LoRA 中有 {percent}%（{count}/{total}）從未被使用過。",
+                    "suggestion": "考慮整理或封存未使用的模型以釋放儲存空間。"
+                }
+            },
+            "unusedCheckpoints": {
+                "detected": {
+                    "title": "檢測到未使用的 Checkpoint",
+                    "description": "你的 Checkpoint 中有 {percent}%（{count}/{total}）從未被使用過。",
+                    "suggestion": "審查並考慮刪除不再需要的 Checkpoint。"
+                }
+            },
+            "unusedEmbeddings": {
+                "high": {
+                    "title": "大量未使用的 Embedding",
+                    "description": "你的 Embedding 中有 {percent}%（{count}/{total}）從未被使用過。",
+                    "suggestion": "考慮整理或封存未使用的 Embedding 以優化你的收藏。"
+                }
+            },
+            "collection": {
+                "large": {
+                    "title": "檢測到大型收藏",
+                    "description": "你的模型收藏正在使用 {size} 的儲存空間。",
+                    "suggestion": "考慮使用外部儲存或雲端解決方案以獲得更好的組織。"
+                }
+            },
+            "activity": {
+                "active": {
+                    "title": "活躍用戶",
+                    "description": "你已經完成了 {count} 次生成！",
+                    "suggestion": "繼續探索並用你的模型創作精彩內容。"
+                }
+            }
         },
         "charts": {
             "collectionOverview": "收藏總覽",
             "baseModelDistribution": "基礎模型分布",
             "usageTrends": "使用趨勢（最近 30 天）",
-            "usageDistribution": "使用分布"
+            "usageDistribution": "使用分布",
+            "date": "日期",
+            "usageCount": "使用次數",
+            "fileSizeBytes": "檔案大小（位元組）",
+            "models": "模型",
+            "loraUsage": "LoRA 使用量",
+            "checkpointUsage": "Checkpoint 使用量",
+            "embeddingUsage": "Embedding 使用量"
+        },
+        "modelTypes": {
+            "lora": "LoRA",
+            "locon": "LyCORIS",
+            "dora": "DoRA",
+            "checkpoint": "Checkpoint",
+            "diffusion_model": "擴散模型",
+            "embedding": "Embedding"
+        },
+        "placeholders": {
+            "loading": "載入中...",
+            "noModels": "找不到模型",
+            "errorLoading": "資料載入失敗",
+            "noStorageData": "暫無儲存資料",
+            "rootFolder": "根目錄",
+            "chartLibraryMissing": "需要 Chart.js 函式庫來顯示圖表"
+        },
+        "tooltips": {
+            "tagCount": "{tag}：{count} 個模型",
+            "chartUsage": "{name}：{size}，{count} 次使用",
+            "chartPercentage": "{label}：{value}（{pct}%）"
         }
     },
     "modals": {
@@ -992,9 +1152,12 @@
         "download": {
             "title": "從網址下載模型",
             "titleWithType": "從網址下載 {type}",
-            "url": "Civitai 網址",
             "civitaiUrl": "Civitai 網址：",
             "placeholder": "https://civitai.com/models/...",
+            "urlHint": "每行輸入一個 CivitAI、CivArchive 或 Hugging Face URL。支援批量下載多個 URL。",
+            "selectHfFiles": "選擇從此倉庫下載的檔案：",
+            "selectAll": "全選",
+            "fetchingRepoFiles": "正在獲取倉庫檔案...",
             "locationPreview": "下載位置預覽",
             "useDefaultPath": "使用預設路徑",
             "useDefaultPathTooltip": "啟用後，檔案將依照設定的路徑範本自動整理",
@@ -1016,9 +1179,16 @@
             "downloadedTooltip": "先前已下載，但目前不在你的庫中。",
             "alreadyInLibrary": "已在庫存",
             "autoOrganizedPath": "[依路徑範本自動整理]",
+            "fileSelection": {
+                "title": "選擇檔案格式",
+                "files": "個檔案",
+                "select": "選擇檔案"
+            },
             "errors": {
                 "invalidUrl": "Civitai 網址格式無效",
-                "noVersions": "此模型無可用版本"
+                "noVersions": "此模型無可用版本",
+                "mixedSources": "無法在同一批次中混合使用 CivitAI 和 Hugging Face URL。",
+                "noModelFiles": "在此倉庫中未找到模型檔案。"
             },
             "status": {
                 "preparing": "準備下載中...",
@@ -1080,6 +1250,12 @@
             "countMessage": "模型將被永久刪除。",
             "action": "全部刪除"
         },
+        "bulkDeleteRecipes": {
+            "title": "刪除多個配方",
+            "message": "您確定要刪除所有選取的配方及其相關檔案嗎？",
+            "countMessage": "配方將被永久刪除。",
+            "action": "全部刪除"
+        },
         "checkUpdates": {
             "title": "要檢查所有 {type} 的更新嗎？",
             "message": "這會為資料庫中的每個 {type} 檢查更新，大型收藏可能會花上一些時間。",
@@ -1160,8 +1336,11 @@
                 "editModelName": "編輯模型名稱",
                 "editFileName": "編輯檔案名稱",
                 "editBaseModel": "編輯基礎模型",
+                "editVersionName": "編輯版本名稱",
                 "viewOnCivitai": "在 Civitai 查看",
                 "viewOnCivitaiText": "在 Civitai 查看",
+                "viewOnHuggingFace": "在 Hugging Face 查看",
+                "viewOnHuggingFaceText": "在 Hugging Face 查看",
                 "viewCreatorProfile": "查看創作者個人檔案",
                 "openFileLocation": "開啟檔案位置",
                 "sendToWorkflow": "傳送到 ComfyUI",
@@ -1187,11 +1366,16 @@
                 "additionalNotes": "附加備註",
                 "notesHint": "按 Enter 儲存，Shift+Enter 換行",
                 "addNotesPlaceholder": "在此新增備註...",
-                "aboutThisVersion": "關於此版本"
+                "aboutThisVersion": "關於此版本",
+                "baseModelSearchPlaceholder": "搜尋基礎模型…",
+                "baseModelSuggested": "推薦",
+                "baseModelNoMatch": "沒有符合的基礎模型"
             },
             "notes": {
                 "saved": "備註已儲存",
-                "saveFailed": "儲存備註失敗"
+                "saveFailed": "儲存備註失敗",
+                "showMore": "展開",
+                "showLess": "收起"
             },
             "usageTips": {
                 "addPresetParameter": "新增預設參數...",
@@ -1344,6 +1528,21 @@
                     "versionDeleted": "已刪除此版本"
                 }
             }
+        },
+        "metadataFetchSummary": {
+            "title": "元資料獲取摘要",
+            "statSuccess": "成功",
+            "statFailed": "失敗",
+            "statSkipped": "已跳過",
+            "statTotal": "總計掃描",
+            "statDuration": "耗時",
+            "successMessage": "全部 {count} 個 {type} 更新成功！",
+            "failedItems": "失敗項目 ({count})",
+            "close": "關閉",
+            "copyReport": "複製報告",
+            "downloadCsv": "下載 CSV",
+            "columnModelName": "模型名稱",
+            "columnError": "錯誤"
         }
     },
     "modelTags": {
@@ -1357,15 +1556,6 @@
             "duplicate": "此標籤已存在"
         }
     },
-    "keyboard": {
-        "navigation": "鍵盤導覽：",
-        "shortcuts": {
-            "pageUp": "向上捲動一頁",
-            "pageDown": "向下捲動一頁",
-            "home": "跳至頂部",
-            "end": "跳至底部"
-        }
-    },
     "initialization": {
         "title": "初始化",
         "message": "正在準備您的工作區...",
@@ -1453,11 +1643,17 @@
             "noMatchingNodes": "目前工作流程中沒有相容的節點",
             "noTargetNodeSelected": "未選擇目標節點",
             "modelUpdated": "模型已更新到工作流",
-            "modelFailed": "更新模型節點失敗"
+            "modelFailed": "更新模型節點失敗",
+            "embeddingAdded": "Embedding 已附加到工作流",
+            "embeddingFailed": "傳送 Embedding 到工作流失敗",
+            "promptSent": "提示詞已發送到工作流",
+            "promptFailed": "提示詞發送失敗"
         },
         "nodeSelector": {
             "recipe": "配方",
             "lora": "LoRA",
+            "embedding": "Embedding",
+            "prompt": "提示詞",
             "replace": "取代",
             "append": "附加",
             "selectTargetNode": "選擇目標節點",
@@ -1634,12 +1830,17 @@
             "noRecipeId": "無配方 ID",
             "sendToWorkflowFailed": "傳送配方到工作流失敗：{message}",
             "copyFailed": "複製配方語法錯誤：{message}",
+            "createError": "建立配方時發生錯誤：{message}",
+            "createFailed": "建立配方失敗：{error}",
+            "createMissingData": "缺少建立配方所需的資料",
+            "created": "配方建立成功",
             "noMissingLoras": "無缺少的 LoRA 可下載",
             "missingLorasInfoFailed": "取得缺少 LoRA 資訊失敗",
             "preparingForDownloadFailed": "準備下載 LoRA 時發生錯誤",
             "enterLoraName": "請輸入 LoRA 名稱或語法",
             "reconnectedSuccessfully": "LoRA 重新連結成功",
             "reconnectFailed": "LoRA 重新連結錯誤：{message}",
+            "noPromptToSend": "沒有可發送的提示詞",
             "cannotSend": "無法傳送配方：缺少配方 ID",
             "sendFailed": "傳送配方到工作流失敗",
             "sendError": "傳送配方到工作流錯誤",
@@ -1672,6 +1873,13 @@
             "batchImportBrowseFailed": "瀏覽目錄失敗：{message}",
             "batchImportDirectorySelected": "已選擇目錄：{path}",
             "noRecipesSelected": "未選取任何食譜",
+            "repairBulkComplete": "修復完成：{repaired} 個已修復，{skipped} 個已跳過（共 {total} 個）",
+            "repairBulkSkipped": "所選 {total} 個配方無需修復",
+            "repairBulkFailed": "修復所選配方失敗：{message}",
+            "reimporting": "正在從來源重新匯入配方...",
+            "reimportSuccess": "配方已從來源重新匯入成功",
+            "reimportBulkComplete": "重新匯入完成：{completed} 個已匯入，{failed} 個失敗（共 {total} 個）",
+            "reimportBulkFailed": "重新匯入某些配方失敗",
             "noMissingLorasInSelection": "在選取的食譜中未找到缺失的 LoRAs",
             "noLoraRootConfigured": "未配置 LoRA 根目錄。請在設定中設定預設的 LoRA 根目錄。"
         },
@@ -1889,7 +2097,15 @@
             "bulkMoveSuccess": "已成功移動 {successCount} 個 {type}",
             "exampleImagesDownloadSuccess": "範例圖片下載成功！",
             "exampleImagesDownloadFailed": "下載範例圖片失敗：{message}",
-            "moveFailed": "Failed to move item: {message}"
+            "moveFailed": "Failed to move item: {message}",
+            "copiedToClipboard": "已複製到剪貼簿",
+            "downloadStarted": "下載已開始"
+        },
+        "agent": {
+            "llmNotConfigured": "AI 提供者尚未設定。請在 設定 → AI 提供者 中進行設定。",
+            "enrichStarted": "正在使用 AI 增強中繼資料...",
+            "enrichComplete": "中繼資料增強完成：{{summary}}",
+            "enrichFailed": "中繼資料增強失敗：{{error}}"
         }
     },
     "doctor": {
@@ -1909,9 +2125,32 @@
             "warning": "需要注意",
             "error": "需要處理"
         },
+        "issues": {
+            "civitai_api_key": {
+                "title": "Civitai API 金鑰"
+            },
+            "cache_health": {
+                "title": "模型快取健康狀態"
+            },
+            "filename_conflicts": {
+                "title": "檔案名稱重複衝突"
+            },
+            "ui_version": {
+                "title": "UI 版本"
+            }
+        },
         "actions": {
             "runAgain": "重新執行",
-            "exportBundle": "匯出套件"
+            "exportBundle": "匯出套件",
+            "open-settings": "開啟設定",
+            "open-settings-syntax-format": "切換為完整路徑語法",
+            "repair-cache": "重建快取",
+            "resolve-filename-conflicts": "解決衝突",
+            "reload-page": "重新載入 UI"
+        },
+        "labels": {
+            "conflicts": "衝突詳情",
+            "version": "版本"
         },
         "toast": {
             "loadFailed": "載入診斷失敗：{message}",
@@ -1923,6 +2162,15 @@
             "conflictsResolveFailed": "解決檔案名稱衝突失敗：{message}"
         }
     },
+    "conflictConfirm": {
+        "title": "解決檔案名稱衝突",
+        "message": "通過在每個重複檔案名稱後附加 4 位元哈希值來重新命名檔案。",
+        "note": "此操作會重新命名磁碟上的檔案。如果使用 A1111 語法格式，現有工作流程中的模型參考可能需要更新。",
+        "detail": "示例：<code>filename_v1.2</code> → <code>filename_v1.2-ab3c</code>",
+        "impact": "將重新命名 <strong>{count}</strong> 個檔案（共 <strong>{groups}</strong> 組重複）",
+        "confirm": "重新命名檔案",
+        "cancel": "取消"
+    },
     "banners": {
         "versionMismatch": {
             "title": "偵測到應用程式更新",

py/agent_cli/__init__.py

@@ -0,0 +1,225 @@
+"""Agent CLI — thin in-process wrappers around LoRA Manager internal services.
+
+All functions are simple Python async functions that delegate to the
+appropriate internal service.  They use **relative imports** within the
+``py`` package, so ``sys.modules`` caching works normally and there is no
+risk of double import or circular dependencies.
+
+Usage (in-process, primary)::
+
+    from py.agent_cli import list_base_models, read_metadata
+
+    models = await list_base_models()
+    meta   = await read_metadata("/path/to/model.safetensors")
+
+Usage (subprocess, debugging / external)::
+
+    python -m py.agent_cli base-models list
+    python -m py.agent_cli metadata read /path/to/model.safetensors
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+async def _find_scanner_for_model(
+    model_path: str,
+) -> tuple[object, object] | tuple[None, None]:
+    """Find the (scanner, cache_entry) responsible for *model_path*.
+
+    Iterates all known scanner types and returns the first one whose cache
+    contains the given path.  Returns ``(None, None)`` when no scanner
+    claims the model.
+    """
+    from ..services.service_registry import ServiceRegistry
+
+    normalized = os.path.normpath(model_path)
+    for getter_name in (
+        "get_lora_scanner",
+        "get_checkpoint_scanner",
+        "get_embedding_scanner",
+    ):
+        getter = getattr(ServiceRegistry, getter_name, None)
+        if getter is None:
+            continue
+        try:
+            scanner = await getter()
+            if scanner is None:
+                continue
+            cache = await scanner.get_cached_data()
+            for entry in cache.raw_data:
+                if os.path.normpath(entry.get("file_path", "")) == normalized:
+                    return scanner, entry
+        except Exception as exc:
+            logger.debug(
+                "Scanner %s check failed for %s: %s",
+                getter_name,
+                model_path,
+                exc,
+            )
+    return None, None
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+async def list_base_models(limit: int = 0) -> List[str]:
+    """Return deduplicated base model names from all model caches.
+
+    The result is ordered by frequency (most common first).  Pass
+    *limit* = 0 (default) for all models.
+    """
+    from ..services.service_registry import ServiceRegistry
+
+    counts: Dict[str, int] = {}
+    for getter_name in (
+        "get_lora_scanner",
+        "get_checkpoint_scanner",
+        "get_embedding_scanner",
+    ):
+        getter = getattr(ServiceRegistry, getter_name, None)
+        if getter is None:
+            continue
+        try:
+            scanner = await getter()
+            if scanner is None:
+                continue
+            cache = await scanner.get_cached_data()
+            for entry in cache.raw_data:
+                bm = entry.get("base_model")
+                if bm:
+                    counts[bm] = counts.get(bm, 0) + 1
+        except Exception as exc:
+            logger.debug("list_base_models scanner %s error: %s", getter_name, exc)
+
+    sorted_names = [name for name, _ in sorted(counts.items(), key=lambda x: -x[1])]
+    if limit > 0:
+        return sorted_names[:limit]
+    return sorted_names
+
+
+async def read_metadata(model_path: str) -> Dict[str, Any]:
+    """Load the full metadata payload for *model_path* from disk.
+
+    Returns an empty dict when the metadata file does not exist or cannot
+    be parsed — never raises.
+    """
+    from ..utils.metadata_manager import MetadataManager
+
+    try:
+        return await MetadataManager.load_metadata_payload(model_path) or {}
+    except Exception as exc:
+        logger.warning("read_metadata failed for %s: %s", model_path, exc)
+        return {}
+
+
+async def apply_metadata_updates(
+    model_path: str,
+    updates: Dict[str, Any],
+) -> List[str]:
+    """Merge *updates* into the model's on-disk metadata and persist.
+
+    Returns the list of field names that actually changed.
+    """
+    from ..utils.metadata_manager import MetadataManager
+
+    metadata = await read_metadata(model_path)
+    updated_fields: List[str] = []
+    for key, value in updates.items():
+        old = metadata.get(key)
+        if old != value:
+            metadata[key] = value
+            updated_fields.append(key)
+    if updated_fields:
+        await MetadataManager.save_metadata(model_path, metadata)
+    return updated_fields
+
+
+async def download_preview(
+    model_path: str,
+    url: str,
+    *,
+    target_width: int = 480,
+    quality: int = 85,
+) -> bool:
+    """Download a preview image from *url*, optimise to .webp, and save it.
+
+    The output file is placed alongside the model file with a ``.webp``
+    extension.  Returns ``True`` on success.
+    """
+    from ..services.downloader import get_downloader
+    from ..utils.exif_utils import ExifUtils
+
+    if not url or not url.strip():
+        return False
+
+    base_name = os.path.splitext(os.path.basename(model_path))[0]
+    preview_dir = os.path.dirname(model_path)
+    output_path = os.path.join(preview_dir, base_name + ".webp")
+
+    downloader = await get_downloader()
+
+    # Try in-memory download + optimise first
+    success, content, _headers = await downloader.download_to_memory(
+        url, use_auth=False,
+    )
+    if success and content:
+        try:
+            optimized_data, _ = ExifUtils.optimize_image(
+                image_data=content,
+                target_width=target_width,
+                format="webp",
+                quality=quality,
+                preserve_metadata=False,
+            )
+            with open(output_path, "wb") as f:
+                f.write(optimized_data)
+            logger.info("Preview downloaded and optimised for %s", model_path)
+            return True
+        except Exception as exc:
+            logger.warning("Preview optimisation failed, saving raw: %s", exc)
+            # Fall through to raw save
+
+    # Fallback: download directly to file
+    try:
+        ok, _ = await downloader.download_file(url, output_path, use_auth=False)
+        if ok:
+            logger.info("Preview downloaded (fallback) for %s", model_path)
+            return True
+    except Exception as exc:
+        logger.warning("Preview fallback download failed for %s: %s", model_path, exc)
+
+    return False
+
+
+async def refresh_cache(model_path: str) -> bool:
+    """Invalidate and reload the scanner cache entry for *model_path*.
+
+    Returns ``True`` when the model was found and the cache was refreshed.
+    """
+    scanner, entry = await _find_scanner_for_model(model_path)
+    if scanner is None:
+        logger.warning("refresh_cache: no scanner found for %s", model_path)
+        return False
+    try:
+        metadata = await read_metadata(model_path)
+        if not metadata:
+            logger.warning("refresh_cache: no metadata for %s", model_path)
+            return False
+        await scanner.update_single_model_cache(model_path, model_path, metadata)
+        return True
+    except Exception as exc:
+        logger.warning("refresh_cache failed for %s: %s", model_path, exc)
+        return False

py/agent_cli/__main__.py

@@ -0,0 +1,118 @@
+"""Subprocess entry point for AgentCLI (debugging / external use).
+
+Usage::
+
+    python -m py.agent_cli base-models list [--limit N]
+    python -m py.agent_cli metadata read <path>
+    python -m py.agent_cli metadata update <path> --json '{...}'
+    python -m py.agent_cli preview download <path> --url <url>
+    python -m py.agent_cli cache refresh <path>
+
+NOTE: This is an **optional** convenience wrapper.  The primary consumer of
+AgentCLI is the :mod:`AgentService` (in-process).  This entry point exists
+for manual debugging and future integration with subprocess-based agent
+frameworks.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from typing import Any, Dict, List
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="lmcli", description="LoRA Manager Agent CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # base-models list
+    base_models = sub.add_parser("base-models", aliases=["bm"])
+    base_models_cmds = base_models.add_subparsers(dest="subcommand", required=True)
+    base_models_list = base_models_cmds.add_parser("list")
+    base_models_list.add_argument(
+        "--limit", type=int, default=0, help="Max number of models (0 = all)"
+    )
+
+    # metadata read
+    meta = sub.add_parser("metadata", aliases=["md"])
+    meta_cmds = meta.add_subparsers(dest="subcommand", required=True)
+    meta_read = meta_cmds.add_parser("read")
+    meta_read.add_argument("path", type=str, help="Model file path")
+
+    # metadata update
+    meta_update = meta_cmds.add_parser("update")
+    meta_update.add_argument("path", type=str, help="Model file path")
+    meta_update.add_argument(
+        "--json",
+        type=str,
+        required=True,
+        help='JSON object of fields to update, e.g. \'{"base_model": "SDXL 1.0"}\'',
+    )
+
+    # preview download
+    prev = sub.add_parser("preview", aliases=["pv"])
+    prev_cmds = prev.add_subparsers(dest="subcommand", required=True)
+    prev_dl = prev_cmds.add_parser("download")
+    prev_dl.add_argument("path", type=str, help="Model file path")
+    prev_dl.add_argument("--url", type=str, required=True, help="Preview image URL")
+
+    # cache refresh
+    cache = sub.add_parser("cache")
+    cache_cmds = cache.add_subparsers(dest="subcommand", required=True)
+    cache_refresh = cache_cmds.add_parser("refresh")
+    cache_refresh.add_argument("path", type=str, help="Model file path")
+
+    return parser
+
+
+async def _run(args: argparse.Namespace) -> Any:
+    from . import (  # lazy import so startup is fast
+        list_base_models,
+        read_metadata,
+        apply_metadata_updates,
+        download_preview,
+        refresh_cache,
+    )
+
+    cmd = args.command
+    sub = args.subcommand
+
+    if cmd in ("base-models", "bm") and sub == "list":
+        return await list_base_models(limit=args.limit)
+
+    if cmd in ("metadata", "md") and sub == "read":
+        return await read_metadata(args.path)
+
+    if cmd in ("metadata", "md") and sub == "update":
+        updates: Dict[str, Any] = json.loads(args.json)
+        return await apply_metadata_updates(args.path, updates)
+
+    if cmd in ("preview", "pv") and sub == "download":
+        return await download_preview(args.path, args.url)
+
+    if cmd == "cache" and sub == "refresh":
+        return await refresh_cache(args.path)
+
+    raise ValueError(f"Unknown command: {cmd} {sub}")
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    result = asyncio.run(_run(args))
+    # Always print as JSON so callers can parse reliably
+    if isinstance(result, list):
+        for item in result:
+            print(item)
+    elif isinstance(result, dict):
+        json.dump(result, sys.stdout, ensure_ascii=False, indent=2)
+        print()
+    else:
+        print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

py/config.py

@@ -8,6 +8,8 @@ from typing import Any, Dict, Iterable, List, Mapping, Optional, Set, Tuple
 import logging
 import json
 import urllib.parse
+import sys as _sys
+import types as _types
 import time
 
 from .utils.cache_paths import CacheType, get_cache_file_path, get_legacy_cache_paths
@@ -172,6 +174,12 @@ class Config:
         self.extra_unet_roots: List[str] = []
         self.extra_embeddings_roots: List[str] = []
         self.recipes_path: str = ""
+
+        # Load extra folder paths from active library settings before symlink scan
+        # so both primary and extra paths are discovered in a single pass.
+        if not standalone_mode:
+            self._load_extra_paths_from_settings()
+
         # Scan symbolic links during initialization
         self._initialize_symlink_mappings()
 
@@ -179,6 +187,96 @@ class Config:
             # Save the paths to settings.json when running in ComfyUI mode
             self.save_folder_paths_to_settings()
 
+    def _load_extra_paths_from_settings(self) -> None:
+        """Read extra folder paths from the active library and apply them.
+
+        Called during ``Config.__init__`` before the symlink scan so both primary and
+        extra paths are discovered in a single pass.  Mirrors the extra-path
+        portion of ``_apply_library_paths`` without replacing the primary roots
+        that were already resolved from ComfyUI's ``folder_paths``.
+        """
+        try:
+            from .services.settings_manager import get_settings_manager
+
+            settings_manager = get_settings_manager()
+            library_name = settings_manager.get_active_library_name()
+            libraries = settings_manager.get_libraries()
+
+            if not library_name or library_name not in libraries:
+                return
+
+            library_config = libraries[library_name]
+            if not isinstance(library_config, dict):
+                return
+
+            extra_folder_paths = library_config.get("extra_folder_paths")
+            if not isinstance(extra_folder_paths, dict):
+                return
+
+            extra_lora = extra_folder_paths.get("loras", []) or []
+            extra_checkpoint = extra_folder_paths.get("checkpoints", []) or []
+            extra_unet = extra_folder_paths.get("unet", []) or []
+            extra_embedding = extra_folder_paths.get("embeddings", []) or []
+
+            if not any([extra_lora, extra_checkpoint, extra_unet, extra_embedding]):
+                return
+
+            filtered_extra_lora = self._filter_overlapping_extra_lora_paths(
+                self.loras_roots, extra_lora
+            )
+            self.extra_loras_roots = self._prepare_lora_paths(filtered_extra_lora)
+            (
+                _,
+                self.extra_checkpoints_roots,
+                self.extra_unet_roots,
+            ) = self._prepare_checkpoint_paths(extra_checkpoint, extra_unet)
+            self.extra_embeddings_roots = self._prepare_embedding_paths(
+                extra_embedding
+            )
+
+            recipes_path = library_config.get("recipes_path", "")
+            if isinstance(recipes_path, str) and recipes_path:
+                self.recipes_path = recipes_path
+
+            if self.extra_loras_roots:
+                logger.info(
+                    "Found extra LoRA roots:"
+                    + "\n - "
+                    + "\n - ".join(self.extra_loras_roots)
+                )
+            if self.extra_checkpoints_roots:
+                logger.info(
+                    "Found extra checkpoint roots:"
+                    + "\n - "
+                    + "\n - ".join(self.extra_checkpoints_roots)
+                )
+            if self.extra_unet_roots:
+                logger.info(
+                    "Found extra diffusion model roots:"
+                    + "\n - "
+                    + "\n - ".join(self.extra_unet_roots)
+                )
+            if self.extra_embeddings_roots:
+                logger.info(
+                    "Found extra embedding roots:"
+                    + "\n - "
+                    + "\n - ".join(self.extra_embeddings_roots)
+                )
+
+            logger.info(
+                "Applied library settings for '%s' with extra paths: loras=%s, "
+                "checkpoints=%s, embeddings=%s",
+                library_name,
+                extra_lora,
+                extra_checkpoint,
+                extra_embedding,
+            )
+
+        except Exception as exc:
+            logger.debug(
+                "Could not load extra paths from library settings: %s", exc
+            )
+
     def save_folder_paths_to_settings(self):
         """Persist ComfyUI-derived folder paths to the multi-library settings."""
         try:
@@ -1284,4 +1382,20 @@ class Config:
 
 
 # Global config instance
-config = Config()
+# NOTE: Guard against re-import.  When ServiceRegistry.get_lora_scanner() triggers
+# a fresh import of lora_scanner → config, we must NOT re-execute Config.__init__()
+# (which re-scans all roots, re-registers libraries, etc.).
+#
+# Strategy: store the config instance in a dedicated sentinel module
+# ('_lm_config_cache') that is NEVER removed from sys.modules (its key does
+# NOT start with 'py.'), so it survives re-imports of py.* modules.
+_CONFIG_SENTINEL = "_lm_config_cache"
+if _CONFIG_SENTINEL in _sys.modules:
+    # Re-import: reuse the existing singleton from the sentinel.
+    config: Config = _sys.modules[_CONFIG_SENTINEL].config  # type: ignore[valid-type]
+else:
+    config: Config = Config()
+    # Register the sentinel so re-imports of py.config find us.
+    _sentinel_mod = _types.ModuleType(_CONFIG_SENTINEL)
+    _sentinel_mod.config = config
+    _sys.modules[_CONFIG_SENTINEL] = _sentinel_mod

py/lora_manager.py

@@ -33,6 +33,7 @@ from .utils.example_images_migration import ExampleImagesMigration
 from .services.websocket_manager import ws_manager
 from .services.example_images_cleanup_service import ExampleImagesCleanupService
 from .middleware.csp_middleware import relax_csp_for_remote_media
+from .middleware.error_middleware import api_json_error
 
 logger = logging.getLogger(__name__)
 
@@ -76,6 +77,11 @@ class LoraManager:
         """Initialize and register all routes using the new refactored architecture"""
         app = PromptServer.instance.app
 
+        # Register JSON error middleware for /api/* routes as the outermost
+        # middleware so it catches errors from all other middlewares.
+        if api_json_error not in app.middlewares:
+            app.middlewares.insert(0, api_json_error)
+
         if relax_csp_for_remote_media not in app.middlewares:
             # Ensure CSP relaxer executes after ComfyUI's block_external_middleware so it can
             # see and extend the restrictive header instead of being overwritten by it.
@@ -184,44 +190,15 @@ class LoraManager:
     async def _initialize_services(cls):
         """Initialize all services using the ServiceRegistry"""
         try:
-            # Apply library settings to load extra folder paths before scanning
-            # Only apply if extra paths haven't been loaded yet (preserves test mocks)
-            try:
-                from .services.settings_manager import get_settings_manager
-
-                settings_manager = get_settings_manager()
-                library_name = settings_manager.get_active_library_name()
-                libraries = settings_manager.get_libraries()
-                if library_name and library_name in libraries:
-                    library_config = libraries[library_name]
-                    # Only apply settings if extra paths are not already configured
-                    # This preserves values set by tests via monkeypatch
-                    extra_paths = library_config.get("extra_folder_paths", {})
-                    has_extra_paths = (
-                        config.extra_loras_roots
-                        or config.extra_checkpoints_roots
-                        or config.extra_unet_roots
-                        or config.extra_embeddings_roots
-                    )
-                    if not has_extra_paths and any(extra_paths.values()):
-                        config.apply_library_settings(library_config)
-                        logger.info(
-                            "Applied library settings for '%s' with extra paths: loras=%s, checkpoints=%s, embeddings=%s",
-                            library_name,
-                            extra_paths.get("loras", []),
-                            extra_paths.get("checkpoints", []),
-                            extra_paths.get("embeddings", []),
-                        )
-            except Exception as exc:
-                logger.warning(
-                    "Failed to apply library settings during initialization: %s", exc
-                )
-
             # Initialize CivitaiClient first to ensure it's ready for other services
             await ServiceRegistry.get_civitai_client()
 
             # Register DownloadManager with ServiceRegistry
             await ServiceRegistry.get_download_manager()
+
+            # Initialize DownloadQueueService for persistent queue/history
+            await ServiceRegistry.get_download_queue_service()
+
             await ServiceRegistry.get_backup_service()
 
             from .services.metadata_service import initialize_metadata_providers
@@ -459,5 +436,21 @@ class LoraManager:
         try:
             logger.info("LoRA Manager: Cleaning up services")
 
+            # Cancel any in-flight scanner initialization tasks so thread-pool
+            # workers (e.g. _initialize_cache_sync) can break out of their loops
+            # when the server shuts down (e.g. Ctrl+C on WSL).
+            for name in ("lora_scanner", "checkpoint_scanner", "embedding_scanner"):
+                scanner = ServiceRegistry.get_service_sync(name)
+                if scanner is not None and hasattr(scanner, "cancel_task"):
+                    scanner.cancel_task()
+                    logger.debug("LoRA Manager: Cancelled %s", name)
+
+            # Close shared aiohttp sessions to avoid "Unclosed client session" warnings
+            try:
+                from py.routes.handlers.hf_handlers import close_hf_api_session
+                await close_hf_api_session()
+            except Exception as exc:
+                logger.debug("Error closing HF API session: %s", exc)
+
         except Exception as e:
             logger.error(f"Error during cleanup: {e}", exc_info=True)

py/metadata_collector/constants.py

@@ -5,9 +5,10 @@ MODELS = "models"
 PROMPTS = "prompts"
 SAMPLING = "sampling"
 LORAS = "loras"
+EMBEDDINGS = "embeddings"
 SIZE = "size"
 IMAGES = "images"
 IS_SAMPLER = "is_sampler"  # New constant to mark sampler nodes
 
 # Complete list of categories to track
-METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES]
+METADATA_CATEGORIES = [MODELS, PROMPTS, SAMPLING, LORAS, EMBEDDINGS, SIZE, IMAGES]

py/metadata_collector/node_extractors.py

@@ -901,6 +901,55 @@ class LoraLoaderManagerExtractor(NodeMetadataExtractor):
                 "node_id": node_id
             }
 
+class LoraTextLoaderManagerExtractor(NodeMetadataExtractor):
+    """Extract LoRA metadata from LoraTextLoaderLM (LoRA Text Loader).
+
+    The node accepts a `lora_syntax` STRING containing <lora:name:strength> tags
+    (same format as the ComfyUI prompt), plus an optional `lora_stack`.
+    This extractor parses the syntax string using the same regex as the node.
+    """
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+
+        active_loras = []
+
+        # Process lora_stack if available (optional input)
+        if "lora_stack" in inputs:
+            lora_stack = inputs.get("lora_stack", [])
+            for item in lora_stack:
+                # lora_stack entries are (path, model_strength, clip_strength) tuples
+                if isinstance(item, (list, tuple)) and len(item) >= 2:
+                    lora_path = item[0]
+                    model_strength = item[1]
+                    lora_name = os.path.splitext(os.path.basename(lora_path))[0]
+                    active_loras.append({
+                        "name": lora_name,
+                        "strength": round(float(model_strength), 2)
+                    })
+
+        # Process lora_syntax string input
+        if "lora_syntax" in inputs:
+            lora_syntax = inputs.get("lora_syntax", "")
+            if lora_syntax and isinstance(lora_syntax, str):
+                pattern = r"<lora:([^:>]+):([^:>]+)(?::([^:>]+))?>"
+                matches = re.findall(pattern, lora_syntax, re.IGNORECASE)
+                for match in matches:
+                    lora_name = match[0]
+                    model_strength = float(match[1])
+                    active_loras.append({
+                        "name": lora_name,
+                        "strength": round(model_strength, 2)
+                    })
+
+        if active_loras:
+            metadata[LORAS][node_id] = {
+                "lora_list": active_loras,
+                "node_id": node_id
+            }
+
+
 class FluxGuidanceExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -1146,6 +1195,7 @@ NODE_EXTRACTORS = {
     "UNETLoaderLM": UNETLoaderExtractor,  # LoRA Manager
     "LoraLoader": LoraLoaderExtractor,
     "LoraLoaderLM": LoraLoaderManagerExtractor,
+    "LoraTextLoaderLM": LoraTextLoaderManagerExtractor,
     "RgthreePowerLoraLoader": RgthreePowerLoraLoaderExtractor,
     "TensorRTLoader": TensorRTLoaderExtractor,
     # Conditioning

py/middleware/cache_middleware.py

@@ -16,6 +16,8 @@ IMG_EXTENSIONS = (
     ".tif",
     ".tiff",
     ".webp",
+    ".avif",
+    ".jxl",
     ".mp4"
 )
 

py/middleware/error_middleware.py

@@ -0,0 +1,71 @@
+"""JSON error middleware for API routes.
+
+Ensures all responses to /api/* requests return valid JSON that the
+browser-extension frontend can JSON.parse() without crashing, even when
+the route does not exist (404) or the handler raises an exception (500).
+
+Extension consumers call response.json() unconditionally — an HTML error
+page causes ``SyntaxError: unexpected end of data`` that leaks into the
+popup UI as a toast notification.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Awaitable, Callable
+
+from aiohttp import web
+
+logger = logging.getLogger(__name__)
+
+
+@web.middleware
+async def api_json_error(
+    request: web.Request,
+    handler: Callable[[web.Request], Awaitable[web.Response]],
+) -> web.Response:
+    """Return JSON ``{"success": false, "error": "..."}`` for API errors.
+
+    Only intercepts paths starting with ``/api/`` — all other routes
+    (frontend pages, static files, WebSocket upgrades) pass through
+    unchanged.
+    """
+    if not request.path.startswith("/api/"):
+        return await handler(request)
+
+    try:
+        response = await handler(request)
+        return response
+    except web.HTTPException as exc:
+        # Let redirects (301, 302, 307, 308) propagate — they are not errors.
+        if exc.status < 400:
+            raise
+
+        logger.warning(
+            "API %s %s returned HTTP %d: %s",
+            request.method,
+            request.path,
+            exc.status,
+            exc.reason,
+        )
+
+        return web.json_response(
+            {"success": False, "error": f"{exc.status}: {exc.reason}"},
+            status=exc.status,
+        )
+    except Exception as exc:
+        logger.error(
+            "API %s %s raised unhandled exception: %s",
+            request.method,
+            request.path,
+            exc,
+            exc_info=True,
+        )
+
+        return web.json_response(
+            {
+                "success": False,
+                "error": f"500: Internal Server Error ({type(exc).__name__})",
+            },
+            status=500,
+        )

py/nodes/lora_loader.py

@@ -9,6 +9,7 @@ from ..utils.utils import get_lora_info_absolute
 from .utils import (
     FlexibleOptionalInputType,
     any_type,
+    apply_lora_syntax_format,
     detect_nunchaku_model_kind,
     extract_lora_name,
     get_loras_list,
@@ -52,7 +53,7 @@ def _collect_widget_entries(kwargs):
     for lora in get_loras_list(kwargs):
         if not lora.get("active", False):
             continue
-        lora_name = lora["name"]
+        lora_name = apply_lora_syntax_format(lora["name"])
         model_strength = float(lora["strength"])
         clip_strength = float(lora.get("clipStrength", model_strength))
         lora_path, trigger_words = get_lora_info_absolute(lora_name)

py/nodes/lora_stacker.py

@@ -1,6 +1,6 @@
 import os
 from ..utils.utils import get_lora_info
-from .utils import FlexibleOptionalInputType, any_type, extract_lora_name, get_loras_list
+from .utils import FlexibleOptionalInputType, any_type, apply_lora_syntax_format, extract_lora_name, get_loras_list
 
 import logging
 
@@ -48,7 +48,7 @@ class LoraStackerLM:
             if not lora.get('active', False):
                 continue
                 
-            lora_name = lora['name']
+            lora_name = apply_lora_syntax_format(lora['name'])
             model_strength = float(lora['strength'])
             # Get clip strength - use model strength as default if not specified
             clip_strength = float(lora.get('clipStrength', model_strength))

py/nodes/save_image.py

@@ -11,7 +11,7 @@ from ..metadata_collector.metadata_processor import MetadataProcessor
 from ..metadata_collector import get_metadata
 from ..utils.constants import CARD_PREVIEW_WIDTH
 from ..utils.exif_utils import ExifUtils
-from ..utils.utils import calculate_recipe_fingerprint
+from ..utils.utils import calculate_recipe_fingerprint, sanitize_folder_name
 from PIL import Image, PngImagePlugin
 import piexif
 import logging
@@ -298,7 +298,12 @@ class SaveImageLM:
             key = parts[0]
 
             if key == "seed" and "seed" in metadata_dict:
-                filename = filename.replace(segment, str(metadata_dict.get("seed", "")))
+                seed_value = metadata_dict.get("seed")
+                if seed_value is not None:
+                    filename = filename.replace(segment, str(seed_value))
+                else:
+                    # Fallback if seed was not captured by metadata collector
+                    filename = filename.replace(segment, "0")
             elif key == "width" and "size" in metadata_dict:
                 size = metadata_dict.get("size", "x")
                 w = size.split("x")[0] if isinstance(size, str) else size[0]
@@ -309,12 +314,14 @@ class SaveImageLM:
                 filename = filename.replace(segment, str(h))
             elif key == "pprompt" and "prompt" in metadata_dict:
                 prompt = metadata_dict.get("prompt", "").replace("\n", " ")
+                prompt = sanitize_folder_name(prompt)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
                 filename = filename.replace(segment, prompt.strip())
             elif key == "nprompt" and "negative_prompt" in metadata_dict:
                 prompt = metadata_dict.get("negative_prompt", "").replace("\n", " ")
+                prompt = sanitize_folder_name(prompt)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     prompt = prompt[:length]
@@ -328,6 +335,7 @@ class SaveImageLM:
                     model = "model_unavailable"
                 else:
                     model = os.path.splitext(os.path.basename(model_value))[0]
+                    model = sanitize_folder_name(model)
                 if len(parts) >= 2:
                     length = int(parts[1])
                     model = model[:length]
@@ -600,7 +608,7 @@ class SaveImageLM:
             img = Image.fromarray(np.clip(img, 0, 255).astype(np.uint8))
 
             # Generate filename with counter if needed
-            base_filename = filename
+            base_filename = filename.replace("%batch_num%", str(i))
             if add_counter_to_filename:
                 # Use counter + i to ensure unique filenames for all images in batch
                 current_counter = counter + i

py/nodes/utils.py

@@ -44,11 +44,29 @@ import folder_paths  # type: ignore
 logger = logging.getLogger(__name__)
 
 
+def get_lora_syntax_format():
+    try:
+        from ..services.settings_manager import get_settings_manager
+        return get_settings_manager().get("lora_syntax_format", "legacy")
+    except Exception:
+        return "legacy"
+
+
+def apply_lora_syntax_format(name):
+    fmt = get_lora_syntax_format()
+    if fmt == "legacy":
+        return name.replace("\\", "/").rstrip("/").split("/")[-1]
+    return name
+
+
 def extract_lora_name(lora_path):
-    """Extract the lora name from a lora path (e.g., 'IL\\aorunIllstrious.safetensors' -> 'aorunIllstrious')"""
-    # Get the basename without extension
-    basename = os.path.basename(lora_path)
-    return os.path.splitext(basename)[0]
+    normalized = lora_path.replace("\\", "/")
+    basename = os.path.basename(normalized)
+    name_no_ext = os.path.splitext(basename)[0]
+    dirname = os.path.dirname(normalized)
+    if dirname and dirname not in (".", "/") and not normalized.startswith("/"):
+        return apply_lora_syntax_format(f"{dirname}/{name_no_ext}")
+    return apply_lora_syntax_format(name_no_ext)
 
 
 def get_loras_list(kwargs):

py/recipes/base.py

@@ -7,7 +7,7 @@ import re
 from typing import Dict, List, Any, Optional, Tuple
 from abc import ABC, abstractmethod
 from ..config import config
-from ..utils.constants import VALID_LORA_TYPES
+from ..utils.constants import VALID_LORA_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.civitai_utils import rewrite_preview_url
 
 logger = logging.getLogger(__name__)
@@ -58,9 +58,52 @@ class RecipeMetadataParser(ABC):
             civitai_info, error_msg = civitai_info_tuple if isinstance(civitai_info_tuple, tuple) else (civitai_info_tuple, None)
             
             if not civitai_info or error_msg == "Model not found":
-                # Model not found or deleted
-                lora_entry['isDeleted'] = True
-                lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
+                # CivitAI may fail to resolve a hash that is still being
+                # computed (known CivitAI issue). Before marking as deleted,
+                # try to reconcile with a local model that has the same
+                # filename and matching AutoV3 hash.
+                reconciled = False
+                file_name = lora_entry.get("file_name")
+                if file_name and recipe_scanner and hash_value:
+                    lora_scanner = getattr(recipe_scanner, "_lora_scanner", None)
+                    if lora_scanner:
+                        try:
+                            # Local import to avoid circular dependency:
+                            # base.py → file_utils → settings_manager → ...
+                            #  → recipe_scanner → enrichment → base.py
+                            from ..utils.file_utils import calculate_autov3  # fmt: skip
+                            cache = await lora_scanner.get_cached_data()
+                            for item in getattr(cache, "raw_data", []):
+                                if item.get("file_name") == file_name:
+                                    local_path = item.get("file_path")
+                                    if local_path and os.path.exists(local_path):
+                                        local_autov3 = calculate_autov3(local_path)
+                                        if local_autov3 and local_autov3 == hash_value:
+                                            lora_entry["existsLocally"] = True
+                                            lora_entry["localPath"] = local_path
+                                            lora_entry["hash"] = item.get("sha256", hash_value)
+                                            if "preview_url" in item:
+                                                lora_entry["thumbnailUrl"] = config.get_preview_static_url(item["preview_url"])
+                                            civ = item.get("civitai") or {}
+                                            if isinstance(civ, dict):
+                                                if civ.get("id") is not None:
+                                                    lora_entry["id"] = civ["id"]
+                                                if civ.get("modelId") is not None:
+                                                    lora_entry["modelId"] = civ["modelId"]
+                                                if civ.get("name"):
+                                                    lora_entry["version"] = civ["name"]
+                                                # model_name is the CivitAI model display
+                                                # name stored directly in the cache column.
+                                                cached_model_name = item.get("model_name")
+                                                if cached_model_name:
+                                                    lora_entry["name"] = cached_model_name
+                                            reconciled = True
+                                            break
+                        except Exception:
+                            pass
+                if not reconciled:
+                    lora_entry['isDeleted'] = True
+                    lora_entry['thumbnailUrl'] = '/loras_static/images/no-preview.png'
                 return lora_entry
                 
             # Get model type and validate
@@ -173,6 +216,20 @@ class RecipeMetadataParser(ABC):
                 checkpoint['isDeleted'] = True
                 return checkpoint
 
+            # Validate that the model type is actually a checkpoint.
+            # Unlike populate_lora_from_civitai which has this check,
+            # this function was missing type validation — allowing LoRA
+            # version data to be saved as the recipe's checkpoint when the
+            # wrong version ID was passed downstream (fixed in v2.7+).
+            model_type = civitai_data.get('model', {}).get('type', '').lower()
+            if model_type not in VALID_CHECKPOINT_SUB_TYPES:
+                logger.warning(
+                    f"Cannot populate checkpoint: model version {civitai_data.get('id')} "
+                    f"has type '{model_type}', expected one of {VALID_CHECKPOINT_SUB_TYPES}. "
+                    f"Skipping checkpoint enrichment."
+                )
+                return checkpoint
+
             if 'model' in civitai_data and 'name' in civitai_data['model']:
                 checkpoint['name'] = civitai_data['model']['name']
 

py/recipes/enrichment.py

@@ -16,55 +16,65 @@ class RecipeEnricher:
     async def enrich_recipe(
         recipe: Dict[str, Any],
         civitai_client: Any,
-        request_params: Optional[Dict[str, Any]] = None
+        request_params: Optional[Dict[str, Any]] = None,
+        prefetched_civitai_meta_raw: Optional[Dict[str, Any]] = None,
+        prefetched_model_version_id: Optional[int] = None,
     ) -> bool:
         """
         Enrich a recipe dictionary in-place with metadata from Civitai and embedded params.
-        
+
         Args:
             recipe: The recipe dictionary to enrich. Must have 'gen_params' initialized.
             civitai_client: Authenticated Civitai client instance.
             request_params: (Optional) Parameters from a user request (e.g. import).
-            
+            prefetched_civitai_meta_raw: (Optional) Pre-fetched raw meta from Civitai
+                get_image_info, avoiding a duplicate API call.
+            prefetched_model_version_id: (Optional) Pre-fetched model version ID.
+
         Returns:
             bool: True if the recipe was modified, False otherwise.
         """
         updated = False
         gen_params = recipe.get("gen_params", {})
-        
-        # 1. Fetch Civitai Info if available
+
+        # 1. Obtain Civitai metadata
         civitai_meta = None
-        model_version_id = None
-        
-        source_url = recipe.get("source_url") or recipe.get("source_path", "")
-        
-        # Check if it's a Civitai image URL
-        image_id = extract_civitai_image_id(str(source_url))
-        if image_id:
-            try:
-                image_info = await civitai_client.get_image_info(
-                    image_id, source_url=str(source_url)
-                )
-                if image_info:
-                    # Handle nested meta often found in Civitai API responses
-                    raw_meta = image_info.get("meta")
-                    if isinstance(raw_meta, dict):
-                        if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
-                            civitai_meta = raw_meta["meta"]
-                        else:
-                            civitai_meta = raw_meta
-                    
-                    model_version_id = image_info.get("modelVersionId")
-                    
-                    # If not at top level, check resources in meta
-                    if not model_version_id and civitai_meta:
-                        resources = civitai_meta.get("civitaiResources", [])
-                        for res in resources:
-                            if res.get("type") == "checkpoint":
-                                model_version_id = res.get("modelVersionId")
-                                break
-            except Exception as e:
-                logger.warning(f"Failed to fetch Civitai image info: {e}")
+        model_version_id = prefetched_model_version_id
+
+        source_path = recipe.get("source_path", "")
+
+        if prefetched_civitai_meta_raw is not None:
+            raw_meta = prefetched_civitai_meta_raw
+            if isinstance(raw_meta, dict):
+                if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
+                    civitai_meta = raw_meta["meta"]
+                else:
+                    civitai_meta = raw_meta
+        else:
+            image_id = extract_civitai_image_id(str(source_path))
+            if image_id:
+                try:
+                    image_info = await civitai_client.get_image_info(
+                        image_id, source_url=str(source_path)
+                    )
+                    if image_info:
+                        raw_meta = image_info.get("meta")
+                        if isinstance(raw_meta, dict):
+                            if "meta" in raw_meta and isinstance(raw_meta["meta"], dict):
+                                civitai_meta = raw_meta["meta"]
+                            else:
+                                civitai_meta = raw_meta
+
+                        model_version_id = image_info.get("modelVersionId")
+                except Exception as e:
+                    logger.warning(f"Failed to fetch Civitai image info: {e}")
+
+        if not model_version_id and civitai_meta:
+            resources = civitai_meta.get("civitaiResources", [])
+            for res in resources:
+                if res.get("type") == "checkpoint":
+                    model_version_id = res.get("modelVersionId")
+                    break
 
         # 2. Merge Parameters
         # Priority: request_params > civitai_meta > embedded (existing gen_params)
@@ -180,27 +190,42 @@ class RecipeEnricher:
             existing_cp = recipe.get("checkpoint")
             if existing_cp is None:
                 existing_cp = {}
+
+            # Extract baseModel from raw civitai_info before populate_checkpoint_from_civitai
+            # (populate may reject non-checkpoint types and lose this data)
+            base_model_from_civitai: str = ""
+            if isinstance(civitai_info, dict):
+                base_model_from_civitai = civitai_info.get("baseModel", "") or ""
+            elif isinstance(civitai_info, tuple) and len(civitai_info) > 0 and isinstance(civitai_info[0], dict):
+                base_model_from_civitai = civitai_info[0].get("baseModel", "") or ""
+
             checkpoint_data = await RecipeMetadataParser.populate_checkpoint_from_civitai(existing_cp, civitai_info)
-            # 1. First, resolve base_model using full data before we format it away
+
+            # 1. Resolve base_model from checkpoint_data first, then fall back to raw civitai_info
             current_base_model = recipe.get("base_model")
-            resolved_base_model = checkpoint_data.get("baseModel")
+            resolved_base_model = checkpoint_data.get("baseModel") or base_model_from_civitai
             if resolved_base_model:
-                # Update if empty OR if it matches our generic prefix but is less specific
                 is_generic = not current_base_model or current_base_model.lower() in ["flux", "sdxl", "sd15"]
                 if is_generic and resolved_base_model != current_base_model:
                     recipe["base_model"] = resolved_base_model
-            
-            # 2. Format according to requirements: type, modelId, modelVersionId, modelName, modelVersionName
-            formatted_checkpoint = {
-                "type": "checkpoint",
-                "modelId": checkpoint_data.get("modelId"),
-                "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
-                "modelName": checkpoint_data.get("name"), # In base.py, 'name' is populated from civitai_data['model']['name']
-                "modelVersionName": checkpoint_data.get("version") # In base.py, 'version' is populated from civitai_data['name']
-            }
-            # Remove None values
-            recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
-            
+
+            # 2. Only format and save checkpoint if it has real data (not just type after type rejection)
+            has_checkpoint_data = any([
+                checkpoint_data.get("modelId"),
+                checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
+                checkpoint_data.get("name"),
+                checkpoint_data.get("version"),
+            ])
+            if has_checkpoint_data:
+                formatted_checkpoint = {
+                    "type": "checkpoint",
+                    "modelId": checkpoint_data.get("modelId"),
+                    "modelVersionId": checkpoint_data.get("id") or checkpoint_data.get("modelVersionId"),
+                    "modelName": checkpoint_data.get("name"),
+                    "modelVersionName": checkpoint_data.get("version"),
+                }
+                recipe["checkpoint"] = {k: v for k, v in formatted_checkpoint.items() if v is not None}
+
             return True
         else:
             # Fallback to name extraction if we don't already have one

py/recipes/parsers/automatic.py

@@ -123,24 +123,39 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         if model_hash_from_hashes:
                             metadata["model_hash"] = model_hash_from_hashes
                     
-                    # Extract Lora hashes in alternative format
+                    # Extract Lora hashes in alternative format.
+                    # Run unconditionally (not just as fallback) so that
+                    # non-empty hashes from Lora hashes fill in the gaps left
+                    # by empty values in the Hashes JSON dict.  Some WebUI
+                    # builds write real hash values only to Lora hashes and
+                    # leave the Hashes JSON values empty.
                     lora_hashes_match = re.search(self.LORA_HASHES_REGEX, params_section)
-                    if not hashes_match and lora_hashes_match:
+                    if lora_hashes_match:
                         try:
                             lora_hashes_str = lora_hashes_match.group(1)
                             lora_hash_entries = lora_hashes_str.split(', ')
-                            
-                            # Initialize hashes dict if it doesn't exist
-                            if "hashes" not in metadata:
-                                metadata["hashes"] = {}
-                                
+
                             # Parse each lora hash entry (format: "name: hash")
                             for entry in lora_hash_entries:
                                 if ': ' in entry:
                                     lora_name, lora_hash = entry.split(': ', 1)
-                                    # Add as lora type in the same format as regular hashes
-                                    metadata["hashes"][f"lora:{lora_name}"] = lora_hash.strip()
-                            
+                                    lora_hash = lora_hash.strip()
+                                    if not lora_hash:
+                                        # Skip entries without a hash value
+                                        continue
+                                    # Initialize hashes dict if it doesn't exist
+                                    if "hashes" not in metadata:
+                                        metadata["hashes"] = {}
+                                    # Add as lora type in the same format as
+                                    # regular hashes.  Only override an
+                                    # existing entry if its value is empty
+                                    # (Lora hashes is the more reliable
+                                    # source when Hashes JSON has blanks).
+                                    key = f"lora:{lora_name}"
+                                    existing = metadata["hashes"].get(key, "")
+                                    if not existing:
+                                        metadata["hashes"][key] = lora_hash
+
                             # Remove lora hashes from params section
                             params_section = params_section.replace(lora_hashes_match.group(0), '')
                         except Exception as e:
@@ -362,6 +377,12 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         # Only process lora or hypernet types
                         if not hash_key.startswith(("lora:", "hypernet:")):
                             continue
+                        
+                        # Skip entries without a hash value — they can't be
+                        # resolved via CivitAI and would only produce a
+                        # useless "Deleted" entry in the recipe.
+                        if not lora_hash:
+                            continue
                             
                         lora_type, lora_name = hash_key.split(':', 1)
                         
@@ -387,11 +408,7 @@ class AutomaticMetadataParser(RecipeMetadataParser):
                         # Try to get info from Civitai
                         if metadata_provider:
                             try:
-                                if lora_hash:
-                                    # If we have hash, use it for lookup
-                                    civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
-                                else:
-                                    civitai_info = None
+                                civitai_info = await metadata_provider.get_model_by_hash(lora_hash)
                                 
                                 populated_entry = await self.populate_lora_from_civitai(
                                     lora_entry, 

py/recipes/parsers/civitai_image.py

@@ -6,6 +6,7 @@ from typing import Dict, Any, Union
 from ..base import RecipeMetadataParser
 from ..constants import GEN_PARAM_KEYS
 from ...services.metadata_service import get_default_metadata_provider
+from ...config import config
 
 logger = logging.getLogger(__name__)
 
@@ -73,7 +74,8 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
         return False
 
     async def parse_metadata(  # type: ignore[override]
-        self, user_comment, recipe_scanner=None, civitai_client=None
+        self, user_comment, recipe_scanner=None, civitai_client=None,
+        local_cache: dict[str, Any] | None = None,
     ) -> Dict[str, Any]:
         """Parse metadata from Civitai image format
 
@@ -81,6 +83,8 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             user_comment: The metadata from the image (dict)
             recipe_scanner: Optional recipe scanner service
             civitai_client: Optional Civitai API client (deprecated, use metadata_provider instead)
+            local_cache: Optional dict mapping sha256/autov3 hash → scanner cache item.
+                         When provided, matching models skip CivitAI API calls.
 
         Returns:
             Dict containing parsed recipe data
@@ -185,8 +189,77 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
             # Process standard resources array
             if "resources" in metadata and isinstance(metadata["resources"], list):
                 for resource in metadata["resources"]:
+                    resource_type = resource.get("type", "lora")
+
+                    # Track resources with type "model" — these are checkpoint models.
+                    # The resources array is the most reliable source for checkpoint
+                    # identification because it has an explicit type field and hash,
+                    # unlike modelVersionIds which is a flat list with no type info.
+                    if resource_type == "model":
+                        checkpoint_entry = {
+                            "id": 0,
+                            "modelId": 0,
+                            "name": resource.get("name", "Unknown Model"),
+                            "version": "",
+                            "type": resource.get("type", "model"),
+                            "existsLocally": False,
+                            "localPath": None,
+                            "file_name": resource.get("name", ""),
+                            "hash": resource.get("hash", "") or "",
+                            "thumbnailUrl": "/loras_static/images/no-preview.png",
+                            "baseModel": "",
+                            "size": 0,
+                            "downloadUrl": "",
+                            "isDeleted": False,
+                        }
+
+                        # Try to look up base model from the checkpoint hash
+                        cp_hash = checkpoint_entry.get("hash")
+                        if cp_hash and metadata_provider:
+                            local_cached = local_cache.get(cp_hash) if local_cache else None
+                            if local_cached:
+                                self._populate_entry_from_cache(
+                                    checkpoint_entry, local_cached
+                                )
+                                bm = checkpoint_entry.get("baseModel", "")
+                                if bm and not result["base_model"]:
+                                    result["base_model"] = bm
+                            else:
+                                try:
+                                    civitai_info = (
+                                        await metadata_provider.get_model_by_hash(
+                                            cp_hash
+                                        )
+                                    )
+                                    civitai_data, error_msg = (
+                                        (civitai_info, None)
+                                        if not isinstance(civitai_info, tuple)
+                                        else civitai_info
+                                    )
+                                    if civitai_data and error_msg != "Model not found":
+                                        if 'model' in civitai_data and 'name' in civitai_data['model']:
+                                            checkpoint_entry['name'] = civitai_data['model']['name']
+                                        checkpoint_entry['id'] = civitai_data.get('id', 0)
+                                        checkpoint_entry['modelId'] = civitai_data.get('modelId', 0)
+                                        if 'name' in civitai_data:
+                                            checkpoint_entry['version'] = civitai_data['name']
+                                        base_model = civitai_data.get('baseModel', '')
+                                        if base_model:
+                                            checkpoint_entry['baseModel'] = base_model
+                                            if not result['base_model']:
+                                                result['base_model'] = base_model
+                                except Exception as e:
+                                    logger.error(
+                                        f"Error fetching checkpoint info for hash "
+                                        f"{cp_hash}: {e}"
+                                    )
+
+                        if result["model"] is None:
+                            result["model"] = checkpoint_entry
+                        continue
+
                     # Modified to process resources without a type field as potential LoRAs
-                    if resource.get("type", "lora") == "lora":
+                    if resource_type == "lora":
                         lora_hash = resource.get("hash", "")
 
                         # Try to get hash from the hashes field if not present in resource
@@ -220,34 +293,45 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                         }
 
                         # Try to get info from Civitai if hash is available
-                        if lora_entry["hash"] and metadata_provider:
-                            try:
-                                civitai_info = (
-                                    await metadata_provider.get_model_by_hash(lora_hash)
+                        if lora_hash and metadata_provider:
+                            local_cached = local_cache.get(lora_hash) if local_cache else None
+                            if local_cached:
+                                self._populate_entry_from_cache(
+                                    lora_entry, local_cached
                                 )
-
-                                populated_entry = await self.populate_lora_from_civitai(
-                                    lora_entry,
-                                    civitai_info,
-                                    recipe_scanner,
-                                    base_model_counts,
-                                    lora_hash,
-                                )
-
-                                if populated_entry is None:
-                                    continue  # Skip invalid LoRA types
-
-                                lora_entry = populated_entry
-
-                                # If we have a version ID from Civitai, track it for deduplication
-                                if "id" in lora_entry and lora_entry["id"]:
+                                # Track by version ID for deduplication
+                                if lora_entry.get("id"):
                                     added_loras[str(lora_entry["id"])] = len(
                                         result["loras"]
                                     )
-                            except Exception as e:
-                                logger.error(
-                                    f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
-                                )
+                            else:
+                                try:
+                                    civitai_info = (
+                                        await metadata_provider.get_model_by_hash(lora_hash)
+                                    )
+
+                                    populated_entry = await self.populate_lora_from_civitai(
+                                        lora_entry,
+                                        civitai_info,
+                                        recipe_scanner,
+                                        base_model_counts,
+                                        lora_hash,
+                                    )
+
+                                    if populated_entry is None:
+                                        continue  # Skip invalid LoRA types
+
+                                    lora_entry = populated_entry
+
+                                    # If we have a version ID from Civitai, track it for deduplication
+                                    if "id" in lora_entry and lora_entry["id"]:
+                                        added_loras[str(lora_entry["id"])] = len(
+                                            result["loras"]
+                                        )
+                                except Exception as e:
+                                    logger.error(
+                                        f"Error fetching Civitai info for LoRA hash {lora_entry['hash']}: {e}"
+                                    )
 
                         # Track by hash if we have it
                         if lora_hash:
@@ -430,11 +514,21 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
 
                         result["loras"].append(lora_entry)
 
-            # Process modelVersionIds from Civitai image API
-            # These are model version IDs returned at root level when meta doesn't contain resources
-            if "modelVersionIds" in metadata and isinstance(
-                metadata["modelVersionIds"], list
+            # Process modelVersionIds from Civitai image API.
+            # These are version IDs returned at root level of the API response.
+            # When resources or civitaiResources are already present in metadata
+            # (which they are when ?withMeta=true is passed), those sections have
+            # complete hash/type information — modelVersionIds is a fallback for
+            # when meta is null and only the flat ID list is available. Skipping
+            # it here avoids duplicates: the same file hash often resolves to
+            # different version IDs via hash lookup (resources) vs the original
+            # version ID in modelVersionIds, and both paths would create entries.
+            if (
+                "modelVersionIds" in metadata
+                and isinstance(metadata["modelVersionIds"], list)
+                and not result.get("loras")
             ):
+
                 for version_id in metadata["modelVersionIds"]:
                     version_id_str = str(version_id)
 
@@ -442,6 +536,13 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                     if version_id_str in added_loras:
                         continue
 
+                    # Skip if this version ID is already the recipe's checkpoint
+                    # (resolved earlier from embedded resources/Model hash,
+                    # avoiding a duplicate CivitAI API call).
+                    existing_model = result.get("model")
+                    if existing_model and str(existing_model.get("id")) == version_id_str:
+                        continue
+
                     # Initialize lora entry with version ID
                     lora_entry = {
                         "id": version_id,
@@ -475,9 +576,40 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
                             )
 
                             if populated_entry is None:
-                                continue  # Skip invalid LoRA types
+                                # Not a LoRA — try as checkpoint (only if we
+                                # don't already have one).  Reuses the same
+                                # civitai_info from the API call above so no
+                                # extra query is made.
+                                if result["model"] is None:
+                                    checkpoint_entry = {
+                                        "id": version_id,
+                                        "modelId": 0,
+                                        "name": "Unknown Model",
+                                        "version": "",
+                                        "type": "checkpoint",
+                                        "existsLocally": False,
+                                        "localPath": None,
+                                        "file_name": "",
+                                        "hash": "",
+                                        "thumbnailUrl": (
+                                            "/loras_static/images/no-preview.png"
+                                        ),
+                                        "baseModel": "",
+                                        "size": 0,
+                                        "downloadUrl": "",
+                                        "isDeleted": False,
+                                    }
+                                    cp_populated = await (
+                                        self.populate_checkpoint_from_civitai(
+                                            checkpoint_entry, civitai_info
+                                        )
+                                    )
+                                    if cp_populated.get("modelId"):
+                                        result["model"] = cp_populated
+                                continue  # Not a LoRA, don't add to loras
 
                             lora_entry = populated_entry
+
                         except Exception as e:
                             logger.error(
                                 f"Error fetching Civitai info for model version {version_id}: {e}"
@@ -625,3 +757,41 @@ class CivitaiApiMetadataParser(RecipeMetadataParser):
         except Exception as e:
             logger.error(f"Error parsing Civitai image metadata: {e}", exc_info=True)
             return {"error": str(e), "loras": []}
+
+    @staticmethod
+    def _populate_entry_from_cache(
+        entry: dict[str, Any],
+        cache_item: dict[str, Any],
+    ) -> None:
+        """Fill a lora/checkpoint entry from a scanner cache item.
+
+        Avoids CivitAI API calls for models that exist locally.
+        Mirrors the population logic in
+        ``RecipeMetadataParser.populate_lora_from_civitai()`` but operates
+        entirely on cached data.
+        """
+        civ = cache_item.get("civitai") or {}
+        if isinstance(civ, dict):
+            if civ.get("id") is not None:
+                entry["id"] = civ["id"]
+            if civ.get("modelId") is not None:
+                entry["modelId"] = civ["modelId"]
+            if civ.get("name"):
+                entry["version"] = civ["name"]
+            cached_name = cache_item.get("model_name")
+            if cached_name:
+                entry["name"] = cached_name
+        entry["existsLocally"] = True
+        local_path = cache_item.get("file_path")
+        if local_path:
+            entry["localPath"] = local_path
+        sha256 = cache_item.get("sha256")
+        if sha256:
+            entry["hash"] = sha256
+        if "preview_url" in cache_item:
+            entry["thumbnailUrl"] = config.get_preview_static_url(
+                cache_item["preview_url"]
+            )
+        base_model = cache_item.get("base_model", "")
+        if base_model:
+            entry["baseModel"] = base_model

py/routes/handlers/agent_handlers.py

@@ -0,0 +1,167 @@
+"""HTTP route handlers for agent skill endpoints.
+
+These handlers expose the :class:`AgentService` via HTTP, allowing the
+frontend to list available skills and execute them on selected models.
+Progress is reported via WebSocket broadcast.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Dict
+
+from aiohttp import web
+
+from ...services.agent import AgentService, AgentProgressReporter
+from ...services.llm_service import LLMNotConfiguredError
+
+logger = logging.getLogger(__name__)
+
+
+class AgentHandler:
+    """HTTP handler for agent skill operations."""
+
+    def __init__(self, agent_service: AgentService | None = None) -> None:
+        self._agent_service = agent_service
+
+    async def _ensure_service(self) -> AgentService:
+        if self._agent_service is None:
+            self._agent_service = await AgentService.get_instance()
+        return self._agent_service
+
+    # ------------------------------------------------------------------
+    # GET /api/lm/agent/skills
+    # ------------------------------------------------------------------
+
+    async def get_agent_skills(self, request: web.Request) -> web.Response:
+        """Return a list of available agent skills."""
+
+        service = await self._ensure_service()
+        skills = await service.list_skills()
+        return web.json_response({"skills": skills})
+
+    # ------------------------------------------------------------------
+    # POST /api/lm/agent/execute/{skill_name}
+    # ------------------------------------------------------------------
+
+    async def execute_agent_skill(self, request: web.Request) -> web.Response:
+        """Execute an agent skill on the provided model paths.
+
+        Request body::
+
+            {"model_paths": ["/path/to/model1.safetensors", ...], "options": {}}
+
+        Returns immediately with a task ID.  Execution runs in the
+        background; progress and completion are pushed via WebSocket
+        events of type ``agent_progress``.
+        """
+
+        skill_name = request.match_info.get("skill_name", "")
+        if not skill_name:
+            return web.json_response(
+                {"error": "Skill name is required"}, status_code=400
+            )
+
+        try:
+            body = await request.json()
+        except Exception:
+            return web.json_response(
+                {"error": "Invalid JSON body"}, status_code=400
+            )
+
+        model_paths = body.get("model_paths", [])
+        if not model_paths or not isinstance(model_paths, list):
+            return web.json_response(
+                {"error": "model_paths must be a non-empty array"},
+                status_code=400,
+            )
+
+        service = await self._ensure_service()
+
+        # Validate LLM configuration early for skills that need it
+        # (fail fast rather than after starting background work)
+        try:
+            from ...services.llm_service import LLMService
+
+            llm = await LLMService.get_instance()
+            if not llm.is_configured():
+                return web.json_response(
+                    {
+                        "error": "LLM provider is not configured. "
+                        "Enable it in Settings → AI Provider.",
+                    },
+                    status=400,
+                )
+        except Exception as exc:
+            logger.error("Failed to check LLM configuration: %s", exc)
+
+        # Launch execution in the background
+        progress_reporter = AgentProgressReporter()
+        logger.info(
+            "Agent skill '%s' starting for %d model(s) in background task",
+            skill_name, len(model_paths),
+        )
+
+        async def _run() -> None:
+            logger.info("_run background task started for skill '%s'", skill_name)
+            try:
+                result = await service.execute_skill(
+                    skill_name=skill_name,
+                    input_data={"model_paths": model_paths},
+                    progress_callback=progress_reporter,
+                )
+                logger.info(
+                    "Agent skill '%s' finished: success=%s, summary='%s', errors=%s",
+                    skill_name, result.success, result.summary, result.errors,
+                )
+            except LLMNotConfiguredError as exc:
+                logger.warning("Agent skill '%s' not configured: %s", skill_name, exc)
+                await progress_reporter.on_progress(
+                    {
+                        "type": "agent_progress",
+                        "skill": skill_name,
+                        "status": "error",
+                        "error": str(exc),
+                    }
+                )
+            except Exception as exc:
+                logger.error("Agent skill '%s' failed: %s", skill_name, exc, exc_info=True)
+                await progress_reporter.on_progress(
+                    {
+                        "type": "agent_progress",
+                        "skill": skill_name,
+                        "status": "error",
+                        "error": str(exc),
+                    }
+                )
+
+        # Fire and forget — progress comes via WebSocket
+        task = asyncio.create_task(_run())
+        logger.info("Agent skill '%s' background task created (id=%s)", skill_name, task)
+
+        return web.json_response(
+            {
+                "status": "started",
+                "skill": skill_name,
+                "model_count": len(model_paths),
+            }
+        )
+
+    # ------------------------------------------------------------------
+    # POST /api/lm/agent/cancel
+    # ------------------------------------------------------------------
+
+    async def cancel_agent_skill(self, request: web.Request) -> web.Response:
+        """Cancel a running agent skill.
+
+        NOTE: Cancellation is a stub for now — the AgentService processes
+        models sequentially and does not yet support mid-execution
+        cancellation.  This endpoint exists for API completeness.
+        """
+
+        # TODO: implement cooperative cancellation in AgentService
+        return web.json_response(
+            {"status": "acknowledged", "note": "Cancellation not yet implemented"},
+            status_code=200,
+        )

py/routes/handlers/hf_handlers.py

@@ -0,0 +1,417 @@
+"""Handlers for Hugging Face model listing and download.
+
+Minimal MVP implementation — uses direct HTTP to the HF API for file
+listing and the project's existing aiohttp-based Downloader for
+downloading.  No huggingface_hub dependency required.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import Any
+
+import aiohttp
+from aiohttp import web
+
+from ...config import config
+from ...services.downloader import (
+    DownloadProgress,
+    get_downloader,
+)
+from ...services.aria2_downloader import Aria2Downloader
+from ...services.settings_manager import get_settings_manager
+from ...services.service_registry import ServiceRegistry
+from ...services.websocket_manager import ws_manager
+from ...utils.constants import MODEL_FILE_EXTENSIONS
+from ...utils.metadata_manager import MetadataManager
+from ...utils.models import LoraMetadata, CheckpointMetadata, EmbeddingMetadata
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MODEL_CLASS = LoraMetadata
+_DEFAULT_SCANNER_GETTER = "get_lora_scanner"
+
+# Shared aiohttp session for HF API calls (created on first use)
+_hf_api_session: aiohttp.ClientSession | None = None
+
+
+async def _get_hf_api_session() -> aiohttp.ClientSession:
+    """Get or create the shared aiohttp session for HF API calls."""
+    global _hf_api_session  # needed because we reassign the module-level name
+    if _hf_api_session is None or _hf_api_session.closed:
+        _hf_api_session = aiohttp.ClientSession(
+            headers={"User-Agent": "ComfyUI-LoRA-Manager/1.0"},
+            timeout=aiohttp.ClientTimeout(total=30),
+        )
+    return _hf_api_session
+
+
+async def close_hf_api_session() -> None:
+    """Close the shared HF API session, if it was ever created."""
+    global _hf_api_session
+    if _hf_api_session is not None and not _hf_api_session.closed:
+        await _hf_api_session.close()
+        _hf_api_session = None
+
+
+def _infer_model_type(model_root: str) -> tuple[Any, str]:
+    """Determine model class and scanner by matching ``model_root`` against the
+    configured root paths for each model type (from ``Config``).
+
+    The ``model_root`` value comes from the frontend's model-root dropdown,
+    which is populated from the current page's scanner roots.  By checking
+    which scanner's root list it belongs to, we avoid fragile heuristics
+    like substring-matching path names.
+    """
+    norm = os.path.normpath(model_root).replace(os.sep, "/")
+
+    # LoRA roots
+    for p in (config.loras_roots or []) + (config.extra_loras_roots or []):
+        if os.path.normpath(p).replace(os.sep, "/") == norm:
+            return LoraMetadata, "get_lora_scanner"
+
+    # Checkpoint / UNet roots
+    for p in (
+        (config.checkpoints_roots or [])
+        + (config.extra_checkpoints_roots or [])
+        + (config.unet_roots or [])
+        + (config.extra_unet_roots or [])
+    ):
+        if os.path.normpath(p).replace(os.sep, "/") == norm:
+            return CheckpointMetadata, "get_checkpoint_scanner"
+
+    # Embedding roots
+    for p in (config.embeddings_roots or []) + (config.extra_embeddings_roots or []):
+        if os.path.normpath(p).replace(os.sep, "/") == norm:
+            return EmbeddingMetadata, "get_embedding_scanner"
+
+    # Fallback — should not happen in normal use
+    logger.warning(
+        "Could not determine model type for root '%s'; defaulting to LoRA",
+        model_root,
+    )
+    return _DEFAULT_MODEL_CLASS, _DEFAULT_SCANNER_GETTER
+
+
+async def _save_hf_metadata(dest_path: str, repo: str, model_root: str) -> None:
+    """Create a proper .metadata.json and add the model to the scanner cache.
+
+    Uses ``MetadataManager.create_default_metadata()`` which computes the
+    SHA256 hash, extracts safetensors header metadata (base_model), and
+    produces a fully-populated ``LoraMetadata`` (or ``CheckpointMetadata`` /
+    ``EmbeddingMetadata``) object.  We then overlay HF-specific fields and
+    register the model in the in-memory scanner cache so it appears
+    immediately without a full filesystem walk.
+    """
+    try:
+        hf_url = f"https://huggingface.co/{repo}"
+        model_class, scanner_getter_name = _infer_model_type(model_root)
+
+        # 1. Create proper metadata (computes SHA256, reads safetensors headers)
+        metadata = await MetadataManager.create_default_metadata(
+            dest_path, model_class=model_class
+        )
+        if metadata is None:
+            logger.warning("create_default_metadata returned None for %s", dest_path)
+            return
+
+        # 2. Overlay HF-specific fields
+        metadata._unknown_fields["hf_url"] = hf_url
+        metadata.from_civitai = False  # HF models are not from CivitAI
+
+        # 3. Save metadata atomically
+        await MetadataManager.save_metadata(dest_path, metadata)
+        logger.info("Saved HF metadata (with hf_url) for %s", dest_path)
+
+        # 4. Determine relative folder path for cache
+        #    model_root is an absolute path; dest_path is under it
+        folder = ""
+        if os.path.isabs(model_root) and dest_path.startswith(model_root):
+            rel = os.path.relpath(os.path.dirname(dest_path), model_root)
+            folder = rel.replace(os.sep, "/") if rel != "." else ""
+
+        # 5. Add to scanner cache (same as CivitAI's _execute_download does)
+        scanner_getter = getattr(ServiceRegistry, scanner_getter_name, None)
+        if scanner_getter is not None:
+            scanner = await scanner_getter()
+            if scanner is not None:
+                metadata_dict = metadata.to_dict()
+                metadata_dict["hf_url"] = hf_url
+                await scanner.add_model_to_cache(metadata_dict, folder)
+                logger.info("Added %s to scanner cache (folder=%s)", dest_path, folder)
+
+    except Exception as exc:
+        logger.warning("Failed to save HF metadata for %s: %s", dest_path, exc)
+
+
+class HfHandler:
+    """Handle Hugging Face model browsing and download."""
+
+    async def get_hf_repo_files(self, request: web.Request) -> web.Response:
+        """List model-weight files from a HF repo with real file sizes.
+
+        Uses the HF tree API endpoint which returns accurate file sizes
+        (including LFS-tracked files), unlike the model info endpoint.
+        """
+        repo = request.query.get("repo", "").strip()
+        if not repo or "/" not in repo:
+            return web.json_response(
+                {"error": "Missing or invalid 'repo' parameter (expected user/repo)"},
+                status=400,
+            )
+
+        url = f"https://huggingface.co/api/models/{repo}/tree/main"
+
+        try:
+            session = await _get_hf_api_session()
+            async with session.get(url) as resp:
+                if resp.status == 404:
+                    return web.json_response(
+                        {"error": f"Repo '{repo}' not found"}, status=404
+                    )
+                if resp.status != 200:
+                    text = await resp.text()
+                    return web.json_response(
+                        {"error": f"HF API error {resp.status}: {text[:200]}"},
+                        status=resp.status,
+                    )
+                tree: list[dict[str, Any]] = await resp.json()
+        except Exception as exc:
+            logger.error("Failed to fetch HF repo files: %s", exc)
+            return web.json_response({"error": str(exc)}, status=502)
+
+        files: list[dict[str, Any]] = []
+        for entry in tree:
+            path: str = entry.get("path", "")
+            ext = os.path.splitext(path)[1].lower()
+            if ext not in MODEL_FILE_EXTENSIONS:
+                continue
+            size = entry.get("size", 0) or 0
+            if size == 0 and "lfs" in entry:
+                size = entry["lfs"].get("size", 0) or 0
+            files.append({
+                "filename": path,
+                "size": size,
+            })
+
+        files.sort(key=lambda f: f["size"], reverse=True)
+        return web.json_response(files)
+
+    async def download_hf_model(self, request: web.Request) -> web.Response:
+        """Download a single file from Hugging Face into the model directory.
+
+        POST JSON body::
+
+            {
+              "repo": "dx8152/Flux2-Klein-9B-Consistency",
+              "filename": "Flux2-Klein-9B-consistency-V2.safetensors",
+              "revision": "main",
+              "model_root": "loras",
+              "relative_path": "",
+              "use_default_paths": false,
+              "download_id": "optional-batch-id"
+            }
+
+        If ``download_id`` is provided, real-time progress (bytes, speed,
+        percentage) is broadcast via the WebSocket progress system, matching
+        the CivitAI download experience.
+
+        Respects the ``download_backend`` setting (``aria2`` or ``default``).
+        """
+        try:
+            payload: dict[str, Any] = await request.json()
+        except json.JSONDecodeError:
+            return web.json_response({"error": "Invalid JSON"}, status=400)
+
+        repo = (payload.get("repo") or "").strip()
+        filename = (payload.get("filename") or "").strip()
+        revision = (payload.get("revision") or "main").strip()
+        model_root = (payload.get("model_root") or "").strip()
+        relative_path = (payload.get("relative_path") or "").strip()
+        use_default_paths = bool(payload.get("use_default_paths", False))
+        download_id: str | None = payload.get("download_id")
+
+        logger.info(
+            "download_hf_model: repo=%s file=%s root=%s download_id=%s",
+            repo, filename, model_root, download_id,
+        )
+
+        if not repo or not filename:
+            return web.json_response(
+                {"error": "Missing required fields: 'repo' and 'filename'"}, status=400
+            )
+
+        # Validate repo format — must be user/repo_name
+        if repo.count("/") != 1 or not re.match(r"^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$", repo):
+            return web.json_response({"error": f"Invalid repo format: {repo}"}, status=400)
+        author, repo_name = repo.split("/", 1)
+        if ".." in (author, repo_name) or "." in (author, repo_name):
+            return web.json_response({"error": f"Invalid repo format: {repo}"}, status=400)
+
+        # Validate filename — must not contain path separators or ..
+        if "/" in filename or "\\" in filename or ".." in filename:
+            return web.json_response({"error": "Invalid filename"}, status=400)
+
+        # Validate relative_path — must not be absolute or escape base directory
+        if relative_path:
+            if os.path.isabs(relative_path):
+                return web.json_response({"error": "relative_path must not be absolute"}, status=400)
+            if ".." in relative_path.split("/") or "\\" in relative_path:
+                return web.json_response({"error": "Invalid relative_path"}, status=400)
+
+        # Validate model_root — must not contain path traversal
+        if not os.path.isabs(model_root):
+            # For relative model_root, check it doesn't escape
+            resolved_model_root = os.path.realpath(
+                os.path.join(os.getcwd(), "models", model_root)
+            )
+        else:
+            resolved_model_root = os.path.realpath(model_root)
+
+        # Verify model_root is within a configured scanner root
+        allowed_roots = set()
+        for root_list in (
+            config.loras_roots or [],
+            config.extra_loras_roots or [],
+            config.checkpoints_roots or [],
+            config.extra_checkpoints_roots or [],
+            config.unet_roots or [],
+            config.extra_unet_roots or [],
+            config.embeddings_roots or [],
+            config.extra_embeddings_roots or [],
+        ):
+            for r in root_list:
+                allowed_roots.add(os.path.realpath(r))
+
+        if not any(resolved_model_root == root or resolved_model_root.startswith(root + os.sep) for root in allowed_roots):
+            logger.warning("Invalid model_root rejected: %s", model_root)
+            return web.json_response({"error": f"Invalid model_root: {model_root}"}, status=400)
+
+        base_dir = resolved_model_root
+
+        if use_default_paths:
+            target_dir = os.path.join(base_dir, "huggingface", author, repo_name)
+        elif relative_path:
+            target_dir = os.path.join(base_dir, relative_path)
+        else:
+            target_dir = base_dir
+
+        os.makedirs(target_dir, exist_ok=True)
+        dest_path = os.path.join(target_dir, filename)
+
+        # Resolve symlinks and check for path traversal escape
+        real_dest = os.path.realpath(dest_path)
+        real_base = os.path.realpath(target_dir)
+        if not real_dest.startswith(real_base + os.sep):
+            logger.warning("Path traversal blocked: %s -> %s", dest_path, real_dest)
+            return web.json_response({"error": "Path traversal detected"}, status=400)
+
+        # Check if already exists (simple skip)
+        if os.path.exists(dest_path) and os.path.getsize(dest_path) > 0:
+            logger.info("download_hf_model: file already exists, skipping — %s", dest_path)
+            return web.json_response({
+                "success": True,
+                "message": f"File already exists: {dest_path}",
+                "path": dest_path,
+            })
+
+        # Build HF resolve URL
+        resolve_url = (
+            f"https://huggingface.co/{repo}/resolve/{revision}/{filename}"
+        )
+
+        # Set up progress callback if download_id is provided
+        progress_callback = None
+        if download_id:
+
+            async def _progress_callback(
+                progress: float | DownloadProgress,
+                snapshot: DownloadProgress | None = None,
+            ) -> None:
+                percent = 0.0
+                metrics = snapshot if isinstance(snapshot, DownloadProgress) else None
+
+                if isinstance(progress, DownloadProgress):
+                    percent = progress.percent_complete
+                    metrics = progress
+                elif isinstance(snapshot, DownloadProgress):
+                    percent = snapshot.percent_complete
+                else:
+                    percent = float(progress)
+
+                broadcast: dict[str, Any] = {
+                    "status": "progress",
+                    "progress": round(percent),
+                }
+                if metrics:
+                    broadcast["bytes_downloaded"] = metrics.bytes_downloaded
+                    broadcast["total_bytes"] = metrics.total_bytes
+                    broadcast["bytes_per_second"] = metrics.bytes_per_second
+
+                await ws_manager.broadcast_download_progress(download_id, broadcast)
+
+            progress_callback = _progress_callback
+
+        # Respect download backend setting (aria2 vs default)
+        download_backend = (
+            get_settings_manager().get("download_backend", "default")
+        )
+
+        if download_backend == "aria2":
+            aria2 = await Aria2Downloader.get_instance()
+            aid = download_id or f"hf_{repo}_{filename}"
+            try:
+                hf_success, hf_result = await aria2.download_file(
+                    url=resolve_url,
+                    save_path=dest_path,
+                    download_id=aid,
+                    progress_callback=progress_callback,
+                )
+                if hf_success:
+                    await _save_hf_metadata(dest_path, repo, model_root)
+                    return web.json_response({
+                        "success": True,
+                        "message": f"Downloaded to {dest_path}",
+                        "path": dest_path,
+                    })
+                else:
+                    return web.json_response(
+                        {"success": False, "error": hf_result or "aria2 download failed"},
+                        status=500,
+                    )
+            except Exception as exc:
+                logger.error("HF download (aria2) failed: %s", exc)
+                return web.json_response(
+                    {"success": False, "error": str(exc)}, status=500
+                )
+
+        # Default: use built-in aiohttp Downloader
+        downloader = await get_downloader()
+        try:
+            success, result = await downloader.download_file(
+                url=resolve_url,
+                save_path=dest_path,
+                use_auth=False,
+                allow_resume=True,
+                progress_callback=progress_callback,
+            )
+            if success:
+                await _save_hf_metadata(dest_path, repo, model_root)
+                return web.json_response({
+                    "success": True,
+                    "message": f"Downloaded to {result}",
+                    "path": result,
+                })
+            else:
+                return web.json_response(
+                    {"success": False, "error": result or "Download failed"},
+                    status=500,
+                )
+        except Exception as exc:
+            logger.error("HF download failed: %s", exc)
+            return web.json_response(
+                {"success": False, "error": str(exc)}, status=500
+            )

py/routes/handlers/misc_handlers.py

@@ -48,8 +48,13 @@ from ...utils.constants import (
     SUPPORTED_MEDIA_EXTENSIONS,
     VALID_LORA_TYPES,
 )
+from .hf_handlers import HfHandler
+from .agent_handlers import AgentHandler
 from ...utils.civitai_utils import rewrite_preview_url
-from ...utils.example_images_paths import is_valid_example_images_root
+from ...utils.example_images_paths import (
+    find_non_compliant_items_in_example_images_root,
+    is_valid_example_images_root,
+)
 from ...utils.lora_metadata import extract_trained_words
 from ...utils.session_logging import get_standalone_session_log_snapshot
 from ...utils.usage_stats import UsageStats
@@ -411,9 +416,10 @@ class PromptServerProtocol(Protocol):
     """Subset of PromptServer used by the handlers."""
 
     instance: "PromptServerProtocol"
+    sockets: dict  # maps clientId (sid) → WebSocketResponse
 
     def send_sync(
-        self, event: str, payload: dict
+        self, event: str, payload: dict | None = None, sid: str | None = None
     ) -> None:  # pragma: no cover - protocol
         ...
 
@@ -468,89 +474,154 @@ class BackupServiceProtocol(Protocol):
 
 
 class NodeRegistry:
-    """Thread-safe registry for tracking LoRA nodes in active workflows."""
+    """Thread-safe registry for tracking LoRA nodes across ComfyUI tabs.
+
+    Each connected ComfyUI browser tab (identified by its ``sid`` / ``clientId``)
+    registers its own set of workflow nodes.  Queries merge all known tabs into
+    a single result so that the calling LM panel always sees *every* available
+    target node, regardless of which tab responded fastest.
+    """
 
     def __init__(self) -> None:
         self._lock = asyncio.Lock()
-        self._nodes: Dict[str, dict] = {}
-        self._registry_updated = asyncio.Event()
+        # sid → {unique_id → node_info}
+        self._tab_nodes: Dict[str, Dict[str, dict]] = {}
+        self._ready = asyncio.Event()
+        self._waiting_clients: set[str] = set()
+
+    @property
+    def pending_client_count(self) -> int:
+        """Number of clients that have not yet responded in the current refresh cycle."""
+        return len(self._waiting_clients)
+
+    # ------------------------------------------------------------------
+    # Helpers to build one node dict (extracted so it's reused for each tab)
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _build_node_dict(node: dict) -> dict:
+        node_id = node["node_id"]
+        graph_id = str(node["graph_id"])
+        unique_id = f"{graph_id}:{node_id}"
+        node_type = node.get("type", "")
+        type_id = NODE_TYPES.get(node_type, 0)
+        bgcolor = node.get("bgcolor") or DEFAULT_NODE_COLOR
+
+        raw_capabilities = node.get("capabilities")
+        capabilities: dict = {}
+        if isinstance(raw_capabilities, dict):
+            capabilities = dict(raw_capabilities)
+
+        raw_widget_names: list | None = node.get("widget_names")
+        if not isinstance(raw_widget_names, list):
+            capability_widget_names = capabilities.get("widget_names")
+            raw_widget_names = (
+                capability_widget_names
+                if isinstance(capability_widget_names, list)
+                else None
+            )
+
+        widget_names: list[str] = []
+        if isinstance(raw_widget_names, list):
+            widget_names = [
+                str(widget_name)
+                for widget_name in raw_widget_names
+                if isinstance(widget_name, str) and widget_name
+            ]
+
+        if widget_names:
+            capabilities["widget_names"] = widget_names
+        else:
+            capabilities.pop("widget_names", None)
+
+        if "supports_lora" in capabilities:
+            capabilities["supports_lora"] = bool(capabilities["supports_lora"])
+
+        comfy_class = node.get("comfy_class")
+        if not isinstance(comfy_class, str) or not comfy_class:
+            comfy_class = node_type if isinstance(node_type, str) else None
+
+        return {
+            "id": node_id,
+            "graph_id": graph_id,
+            "graph_name": node.get("graph_name"),
+            "unique_id": unique_id,
+            "bgcolor": bgcolor,
+            "title": node.get("title"),
+            "type": type_id,
+            "type_name": node_type,
+            "comfy_class": comfy_class,
+            "capabilities": capabilities,
+            "widget_names": widget_names,
+            "mode": node.get("mode"),
+            "marker_role": node.get("marker_role"),
+        }
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    async def register_nodes(self, sid: str, nodes: list[dict]) -> None:
+        """Register/replace the node list for a single ComfyUI tab (identified by *sid*)."""
+        tab_nodes: dict[str, dict] = {}
+        for node in nodes:
+            nd = self._build_node_dict(node)
+            tab_nodes[nd["unique_id"]] = nd
 
-    async def register_nodes(self, nodes: list[dict]) -> None:
         async with self._lock:
-            self._nodes.clear()
-            for node in nodes:
-                node_id = node["node_id"]
-                graph_id = str(node["graph_id"])
-                unique_id = f"{graph_id}:{node_id}"
-                node_type = node.get("type", "")
-                type_id = NODE_TYPES.get(node_type, 0)
-                bgcolor = node.get("bgcolor") or DEFAULT_NODE_COLOR
-                raw_capabilities = node.get("capabilities")
-                capabilities: dict = {}
-                if isinstance(raw_capabilities, dict):
-                    capabilities = dict(raw_capabilities)
+            self._tab_nodes[sid] = tab_nodes
+            self._waiting_clients.discard(sid)
+            if not self._waiting_clients:
+                self._ready.set()
 
-                raw_widget_names: list | None = node.get("widget_names")
-                if not isinstance(raw_widget_names, list):
-                    capability_widget_names = capabilities.get("widget_names")
-                    raw_widget_names = (
-                        capability_widget_names
-                        if isinstance(capability_widget_names, list)
-                        else None
-                    )
+        logger.debug("Registered %s nodes from client %s", len(nodes), sid)
 
-                widget_names: list[str] = []
-                if isinstance(raw_widget_names, list):
-                    widget_names = [
-                        str(widget_name)
-                        for widget_name in raw_widget_names
-                        if isinstance(widget_name, str) and widget_name
-                    ]
+    def prepare_for_refresh(self, active_sids: list[str]) -> None:
+        """Set the list of client IDs we expect to hear from during the next refresh cycle."""
+        self._ready.clear()
+        self._waiting_clients = set(active_sids)
 
-                if widget_names:
-                    capabilities["widget_names"] = widget_names
-                else:
-                    capabilities.pop("widget_names", None)
-
-                if "supports_lora" in capabilities:
-                    capabilities["supports_lora"] = bool(capabilities["supports_lora"])
-
-                comfy_class = node.get("comfy_class")
-                if not isinstance(comfy_class, str) or not comfy_class:
-                    comfy_class = node_type if isinstance(node_type, str) else None
-
-                self._nodes[unique_id] = {
-                    "id": node_id,
-                    "graph_id": graph_id,
-                    "graph_name": node.get("graph_name"),
-                    "unique_id": unique_id,
-                    "bgcolor": bgcolor,
-                    "title": node.get("title"),
-                    "type": type_id,
-                    "type_name": node_type,
-                    "comfy_class": comfy_class,
-                    "capabilities": capabilities,
-                    "widget_names": widget_names,
-                    "mode": node.get("mode"),
-                }
-            logger.debug("Registered %s nodes in registry", len(nodes))
-            self._registry_updated.set()
-
-    async def get_registry(self) -> dict:
-        async with self._lock:
-            return {
-                "nodes": dict(self._nodes),
-                "node_count": len(self._nodes),
-            }
-
-    async def wait_for_update(self, timeout: float = 1.0) -> bool:
-        self._registry_updated.clear()
+    async def wait_for_all(self, timeout: float = 2.0) -> bool:
+        """Block until every client in the current waiting set has responded
+        (or *timeout* seconds elapse).  Returns ``True`` if all responded."""
+        if not self._waiting_clients:
+            return True
         try:
-            await asyncio.wait_for(self._registry_updated.wait(), timeout=timeout)
+            await asyncio.wait_for(self._ready.wait(), timeout=timeout)
             return True
         except asyncio.TimeoutError:
             return False
 
+    async def get_merged_registry(self, active_sids: set[str] | None = None) -> dict:
+        """Return the union of all known tab nodes, pruning any tab that is no
+        longer connected."""
+        async with self._lock:
+            # Garbage-collect stale entries (disconnected tabs)
+            if active_sids is not None:
+                for sid in list(self._tab_nodes):
+                    if sid not in active_sids:
+                        del self._tab_nodes[sid]
+
+            merged: dict[str, dict] = {}
+            tab_info: dict[str, dict] = {}
+            for sid, nodes in self._tab_nodes.items():
+                tab_info[sid] = {
+                    "node_count": len(nodes),
+                    "graph_names": list(
+                        {
+                            n.get("graph_name")
+                            for n in nodes.values()
+                            if n.get("graph_name")
+                        }
+                    ),
+                }
+                merged.update(nodes)
+
+            return {
+                "nodes": merged,
+                "node_count": len(merged),
+                "tab_count": len(self._tab_nodes),
+                "tabs": tab_info,
+            }
+
 
 class HealthCheckHandler:
     async def health_check(self, request: web.Request) -> web.Response:
@@ -686,6 +757,9 @@ class DoctorHandler:
         )
 
     async def resolve_filename_conflicts(self, request: web.Request) -> web.Response:
+        if self._settings.get("lora_syntax_format", "legacy") == "full":
+            return web.json_response({"success": True, "renamed": [], "count": 0})
+
         renamed: list[dict[str, Any]] = []
 
         try:
@@ -990,11 +1064,29 @@ class DoctorHandler:
         }
 
     async def _check_filename_conflicts(self) -> dict[str, Any]:
+        # When full path syntax is active, duplicate filenames across subfolders
+        # are not ambiguous (<lora:subfolder/name:strength>), so skip the check.
+        if self._settings.get("lora_syntax_format", "legacy") == "full":
+            return {
+                "id": "filename_conflicts",
+                "title": "Duplicate Filename Conflicts",
+                "status": "ok",
+                "summary": "Full path syntax is active — duplicate filenames across folders are not ambiguous.",
+                "details": [],
+                "actions": [],
+            }
+
         all_conflicts: list[dict[str, Any]] = []
         total_conflict_groups = 0
         total_conflict_files = 0
 
         for model_type, label, factory in self._scanner_factories:
+            # Duplicate filename detection targets LoRAs which use basename-only
+            # syntax (<lora:name:strength>). Checkpoints/embeddings reference
+            # models via relative paths with extensions, so conflicts there would
+            # be false positives.
+            if model_type != "lora":
+                continue
             try:
                 scanner = await factory()
                 hash_index = getattr(scanner, "_hash_index", None)
@@ -1042,12 +1134,22 @@ class DoctorHandler:
                 "total_conflict_files": total_conflict_files,
             }
         ]
-        for conflict in all_conflicts:
+
+        # Show at most 5 conflict groups inline; note any remainder.
+        MAX_VISIBLE_CONFLICTS = 5
+        visible_conflicts = all_conflicts[:MAX_VISIBLE_CONFLICTS]
+        for conflict in visible_conflicts:
             details.append(
-                f"[{conflict['label']}] '{conflict['filename']}' "
+                f"'{conflict['filename']}' "
                 f"found in {len(conflict['paths'])} locations"
             )
 
+        hidden_count = len(all_conflicts) - MAX_VISIBLE_CONFLICTS
+        if hidden_count > 0:
+            details.append(
+                f"...and {hidden_count} more duplicate filename group(s)"
+            )
+
         return {
             "id": "filename_conflicts",
             "title": "Duplicate Filename Conflicts",
@@ -1058,7 +1160,11 @@ class DoctorHandler:
                 {
                     "id": "resolve-filename-conflicts",
                     "label": "Resolve Conflicts",
-                }
+                },
+                {
+                    "id": "open-settings-syntax-format",
+                    "label": "Switch to Full Path Syntax",
+                },
             ],
         }
 
@@ -1293,6 +1399,9 @@ class SettingsHandler:
             "folder_paths",
             "libraries",
             "active_library",
+            # Sensitive — never expose the actual value to the frontend;
+            # frontend receives a boolean instead (civitai_api_key_set).
+            "civitai_api_key",
         }
     )
 
@@ -1347,6 +1456,9 @@ class SettingsHandler:
                     value = self._settings.get(key)
                     if value is not None:
                         response_data[key] = value
+            # Sensitive fields: only expose a boolean indicating whether set
+            raw_key = self._settings.get("civitai_api_key")
+            response_data["civitai_api_key_set"] = bool(raw_key)
             settings_file = getattr(self._settings, "settings_file", None)
             if settings_file:
                 response_data["settings_file"] = settings_file
@@ -1457,6 +1569,16 @@ class SettingsHandler:
         if not os.path.isdir(folder_path):
             return "Please set a dedicated folder for example images."
         if not self._is_dedicated_example_images_folder(folder_path):
+            offending = find_non_compliant_items_in_example_images_root(folder_path)
+            if offending:
+                items_str = ", ".join(repr(item) for item in offending[:5])
+                if len(offending) > 5:
+                    items_str += f" … and {len(offending) - 5} more"
+                return (
+                    f"The folder contains items that are not valid example image "
+                    f"folders: {items_str}. Please use a dedicated, empty folder "
+                    f"for example images to prevent accidental data loss."
+                )
             return "Please set a dedicated folder for example images."
         return None
 
@@ -2065,7 +2187,7 @@ class ModelLibraryHandler:
                     file_path=file_path if isinstance(file_path, str) else None,
                 )
             else:
-                await history_service.mark_not_downloaded(model_type, model_version_id)
+                await history_service.mark_as_deleted(model_type, model_version_id)
 
             return web.json_response(
                 {
@@ -2139,8 +2261,19 @@ class ModelLibraryHandler:
                 ]
                 await found_cache.resort()
 
+            scanner_map = {
+                "lora": lora_scanner,
+                "checkpoint": checkpoint_scanner,
+                "embedding": embedding_scanner,
+            }
+            scanner = scanner_map.get(found_type)
+            if scanner:
+                persist = getattr(scanner, "_persist_current_cache", None)
+                if callable(persist):
+                    await persist()
+
             history_service = await self._get_download_history_service()
-            await history_service.mark_not_downloaded(found_type, model_version_id)
+            await history_service.mark_as_deleted(found_type, model_version_id)
 
             return web.json_response(
                 {
@@ -2929,10 +3062,21 @@ class NodeRegistryHandler:
         try:
             data = await request.json()
             nodes = data.get("nodes", [])
+            client_id = data.get("client_id")
             if not isinstance(nodes, list):
                 return web.json_response(
                     {"success": False, "error": "nodes must be a list"}, status=400
                 )
+
+            if not isinstance(client_id, str) or not client_id:
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "Missing client_id parameter",
+                    },
+                    status=400,
+                )
+
             for index, node in enumerate(nodes):
                 if not isinstance(node, dict):
                     return web.json_response(
@@ -2976,7 +3120,7 @@ class NodeRegistryHandler:
                 else:
                     node["graph_name"] = str(graph_name)
 
-            await self._node_registry.register_nodes(nodes)
+            await self._node_registry.register_nodes(client_id, nodes)
             return web.json_response(
                 {
                     "success": True,
@@ -3000,9 +3144,15 @@ class NodeRegistryHandler:
                     status=503,
                 )
 
+            # Snapshot of currently-connected ComfyUI tabs
+            active_sids = list(self._prompt_server.instance.sockets.keys())
+            self._node_registry.prepare_for_refresh(active_sids)
+
             try:
                 self._prompt_server.instance.send_sync("lora_registry_refresh", {})
-                logger.debug("Sent registry refresh request to frontend")
+                logger.debug(
+                    "Sent registry refresh request (expecting %s clients)", len(active_sids)
+                )
             except Exception as exc:
                 logger.error("Failed to send registry refresh message: %s", exc)
                 return web.json_response(
@@ -3014,19 +3164,31 @@ class NodeRegistryHandler:
                     status=500,
                 )
 
-            registry_updated = await self._node_registry.wait_for_update(timeout=1.0)
-            if not registry_updated:
-                logger.warning("Registry refresh timeout after 1 second")
+            if not await self._node_registry.wait_for_all(timeout=2.0):
+                logger.warning(
+                    "Registry refresh timeout after 2s (%s/%s clients responded)",
+                    len(active_sids) - self._node_registry.pending_client_count,
+                    len(active_sids),
+                )
+
+            # Re-read current sockets after the wait: a tab may have connected
+            # while we were waiting, and we don't want to garbage-collect it.
+            current_sids = set(self._prompt_server.instance.sockets.keys())
+            registry_info = await self._node_registry.get_merged_registry(
+                active_sids=current_sids
+            )
+
+            if registry_info["node_count"] == 0:
+                logger.warning("No nodes registered after refresh")
                 return web.json_response(
                     {
                         "success": False,
-                        "error": "Timeout Error",
-                        "message": "Registry refresh timeout - ComfyUI frontend may not be responsive",
+                        "error": "Empty Registry",
+                        "message": "No workflow nodes found — ensure ComfyUI is open and the extension is loaded.",
                     },
                     status=408,
                 )
 
-            registry_info = await self._node_registry.get_registry()
             return web.json_response({"success": True, "data": registry_info})
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to get registry: %s", exc, exc_info=True)
@@ -3039,12 +3201,17 @@ class NodeRegistryHandler:
         try:
             data = await request.json()
             widget_name = data.get("widget_name")
+            action = data.get("action")
             value = data.get("value")
+            mode = data.get("mode", "replace")
             node_ids = data.get("node_ids")
 
-            if not isinstance(widget_name, str) or not widget_name:
+            if not action and (not isinstance(widget_name, str) or not widget_name):
                 return web.json_response(
-                    {"success": False, "error": "Missing widget_name parameter"},
+                    {
+                        "success": False,
+                        "error": "Missing parameter: provide either 'action' or 'widget_name'",
+                    },
                     status=400,
                 )
 
@@ -3083,11 +3250,15 @@ class NodeRegistryHandler:
                 except (TypeError, ValueError):
                     parsed_node_id = node_identifier
 
-                payload = {
+                payload: dict = {
                     "id": parsed_node_id,
-                    "widget_name": widget_name,
                     "value": value,
+                    "mode": mode,
                 }
+                if action:
+                    payload["action"] = action
+                if widget_name:
+                    payload["widget_name"] = widget_name
 
                 if graph_identifier is not None:
                     payload["graph_id"] = str(graph_identifier)
@@ -3146,6 +3317,8 @@ class MiscHandlerSet:
         doctor: DoctorHandler,
         example_workflows: ExampleWorkflowsHandler,
         base_model: BaseModelHandlerSet,
+        hf_handler: HfHandler | None = None,
+        agent_handler: AgentHandler | None = None,
     ) -> None:
         self.health = health
         self.settings = settings
@@ -3164,6 +3337,8 @@ class MiscHandlerSet:
         self.doctor = doctor
         self.example_workflows = example_workflows
         self.base_model = base_model
+        self.hf_handler = hf_handler
+        self.agent_handler = agent_handler
 
     def to_route_mapping(
         self,
@@ -3209,6 +3384,13 @@ class MiscHandlerSet:
             "get_supporters": self.supporters.get_supporters,
             "get_example_workflows": self.example_workflows.get_example_workflows,
             "get_example_workflow": self.example_workflows.get_example_workflow,
+            # Hugging Face handlers
+            "get_hf_repo_files": self.hf_handler.get_hf_repo_files,
+            "download_hf_model": self.hf_handler.download_hf_model,
+            # Agent skill handlers
+            "get_agent_skills": self.agent_handler.get_agent_skills,
+            "execute_agent_skill": self.agent_handler.execute_agent_skill,
+            "cancel_agent_skill": self.agent_handler.cancel_agent_skill,
             # Base model handlers
             "get_base_models": self.base_model.get_base_models,
             "refresh_base_models": self.base_model.refresh_base_models,

py/routes/handlers/model_handlers.py

@@ -37,6 +37,7 @@ from ...services.use_cases import (
 )
 from ...services.websocket_manager import WebSocketManager
 from ...services.websocket_progress_callback import WebSocketProgressCallback
+from ...services.download_queue_service import DownloadQueueService
 from ...services.errors import RateLimitError, ResourceNotFoundError
 from ...utils.civitai_utils import resolve_license_payload
 from ...utils.file_utils import calculate_sha256
@@ -202,11 +203,17 @@ class ModelListingHandler:
             result = await self._service.get_paginated_data(**params)
 
             format_start = time.perf_counter()
+            formatted_raw = [
+                await self._service.format_response(entry)
+                for entry in result["items"]
+            ]
+            # Filter out None entries returned for corrupted cache rows (issue #730).
+            # Note: "total" intentionally remains the pre-filter count to reflect
+            # the true number of models in the cache; corrupted entries are rare
+            # and adjusting total would cause pagination drift on every page.
+            formatted_items = [item for item in formatted_raw if item is not None]
             formatted_result = {
-                "items": [
-                    await self._service.format_response(item)
-                    for item in result["items"]
-                ],
+                "items": formatted_items,
                 "total": result["total"],
                 "page": result["page"],
                 "page_size": result["page_size"],
@@ -232,14 +239,20 @@ class ModelListingHandler:
         start_time = time.perf_counter()
         try:
             params = self._parse_common_params(request)
+            # group_by_model is meaningless for excluded view; strip it
+            params.pop("group_by_model", None)
             result = await self._service.get_excluded_paginated_data(**params)
 
             format_start = time.perf_counter()
+            formatted_raw = [
+                await self._service.format_response(entry)
+                for entry in result["items"]
+            ]
+            # Filter out None entries returned for corrupted cache rows (issue #730).
+            # "total" stays at the pre-filter count; see get_models for rationale.
+            formatted_items = [item for item in formatted_raw if item is not None]
             formatted_result = {
-                "items": [
-                    await self._service.format_response(item)
-                    for item in result["items"]
-                ],
+                "items": formatted_items,
                 "total": result["total"],
                 "page": result["page"],
                 "page_size": result["page_size"],
@@ -301,6 +314,15 @@ class ModelListingHandler:
         for tag in exclude_tags:
             if tag:
                 tag_filters[tag] = "exclude"
+
+        auto_tag_filters: Dict[str, str] = {}
+        for tag in request.query.getall("auto_tag_include", []):
+            if tag:
+                auto_tag_filters[tag] = "include"
+        for tag in request.query.getall("auto_tag_exclude", []):
+            if tag:
+                auto_tag_filters[tag] = "exclude"
+
         favorites_only = request.query.get("favorites_only", "false").lower() == "true"
 
         search_options = {
@@ -356,6 +378,19 @@ class ModelListingHandler:
             request.query.get("name_pattern_use_regex", "false").lower() == "true"
         )
 
+        # Group-by-model flag: deduplicate versions sharing the same civitai modelId
+        group_by_model = (
+            request.query.get("group_by_model", "false").lower() == "true"
+        )
+
+        # View-local-versions filter: show all local versions of a specific model
+        civitai_model_id = request.query.get("civitai_model_id")
+        if civitai_model_id is not None:
+            try:
+                civitai_model_id = int(civitai_model_id)
+            except (TypeError, ValueError):
+                civitai_model_id = None
+
         return {
             "page": page,
             "page_size": page_size,
@@ -367,6 +402,7 @@ class ModelListingHandler:
             "fuzzy_search": fuzzy_search,
             "base_models": base_models,
             "tags": tag_filters,
+            "auto_tags": auto_tag_filters,
             "tag_logic": tag_logic,
             "search_options": search_options,
             "hash_filters": hash_filters,
@@ -378,6 +414,8 @@ class ModelListingHandler:
             "name_pattern_include": name_pattern_include,
             "name_pattern_exclude": name_pattern_exclude,
             "name_pattern_use_regex": name_pattern_use_regex,
+            "group_by_model": group_by_model,
+            "civitai_model_id": civitai_model_id,
             **self._parse_specific_params(request),
         }
 
@@ -505,8 +543,13 @@ class ModelManagementHandler:
             if not success:
                 return web.json_response({"success": False, "error": error})
 
-            formatted_metadata = await self._service.format_response(model_data)
-            return web.json_response({"success": True, "metadata": formatted_metadata})
+            formatted = await self._service.format_response(model_data)
+            if formatted is None:
+                return web.json_response(
+                    {"success": False, "error": "Model entry is corrupted (missing file_path)"},
+                    status=500,
+                )
+            return web.json_response({"success": True, "metadata": formatted})
         except Exception as exc:
             if is_expected_offline_error(str(exc)):
                 return web.json_response(
@@ -778,7 +821,7 @@ class ModelManagementHandler:
 
             metadata_updates = {k: v for k, v in data.items() if k != "file_path"}
 
-            await self._metadata_sync.save_metadata_updates(
+            updated_metadata = await self._metadata_sync.save_metadata_updates(
                 file_path=file_path,
                 updates=metadata_updates,
                 metadata_loader=self._metadata_sync.load_local_metadata,
@@ -789,7 +832,12 @@ class ModelManagementHandler:
                 cache = await self._service.scanner.get_cached_data()
                 await cache.resort()
 
-            return web.json_response({"success": True})
+            from ...services.auto_tag_service import extract_auto_tags
+            auto_tags = extract_auto_tags(updated_metadata)
+
+            return web.json_response(
+                {"success": True, "auto_tags": auto_tags}
+            )
         except Exception as exc:
             self._logger.error("Error saving metadata: %s", exc, exc_info=True)
             return web.Response(text=str(exc), status=500)
@@ -806,14 +854,16 @@ class ModelManagementHandler:
             if not isinstance(new_tags, list):
                 return web.Response(text="Tags must be a list", status=400)
 
-            tags = await self._tag_update_service.add_tags(
+            tags, auto_tags = await self._tag_update_service.add_tags(
                 file_path=file_path,
                 new_tags=new_tags,
                 metadata_loader=self._metadata_sync.load_local_metadata,
                 update_cache=self._service.scanner.update_single_model_cache,
             )
 
-            return web.json_response({"success": True, "tags": tags})
+            return web.json_response(
+                {"success": True, "tags": tags, "auto_tags": auto_tags}
+            )
         except Exception as exc:
             self._logger.error("Error adding tags: %s", exc, exc_info=True)
             return web.Response(text=str(exc), status=500)
@@ -1056,10 +1106,12 @@ class ModelQueryHandler:
                 # Sort: originals first, copies last
                 sorted_models = self._sort_duplicate_group(filtered)
 
-                # Format response
+                # Format response, filtering out corrupted entries (issue #730)
                 group = {"hash": sha256, "models": []}
                 for model in sorted_models:
-                    group["models"].append(await self._service.format_response(model))
+                    formatted = await self._service.format_response(model)
+                    if formatted is not None:
+                        group["models"].append(formatted)
 
                 # Only include groups with 2+ models after filtering
                 if len(group["models"]) > 1:
@@ -1160,6 +1212,12 @@ class ModelQueryHandler:
 
     async def find_filename_conflicts(self, request: web.Request) -> web.Response:
         try:
+            settings = get_settings_manager()
+            if settings.get("lora_syntax_format", "legacy") == "full":
+                return web.json_response(
+                    {"success": True, "conflicts": [], "count": 0}
+                )
+
             duplicates = self._service.find_duplicate_filenames()
             result = []
             cache = await self._service.scanner.get_cached_data()
@@ -1170,9 +1228,9 @@ class ModelQueryHandler:
                         (m for m in cache.raw_data if m["file_path"] == path), None
                     )
                     if model:
-                        group["models"].append(
-                            await self._service.format_response(model)
-                        )
+                        formatted = await self._service.format_response(model)
+                        if formatted is not None:
+                            group["models"].append(formatted)
                 hash_val = self._service.scanner.get_hash_by_filename(filename)
                 if hash_val:
                     main_path = self._service.get_path_by_hash(hash_val)
@@ -1182,9 +1240,9 @@ class ModelQueryHandler:
                             None,
                         )
                         if main_model:
-                            group["models"].insert(
-                                0, await self._service.format_response(main_model)
-                            )
+                            formatted = await self._service.format_response(main_model)
+                            if formatted is not None:
+                                group["models"].insert(0, formatted)
                 if group["models"]:
                     result.append(group)
             return web.json_response(
@@ -1248,6 +1306,14 @@ class ModelQueryHandler:
                     license_flags = (model_data or {}).get("license_flags")
                     if license_flags is not None:
                         response_payload["license_flags"] = int(license_flags)
+                    # Include the user's license icon style preference so the
+                    # ComfyUI tooltip can pick the right set without a separate
+                    # API call.
+                    try:
+                        settings = get_settings_manager()
+                        response_payload["use_new_license_icons"] = settings.get("use_new_license_icons", True)
+                    except Exception:
+                        pass
                 return web.json_response(response_payload)
             return web.json_response(
                 {
@@ -1449,6 +1515,21 @@ class ModelDownloadHandler:
             )
             return web.Response(status=500, text=str(exc))
 
+    async def skip_download_get(self, request: web.Request) -> web.Response:
+        try:
+            download_id = request.query.get("download_id")
+            if not download_id:
+                return web.json_response(
+                    {"success": False, "error": "Download ID is required"}, status=400
+                )
+            result = await self._download_coordinator.skip_download(download_id)
+            return web.json_response(result)
+        except Exception as exc:
+            self._logger.error(
+                "Error skipping download via GET: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def cancel_download_get(self, request: web.Request) -> web.Response:
         try:
             download_id = request.query.get("download_id")
@@ -1529,6 +1610,291 @@ class ModelDownloadHandler:
             )
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    # ------------------------------------------------------------------
+    # Download queue / history handlers
+    # ------------------------------------------------------------------
+
+    async def get_download_queue(self, request: web.Request) -> web.Response:
+        try:
+            service = await DownloadQueueService.get_instance()
+            queue = await service.get_queue()
+            stats = await service.get_stats()
+            return web.json_response({"success": True, "queue": queue, "stats": stats})
+        except Exception as exc:
+            self._logger.error(
+                "Error getting download queue: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def add_to_download_queue(self, request: web.Request) -> web.Response:
+        try:
+            import uuid
+
+            download_id = request.query.get("download_id") or str(uuid.uuid4())
+            model_id_str = request.query.get("model_id")
+            model_version_id_str = request.query.get("model_version_id")
+            model_name = request.query.get("model_name", "")
+            version_name = request.query.get("version_name", "")
+            thumbnail_url = request.query.get("thumbnail_url", "")
+            source = request.query.get("source")
+            file_params_json = request.query.get("file_params")
+
+            model_id = int(model_id_str) if model_id_str else None
+            model_version_id = int(model_version_id_str) if model_version_id_str else None
+            file_params = json.loads(file_params_json) if file_params_json else None
+
+            service = await DownloadQueueService.get_instance()
+            item = await service.add_to_queue(
+                download_id=download_id,
+                model_id=model_id,
+                model_version_id=model_version_id,
+                model_name=model_name,
+                version_name=version_name,
+                thumbnail_url=thumbnail_url,
+                source=source,
+                file_params=file_params,
+            )
+            return web.json_response({"success": True, "item": item})
+        except Exception as exc:
+            self._logger.error(
+                "Error adding to download queue: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def remove_from_download_queue(self, request: web.Request) -> web.Response:
+        try:
+            download_id = request.query.get("download_id")
+            if not download_id:
+                return web.json_response(
+                    {"success": False, "error": "download_id is required"}, status=400
+                )
+
+            service = await DownloadQueueService.get_instance()
+            removed = await service.remove_from_queue(download_id)
+            return web.json_response({"success": removed})
+        except Exception as exc:
+            self._logger.error(
+                "Error removing from download queue: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def move_queue_item_to_top(self, request: web.Request) -> web.Response:
+        try:
+            download_id = request.query.get("download_id")
+            if not download_id:
+                return web.json_response(
+                    {"success": False, "error": "download_id is required"}, status=400
+                )
+
+            service = await DownloadQueueService.get_instance()
+            moved = await service.move_to_top(download_id)
+            return web.json_response({"success": moved})
+        except Exception as exc:
+            self._logger.error(
+                "Error moving queue item to top: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def move_queue_item_to_end(self, request: web.Request) -> web.Response:
+        try:
+            download_id = request.query.get("download_id")
+            if not download_id:
+                return web.json_response(
+                    {"success": False, "error": "download_id is required"}, status=400
+                )
+
+            service = await DownloadQueueService.get_instance()
+            moved = await service.move_to_end(download_id)
+            return web.json_response({"success": moved})
+        except Exception as exc:
+            self._logger.error(
+                "Error moving queue item to end: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def clear_download_queue(self, request: web.Request) -> web.Response:
+        try:
+            status_filter = request.query.get("status") or None
+            service = await DownloadQueueService.get_instance()
+            cleared = await service.clear_queue(status_filter=status_filter)
+            return web.json_response({"success": True, "cleared": cleared})
+        except Exception as exc:
+            self._logger.error(
+                "Error clearing download queue: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_download_history(self, request: web.Request) -> web.Response:
+        try:
+            limit = min(int(request.query.get("limit", "50")), 500)
+            offset = int(request.query.get("offset", "0"))
+            status_filter = request.query.get("status") or None
+            service = await DownloadQueueService.get_instance()
+            result = await service.get_history(
+                limit=limit, offset=offset, status_filter=status_filter
+            )
+            return web.json_response(
+                {
+                    "success": True,
+                    "items": result["items"],
+                    "total": result["total"],
+                    "limit": result["limit"],
+                    "offset": result["offset"],
+                }
+            )
+        except Exception as exc:
+            self._logger.error(
+                "Error getting download history: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def clear_download_history(self, request: web.Request) -> web.Response:
+        try:
+            status_filter = request.query.get("status") or None
+            service = await DownloadQueueService.get_instance()
+            cleared = await service.clear_history(status_filter=status_filter)
+            return web.json_response({"success": True, "cleared": cleared})
+        except Exception as exc:
+            self._logger.error(
+                "Error clearing download history: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def delete_download_history_item(self, request: web.Request) -> web.Response:
+        try:
+            item_id = int(request.query.get("id", "0"))
+            if not item_id:
+                return web.json_response(
+                    {"success": False, "error": "id is required"}, status=400
+                )
+
+            service = await DownloadQueueService.get_instance()
+            deleted = await service.delete_history_item(item_id)
+            return web.json_response({"success": deleted})
+        except Exception as exc:
+            self._logger.error(
+                "Error deleting download history item: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def retry_download_from_history(self, request: web.Request) -> web.Response:
+        try:
+            item_id = int(request.query.get("id", "0"))
+            if not item_id:
+                return web.json_response(
+                    {"success": False, "error": "id is required"}, status=400
+                )
+
+            service = await DownloadQueueService.get_instance()
+            item = await service.retry_from_history(item_id)
+            if item is None:
+                return web.json_response(
+                    {"success": False, "error": "History item not found or not retryable"},
+                    status=404,
+                )
+            return web.json_response({"success": True, "item": item})
+        except Exception as exc:
+            self._logger.error(
+                "Error retrying download from history: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def retry_all_failed_downloads(self, request: web.Request) -> web.Response:
+        try:
+            service = await DownloadQueueService.get_instance()
+            retry_count = await service.retry_all_failed()
+            return web.json_response({"success": True, "retry_count": retry_count})
+        except Exception as exc:
+            self._logger.error(
+                "Error retrying all failed downloads: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def complete_download_in_queue(self, request: web.Request) -> web.Response:
+        """Atomically move a download from queue to history with terminal status."""
+        try:
+            download_id = request.query.get("download_id")
+            if not download_id:
+                return web.json_response(
+                    {"success": False, "error": "download_id is required"}, status=400
+                )
+            status = request.query.get("status", "completed")
+            error = request.query.get("error")
+            file_path = request.query.get("file_path")
+            try:
+                bytes_downloaded = int(request.query.get("bytes_downloaded", "0"))
+            except (TypeError, ValueError):
+                bytes_downloaded = 0
+            total_bytes_raw = request.query.get("total_bytes")
+            total_bytes = int(total_bytes_raw) if total_bytes_raw else None
+            completed_at_raw = request.query.get("completed_at")
+            completed_at = float(completed_at_raw) if completed_at_raw else None
+
+            service = await DownloadQueueService.get_instance()
+            item = await service.complete_download(
+                download_id=download_id,
+                status=status,
+                error=error,
+                file_path=file_path,
+                bytes_downloaded=bytes_downloaded,
+                total_bytes=total_bytes,
+                completed_at=completed_at,
+            )
+            if item is None:
+                return web.json_response(
+                    {"success": False, "error": "Download not found in queue"}, status=404
+                )
+            return web.json_response({"success": True, "item": item})
+        except Exception as exc:
+            self._logger.error(
+                "Error completing download: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_download_stats(self, request: web.Request) -> web.Response:
+        try:
+            service = await DownloadQueueService.get_instance()
+            stats = await service.get_stats()
+            return web.json_response({"success": True, "stats": stats})
+        except Exception as exc:
+            self._logger.error(
+                "Error getting download stats: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def update_download_queue_status(self, request: web.Request) -> web.Response:
+        """Update the status of a queue item (non-terminal transitions).
+
+        Supported transitions include ``queued → downloading``,
+        ``downloading → paused``, ``paused → downloading``, etc.
+        Terminal transitions (``completed``, ``failed``, ``canceled``)
+        should use ``complete_download_in_queue`` instead.
+        """
+        try:
+            download_id = request.query.get("download_id")
+            status = request.query.get("status")
+            if not download_id or not status:
+                return web.json_response(
+                    {
+                        "success": False,
+                        "error": "download_id and status are required",
+                    },
+                    status=400,
+                )
+            service = await DownloadQueueService.get_instance()
+            updated = await service.update_status(download_id, status)
+            if not updated:
+                return web.json_response(
+                    {"success": False, "error": "Download not found in queue"},
+                    status=404,
+                )
+            return web.json_response({"success": True})
+        except Exception as exc:
+            self._logger.error(
+                "Error updating download queue status: %s", exc, exc_info=True
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
 
 class ModelCivitaiHandler:
     """CivitAI integration endpoints."""
@@ -1570,7 +1936,9 @@ class ModelCivitaiHandler:
             return web.json_response(result)
         except Exception as exc:
             self._logger.error(
-                "Error in fetch_all_civitai for %ss: %s", self._service.model_type, exc
+                "Error in fetch_all_civitai for %ss: %s",
+                self._service.model_type, exc,
+                exc_info=True,
             )
             return web.Response(text=str(exc), status=500)
 
@@ -1937,6 +2305,10 @@ class ModelUpdateHandler:
         if target_model_ids:
             target_model_ids = sorted(set(target_model_ids))
 
+        folder_path: Optional[str] = payload.get("folder_path")
+        if folder_path is not None and not isinstance(folder_path, str):
+            folder_path = None
+
         provider = await self._get_civitai_provider()
         if provider is None:
             return web.json_response(
@@ -1951,6 +2323,7 @@ class ModelUpdateHandler:
                 provider,
                 force_refresh=force_refresh,
                 target_model_ids=target_model_ids or None,
+                folder_path=folder_path,
             )
             if self._service.scanner.is_cancelled():
                 return web.json_response(
@@ -1973,10 +2346,21 @@ class ModelUpdateHandler:
             self._logger.error("Failed to refresh model updates: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+        hide_early_access = False
+        if self._settings is not None:
+            try:
+                hide_early_access = bool(
+                    self._settings.get("hide_early_access_updates", False)
+                )
+            except Exception:
+                pass
+
         serialized_records = []
         for record in records.values():
             has_update_fn = getattr(record, "has_update", None)
-            if callable(has_update_fn) and has_update_fn():
+            if callable(has_update_fn) and has_update_fn(
+                hide_early_access=hide_early_access
+            ):
                 serialized_records.append(self._serialize_record(record))
 
         return web.json_response(
@@ -2538,9 +2922,24 @@ class ModelHandlerSet:
             "download_model": self.download.download_model,
             "download_model_get": self.download.download_model_get,
             "cancel_download_get": self.download.cancel_download_get,
+            "skip_download_get": self.download.skip_download_get,
             "pause_download_get": self.download.pause_download_get,
             "resume_download_get": self.download.resume_download_get,
             "get_download_progress": self.download.get_download_progress,
+            "get_download_queue": self.download.get_download_queue,
+            "add_to_download_queue": self.download.add_to_download_queue,
+            "remove_from_download_queue": self.download.remove_from_download_queue,
+            "move_queue_item_to_top": self.download.move_queue_item_to_top,
+            "move_queue_item_to_end": self.download.move_queue_item_to_end,
+            "clear_download_queue": self.download.clear_download_queue,
+            "get_download_history": self.download.get_download_history,
+            "clear_download_history": self.download.clear_download_history,
+            "delete_download_history_item": self.download.delete_download_history_item,
+            "retry_download_from_history": self.download.retry_download_from_history,
+            "retry_all_failed_downloads": self.download.retry_all_failed_downloads,
+            "complete_download_in_queue": self.download.complete_download_in_queue,
+            "get_download_stats": self.download.get_download_stats,
+            "update_download_queue_status": self.download.update_download_queue_status,
             "get_civitai_versions": self.civitai.get_civitai_versions,
             "get_civitai_model_by_version": self.civitai.get_civitai_model_by_version,
             "get_civitai_model_by_hash": self.civitai.get_civitai_model_by_hash,

py/routes/handlers/preview_handlers.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import mimetypes
 import urllib.parse
 from pathlib import Path
 
@@ -12,6 +13,12 @@ from ...config import config as global_config
 
 logger = logging.getLogger(__name__)
 
+_CHUNK_SIZE = 1024 * 1024  # 1 MB — balance between streaming iteration overhead and per-chunk memory
+
+# Video file extensions that bypass native sendfile on Windows
+# to avoid IOCP/ProactorEventLoop crashes during client disconnect.
+_VIDEO_EXTENSIONS = frozenset({".mp4", ".webm", ".mov", ".avi", ".mkv"})
+
 
 class PreviewHandler:
     """Serve preview assets for the active library at request time."""
@@ -48,8 +55,58 @@ class PreviewHandler:
             logger.debug("Preview file not found at %s", str(resolved))
             raise web.HTTPNotFound(text="Preview file not found")
 
-        # aiohttp's FileResponse handles range requests and content headers for us.
-        return web.FileResponse(path=resolved, chunk_size=256 * 1024)
+        # aiohttp's FileResponse handles range requests, content headers, and
+        # uses kernel sendfile (zero-copy DMA) on Linux/macOS. On Windows it
+        # uses IOCP-based _sendfile_native which can crash when the client
+        # disconnects mid-transfer during fast scrolling. The _stream_file()
+        # fallback is kept for a future compat toggle.
+        #
+        # Set explicit Cache-Control so the browser can cache video (and image)
+        # previews across VirtualScroller recycling cycles. Without this,
+        # Chrome does not cache 206 Partial Content responses for <video>
+        # elements, causing the same video to be re-downloaded on every scroll.
+        resp = web.FileResponse(path=resolved, chunk_size=_CHUNK_SIZE)
+        resp.headers["Cache-Control"] = "public, max-age=86400"
+        return resp
+
+    async def _stream_file(
+        self, request: web.Request, path: Path
+    ) -> web.StreamResponse:
+        """Stream a file chunk-by-chunk, bypassing native sendfile.
+
+        This avoids the Windows IOCP ``_sendfile_native`` crash that occurs
+        when the client disconnects during a large file transfer.
+        """
+        content_type, _ = mimetypes.guess_type(str(path))
+        if content_type is None:
+            content_type = "application/octet-stream"
+
+        file_size = path.stat().st_size
+        resp = web.StreamResponse()
+        resp.content_type = content_type
+        resp.content_length = file_size
+
+        # Allow browser caching: video previews rarely change during a session.
+        # The frontend already appends ?t={version} to bust cache on update.
+        resp.headers["Cache-Control"] = "public, max-age=86400"
+
+        await resp.prepare(request)
+
+        try:
+            with open(path, "rb") as f:
+                while True:
+                    chunk = f.read(_CHUNK_SIZE)
+                    if not chunk:
+                        break
+                    await resp.write(chunk)
+        except (ConnectionResetError, ConnectionAbortedError):
+            # Client disconnected during streaming — expected when scrolling
+            # rapidly through a library with animated previews.
+            pass
+        except OSError as exc:
+            logger.debug("I/O error streaming preview %s: %s", path, exc)
+
+        return resp
 
 
 __all__ = ["PreviewHandler"]

py/routes/misc_route_registrar.py

@@ -94,6 +94,23 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition(
         "GET", "/api/lm/delete-model-version", "delete_model_version"
     ),
+    # Hugging Face model endpoints
+    RouteDefinition(
+        "GET", "/api/lm/hf-repo-files", "get_hf_repo_files"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/download-hf-model", "download_hf_model"
+    ),
+    # Agent skill endpoints
+    RouteDefinition(
+        "GET", "/api/lm/agent/skills", "get_agent_skills"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/agent/execute/{skill_name}", "execute_agent_skill"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/agent/cancel", "cancel_agent_skill"
+    ),
 )
 
 

py/routes/misc_routes.py

@@ -39,6 +39,8 @@ from .handlers.misc_handlers import (
     build_service_registry_adapter,
 )
 from .handlers.base_model_handlers import BaseModelHandlerSet
+from .handlers.hf_handlers import HfHandler
+from .handlers.agent_handlers import AgentHandler
 from .misc_route_registrar import MiscRouteRegistrar
 
 logger = logging.getLogger(__name__)
@@ -136,6 +138,8 @@ class MiscRoutes:
         doctor = DoctorHandler(settings_service=self._settings)
         example_workflows = ExampleWorkflowsHandler()
         base_model = BaseModelHandlerSet()
+        hf_handler = HfHandler()
+        agent_handler = AgentHandler()
 
         return self._handler_set_factory(
             health=health,
@@ -155,6 +159,8 @@ class MiscRoutes:
             doctor=doctor,
             example_workflows=example_workflows,
             base_model=base_model,
+            hf_handler=hf_handler,
+            agent_handler=agent_handler,
         )
 
 

py/routes/model_route_registrar.py

@@ -101,11 +101,46 @@ COMMON_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/download-model", "download_model"),
     RouteDefinition("GET", "/api/lm/download-model-get", "download_model_get"),
     RouteDefinition("GET", "/api/lm/cancel-download-get", "cancel_download_get"),
+    RouteDefinition("GET", "/api/lm/skip-download", "skip_download_get"),
     RouteDefinition("GET", "/api/lm/pause-download", "pause_download_get"),
     RouteDefinition("GET", "/api/lm/resume-download", "resume_download_get"),
     RouteDefinition(
         "GET", "/api/lm/download-progress/{download_id}", "get_download_progress"
     ),
+    RouteDefinition("GET", "/api/lm/downloads/queue", "get_download_queue"),
+    RouteDefinition("GET", "/api/lm/downloads/queue/add", "add_to_download_queue"),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/remove", "remove_from_download_queue"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/move-to-top", "move_queue_item_to_top"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/move-to-end", "move_queue_item_to_end"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/clear", "clear_download_queue"
+    ),
+    RouteDefinition("GET", "/api/lm/downloads/history", "get_download_history"),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/history/clear", "clear_download_history"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/history/delete", "delete_download_history_item"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/history/retry", "retry_download_from_history"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/history/retry-all", "retry_all_failed_downloads"
+    ),
+    RouteDefinition("GET", "/api/lm/downloads/stats", "get_download_stats"),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/complete", "complete_download_in_queue"
+    ),
+    RouteDefinition(
+        "GET", "/api/lm/downloads/queue/status", "update_download_queue_status"
+    ),
     RouteDefinition("POST", "/api/lm/{prefix}/cancel-task", "cancel_task"),
     RouteDefinition("GET", "/{prefix}", "handle_models_page"),
 )

py/routes/recipe_route_registrar.py

@@ -58,6 +58,7 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/recipes/repair", "repair_recipes"),
     RouteDefinition("POST", "/api/lm/recipes/cancel-repair", "cancel_repair"),
     RouteDefinition("POST", "/api/lm/recipe/{recipe_id}/repair", "repair_recipe"),
+    RouteDefinition("POST", "/api/lm/recipes/repair-bulk", "repair_recipes_bulk"),
     RouteDefinition("GET", "/api/lm/recipes/repair-progress", "get_repair_progress"),
     RouteDefinition("POST", "/api/lm/recipes/batch-import/start", "start_batch_import"),
     RouteDefinition(
@@ -70,6 +71,16 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
         "POST", "/api/lm/recipes/batch-import/directory", "start_directory_import"
     ),
     RouteDefinition("POST", "/api/lm/recipes/browse-directory", "browse_directory"),
+    RouteDefinition(
+        "GET", "/api/lm/recipes/check-image-exists", "check_image_exists"
+    ),
+    RouteDefinition("GET", "/api/lm/recipes/import-from-url", "import_from_url"),
+    RouteDefinition(
+        "POST", "/api/lm/recipes/create-from-example", "create_from_example"
+    ),
+    RouteDefinition(
+        "POST", "/api/lm/recipe/{recipe_id}/reimport", "reimport_recipe"
+    ),
 )
 
 

py/routes/stats_routes.py

@@ -11,6 +11,8 @@ from ..config import config
 from ..services.settings_manager import get_settings_manager
 from ..services.server_i18n import server_i18n
 from ..services.service_registry import ServiceRegistry
+from ..services.model_query import normalize_sub_type, resolve_sub_type
+from ..utils.constants import VALID_LORA_SUB_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.usage_stats import UsageStats
 
 logger = logging.getLogger(__name__)
@@ -140,6 +142,21 @@ class StatsRoutes:
             # Get usage statistics
             usage_data = await self.usage_stats.get_stats()
             
+            # CivitAI model type distribution across all model types
+            # Use the same logic as the filter panel: normalize_sub_type(resolve_sub_type(entry))
+            # with sub-type validation per model type
+            model_types_counter: Counter[str] = Counter()
+            for entry in lora_cache.raw_data:
+                ntype = normalize_sub_type(resolve_sub_type(entry))
+                if ntype and ntype in VALID_LORA_SUB_TYPES:
+                    model_types_counter[ntype] += 1
+            for entry in checkpoint_cache.raw_data:
+                ntype = normalize_sub_type(resolve_sub_type(entry))
+                if ntype and ntype in VALID_CHECKPOINT_SUB_TYPES:
+                    model_types_counter[ntype] += 1
+            # Embeddings: always count as "embedding" regardless of CivitAI sub-type
+            model_types_counter['embedding'] = len(embedding_cache.raw_data)
+            
             return web.json_response({
                 'success': True,
                 'data': {
@@ -154,7 +171,8 @@ class StatsRoutes:
                     'total_generations': usage_data.get('total_executions', 0),
                     'unused_loras': self._count_unused_models(lora_cache.raw_data, usage_data.get('loras', {})),
                     'unused_checkpoints': self._count_unused_models(checkpoint_cache.raw_data, usage_data.get('checkpoints', {})),
-                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {}))
+                    'unused_embeddings': self._count_unused_models(embedding_cache.raw_data, usage_data.get('embeddings', {})),
+                    'model_types_distribution': dict(model_types_counter.most_common())
                 }
             })
             
@@ -459,9 +477,12 @@ class StatsRoutes:
                 if unused_lora_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'title': 'High Number of Unused LoRAs',
-                        'description': f'{unused_lora_percent:.1f}% of your LoRAs ({unused_loras}/{total_loras}) have never been used.',
-                        'suggestion': 'Consider organizing or archiving unused models to free up storage space.'
+                        'key': 'insights.unusedLoras.high',
+                        'params': {
+                            'percent': f'{unused_lora_percent:.1f}',
+                            'count': str(unused_loras),
+                            'total': str(total_loras)
+                        }
                     })
             
             if total_checkpoints > 0:
@@ -469,9 +490,12 @@ class StatsRoutes:
                 if unused_checkpoint_percent > 30:
                     insights.append({
                         'type': 'warning',
-                        'title': 'Unused Checkpoints Detected',
-                        'description': f'{unused_checkpoint_percent:.1f}% of your checkpoints ({unused_checkpoints}/{total_checkpoints}) have never been used.',
-                        'suggestion': 'Review and consider removing checkpoints you no longer need.'
+                        'key': 'insights.unusedCheckpoints.detected',
+                        'params': {
+                            'percent': f'{unused_checkpoint_percent:.1f}',
+                            'count': str(unused_checkpoints),
+                            'total': str(total_checkpoints)
+                        }
                     })
             
             if total_embeddings > 0:
@@ -479,9 +503,12 @@ class StatsRoutes:
                 if unused_embedding_percent > 50:
                     insights.append({
                         'type': 'warning',
-                        'title': 'High Number of Unused Embeddings',
-                        'description': f'{unused_embedding_percent:.1f}% of your embeddings ({unused_embeddings}/{total_embeddings}) have never been used.',
-                        'suggestion': 'Consider organizing or archiving unused embeddings to optimize your collection.'
+                        'key': 'insights.unusedEmbeddings.high',
+                        'params': {
+                            'percent': f'{unused_embedding_percent:.1f}',
+                            'count': str(unused_embeddings),
+                            'total': str(total_embeddings)
+                        }
                     })
             
             # Storage insights
@@ -492,18 +519,20 @@ class StatsRoutes:
             if total_size > 100 * 1024 * 1024 * 1024:  # 100GB
                 insights.append({
                     'type': 'info',
-                    'title': 'Large Collection Detected',
-                    'description': f'Your model collection is using {self._format_size(total_size)} of storage.',
-                    'suggestion': 'Consider using external storage or cloud solutions for better organization.'
+                    'key': 'insights.collection.large',
+                    'params': {
+                        'size': self._format_size(total_size)
+                    }
                 })
             
             # Recent activity insight
             if usage_data.get('total_executions', 0) > 100:
                 insights.append({
                     'type': 'success',
-                    'title': 'Active User',
-                    'description': f'You\'ve completed {usage_data["total_executions"]} generations so far!',
-                    'suggestion': 'Keep exploring and creating amazing content with your models.'
+                    'key': 'insights.activity.active',
+                    'params': {
+                        'count': str(usage_data['total_executions'])
+                    }
                 })
             
             return web.json_response({

py/routes/update_routes.py

@@ -1,7 +1,6 @@
 import os
 import logging
 import toml
-import git
 import zipfile
 import shutil
 import tempfile
@@ -11,11 +10,33 @@ from typing import Dict, List
 
 from ..utils.settings_paths import ensure_settings_file
 from ..services.downloader import get_downloader
+from ..services.service_registry import ServiceRegistry
 
 logger = logging.getLogger(__name__)
 
 NETWORK_EXCEPTIONS = (ClientError, OSError, asyncio.TimeoutError)
 
+# User-managed directories that live inside the plugin folder (portable
+# mode) and must survive a Git-based update. ``git clean -fd`` would
+# otherwise delete them because they are untracked and, in released tags,
+# not listed in ``.gitignore``. ``-e`` excludes a path from cleaning
+# regardless of whether it is ignored.
+_PRESERVE_DIRS = ('settings.json', 'civitai', 'wildcards', 'backups', 'stats', 'logs', 'cache', 'model_cache')
+
+
+def _clean_excludes() -> List[str]:
+    """Build the ``-e`` arguments for ``git clean`` from :data:`_PRESERVE_DIRS`."""
+    excludes: List[str] = []
+    for name in _PRESERVE_DIRS:
+        excludes.append('-e')
+        excludes.append(name)
+        # For directories, also exclude nested matches explicitly
+        # (``-e dir`` alone matches the dir entry; ``-e dir/**`` guards
+        # contents under all git versions as defense-in-depth).
+        excludes.append('-e')
+        excludes.append(f'{name}/**')
+    return excludes
+
 
 class UpdateRoutes:
     """Routes for handling plugin update checks"""
@@ -212,8 +233,19 @@ class UpdateRoutes:
 
             zip_path = tmp_zip_path
 
-            # Skip both settings.json, civitai and model cache folder
-            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache'])
+            # Close the downloaded-versions SQLite connection before cleaning,
+            # so that shutil.rmtree() does not fail on Windows (the process
+            # cannot delete a file with an outstanding open handle).
+            try:
+                history_svc = ServiceRegistry._services.get("downloaded_version_history_service")
+                if history_svc is not None:
+                    history_svc.close()
+                    logger.info("Closed downloaded-version history database connection")
+            except Exception:
+                logger.debug("Could not close downloaded-version history database", exc_info=True)
+
+            # Skip settings.json, civitai, model cache and runtime cache folders
+            UpdateRoutes._clean_plugin_folder(plugin_root, skip_files=['settings.json', 'civitai', 'model_cache', 'cache', 'wildcards', 'backups', 'stats'])
 
             # Extract ZIP to temp dir
             with tempfile.TemporaryDirectory() as tmp_dir:
@@ -222,16 +254,17 @@ class UpdateRoutes:
                     # Find extracted folder (GitHub ZIP contains a root folder)
                     extracted_root = next(os.scandir(tmp_dir)).path
 
-                    # Copy files, skipping settings.json and civitai folder
+                    # Copy files, skipping user data that should be preserved
+                    skip_items = {'settings.json', 'civitai', 'wildcards', 'backups', 'stats'}
                     for item in os.listdir(extracted_root):
-                        if item == 'settings.json' or item == 'civitai':
+                        if item in skip_items:
                             continue
                         src = os.path.join(extracted_root, item)
                         dst = os.path.join(plugin_root, item)
                         if os.path.isdir(src):
                             if os.path.exists(dst):
                                 shutil.rmtree(dst)
-                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns('settings.json', 'civitai'))
+                            shutil.copytree(src, dst, ignore=shutil.ignore_patterns(*skip_items))
                         else:
                             shutil.copy2(src, dst)
 
@@ -239,15 +272,17 @@ class UpdateRoutes:
                     # for ComfyUI Manager to work properly
                     tracking_info_file = os.path.join(plugin_root, '.tracking')
                     tracking_files = []
+                    skip_tracked = {'civitai', 'wildcards', 'backups', 'stats'}
                     for root, dirs, files in os.walk(extracted_root):
-                        # Skip civitai folder and its contents
+                        # Skip user data directories and their contents
                         rel_root = os.path.relpath(root, extracted_root)
-                        if rel_root == 'civitai' or rel_root.startswith('civitai' + os.sep):
+                        top_dir = rel_root.split(os.sep)[0] if rel_root != '.' else ''
+                        if top_dir in skip_tracked:
                             continue
                         for file in files:
                             rel_path = os.path.relpath(os.path.join(root, file), extracted_root)
-                            # Skip settings.json and any file under civitai
-                            if rel_path == 'settings.json' or rel_path.startswith('civitai' + os.sep):
+                            # Skip settings.json and any file under user data dirs
+                            if rel_path == 'settings.json' or rel_path.split(os.sep)[0] in skip_tracked:
                                 continue
                             tracking_files.append(rel_path.replace("\\", "/"))
                     with open(tracking_info_file, "w", encoding='utf-8') as file:
@@ -342,6 +377,17 @@ class UpdateRoutes:
         Returns:
             tuple: (success, new_version)
         """
+        try:
+            import git
+        except ImportError:
+            logger.error(
+                "GitPython is not available: the git executable was not found in PATH. "
+                "Install git or set $GIT_PYTHON_GIT_EXECUTABLE to the git binary path."
+            )
+            return False, ""
+
+        clean_excludes = _clean_excludes()
+
         try:
             # Open the Git repository
             repo = git.Repo(plugin_root)
@@ -353,8 +399,9 @@ class UpdateRoutes:
             if nightly:
                 # Reset to discard any local changes
                 repo.git.reset('--hard')
-                # Clean untracked files
-                repo.git.clean('-fd')
+                # Clean untracked files, but preserve user-managed directories
+                # (wildcards, backups, stats, civitai, caches, settings.json).
+                repo.git.clean('-fd', *clean_excludes)
                 
                 # Switch to main branch and pull latest
                 main_branch = 'main'
@@ -371,8 +418,9 @@ class UpdateRoutes:
             else:
                 # Reset to discard any local changes
                 repo.git.reset('--hard')
-                # Clean untracked files
-                repo.git.clean('-fd')
+                # Clean untracked files, but preserve user-managed directories
+                # (wildcards, backups, stats, civitai, caches, settings.json).
+                repo.git.clean('-fd', *clean_excludes)
                 
                 # Get latest release tag
                 tags = sorted(repo.tags, key=lambda t: t.commit.committed_datetime, reverse=True)
@@ -438,6 +486,7 @@ class UpdateRoutes:
             if not os.path.exists(os.path.join(plugin_root, '.git')):
                 return git_info
 
+            import git
             repo = git.Repo(plugin_root)
             commit = repo.head.commit
             git_info['commit_hash'] = commit.hexsha

py/services/agent/__init__.py

@@ -0,0 +1,23 @@
+"""Agent-powered skill system for LoRA Manager.
+
+This package provides the orchestration layer for LLM/agent-powered features.
+Skills define *what* to do (prompt template).  The :class:`AgentService`
+handles *how* (LLM calls, context gathering, validation, progress).
+"""
+
+from __future__ import annotations
+
+from .skill_definition import SkillDefinition, SkillPermissions
+from .skill_registry import SkillRegistry
+from .agent_service import AgentService, AgentProgressReporter, SkillResult
+from .post_processor import PostProcessor
+
+__all__ = [
+    "AgentProgressReporter",
+    "AgentService",
+    "PostProcessor",
+    "SkillDefinition",
+    "SkillPermissions",
+    "SkillRegistry",
+    "SkillResult",
+]

py/services/agent/agent_service.py

@@ -0,0 +1,413 @@
+"""Agent orchestration service.
+
+The :class:`AgentService` coordinates skill execution:
+
+1. Look up the skill in :class:`SkillRegistry`
+2. Validate input against the skill's ``input_schema``
+3. Prepare context via :mod:`~py.agent_cli` (read metadata, list base models, fetch HF README)
+4. If ``llm_required``: call :class:`LLMService` with the rendered prompt
+5. Post-process via :class:`PostProcessor` (delegates I/O to :mod:`~py.agent_cli`)
+6. Broadcast progress and completion via :class:`WebSocketManager`
+
+Skills define *what* to do (prompt template).  The AgentService handles *how*
+(LLM calls, context gathering, validation, progress).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+
+from ..llm_service import LLMService
+from ..websocket_manager import ws_manager
+from .post_processor import PostProcessor
+from .skill_registry import SkillRegistry
+
+logger = logging.getLogger(__name__)
+
+
+class AgentProgressReporter:
+    """Protocol-compatible progress reporter backed by WebSocket broadcast."""
+
+    async def on_progress(self, payload: Dict[str, Any]) -> None:
+        await ws_manager.broadcast(payload)
+
+
+@dataclass
+class SkillResult:
+    """Outcome of a skill execution."""
+
+    success: bool
+    updated_models: List[Dict[str, Any]] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    summary: str = ""
+
+
+def _validate_schema(data: Any, schema: Dict[str, Any], path: str = "") -> List[str]:
+    """Minimal JSON schema validator.
+
+    Supports a subset of JSON Schema: ``type``, ``properties``, ``required``,
+    ``items``, ``enum``.  Returns a list of error messages (empty = valid).
+    """
+
+    errors: List[str] = []
+    if not schema:
+        return errors
+
+    expected_type = schema.get("type")
+    if expected_type:
+        type_map = {
+            "string": str,
+            "number": (int, float),
+            "integer": int,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+            "null": type(None),
+        }
+        expected_py = type_map.get(expected_type)
+        if expected_py is not None and not isinstance(data, expected_py):
+            errors.append(f"{path or 'root'}: expected {expected_type}, got {type(data).__name__}")
+            return errors
+
+    if expected_type == "object" and isinstance(data, dict):
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+        for req_key in required:
+            if req_key not in data:
+                errors.append(f"{path or 'root'}: missing required property '{req_key}'")
+        for key, value in data.items():
+            if key in properties:
+                errors.extend(_validate_schema(value, properties[key], f"{path}.{key}"))
+
+    if expected_type == "array" and isinstance(data, list):
+        items_schema = schema.get("items")
+        if items_schema:
+            for i, item in enumerate(data):
+                errors.extend(_validate_schema(item, items_schema, f"{path}[{i}]"))
+
+    if "enum" in schema and data not in schema["enum"]:
+        errors.append(f"{path or 'root'}: value '{data}' not in enum {schema['enum']}")
+
+    return errors
+
+
+# ------------------------------------------------------------------
+# Prompt template rendering
+# ------------------------------------------------------------------
+
+
+def _render_prompt(template: str, variables: Dict[str, Any]) -> str:
+    """Render a prompt template with ``{{variable}}`` placeholders.
+
+    Uses simple regex substitution — no Jinja2 dependency needed.
+    """
+
+    def replace(match: re.Match) -> str:
+        key = match.group(1).strip()
+        value = variables.get(key, "")
+        if isinstance(value, (dict, list)):
+            return json.dumps(value, ensure_ascii=False, indent=2)
+        return str(value)
+
+    return re.sub(r"\{\{(\w+)\}\}", replace, template)
+
+
+class AgentService:
+    """Orchestrate agent skill execution.
+
+    Usage::
+
+        service = await AgentService.get_instance()
+        result = await service.execute_skill(
+            skill_name="enrich_hf_metadata",
+            input_data={"model_paths": ["/path/to/model.safetensors"]},
+            progress_callback=AgentProgressReporter(),
+        )
+    """
+
+    _instance: Optional["AgentService"] = None
+    _lock: asyncio.Lock = asyncio.Lock()
+
+    def __init__(
+        self,
+        *,
+        skill_registry: Optional[SkillRegistry] = None,
+        llm_service: Optional[LLMService] = None,
+    ) -> None:
+        self._registry = skill_registry
+        self._llm_service = llm_service
+
+    @classmethod
+    async def get_instance(cls) -> "AgentService":
+        """Return the lazily-initialised global ``AgentService``."""
+
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls(
+                        skill_registry=await SkillRegistry.get_instance(),
+                        llm_service=await LLMService.get_instance(),
+                    )
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset the cached singleton — primarily for tests."""
+
+        cls._instance = None
+
+    async def _ensure_registry(self) -> SkillRegistry:
+        if self._registry is None:
+            self._registry = await SkillRegistry.get_instance()
+        return self._registry
+
+    async def _ensure_llm(self) -> LLMService:
+        if self._llm_service is None:
+            self._llm_service = await LLMService.get_instance()
+        return self._llm_service
+
+    async def list_skills(self) -> List[Dict[str, Any]]:
+        """Return a JSON-serialisable list of available skills."""
+
+        registry = await self._ensure_registry()
+        return [
+            {
+                "name": s.name,
+                "title": s.title,
+                "description": s.description,
+                "llm_required": s.llm_required,
+                "model_type_filter": s.model_type_filter,
+            }
+            for s in registry.list_skills()
+        ]
+
+    async def execute_skill(
+        self,
+        *,
+        skill_name: str,
+        input_data: Dict[str, Any],
+        progress_callback: Optional[AgentProgressReporter] = None,
+    ) -> SkillResult:
+        """Execute an agent skill.
+
+        Args:
+            skill_name: Name of the skill to execute
+            input_data: Input validated against the skill's ``input_schema``
+            progress_callback: Optional WebSocket progress reporter
+
+        Returns:
+            :class:`SkillResult` with success status and updated model info
+        """
+
+        registry = await self._ensure_registry()
+        logger.info("execute_skill '%s': looking up skill", skill_name)
+        skill = registry.get_skill(skill_name)
+        if skill is None:
+            return SkillResult(
+                success=False,
+                errors=[f"Skill not found: {skill_name}"],
+                summary=f"Skill '{skill_name}' does not exist",
+            )
+
+        input_errors = _validate_schema(input_data, skill.input_schema)
+        if input_errors:
+            return SkillResult(
+                success=False,
+                errors=input_errors,
+                summary=f"Invalid input: {'; '.join(input_errors)}",
+            )
+
+        model_paths = input_data.get("model_paths", [])
+        if not model_paths:
+            return SkillResult(
+                success=False,
+                errors=["No model_paths provided"],
+                summary="No models to process",
+            )
+
+        total = len(model_paths)
+        processed = 0
+        success_count = 0
+        updated_models: List[Dict[str, Any]] = []
+        errors: List[str] = []
+        post_processor = PostProcessor()
+
+        logger.info("execute_skill '%s': starting with %d model(s)", skill_name, total)
+        await self._emit_progress(
+            progress_callback, skill_name, status="started",
+            total=total, processed=0, success=0,
+        )
+
+        llm = await self._ensure_llm()
+        llm_configured = llm.is_configured() if skill.llm_required else True
+
+        for model_path in model_paths:
+            logger.info(
+                "execute_skill '%s': processing model %d/%d: %s",
+                skill_name, processed + 1, total, model_path,
+            )
+            try:
+                from ...agent_cli import read_metadata
+                metadata = await read_metadata(model_path)
+
+                prompt_vars: Dict[str, Any] = {"model_path": model_path}
+                if skill.llm_required and llm_configured:
+                    prompt_vars = await self._build_prompt_context(
+                        skill_name, model_path, metadata, registry, llm,
+                    )
+
+                llm_response: Optional[Dict[str, Any]] = None
+                if skill.llm_required and llm_configured:
+                    prompt_template = registry.load_prompt(skill_name)
+                    rendered = _render_prompt(prompt_template, prompt_vars)
+                    logger.info(
+                        "execute_skill '%s': LLM call for %s (prompt=%d chars)",
+                        skill_name, model_path, len(rendered),
+                    )
+                    llm_response = await llm.chat_completion_json(
+                        system_prompt=prompt_vars.get(
+                            "system_prompt",
+                            "You are a helpful assistant that extracts structured metadata.",
+                        ),
+                        user_prompt=rendered,
+                    )
+
+                model_result = await post_processor.process(
+                    skill_name=skill_name,
+                    model_path=model_path,
+                    llm_output=llm_response or {},
+                    metadata=metadata,
+                )
+
+                if model_result.get("success", True):
+                    success_count += 1
+                    uf = model_result.get("updated_fields", [])
+                    if uf:
+                        updated_models.append({"path": model_path, "updated_fields": uf})
+                else:
+                    errors.extend(
+                        model_result.get("errors", [model_result.get("error", "Unknown error")])
+                    )
+
+            except Exception as exc:
+                logger.error("Skill %s failed for %s: %s", skill_name, model_path, exc)
+                errors.append(f"{model_path}: {exc}")
+
+            processed += 1
+            await self._emit_progress(
+                progress_callback, skill_name, status="processing",
+                total=total, processed=processed, success=success_count,
+                current_path=model_path,
+            )
+
+        result = SkillResult(
+            success=success_count > 0,
+            updated_models=updated_models,
+            errors=errors,
+            summary=f"Processed {processed}/{total} models, {success_count} succeeded",
+        )
+
+        logger.info("execute_skill '%s': done — %s", skill_name, result.summary)
+        await self._emit_progress(
+            progress_callback, skill_name, status="completed",
+            total=total, processed=processed, success=success_count,
+            updated_models=updated_models, errors=errors, summary=result.summary,
+        )
+
+        return result
+
+    async def _build_prompt_context(
+        self,
+        skill_name: str,
+        model_path: str,
+        metadata: Dict[str, Any],
+        registry: SkillRegistry,
+        llm: Any,
+    ) -> Dict[str, Any]:
+        """Gather variables for the skill's prompt template.
+
+        Reads metadata, fetches the HF README (if applicable), lists available
+        base models, and returns a dict that maps to ``{{variable}}``
+        placeholders in ``prompt.md``.
+        """
+        from ...agent_cli import list_base_models
+
+        context: Dict[str, Any] = {
+            "model_path": model_path,
+            "hf_url": "",
+            "repo": "",
+            "readme_content": "",
+            "current_metadata": {},
+            "base_models": [],
+        }
+
+        context["current_metadata"] = {
+            "file_name": metadata.get("file_name", ""),
+            "base_model": metadata.get("base_model", ""),
+            "tags": metadata.get("tags", []),
+            "modelDescription": metadata.get("modelDescription", ""),
+            "trainedWords": metadata.get("trainedWords", []),
+            "sha256": (metadata.get("sha256") or "")[:16] + "..." if metadata.get("sha256") else "",
+            "size": metadata.get("size", 0),
+        }
+
+        hf_url = metadata.get("hf_url", "")
+        context["hf_url"] = hf_url
+        repo = self._extract_repo_from_url(hf_url) if hf_url else ""
+        context["repo"] = repo or ""
+        if repo:
+            readme = await self._fetch_readme(repo)
+            context["readme_content"] = readme[:8000] if readme else "(README not available)"
+
+        try:
+            context["base_models"] = await list_base_models()
+        except Exception as exc:
+            logger.debug("Failed to list base models: %s", exc)
+
+        return context
+
+    @staticmethod
+    def _extract_repo_from_url(hf_url: str) -> Optional[str]:
+        """Extract ``user/repo`` from a HuggingFace URL."""
+        if not hf_url:
+            return None
+        m = re.match(r"https?://huggingface\.co/([^/]+/[^/]+)", hf_url)
+        return m.group(1) if m else None
+
+    @staticmethod
+    async def _fetch_readme(repo: str) -> str:
+        """Fetch README.md from HuggingFace (tries ``main``, then ``master``)."""
+        async with aiohttp.ClientSession(
+            headers={"User-Agent": "ComfyUI-LoRA-Manager/1.0"},
+            timeout=aiohttp.ClientTimeout(total=30),
+        ) as session:
+            for branch in ("main", "master"):
+                url = f"https://huggingface.co/{repo}/raw/{branch}/README.md"
+                try:
+                    async with session.get(url) as resp:
+                        if resp.status == 200:
+                            return await resp.text()
+                except Exception as exc:
+                    logger.debug("Failed to fetch README from %s: %s", url, exc)
+        return ""
+
+    async def _emit_progress(
+        self,
+        callback: Optional[AgentProgressReporter],
+        skill_name: str,
+        *,
+        status: str,
+        **extra: Any,
+    ) -> None:
+        """Send a progress update via WebSocket (if callback is set)."""
+        payload: Dict[str, Any] = {"type": "agent_progress", "skill": skill_name, "status": status}
+        payload.update(extra)
+        if callback is not None:
+            await callback.on_progress(payload)

py/services/agent/post_processor.py

@@ -0,0 +1,168 @@
+"""Post-processing engine for agent skill outputs.
+
+The :class:`PostProcessor` takes the LLM's structured JSON output and applies
+it to a model's on-disk metadata via the :mod:`~py.agent_cli` functions.
+
+It handles all the skill-specific business logic — conditions, transformations,
+and orchestration of multiple side-effects (write metadata, download preview,
+refresh cache).  All actual I/O is delegated to :mod:`~py.agent_cli`.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PostProcessor:
+    """Deterministic post-processor for agent skill outputs.
+
+    Usage (called by :class:`~py.services.agent.agent_service.AgentService`)::
+
+        processor = PostProcessor()
+        result = await processor.process(
+            skill_name="enrich_hf_metadata",
+            model_path="/path/to/model.safetensors",
+            llm_output={...},
+            metadata={...},    # from agent_cli.read_metadata()
+        )
+    """
+
+    async def process(
+        self,
+        *,
+        skill_name: str,
+        model_path: str,
+        llm_output: Dict[str, Any],
+        metadata: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Route *llm_output* to the correct skill post-processor.
+
+        Returns a dict with keys ``success`` (bool), ``updated_fields`` (list),
+        ``preview_downloaded`` (bool), and ``errors`` (list).
+        """
+        if skill_name == "enrich_hf_metadata":
+            return await self._process_enrich_hf_metadata(
+                model_path, llm_output, metadata,
+            )
+        return {
+            "success": False,
+            "updated_fields": [],
+            "errors": [f"No post-processor registered for skill: {skill_name}"],
+        }
+
+    # ------------------------------------------------------------------
+    # enrich_hf_metadata
+    # ------------------------------------------------------------------
+
+    async def _process_enrich_hf_metadata(
+        self,
+        model_path: str,
+        llm_output: Dict[str, Any],
+        metadata: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        from ...agent_cli import (
+            apply_metadata_updates,
+            download_preview,
+            refresh_cache,
+        )
+
+        updated_fields: List[str] = []
+        preview_downloaded = False
+
+        # -- Determine whether this is an HF-sourced model -----------------
+        is_hf_model = not metadata.get("from_civitai", True)
+
+        # -- Collect updates -----------------------------------------------
+        updates: Dict[str, Any] = {}
+
+        # base_model
+        new_base = (llm_output.get("base_model") or "").strip()
+        current_base = metadata.get("base_model", "") or ""
+        if new_base and self._should_overwrite(current_base, is_hf_model):
+            updates["base_model"] = new_base
+
+        # trainedWords / trigger words
+        new_triggers = llm_output.get("trigger_words", [])
+        if isinstance(new_triggers, list):
+            cleaned = [t.strip() for t in new_triggers if t.strip()]
+            if cleaned:
+                current_triggers = metadata.get("trainedWords") or []
+                if self._should_overwrite_list(current_triggers, is_hf_model):
+                    updates["trainedWords"] = cleaned
+
+        # modelDescription
+        new_desc = (llm_output.get("description") or "").strip()
+        if new_desc:
+            current_desc = metadata.get("modelDescription", "") or ""
+            if self._should_overwrite(current_desc, is_hf_model):
+                updates["modelDescription"] = new_desc
+
+        # tags — merge with existing, deduplicate (case-insensitive)
+        new_tags = llm_output.get("tags", [])
+        if isinstance(new_tags, list) and new_tags:
+            existing_tags = metadata.get("tags") or []
+            merged = self._merge_tags(existing_tags, new_tags)
+            if len(merged) > len(existing_tags) or is_hf_model:
+                updates["tags"] = merged
+
+        # metadata_source & llm_enriched_at (always set)
+        updates["metadata_source"] = "agent:enrich_hf_metadata"
+        updates["llm_enriched_at"] = datetime.now(timezone.utc).isoformat()
+
+        # -- Persist updates ------------------------------------------------
+        if updates:
+            updated_fields = await apply_metadata_updates(model_path, updates)
+
+        # -- Download preview -----------------------------------------------
+        preview_url = (llm_output.get("preview_url") or "").strip()
+        current_preview = metadata.get("preview_url") or ""
+        if preview_url and not (current_preview and os.path.exists(current_preview)):
+            preview_downloaded = await download_preview(model_path, preview_url)
+
+        # -- Refresh scanner cache ------------------------------------------
+        if updated_fields or preview_downloaded:
+            await refresh_cache(model_path)
+
+        return {
+            "success": True,
+            "updated_fields": updated_fields,
+            "preview_downloaded": preview_downloaded,
+            "errors": [],
+        }
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _should_overwrite(current_value: str, is_hf_model: bool) -> bool:
+        """Return ``True`` when a scalar field should be overwritten."""
+        return is_hf_model or not current_value or current_value.lower() in (
+            "", "unknown",
+        )
+
+    @staticmethod
+    def _should_overwrite_list(current_list: List[str], is_hf_model: bool) -> bool:
+        """Return ``True`` when a list field should be overwritten."""
+        return is_hf_model or not current_list
+
+    @staticmethod
+    def _merge_tags(existing: List[str], new: List[str]) -> List[str]:
+        """Merge *new* tags into *existing*, all lowercased.
+
+        This matches the behaviour of :class:`TagUpdateService` which
+        normalises every tag to lowercase for case-insensitive dedup.
+        """
+        merged: List[str] = []
+        seen: set = set()
+        for tag in list(existing) + list(new):
+            t = tag.strip().lower()
+            if t and t not in seen:
+                merged.append(t)
+                seen.add(t)
+        return merged

py/services/agent/skill_definition.py

@@ -0,0 +1,45 @@
+"""Skill definition data structures.
+
+Each skill is described by a :class:`SkillDefinition` that declares its
+input/output schemas, whether it needs an LLM call, and what permissions
+its post-processor has.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass(frozen=True)
+class SkillPermissions:
+    """Declarative permission scope for a skill's post-processor.
+
+    These are auditable constraints — the :class:`AgentService` checks them
+    before invoking the handler.  They are defense-in-depth, not a sandbox.
+    """
+
+    write_metadata: bool = True
+    write_previews: bool = True
+    network_domains: Tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class SkillDefinition:
+    """Immutable description of an agent skill."""
+
+    name: str
+    title: str
+    description: str
+    llm_required: bool
+    input_schema: Dict[str, Any] = field(default_factory=dict)
+    output_schema: Dict[str, Any] = field(default_factory=dict)
+    model_type_filter: Optional[List[str]] = None
+    permissions: SkillPermissions = field(default_factory=SkillPermissions)
+
+    def applies_to_model_type(self, model_type: str) -> bool:
+        """Return ``True`` if this skill can run on the given model type."""
+
+        if self.model_type_filter is None:
+            return True
+        return model_type in self.model_type_filter

py/services/agent/skill_registry.py

@@ -0,0 +1,184 @@
+"""Discovery and loading of agent skills.
+
+Skills live in ``py/services/agent/skills/<name>/`` directories.  Each
+directory must contain a ``SKILL.md`` file with YAML frontmatter::
+
+    ---
+    name: my_skill
+    title: "My Skill"
+    description: "What this skill does"
+    llm_required: true
+    ---
+
+    Prompt template with ``{{variable}}`` placeholders.
+
+The registry scans the skills directory on first access and caches results.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from .skill_definition import SkillDefinition, SkillPermissions
+
+logger = logging.getLogger(__name__)
+
+# Directory where built-in skills are stored
+_SKILLS_DIR = Path(__file__).parent / "skills"
+
+
+# ---------------------------------------------------------------------------
+# Frontmatter parser
+# ---------------------------------------------------------------------------
+
+_FRONTMATTER_RE = re.compile(
+    r"^---\s*\n(.*?\n)---\s*\n?(.*)", re.DOTALL
+)
+
+
+def _parse_skill_file(path: Path) -> tuple[dict, str]:
+    """Read a ``SKILL.md`` file and return (frontmatter_dict, body_text).
+
+    Raises ``ValueError`` if the file lacks valid YAML frontmatter.
+    """
+    text = path.read_text(encoding="utf-8")
+    m = _FRONTMATTER_RE.match(text)
+    if not m:
+        raise ValueError(f"Missing or invalid YAML frontmatter in {path}")
+    frontmatter = yaml.safe_load(m.group(1))
+    if not isinstance(frontmatter, dict):
+        raise ValueError(f"Frontmatter in {path} is not a mapping")
+    body = m.group(2).strip()
+    return frontmatter, body
+
+
+class SkillRegistry:
+    """Discover and load agent skills from the filesystem."""
+
+    _instance: Optional["SkillRegistry"] = None
+    _lock: asyncio.Lock = asyncio.Lock()
+
+    def __init__(self, skills_dir: Path = _SKILLS_DIR) -> None:
+        self._skills_dir = skills_dir
+        self._skills: Dict[str, SkillDefinition] = {}
+        self._loaded: bool = False
+
+    # ------------------------------------------------------------------
+    # Singleton access
+    # ------------------------------------------------------------------
+
+    @classmethod
+    async def get_instance(cls) -> "SkillRegistry":
+        """Return the lazily-initialised global ``SkillRegistry``."""
+
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    registry = cls()
+                    registry._discover()
+                    cls._instance = registry
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset the cached singleton — primarily for tests."""
+
+        cls._instance = None
+
+    # ------------------------------------------------------------------
+    # Discovery
+    # ------------------------------------------------------------------
+
+    def _discover(self) -> None:
+        """Scan the skills directory and load all valid skill definitions."""
+
+        self._skills.clear()
+        if not self._skills_dir.is_dir():
+            logger.warning("Skills directory does not exist: %s", self._skills_dir)
+            self._loaded = True
+            return
+
+        for entry in sorted(self._skills_dir.iterdir()):
+            if not entry.is_dir():
+                continue
+            skill_md = entry / "SKILL.md"
+            if not skill_md.exists():
+                continue
+            try:
+                definition = self._load_skill_definition(skill_md)
+                if definition is not None:
+                    self._skills[definition.name] = definition
+                    logger.debug("Loaded skill: %s", definition.name)
+            except Exception as exc:
+                logger.warning("Failed to load skill from %s: %s", skill_md, exc)
+
+        self._loaded = True
+        logger.info("Discovered %d agent skills", len(self._skills))
+
+    def _load_skill_definition(self, path: Path) -> Optional[SkillDefinition]:
+        """Parse a ``SKILL.md`` frontmatter into a :class:`SkillDefinition`."""
+
+        try:
+            data, _body = _parse_skill_file(path)
+        except (ValueError, yaml.YAMLError) as exc:
+            logger.warning("Failed to parse SKILL.md %s: %s", path, exc)
+            return None
+
+        if "name" not in data:
+            logger.warning("SKILL.md missing required 'name' field: %s", path)
+            return None
+
+        perm_data = data.get("permissions", {})
+        permissions = SkillPermissions(
+            write_metadata=perm_data.get("write_metadata", True),
+            write_previews=perm_data.get("write_previews", True),
+            network_domains=tuple(perm_data.get("network_domains", [])),
+        )
+
+        return SkillDefinition(
+            name=data["name"],
+            title=data.get("title", data["name"]),
+            description=data.get("description", ""),
+            llm_required=data.get("llm_required", False),
+            input_schema=data.get("input_schema", {}),
+            output_schema=data.get("output_schema", {}),
+            model_type_filter=data.get("model_type_filter"),
+            permissions=permissions,
+        )
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def list_skills(self) -> List[SkillDefinition]:
+        """Return all discovered skill definitions."""
+
+        if not self._loaded:
+            self._discover()
+        return list(self._skills.values())
+
+    def get_skill(self, name: str) -> Optional[SkillDefinition]:
+        """Return the skill definition for ``name``, or ``None`` if not found."""
+
+        if not self._loaded:
+            self._discover()
+        return self._skills.get(name)
+
+    def load_prompt(self, name: str) -> str:
+        """Load and return the prompt template body from a skill's ``SKILL.md``."""
+
+        skill_dir = self._skills_dir / name
+        skill_path = skill_dir / "SKILL.md"
+        if not skill_path.exists():
+            raise FileNotFoundError(f"SKILL.md not found: {skill_path}")
+        try:
+            _frontmatter, body = _parse_skill_file(skill_path)
+            return body
+        except (ValueError, yaml.YAMLError) as exc:
+            raise ValueError(f"Failed to parse prompt from {skill_path}: {exc}") from exc

py/services/agent/skills/enrich_hf_metadata/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: enrich_hf_metadata
+title: "Enrich Metadata from HuggingFace"
+description: >
+  Parse the HuggingFace model card via LLM to extract description, trigger
+  words, base model, tags, and preview image URL.
+llm_required: true
+---
+
+You are an expert assistant for AI image generation models. Your task is to extract structured metadata from a HuggingFace model card (README.md).
+
+## Model Information
+
+- **Repository**: {{hf_url}}
+- **Model file path**: {{model_path}}
+- **Repository ID**: {{repo}}
+
+## Current Metadata (may be incomplete)
+
+```json
+{{current_metadata}}
+```
+
+## Available Base Models
+
+The following base models are currently valid in this system:
+{{base_models}}
+
+## HuggingFace README Content
+
+```
+{{readme_content}}
+```
+
+## Extraction Instructions
+
+Extract the following information from the README content above:
+
+### base_model
+The base model this LoRA/checkpoint was trained on. Use EXACTLY one of the names from the **Available Base Models** list above. Do not invent new names or use aliases.
+
+Check the YAML frontmatter (between --- markers) for `base_model:` first, then look at the description text and safetensors metadata. If you cannot determine it, return an empty string.
+
+### trigger_words
+The trigger words or activation prompts needed to use this LoRA. Look for:
+- `instance_prompt:` in the YAML frontmatter
+- Phrases like "trigger word:", "trigger:", "use this prompt:", "activation prompt:"
+- Example prompts at the start (usually the first word or phrase before any description)
+Return as an array of strings. If none found, return an empty array.
+
+### description
+A concise 1-2 sentence summary of what this model does. Extract from the "Model description" section or the first paragraph. Return empty string if the README is too minimal.
+
+### tags
+3-8 relevant tags for categorizing this model. Extract from:
+- The YAML frontmatter `tags:` list (often contains excellent categorization tags)
+- The model type (e.g. "lora", "checkpoint", "flux", "sdxl")
+- The style/subject (e.g. "anime", "photorealistic", "style", "character")
+All lowercase, no spaces. Return empty array if none found.
+
+### preview_url
+The URL of the most suitable preview image from the README. Look for image tags (e.g. `![alt](url)`) and the YAML frontmatter `widget:` section (which often has `output.url` fields). Choose the first image that appears to be a generation example (not a logo or diagram). Construct the absolute URL as `https://huggingface.co/{{repo}}/resolve/main/{filename}`. If no suitable image is found, return an empty string.
+
+### confidence
+Your confidence level in the extracted data:
+- "high" — most fields were explicitly stated in the README
+- "medium" — some fields were inferred from context
+- "low" — most fields are guesses based on limited information
+
+## Output Format
+
+Return ONLY a JSON object with exactly these fields (no markdown fences, no extra text):
+
+```json
+{
+  "model_path": "{{model_path}}",
+  "base_model": "<canonical name or empty string>",
+  "trigger_words": ["<word1>", "<word2>"],
+  "description": "<1-2 sentence summary>",
+  "tags": ["<tag1>", "<tag2>"],
+  "preview_url": "<image URL or empty string>",
+  "confidence": "<high|medium|low>"
+}
+```
+
+Important:
+- Only include the JSON object, no other text
+- If a field cannot be determined, use an empty string or empty array
+- Do not fabricate information not supported by the README

py/services/aria2_downloader.py

@@ -14,12 +14,30 @@ from typing import Any, Dict, Optional, Tuple
 
 import aiohttp
 
-from .downloader import DownloadProgress, get_downloader
+from .downloader import DownloadProgress, get_downloader, is_ssl_cert_verify_error
 from .aria2_transfer_state import Aria2TransferStateStore
 from .settings_manager import get_settings_manager
 
 logger = logging.getLogger(__name__)
 
+def _try_certifi_ca_path() -> str | None:
+    """Return the certifi CA bundle path if available, else None."""
+    try:
+        import certifi  # type: ignore[import-untyped]
+
+        path = certifi.where()
+        if os.path.isfile(path):
+            logger.debug(
+                "aria2 --ca-certificate: using certifi CA bundle at %s", path
+            )
+            return path
+    except ImportError:
+        pass
+
+    logger.debug("aria2 --ca-certificate: certifi not available")
+    return None
+
+
 CIVITAI_DOWNLOAD_URL_PREFIXES = (
     "https://civitai.com/api/download/",
     "https://civitai.red/api/download/",
@@ -39,7 +57,7 @@ class Aria2Transfer:
 
 
 class Aria2Downloader:
-    """Manage an aria2 RPC daemon for experimental model downloads."""
+    """Manage an aria2 RPC daemon for recommended model downloads."""
 
     _instance = None
     _lock = asyncio.Lock()
@@ -66,6 +84,7 @@ class Aria2Downloader:
         self._transfers: Dict[str, Aria2Transfer] = {}
         self._poll_interval = 0.5
         self._state_store = Aria2TransferStateStore()
+        self._stderr_reader_task: Optional[asyncio.Task] = None
 
     @property
     def is_running(self) -> bool:
@@ -97,7 +116,7 @@ class Aria2Downloader:
 
         try:
             while True:
-                status = await self.get_status(download_id)
+                status = await self._get_status_with_retry(download_id)
                 if status is None:
                     return False, "aria2 download not found"
 
@@ -118,6 +137,35 @@ class Aria2Downloader:
         finally:
             self._transfers.pop(download_id, None)
 
+    async def _get_status_with_retry(
+        self, download_id: str, *, max_retries: int = 4, retry_delay: float = 3.0
+    ) -> Optional[Dict[str, Any]]:
+        """Call get_status with retry for transient RPC failures.
+
+        Only retries on :exc:`Aria2Error` (RPC-level failure).  Returns
+        ``None`` immediately when the download_id is not tracked (a missing
+        transfer is not a transient condition, so retrying is pointless).
+
+        A single failed RPC call should not immediately fail the download,
+        because aria2 may be temporarily busy (e.g. finalizing multiple
+        concurrent downloads) and a retry will often succeed.
+        """
+        last_exc: Optional[Exception] = None
+        for attempt in range(max_retries):
+            try:
+                return await self.get_status(download_id)
+            except Aria2Error as exc:
+                last_exc = exc
+                if attempt < max_retries - 1:
+                    logger.warning(
+                        "aria2 get_status transient failure (attempt %d/%d) for %s: %s",
+                        attempt + 1, max_retries, download_id, exc,
+                    )
+                    await asyncio.sleep(retry_delay)
+        raise Aria2Error(
+            f"Failed to query aria2 download status after {max_retries} attempts: {last_exc}"
+        ) from last_exc
+
     async def _schedule_download(
         self,
         url: str,
@@ -294,6 +342,16 @@ class Aria2Downloader:
     async def close(self) -> None:
         """Shut down the RPC process and session."""
 
+        # Cancel the background stderr reader first so it stops reading
+        # from the pipe before the subprocess is terminated.
+        if self._stderr_reader_task is not None:
+            self._stderr_reader_task.cancel()
+            try:
+                await asyncio.wait_for(self._stderr_reader_task, timeout=2.0)
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                pass
+            self._stderr_reader_task = None
+
         if self._rpc_session is not None:
             await self._rpc_session.close()
             self._rpc_session = None
@@ -313,6 +371,23 @@ class Aria2Downloader:
                 process.kill()
                 await process.wait()
 
+    async def _drain_stderr(self) -> None:
+        """Continuously drain aria2's stderr pipe so it never blocks.
+
+        When the 64 KB pipe buffer fills up, aria2's ``write()`` to stderr
+        blocks, which freezes the entire ``aria2c`` process — including its
+        RPC handler.  This background task reads lines from stderr as they
+        arrive and forwards them to Python's logger.
+        """
+        try:
+            assert self._process is not None and self._process.stderr is not None
+            async for line in self._process.stderr:
+                text = line.decode("utf-8", errors="replace").rstrip()
+                if text:
+                    logger.debug("aria2 stderr: %s", text)
+        except Exception:
+            pass
+
     async def _dispatch_progress(self, callback, snapshot: DownloadProgress) -> None:
         try:
             result = callback(snapshot, snapshot)
@@ -391,6 +466,15 @@ class Aria2Downloader:
                     f"Failed to resolve authenticated Civitai redirect: status={response.status} body={body[:300]}"
                 )
         except aiohttp.ClientError as exc:
+            if is_ssl_cert_verify_error(exc):
+                logger.error(
+                    "SSL certificate verification failed during Civitai redirect "
+                    "resolution for %s. This is usually caused by an outdated CA "
+                    "certificate bundle. Recommended fixes:\n"
+                    "  1. pip install --upgrade certifi\n"
+                    "  2. pip install pip-system-certs",
+                    url,
+                )
             raise Aria2Error(
                 f"Failed to resolve authenticated Civitai redirect: {exc}"
             ) from exc
@@ -414,6 +498,11 @@ class Aria2Downloader:
                 f"--rpc-listen-port={self._rpc_port}",
                 f"--rpc-secret={self._rpc_secret}",
                 "--check-certificate=true",
+                # Point aria2 at certifi's CA bundle when available so it uses
+                # the same certificate store as Python downloads.
+                *((
+                    f"--ca-certificate={ca_cert}",
+                ) if (ca_cert := _try_certifi_ca_path()) else ()),
                 "--allow-overwrite=true",
                 "--auto-file-renaming=false",
                 "--file-allocation=none",
@@ -433,6 +522,17 @@ class Aria2Downloader:
 
             await self._wait_until_ready()
 
+            # Drain aria2's stderr in a background task so the pipe buffer
+            # never fills up.  If the pipe blocks, aria2 itself freezes and
+            # cannot respond to RPC — this was the root cause of the
+            # "Failed to query aria2 download status" timeout bug.
+            # Must start AFTER _wait_until_ready to avoid a race where the
+            # drain task consumes aria2's early-exit error message before
+            # _wait_until_ready can read it.
+            self._stderr_reader_task = asyncio.create_task(
+                self._drain_stderr()
+            )
+
     def _resolve_executable(self) -> str:
         settings = get_settings_manager()
         configured_path = (settings.get("aria2c_path") or "").strip()
@@ -552,7 +652,9 @@ class Aria2Downloader:
         if self._rpc_session is None or self._rpc_session.closed:
             async with self._rpc_session_lock:
                 if self._rpc_session is None or self._rpc_session.closed:
-                    timeout = aiohttp.ClientTimeout(total=30)
+                    timeout = aiohttp.ClientTimeout(
+                        total=None, sock_connect=10, sock_read=60
+                    )
                     self._rpc_session = aiohttp.ClientSession(timeout=timeout)
         return self._rpc_session
 

py/services/auto_tag_service.py

@@ -0,0 +1,139 @@
+"""
+Auto-tag extraction service for model cards.
+
+Extracts implicit model attributes (HIGH/LOW, I2V/T2V/TI2V, Lightning, Turbo)
+from filename, base_model, and CivitAI version name — no manual tagging required.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Set
+
+# ── Tag category definitions ──────────────────────────────────────────
+# Each category maps a display label to a regex pattern.
+# Patterns are case-insensitive and matched against filename, base_model,
+# and civitai version name.
+
+# Use (?<![a-zA-Z0-9]) and (?![a-zA-Z0-9]) instead of \b because
+# Python's \b treats underscore as a word character, so \bHIGH\b
+# won't match '_HIGH_' in filenames.
+_B = r"(?<![a-zA-Z0-9])"   # left boundary
+_E = r"(?![a-zA-Z0-9])"    # right boundary
+
+AUTO_TAG_CATEGORIES: Dict[str, str] = {
+    "HIGH":      _B + r"HIGH" + _E,
+    "LOW":       _B + r"(?<!F)LOW" + _E,
+    "I2V":       _B + r"I2V" + _E,
+    "T2V":       _B + r"T2V" + _E,
+    "TI2V":      _B + r"TI2V" + _E,
+    "Lightning": _B + r"Lightning" + _E,
+    "Turbo":     _B + r"Turbo" + _E,
+}
+
+# Tags that belong to the "mode" group (HIGH/LOW)
+MODE_TAGS = {"HIGH", "LOW"}
+
+# Tags that belong to the "video mode" group (I2V/T2V/TI2V)
+VIDEO_MODE_TAGS = {"I2V", "T2V", "TI2V"}
+
+# Tags that belong to the "speed/optimization" group
+SPEED_TAGS = {"Lightning", "Turbo"}
+
+# ── Display category groups (for settings UI) ─────────────────────────
+
+AUTO_TAG_GROUPS = {
+    "mode":   {"HIGH", "LOW"},
+    "video":  {"I2V", "T2V", "TI2V"},
+    "speed":  {"Lightning", "Turbo"},
+}
+
+# Default enabled categories
+DEFAULT_ENABLED_GROUPS = {"mode", "video"}
+
+
+def _collect_sources(model_data: Dict) -> List[str]:
+    """Collect all text sources from model data for tag matching."""
+    sources: List[str] = []
+
+    file_name = model_data.get("file_name", "")
+    if file_name:
+        sources.append(file_name)
+
+    base_model = model_data.get("base_model", "")
+    if base_model:
+        sources.append(base_model)
+
+    civitai = model_data.get("civitai", {})
+    if isinstance(civitai, dict):
+        version_name = civitai.get("name", "")
+        if version_name:
+            sources.append(version_name)
+
+    return sources
+
+
+def extract_auto_tags(model_data: Dict) -> List[str]:
+    """Extract auto-detected tags from model metadata.
+
+    Uses a two-layer approach:
+      Layer 1 — Regex-based detection against filename, base_model, and
+                CivitAI version name.
+      Layer 2 — Merge in any user-defined tags that overlap with known
+                auto-tag categories. This provides a manual fallback when
+                auto-detection fails (e.g. "I2V HN" or unlabeled models).
+
+    HIGH/LOW tags are only returned when the base_model indicates a Wan
+    family model — no other model architecture uses this distinction.
+
+    Args:
+        model_data: Model metadata dict with keys:
+            file_name, base_model, civitai (with optional 'name' field),
+            tags (user-defined tag list, used as fallback).
+
+    Returns:
+        Sorted list of unique auto-tag strings (e.g. ["I2V"]).
+    """
+    sources = _collect_sources(model_data)
+    base_model = model_data.get("base_model", "")
+    is_wan = "wan" in base_model.lower()
+
+    found: Set[str] = set()
+
+    # ── Layer 1: regex-based detection ────────────────────────────
+    if sources:
+        for label, pattern in AUTO_TAG_CATEGORIES.items():
+            # HIGH/LOW are Wan-specific — skip for non-Wan to avoid noise
+            if label in ("HIGH", "LOW"):
+                if not is_wan:
+                    continue
+                # Use case-insensitive character class + case-sensitive boundary,
+                # so "HighNoise" (camelCase) matches but "highlight" doesn't.
+                # Boundary: not followed by lowercase letter (= word has ended).
+                ci = "".join(f"[{c.lower()}{c.upper()}]" for c in label)
+                if label == "LOW":
+                    regex = re.compile(r"(?<![Ff])" + ci + r"(?![a-z])")
+                else:
+                    regex = re.compile(ci + r"(?![a-z])")
+            else:
+                regex = re.compile(pattern, re.IGNORECASE)
+            for source in sources:
+                if regex.search(source):
+                    found.add(label)
+                    break
+
+    # ── Layer 2: user-defined tags as manual fallback ─────────────
+    # When auto-detection fails (abbreviated names like "Hi"/"Lo",
+    # "I2V HN", or unlabeled models), users can add canonical tags
+    # (HIGH, LOW, I2V, etc.) to the model's regular tags for correct
+    # badge display and filtering. Matching is case-insensitive so
+    # "high"/"High"/"HIGH" all resolve to the canonical label.
+    user_tags = model_data.get("tags")
+    if user_tags:
+        label_map = {label.lower(): label for label in AUTO_TAG_CATEGORIES}
+        for t in user_tags:
+            canonical = label_map.get(t.lower())
+            if canonical:
+                found.add(canonical)
+
+    return sorted(found)

py/services/backup_service.py

@@ -141,6 +141,16 @@ class BackupService:
                     )
                 )
 
+        stats_path = os.path.join(get_settings_dir(create=True), "stats", "lora_manager_stats.json")
+        if os.path.exists(stats_path):
+            targets.append(
+                (
+                    "usage_stats",
+                    "stats/lora_manager_stats.json",
+                    stats_path,
+                )
+            )
+
         return targets
 
     @staticmethod
@@ -348,6 +358,8 @@ class BackupService:
         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)
+        if kind == "usage_stats":
+            return os.path.join(get_settings_dir(create=True), "stats", "lora_manager_stats.json")
         return None
 
     async def create_auto_snapshot_if_due(self) -> Optional[dict[str, Any]]:

py/services/base_model_service.py

@@ -77,6 +77,7 @@ class BaseModelService(ABC):
         base_models: list = None,
         model_types: list = None,
         tags: Optional[Dict[str, str]] = None,
+        auto_tags: Optional[Dict[str, str]] = None,
         search_options: dict = None,
         hash_filters: dict = None,
         favorites_only: bool = False,
@@ -95,9 +96,108 @@ class BaseModelService(ABC):
             sorted_data = await self._fetch_with_usage_sort(sort_params)
         else:
             sorted_data = await self.cache_repository.fetch_sorted(sort_params)
+        # Pre-compute auto_tags for every item — needed for both filtering
+        # and display. Computation is cheap (string regex on 2-3 fields).
+        from .auto_tag_service import extract_auto_tags
+        for item in sorted_data:
+            item["auto_tags"] = extract_auto_tags(item)
         fetch_duration = time.perf_counter() - t0
         initial_count = len(sorted_data)
 
+        # Optionally filter by civitai model ID (shows all local versions of a specific model)
+        civitai_model_id = kwargs.get("civitai_model_id")
+        if civitai_model_id is not None:
+            sorted_data = [
+                item for item in sorted_data
+                if self._extract_model_id(item) == civitai_model_id
+            ]
+            # VLM mode: always sort by version ID descending (newest version first),
+            # regardless of the current sort_by preference.
+            sorted_data.sort(
+                key=lambda x: self._extract_version_id(x) or 0,
+                reverse=True,
+            )
+
+        # Optionally group by civitai modelId, showing only the latest version per model
+        dedup_lost = 0
+        if kwargs.get("group_by_model") and civitai_model_id is None:
+            # Determine whether to further sub-group by base model
+            # When version_grouping is "same_base", versions with different
+            # base models are effectively different groups — the dedup key
+            # needs to include base_model so the version count and VLM flow
+            # stay consistent (card shows correct count for its base model).
+            ufs = self.settings.get("version_grouping", "same_base")
+            group_by_base = ufs == "same_base"
+
+            dedup_map = {}  # (modelId [,base_model]) -> (item, version_id)
+            version_counter = {}  # same-key -> count
+            standalone = []
+            for item in sorted_data:
+                mid = self._extract_model_id(item)
+                if mid is None:
+                    standalone.append(item)
+                    continue
+                key = (mid, item.get("base_model") or "") if group_by_base else mid
+                # Count all versions per key
+                version_counter[key] = version_counter.get(key, 0) + 1
+                vid = self._extract_version_id(item) or 0
+                if key not in dedup_map or vid > dedup_map[key][1]:
+                    dedup_map[key] = (item, vid)
+            # Attach version_count to each surviving grouped item (shallow copy
+            # to avoid mutating cached dicts — the cache is shared across requests)
+            for key, (item, vid) in dedup_map.items():
+                item = dict(item)
+                item["version_count"] = version_counter[key]
+                dedup_map[key] = (item, vid)
+            dedup_lost = len(sorted_data) - (len(dedup_map) + len(standalone))
+            sorted_data = [entry[0] for entry in dedup_map.values()] + standalone
+
+        # Re-sort by version_count (grouped: after dedup; non-grouped: group internally, sort, expand)
+        if sort_params.key == "versions_count" and civitai_model_id is None:
+            reverse = sort_params.order == "desc"
+            if kwargs.get("group_by_model"):
+                # Grouped mode: items are already dedup'd with version_count attached
+                sorted_data.sort(
+                    key=lambda x: (
+                        x.get("version_count", 0),
+                        (x.get("model_name") or x.get("file_name") or "").lower(),
+                        x.get("file_path", "").lower(),
+                    ),
+                    reverse=reverse,
+                )
+            else:
+                # Non-grouped mode: group internally, sort groups by count, expand
+                # Respect the version_grouping setting (same logic as grouped dedup)
+                ufs = self.settings.get("version_grouping", "same_base")
+                group_by_base = ufs == "same_base"
+
+                model_groups: Dict[Any, List[Dict]] = {}
+                ungrouped_standalone: List[Dict] = []
+                for item in sorted_data:
+                    mid = self._extract_model_id(item)
+                    if mid is None:
+                        ungrouped_standalone.append(item)
+                        continue
+                    key = (mid, item.get("base_model") or "") if group_by_base else mid
+                    model_groups.setdefault(key, []).append(item)
+                # Sort versions within each group by version id descending
+                for items in model_groups.values():
+                    items.sort(
+                        key=lambda x: self._extract_version_id(x) or 0,
+                        reverse=True,
+                    )
+                # Sort groups by version count
+                sorted_groups = sorted(
+                    model_groups.values(),
+                    key=lambda items: len(items),
+                    reverse=reverse,
+                )
+                # Flatten: grouped items first, standalone items last
+                sorted_data = []
+                for items in sorted_groups:
+                    sorted_data.extend(items)
+                sorted_data.extend(ungrouped_standalone)
+
         t1 = time.perf_counter()
         if hash_filters:
             filtered_data = await self._apply_hash_filters(sorted_data, hash_filters)
@@ -110,6 +210,7 @@ class BaseModelService(ABC):
                 base_models=base_models,
                 model_types=model_types,
                 tags=tags,
+                auto_tags=auto_tags,
                 favorites_only=favorites_only,
                 search_options=search_options,
                 tag_logic=tag_logic,
@@ -165,7 +266,7 @@ class BaseModelService(ABC):
         overall_duration = time.perf_counter() - overall_start
         logger.debug(
             "%s.get_paginated_data took %.3fs (fetch: %.3fs, filter: %.3fs, update_filter: %.3fs, pagination: %.3fs, annotate: %.3fs). "
-            "Counts: initial=%d, post_filter=%d, final=%d",
+            "Counts: initial=%d, dedup=%d, post_filter=%d, final=%d",
             self.__class__.__name__,
             overall_duration,
             fetch_duration,
@@ -174,6 +275,7 @@ class BaseModelService(ABC):
             pagination_duration,
             annotate_duration,
             initial_count,
+            dedup_lost,
             post_filter_count,
             final_count,
         )
@@ -354,6 +456,7 @@ class BaseModelService(ABC):
         base_models: list = None,
         model_types: list = None,
         tags: Optional[Dict[str, str]] = None,
+        auto_tags: Optional[Dict[str, str]] = None,
         favorites_only: bool = False,
         search_options: dict = None,
         tag_logic: str = "any",
@@ -367,6 +470,7 @@ class BaseModelService(ABC):
             base_models=base_models,
             model_types=model_types,
             tags=tags,
+            auto_tags=auto_tags,
             favorites_only=favorites_only,
             search_options=normalized_options,
             tag_logic=tag_logic,
@@ -486,7 +590,7 @@ class BaseModelService(ABC):
         if not ordered_ids:
             return annotated
 
-        strategy_value = self.settings.get("update_flag_strategy")
+        strategy_value = self.settings.get("version_grouping")
         if isinstance(strategy_value, str) and strategy_value.strip():
             strategy = strategy_value.strip().lower()
         else:
@@ -687,8 +791,12 @@ class BaseModelService(ABC):
         }
 
     @abstractmethod
-    async def format_response(self, model_data: Dict) -> Dict:
-        """Format model data for API response - must be implemented by subclasses"""
+    async def format_response(self, model_data: Dict) -> Optional[Dict]:
+        """Format model data for API response - must be implemented by subclasses.
+
+        Subclasses should return None for corrupted entries so the handler
+        layer can filter them out. See issue #730.
+        """
         pass
 
     # Common service methods that delegate to scanner
@@ -861,22 +969,75 @@ class BaseModelService(ABC):
         """Get the static preview URL for a model file"""
         cache = await self.scanner.get_cached_data()
 
+        name_normalized = model_name.replace("\\", "/")
+        name_no_ext = name_normalized
+        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+            if name_no_ext.lower().endswith(ext):
+                name_no_ext = name_no_ext[: -len(ext)]
+                break
+
+        has_path = "/" in name_no_ext
+        basename = os.path.basename(name_no_ext) if has_path else name_no_ext
+        best_fallback = None
+
         for model in cache.raw_data:
-            if model["file_name"] == model_name:
+            file_name = model.get("file_name", "")
+            folder = model.get("folder", "")
+            file_name_no_ext = file_name
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if file_name_no_ext.lower().endswith(ext):
+                    file_name_no_ext = file_name_no_ext[: -len(ext)]
+                    break
+            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+
+            if name_no_ext == file_name_no_ext or name_no_ext == path_name:
                 preview_url = model.get("preview_url")
                 if preview_url:
                     from ..config import config
 
                     return config.get_preview_static_url(preview_url)
 
+            if has_path and file_name_no_ext == basename:
+                if folder and name_no_ext.startswith(folder.replace("\\", "/") + "/"):
+                    best_fallback = model
+                elif best_fallback is None:
+                    best_fallback = model
+
+        if best_fallback:
+            preview_url = best_fallback.get("preview_url")
+            if preview_url:
+                from ..config import config
+
+                return config.get_preview_static_url(preview_url)
+
         return "/loras_static/images/no-preview.png"
 
     async def get_model_civitai_url(self, model_name: str) -> Dict[str, Optional[str]]:
         """Get the Civitai URL for a model file"""
         cache = await self.scanner.get_cached_data()
 
+        name_normalized = model_name.replace("\\", "/")
+        name_no_ext = name_normalized
+        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+            if name_no_ext.lower().endswith(ext):
+                name_no_ext = name_no_ext[: -len(ext)]
+                break
+
+        has_path = "/" in name_no_ext
+        basename = os.path.basename(name_no_ext) if has_path else name_no_ext
+        best_fallback = None
+
         for model in cache.raw_data:
-            if model["file_name"] == model_name:
+            file_name = model.get("file_name", "")
+            folder = model.get("folder", "")
+            file_name_no_ext = file_name
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if file_name_no_ext.lower().endswith(ext):
+                    file_name_no_ext = file_name_no_ext[: -len(ext)]
+                    break
+            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+
+            if name_no_ext == file_name_no_ext or name_no_ext == path_name:
                 civitai_data = model.get("civitai", {})
                 model_id = civitai_data.get("modelId")
                 version_id = civitai_data.get("id")
@@ -895,6 +1056,27 @@ class BaseModelService(ABC):
                         "version_id": str(version_id) if version_id else None,
                     }
 
+            if has_path and file_name_no_ext == basename:
+                if folder and name_no_ext.startswith(folder.replace("\\", "/") + "/"):
+                    best_fallback = model
+                elif best_fallback is None:
+                    best_fallback = model
+
+        if best_fallback:
+            civitai_data = best_fallback.get("civitai", {})
+            model_id = civitai_data.get("modelId")
+            if model_id:
+                version_id = civitai_data.get("id")
+                civitai_host = self.settings.get("civitai_host", "civitai.com")
+                civitai_url = build_civitai_model_page_url(
+                    model_id, version_id, host=civitai_host
+                )
+                return {
+                    "civitai_url": civitai_url,
+                    "model_id": str(model_id),
+                    "version_id": str(version_id) if version_id else None,
+                }
+
         return {"civitai_url": None, "model_id": None, "version_id": None}
 
     async def get_model_metadata(self, file_path: str) -> Optional[Dict]:
@@ -908,6 +1090,17 @@ class BaseModelService(ABC):
         )
         if should_skip or metadata is None:
             return None
+
+        # Prune stale example-image metadata entries whose files no longer
+        # exist on disk (e.g. a user deleted the files manually).
+        from ..utils.example_images_metadata import MetadataUpdater
+
+        was_modified = await MetadataUpdater.prune_stale_example_images(metadata)
+        if was_modified:
+            asyncio.create_task(
+                MetadataManager.save_metadata(file_path, metadata)
+            )
+
         return self.filter_civitai_data(metadata.to_dict().get("civitai", {}))
 
     async def get_model_description(self, file_path: str) -> Optional[str]:

py/services/batch_import_service.py

@@ -224,7 +224,7 @@ class BatchImportService:
                 return False
 
             for recipe in getattr(cache, "raw_data", []):
-                source_path = recipe.get("source_path") or recipe.get("source_url")
+                source_path = recipe.get("source_path")
                 if source_path and source_path == source:
                     return True
             return False
@@ -523,6 +523,10 @@ class BatchImportService:
                 if payload.get("checkpoint"):
                     metadata["checkpoint"] = payload["checkpoint"]
 
+                nsfw = payload.get("preview_nsfw_level")
+                if isinstance(nsfw, int) and nsfw > 0:
+                    metadata["preview_nsfw_level"] = nsfw
+
                 image_bytes = None
                 image_base64 = payload.get("image_base64")
 

py/services/checkpoint_service.py

@@ -1,8 +1,9 @@
 import os
 import logging
-from typing import Dict
+from typing import Dict, Optional
 
 from .base_model_service import BaseModelService
+from .auto_tag_service import extract_auto_tags
 from ..utils.models import CheckpointMetadata
 from ..config import config
 
@@ -20,20 +21,37 @@ class CheckpointService(BaseModelService):
         """
         super().__init__("checkpoint", scanner, CheckpointMetadata, update_service=update_service)
     
-    async def format_response(self, checkpoint_data: Dict) -> Dict:
-        """Format Checkpoint data for API response"""
+    async def format_response(self, checkpoint_data: Dict) -> Optional[Dict]:
+        """Format Checkpoint data for API response.
+
+        Returns None when the entry is missing critical fields (corrupted cache
+        row), so the handler layer can filter it out. See issue #730.
+        """
+        # Guard against corrupted cache entries missing critical fields
+        file_path = checkpoint_data.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            logger.warning(
+                "Skipping corrupted checkpoint entry (missing file_path): %s",
+                checkpoint_data.get("file_name", "<unknown>"),
+            )
+            return None
+
         # Get sub_type from cache entry (new canonical field)
         sub_type = checkpoint_data.get("sub_type", "checkpoint")
-        
+
+        file_name = checkpoint_data.get("file_name") or ""
+        model_name = checkpoint_data.get("model_name") or file_name
+        folder = checkpoint_data.get("folder") or ""
+
         return {
-            "model_name": checkpoint_data["model_name"],
-            "file_name": checkpoint_data["file_name"],
+            "model_name": model_name,
+            "file_name": file_name,
             "preview_url": config.get_preview_static_url(checkpoint_data.get("preview_url", "")),
             "preview_nsfw_level": checkpoint_data.get("preview_nsfw_level", 0),
             "base_model": checkpoint_data.get("base_model", ""),
-            "folder": checkpoint_data["folder"],
+            "folder": folder,
             "sha256": checkpoint_data.get("sha256", ""),
-            "file_path": checkpoint_data["file_path"].replace(os.sep, "/"),
+            "file_path": file_path.replace(os.sep, "/"),
             "file_size": checkpoint_data.get("size", 0),
             "modified": checkpoint_data.get("modified", ""),
             "tags": checkpoint_data.get("tags", []),
@@ -45,7 +63,10 @@ class CheckpointService(BaseModelService):
             "exclude": bool(checkpoint_data.get("exclude", False)),
             "update_available": bool(checkpoint_data.get("update_available", False)),
             "skip_metadata_refresh": bool(checkpoint_data.get("skip_metadata_refresh", False)),
-            "civitai": self.filter_civitai_data(checkpoint_data.get("civitai", {}), minimal=True)
+            "civitai": self.filter_civitai_data(checkpoint_data.get("civitai", {}), minimal=True),
+            "auto_tags": checkpoint_data.get("auto_tags") or extract_auto_tags(checkpoint_data),
+            "version_count": checkpoint_data.get("version_count"),
+            "hf_url": checkpoint_data.get("hf_url", ""),
         }
     
     def find_duplicate_hashes(self) -> Dict:

py/services/civarchive_client.py

@@ -186,6 +186,22 @@ class CivArchiveClient:
         if "metadata" in file_data:
             transformed["metadata"] = file_data["metadata"]
 
+        # Infer metadata.format from filename extension
+        name = transformed.get("name")
+        if name and isinstance(name, str):
+            lower_name = name.lower()
+            if lower_name.endswith(".safetensors"):
+                inferred_format = "SafeTensor"
+            elif lower_name.endswith(".ckpt"):
+                inferred_format = "PickleTensor"
+            else:
+                inferred_format = None
+            if inferred_format:
+                if "metadata" not in transformed:
+                    transformed["metadata"] = {}
+                if isinstance(transformed["metadata"], dict):
+                    transformed["metadata"].setdefault("format", inferred_format)
+
         if file_data.get("modelVersionId") is not None:
             transformed["modelVersionId"] = file_data.get("modelVersionId")
         elif file_data.get("model_version_id") is not None:
@@ -213,6 +229,20 @@ class CivArchiveClient:
         for file_data in candidates:
             if isinstance(file_data, dict):
                 transformed_files.append(self._transform_file_entry(file_data))
+
+        # Sort: .safetensors first, .ckpt second, others last
+        # so the backend fallback (no file_params) prefers safetensors
+        def _sort_key(f: Dict) -> int:
+            fname = f.get("name") or ""
+            if isinstance(fname, str):
+                lower = fname.lower()
+                if lower.endswith(".safetensors"):
+                    return 0
+                elif lower.endswith(".ckpt"):
+                    return 1
+            return 2
+
+        transformed_files.sort(key=_sort_key)
         return transformed_files
 
     def _transform_version(
@@ -297,7 +327,7 @@ class CivArchiveClient:
             if resolved:
                 return resolved, None
 
-            logger.error("Error fetching version of CivArchive model by hash %s", model_hash[:10])
+            logger.debug("Error fetching version of CivArchive model by hash %s", model_hash[:10])
             return None, "No version data found"
 
         except RateLimitError:
@@ -387,7 +417,7 @@ class CivArchiveClient:
 
             if version_id is not None:
                 raw_id = version_data.get("id")
-                if raw_id != version_id:
+                if raw_id is not None and str(raw_id) != str(version_id):
                     logger.warning(
                         "Requested version %s doesn't match default version %s for model %s",
                         version_id,

py/services/civitai_base_model_service.py

@@ -196,6 +196,7 @@ class CivitaiBaseModelService:
             "ernie": "ERNI",
             "ernie turbo": "ETRB",
             "nucleus": "NUCL",
+            "krea 2": "KR2",
             "svd": "SVD",
             "ltxv": "LTXV",
             "ltxv2": "LTV2",
@@ -424,6 +425,7 @@ class CivitaiBaseModelService:
                 "Ernie",
                 "Ernie Turbo",
                 "Nucleus",
+                "Krea 2",
             ],
         }
 

py/services/civitai_client.py

@@ -2,6 +2,7 @@ import asyncio
 import copy
 import logging
 import os
+from collections import OrderedDict
 from typing import Any, Optional, Dict, Tuple, List, Sequence
 from .connectivity_guard import (
     OFFLINE_FRIENDLY_MESSAGE,
@@ -45,9 +46,17 @@ class CivitaiClient:
         self._initialized = True
 
         self.base_url = "https://civitai.red/api/v1"
+        # In-memory cache to avoid redundant get_model_version_info calls
+        # within the same import/scan flow. Only successful results are cached.
+        # Uses OrderedDict with LRU eviction at MAX_CACHE_ENTRIES to prevent
+        # unbounded growth in long-running server processes.
+        self._version_info_cache: OrderedDict[
+            str, Tuple[Optional[Dict], Optional[str]]
+        ] = OrderedDict()
+        self._MAX_CACHE_ENTRIES = 500
 
     def _build_image_info_url(self, image_id: str) -> str:
-        return f"{self.base_url}/images?imageId={image_id}&nsfw=X"
+        return f"{self.base_url}/images?imageId={image_id}&nsfw=X&withMeta=true"
 
     async def _make_request(
         self,
@@ -57,22 +66,57 @@ class CivitaiClient:
         use_auth: bool = False,
         **kwargs,
     ) -> Tuple[bool, Dict | str]:
-        """Wrapper around downloader.make_request that surfaces rate limits."""
+        """Wrapper around downloader.make_request that surfaces rate limits,
+        with retry for transient server errors (5xx, Cloudflare 524, network flakiness)."""
 
-        downloader = await get_downloader()
-        success, result = await downloader.make_request(
-            method,
-            url,
-            use_auth=use_auth,
-            **kwargs,
-        )
-        if not success and isinstance(result, RateLimitError):
-            if result.provider is None:
-                result.provider = "civitai_api"
-            raise result
-        if not success and is_offline_cooldown_error(result):
-            return False, OFFLINE_FRIENDLY_MESSAGE
-        return success, result
+        max_retries = 3
+        for attempt in range(max_retries):
+            downloader = await get_downloader()
+            success, result = await downloader.make_request(
+                method,
+                url,
+                use_auth=use_auth,
+                **kwargs,
+            )
+            if success:
+                return True, result
+
+            if isinstance(result, RateLimitError):
+                if result.provider is None:
+                    result.provider = "civitai_api"
+                raise result
+
+            if is_offline_cooldown_error(result):
+                return False, OFFLINE_FRIENDLY_MESSAGE
+
+            # Transient server error — retry with exponential backoff
+            if self._is_transient_server_error(str(result)):
+                if attempt < max_retries - 1:
+                    wait = 2**attempt  # 1s, 2s, 4s
+                    logger.info(
+                        "Transient error on %s %s, retrying in %ds "
+                        "(attempt %d/%d): %s",
+                        method,
+                        url,
+                        wait,
+                        attempt + 1,
+                        max_retries,
+                        result,
+                    )
+                    await asyncio.sleep(wait)
+                    continue
+                logger.warning(
+                    "All %d retries exhausted for %s %s: %s",
+                    max_retries,
+                    method,
+                    url,
+                    result,
+                )
+                return False, result
+
+            return False, result
+
+        return False, "Unexpected error in _make_request"
 
     @staticmethod
     def _remove_comfy_metadata(model_version: Optional[Dict]) -> None:
@@ -201,6 +245,29 @@ class CivitaiClient:
 
         return _from_value(payload)
 
+    @staticmethod
+    def _is_transient_server_error(message: str) -> bool:
+        """Return True when the message indicates a transient upstream failure.
+
+        Recognises Cloudflare 524, generic 5xx, and connectivity-level flakiness
+        that should not be treated as a permanent failure.
+        """
+        normalized = message.lower()
+        if "status 5" in normalized or "status 524" in normalized:
+            return True
+        if any(
+            keyword in normalized
+            for keyword in (
+                "connection refused",
+                "connection reset",
+                "temporary failure",
+                "name resolution",
+                "connection closed",
+            )
+        ):
+            return True
+        return False
+
     async def get_model_versions(self, model_id: str) -> Optional[Dict]:
         """Get all versions of a model with local availability info"""
         try:
@@ -223,6 +290,13 @@ class CivitaiClient:
                 logger.info("Civitai request skipped: %s", OFFLINE_FRIENDLY_MESSAGE)
                 return None
             if message:
+                if self._is_transient_server_error(message):
+                    logger.info(
+                        "Transient server error for model %s: %s",
+                        model_id,
+                        message,
+                    )
+                    return None
                 raise RuntimeError(message)
             return None
         except RateLimitError:
@@ -257,7 +331,7 @@ class CivitaiClient:
                 "GET",
                 f"{self.base_url}/models",
                 use_auth=True,
-                params={"ids": query},
+                params={"ids": query, "nsfw": "true"},
             )
             if not success:
                 return None
@@ -336,6 +410,25 @@ class CivitaiClient:
             return None
 
         target_version = self._select_target_version(model_data, model_id, version_id)
+
+        # If modelVersions is empty (e.g. CivitAI cache lag for newly published
+        # models) but a specific version_id is known, fall back to fetching the
+        # version directly via the individual model-versions endpoint, then
+        # enrich it with the model-level data we already have.
+        if target_version is None and version_id is not None:
+            logger.info(
+                "modelVersions empty for model %s; falling back to direct "
+                "version lookup for %s",
+                model_id,
+                version_id,
+            )
+            version = await self._fetch_version_by_id(version_id)
+            if version:
+                self._enrich_version_with_model_data(version, model_data)
+                self._remove_comfy_metadata(version)
+                return version
+            return None
+
         if target_version is None:
             return None
 
@@ -482,6 +575,14 @@ class CivitaiClient:
                 - The model version data or None if not found
                 - An error message if there was an error, or None on success
         """
+        # In-memory cache avoids redundant API calls within the same
+        # import/scan flow (e.g. _resolve_base_model_from_checkpoint
+        # followed by _resolve_and_populate_checkpoint with the same id).
+        if version_id in self._version_info_cache:
+            logger.debug("Cache hit for model version info: %s", version_id)
+            self._version_info_cache.move_to_end(version_id)  # LRU bump
+            return self._version_info_cache[version_id]
+
         try:
             url = f"{self.base_url}/model-versions/{version_id}"
 
@@ -491,6 +592,11 @@ class CivitaiClient:
             if success:
                 logger.debug("Successfully fetched model version info for: %s", version_id)
                 self._remove_comfy_metadata(result)
+                self._version_info_cache[version_id] = (result, None)
+                self._version_info_cache.move_to_end(version_id)
+                # Evict oldest entry when over capacity
+                if len(self._version_info_cache) > self._MAX_CACHE_ENTRIES:
+                    self._version_info_cache.popitem(last=False)
                 return result, None
 
             # Handle specific error cases
@@ -532,6 +638,13 @@ class CivitaiClient:
             if not success:
                 if is_expected_offline_error(result):
                     return None
+                if self._is_transient_server_error(str(result)):
+                    logger.info(
+                        "Transient server error fetching image info for ID %s: %s",
+                        image_id,
+                        result,
+                    )
+                    return None
                 logger.error(
                     "Failed to fetch image info for ID %s from civitai.red: %s",
                     image_id,
@@ -640,7 +753,7 @@ class CivitaiClient:
                 "GET",
                 f"{self.base_url}/models",
                 use_auth=True,
-                params={"username": username},
+                params={"username": username, "nsfw": "true"},
             )
 
             if not success:

py/services/download_coordinator.py

@@ -110,6 +110,23 @@ class DownloadCoordinator:
 
         return result
 
+    async def skip_download(self, download_id: str) -> Dict[str, Any]:
+        """Skip a download while preserving all partial files on disk."""
+        download_manager = await self._download_manager_factory()
+        result = await download_manager.skip_download(download_id)
+
+        await self._ws_manager.broadcast_download_progress(
+            download_id,
+            {
+                "status": "skipped",
+                "progress": 0,
+                "download_id": download_id,
+                "message": "Download skipped by user (partial files preserved)",
+            },
+        )
+
+        return result
+
     async def pause_download(self, download_id: str) -> Dict[str, Any]:
         """Pause an active download and notify listeners."""
 

py/services/download_manager.py

@@ -18,6 +18,7 @@ from ..utils.constants import (
     VALID_LORA_TYPES,
 )
 from ..utils.civitai_utils import normalize_civitai_download_url, rewrite_preview_url
+from ..utils.file_utils import calculate_sha256
 from ..utils.preview_selection import resolve_mature_threshold, select_preview_media
 from ..utils.utils import sanitize_folder_name
 from ..utils.exif_utils import ExifUtils
@@ -28,6 +29,7 @@ from .metadata_service import get_default_metadata_provider, get_metadata_provid
 from .downloader import get_downloader, DownloadProgress, DownloadStreamControl
 from .aria2_downloader import Aria2Error, get_aria2_downloader
 from .aria2_transfer_state import Aria2TransferStateStore
+from .download_queue_service import DownloadQueueService
 
 # Download to temporary file first
 import tempfile
@@ -359,6 +361,15 @@ class DownloadManager:
                     if self._active_downloads[task_id].get("transfer_backend") == "aria2":
                         await self._persist_aria2_state(task_id)
 
+                # Update SQLite queue status to 'downloading'
+                try:
+                    queue_service = await DownloadQueueService.get_instance()
+                    await queue_service.update_status(task_id, "downloading")
+                except Exception:
+                    logger.warning(
+                        "Failed to update queue status for %s", task_id, exc_info=True
+                    )
+
                 # Use original download implementation
                 try:
                     # Check for cancellation before starting
@@ -395,6 +406,22 @@ class DownloadManager:
                         if self._active_downloads[task_id].get("transfer_backend") == "aria2":
                             await self._persist_aria2_state(task_id)
 
+                    # Move queue item to history on completion
+                    try:
+                        queue_service = await DownloadQueueService.get_instance()
+                        await queue_service.complete_download(
+                            download_id=task_id,
+                            status=result.get("status", "completed") if result.get("success") else "failed",
+                            error=result.get("error") if not result.get("success") else None,
+                            file_path=result.get("file_path"),
+                            bytes_downloaded=self._active_downloads.get(task_id, {}).get("bytes_downloaded", 0),
+                            total_bytes=self._active_downloads.get(task_id, {}).get("total_bytes"),
+                        )
+                    except Exception:
+                        logger.warning(
+                            "Failed to complete queue item for %s", task_id, exc_info=True
+                        )
+
                     return result
                 except asyncio.CancelledError:
                     # Handle cancellation
@@ -403,6 +430,19 @@ class DownloadManager:
                         self._active_downloads[task_id]["bytes_per_second"] = 0.0
                         if self._active_downloads[task_id].get("transfer_backend") == "aria2":
                             await self._persist_aria2_state(task_id)
+
+                    # Move queue item to history as canceled
+                    try:
+                        queue_service = await DownloadQueueService.get_instance()
+                        await queue_service.complete_download(
+                            download_id=task_id,
+                            status="canceled",
+                        )
+                    except Exception:
+                        logger.warning(
+                            "Failed to cancel queue item for %s", task_id, exc_info=True
+                        )
+
                     logger.info(f"Download cancelled for task {task_id}")
                     raise
                 except Exception as e:
@@ -416,6 +456,22 @@ class DownloadManager:
                         self._active_downloads[task_id]["bytes_per_second"] = 0.0
                         if self._active_downloads[task_id].get("transfer_backend") == "aria2":
                             await self._persist_aria2_state(task_id)
+
+                    # Move queue item to history as failed
+                    try:
+                        queue_service = await DownloadQueueService.get_instance()
+                        await queue_service.complete_download(
+                            download_id=task_id,
+                            status="failed",
+                            error=str(e),
+                            bytes_downloaded=self._active_downloads.get(task_id, {}).get("bytes_downloaded", 0),
+                            total_bytes=self._active_downloads.get(task_id, {}).get("total_bytes"),
+                        )
+                    except Exception:
+                        logger.warning(
+                            "Failed to complete queue item for %s", task_id, exc_info=True
+                        )
+
                     return {"success": False, "error": str(e)}
         finally:
             # Schedule cleanup of download record after delay
@@ -1232,10 +1288,24 @@ class DownloadManager:
                     "download_id": download_id,
                 }
 
-            # Check if this checkpoint should be treated as a diffusion model based on baseModel
+            # Check if this checkpoint should be treated as a diffusion model
+            # Priority: (1) any file has type "UNet" or "Diffusion Model",
+            #            (2) baseModel is in DIFFUSION_MODEL_BASE_MODELS
             is_diffusion_model = False
             if model_type == "checkpoint":
-                if base_model_value in DIFFUSION_MODEL_BASE_MODELS:
+                # Check file types first (more direct signal from CivitAI)
+                version_files = version_info.get("files", [])
+                for f in version_files:
+                    f_type = f.get("type", "")
+                    if f_type in ("UNet", "Diffusion Model"):
+                        is_diffusion_model = True
+                        logger.info(
+                            f"File type '{f_type}' detected, routing checkpoint to unet folder"
+                        )
+                        break
+
+                # Fallback to baseModel name check
+                if not is_diffusion_model and base_model_value in DIFFUSION_MODEL_BASE_MODELS:
                     is_diffusion_model = True
                     logger.info(
                         f"baseModel '{base_model_value}' is a known diffusion model, routing to unet folder"
@@ -1364,7 +1434,7 @@ class DownloadManager:
                             f
                             for f in files
                             if f.get("primary")
-                            and f.get("type") in ("Model", "Negative", "Diffusion Model")
+                            and f.get("type") in ("Model", "Negative", "Diffusion Model", "UNet")
                         ),
                         None,
                     )
@@ -1395,7 +1465,7 @@ class DownloadManager:
                     (
                         f
                         for f in files
-                        if f.get("primary") and f.get("type") in ("Model", "Negative", "Diffusion Model")
+                        if f.get("primary") and f.get("type") in ("Model", "Negative", "Diffusion Model", "UNet")
                     ),
                     None,
                 )
@@ -1973,7 +2043,21 @@ class DownloadManager:
                     break
 
                 last_error = result
-                if os.path.exists(save_path):
+                # For aria2: if the .aria2 control file is missing, aria2 considers
+                # the download complete.  A transient RPC failure may have made us
+                # think the download failed even though the file is fully on disk.
+                # Keep the file so a retry can find it already complete.
+                if (
+                    transfer_backend == "aria2"
+                    and os.path.exists(save_path)
+                    and not os.path.exists(f"{save_path}.aria2")
+                ):
+                    logger.warning(
+                        "aria2 download reported failure but .aria2 file is absent "
+                        "for %s — the file is likely complete.  Preserving it for retry.",
+                        save_path,
+                    )
+                elif os.path.exists(save_path):
                     try:
                         os.remove(save_path)
                     except Exception as e:
@@ -2239,8 +2323,11 @@ class DownloadManager:
             entry.file_name = os.path.splitext(os.path.basename(file_path))[0]
             # Update size to actual downloaded file size
             entry.size = os.path.getsize(file_path)
-            # Use SHA256 from API metadata (already set in from_civitai_info)
-            # Do not recalculate to avoid blocking during ComfyUI execution
+            # Compute SHA256 locally when the API response didn't include it
+            if not entry.sha256:
+                sha256 = await calculate_sha256(file_path)
+                if sha256:
+                    entry.sha256 = sha256.lower()
             entries.append(entry)
 
         return entries
@@ -2400,6 +2487,89 @@ class DownloadManager:
                 self._download_tasks.pop(download_id, None)
                 await self._aria2_state_store.remove(download_id)
 
+    async def skip_download(self, download_id: str) -> Dict:
+        """Skip a download while preserving all partial files on disk.
+
+        Removes all in-memory tracking (asyncio task, semaphore, active/pause
+        state) but keeps partial files (.part / .aria2) on disk so that a
+        subsequent download-model-get request for the same save path can
+        auto-resume from the preserved partial download.
+
+        Args:
+            download_id: The unique identifier of the download task
+
+        Returns:
+            Dict: Status of the skip operation
+        """
+        await self._restore_persisted_downloads()
+
+        if download_id not in self._download_tasks and download_id not in self._active_downloads:
+            return {"success": False, "error": "Download task not found"}
+
+        download_info = self._active_downloads.get(download_id)
+        task = self._download_tasks.get(download_id)
+        active_statuses = {"queued", "waiting", "downloading", "paused", "cancelling"}
+        if task is None and (
+            not isinstance(download_info, dict)
+            or download_info.get("status") not in active_statuses
+        ):
+            return {"success": False, "error": "Download task not found"}
+
+        backend = (
+            self._active_downloads.get(download_id, {}).get("transfer_backend")
+            or "python"
+        )
+
+        try:
+            # For aria2: pause the transfer rather than force-removing it, so
+            # the .aria2 control file stays on disk for future resume
+            if backend == "aria2":
+                try:
+                    aria2_downloader = await get_aria2_downloader()
+                    pause_result = await aria2_downloader.pause_download(download_id)
+                    if not pause_result.get("success"):
+                        logger.warning(
+                            "Failed to pause aria2 transfer for %s during skip: %s",
+                            download_id,
+                            pause_result.get("error"),
+                        )
+                except Exception as exc:
+                    logger.warning(
+                        "Failed to pause aria2 transfer for %s during skip: %s",
+                        download_id,
+                        exc,
+                    )
+
+            # Cancel the asyncio task so the semaphore slot is released
+            if task is not None:
+                task.cancel()
+
+            # Resume pause event so the task can exit cleanly
+            pause_control = self._pause_events.get(download_id)
+            if pause_control is not None:
+                pause_control.resume()
+
+            # Wait briefly for task to acknowledge cancellation
+            if task is not None:
+                try:
+                    await asyncio.wait_for(asyncio.shield(task), timeout=2.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
+
+            logger.info(f"Download skipped for task {download_id} (partial files preserved)")
+            return {"success": True, "message": "Download skipped successfully"}
+        except Exception as e:
+            logger.error(f"Error skipping download: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+        finally:
+            # Clean up local in-memory tracking only - NO file deletion
+            self._pause_events.pop(download_id, None)
+            self._download_tasks.pop(download_id, None)
+            if download_id in self._active_downloads:
+                del self._active_downloads[download_id]
+            # Preserve aria2 state store entry so the partial download
+            # info survives restarts and can be resumed later
+
     async def pause_download(self, download_id: str) -> Dict:
         """Pause an active download without losing progress."""
 

py/services/download_queue_service.py

@@ -0,0 +1,871 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import sqlite3
+import time
+from typing import Any, Optional
+
+from ..utils.cache_paths import get_cache_base_dir
+
+logger = logging.getLogger(__name__)
+
+
+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, "download_queue.sqlite")
+
+
+class DownloadQueueService:
+    """Persistent download queue and history manager backed by SQLite.
+
+    Provides a singleton interface for managing a download queue and
+    corresponding history table, both stored in a single SQLite database
+    under the cache directory.
+    """
+
+    _instance: Optional[DownloadQueueService] = None
+    _class_lock: asyncio.Lock = asyncio.Lock()
+
+    _SCHEMA = """
+        CREATE TABLE IF NOT EXISTS download_queue (
+            download_id TEXT PRIMARY KEY,
+            model_id INTEGER,
+            model_version_id INTEGER,
+            model_name TEXT NOT NULL DEFAULT '',
+            version_name TEXT DEFAULT '',
+            thumbnail_url TEXT DEFAULT '',
+            source TEXT,
+            file_params TEXT,
+            status TEXT NOT NULL DEFAULT 'queued',
+            priority INTEGER DEFAULT 0,
+            progress INTEGER DEFAULT 0,
+            bytes_downloaded INTEGER DEFAULT 0,
+            total_bytes INTEGER,
+            bytes_per_second REAL DEFAULT 0.0,
+            error TEXT,
+            file_path TEXT,
+            added_at REAL NOT NULL,
+            started_at REAL,
+            completed_at REAL
+        );
+        CREATE INDEX IF NOT EXISTS idx_dq_status ON download_queue(status);
+        CREATE INDEX IF NOT EXISTS idx_dq_added ON download_queue(added_at);
+
+        CREATE TABLE IF NOT EXISTS download_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            download_id TEXT,
+            model_id INTEGER,
+            model_version_id INTEGER,
+            model_name TEXT NOT NULL DEFAULT '',
+            version_name TEXT DEFAULT '',
+            thumbnail_url TEXT DEFAULT '',
+            status TEXT NOT NULL,
+            error TEXT,
+            file_path TEXT,
+            bytes_downloaded INTEGER DEFAULT 0,
+            total_bytes INTEGER,
+            completed_at REAL NOT NULL,
+            is_already_exists INTEGER DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_dh_completed ON download_history(completed_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_dh_status ON download_history(status);
+    """
+
+    @classmethod
+    async def get_instance(cls) -> DownloadQueueService:
+        """Return the singleton instance, creating it if necessary."""
+        async with cls._class_lock:
+            if cls._instance is None:
+                cls._instance = cls()
+                await cls._instance.deduplicate()
+            return cls._instance
+
+    def __init__(self, db_path: Optional[str] = None) -> None:
+        self._db_path = db_path or _resolve_database_path()
+        self._lock = asyncio.Lock()
+        self._conn: Optional[sqlite3.Connection] = None
+        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 _get_conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self._conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            self._conn.row_factory = sqlite3.Row
+        return self._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 the resolved database file path."""
+        return self._db_path
+
+    def close(self) -> None:
+        """Close the persistent SQLite connection, if open.
+
+        This is called before plugin update operations to release the
+        database file lock on Windows, allowing ``shutil.rmtree()`` to
+        succeed when the cache resides inside the plugin directory.
+        """
+        if self._conn is not None:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+            finally:
+                self._conn = None
+
+    # ------------------------------------------------------------------
+    # Queue methods
+    # ------------------------------------------------------------------
+
+    async def add_to_queue(
+        self,
+        download_id: str,
+        model_id: Optional[int] = None,
+        model_version_id: Optional[int] = None,
+        model_name: str = "",
+        version_name: str = "",
+        thumbnail_url: str = "",
+        source: Optional[str] = None,
+        file_params: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        """Insert a new download into the queue.
+
+        Returns the inserted row as a dict (or an empty dict if the
+        download_id already exists).
+        """
+        now = time.time()
+        file_params_json = json.dumps(file_params) if file_params is not None else None
+
+        async with self._lock:
+            conn = self._get_conn()
+            conn.execute(
+                """
+                INSERT OR IGNORE INTO download_queue (
+                    download_id, model_id, model_version_id, model_name,
+                    version_name, thumbnail_url, source, file_params,
+                    status, priority, added_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'queued', 0, ?)
+                """,
+                (
+                    download_id,
+                    model_id,
+                    model_version_id,
+                    model_name,
+                    version_name,
+                    thumbnail_url,
+                    source,
+                    file_params_json,
+                    now,
+                ),
+            )
+            conn.commit()
+            row = conn.execute(
+                "SELECT * FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            ).fetchone()
+
+        return dict(row) if row else {}
+
+    async def get_queue(self) -> list[dict[str, Any]]:
+        """Return all items in the queue ordered by priority then added time."""
+        async with self._lock:
+            conn = self._get_conn()
+            rows = conn.execute(
+                "SELECT * FROM download_queue ORDER BY priority DESC, added_at ASC"
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    async def get_queued_count(self) -> int:
+        """Return the number of items with status ``'queued'``."""
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                "SELECT COUNT(*) AS cnt FROM download_queue WHERE status = 'queued'"
+            ).fetchone()
+        return row["cnt"] if row else 0
+
+    async def update_status(
+        self,
+        download_id: str,
+        status: str,
+        **extra: Any,
+    ) -> bool:
+        """Update the status and/or extra fields of a queue item.
+
+        Accepted extra keyword arguments:
+        ``progress``, ``error``, ``file_path``, ``bytes_downloaded``,
+        ``total_bytes``, ``bytes_per_second``.
+
+        Returns ``True`` if a row was updated.
+        """
+        allowed_extra = {
+            "progress",
+            "error",
+            "file_path",
+            "bytes_downloaded",
+            "total_bytes",
+            "bytes_per_second",
+        }
+
+        set_clauses: list[str] = ["status = ?"]
+        params: list[Any] = [status]
+        now = time.time()
+
+        if status in ("downloading",):
+            set_clauses.append("started_at = COALESCE(started_at, ?)")
+            params.append(now)
+        if status in ("completed", "failed", "canceled"):
+            set_clauses.append("completed_at = ?")
+            params.append(now)
+
+        for key, value in extra.items():
+            if key in allowed_extra:
+                set_clauses.append(f"{key} = ?")
+                params.append(value)
+
+        params.append(download_id)
+
+        async with self._lock:
+            conn = self._get_conn()
+            cursor = conn.execute(
+                f"UPDATE download_queue SET {', '.join(set_clauses)} "
+                "WHERE download_id = ?",
+                params,
+            )
+            conn.commit()
+        return cursor.rowcount > 0
+
+    async def remove_from_queue(self, download_id: str) -> bool:
+        """Remove a single item from the queue by download_id.
+
+        Returns ``True`` if a row was deleted.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            cursor = conn.execute(
+                "DELETE FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            )
+            conn.commit()
+        return cursor.rowcount > 0
+
+    async def move_to_top(self, download_id: str) -> bool:
+        """Move an item to the front of the queue (highest priority).
+
+        Returns ``True`` if the item was found and updated.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                "SELECT priority FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            ).fetchone()
+            if row is None:
+                return False
+
+            max_row = conn.execute(
+                "SELECT MAX(priority) AS mx FROM download_queue"
+            ).fetchone()
+            max_priority: int = max_row["mx"] if max_row["mx"] is not None else 0
+
+            conn.execute(
+                "UPDATE download_queue SET priority = ? WHERE download_id = ?",
+                (max_priority + 1, download_id),
+            )
+            conn.commit()
+        return True
+
+    async def move_to_end(self, download_id: str) -> bool:
+        """Move an item to the end of the queue (lowest priority).
+
+        Returns ``True`` if the item was found and updated.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                "SELECT priority FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            ).fetchone()
+            if row is None:
+                return False
+
+            min_row = conn.execute(
+                "SELECT MIN(priority) AS mn FROM download_queue"
+            ).fetchone()
+            min_priority: int = min_row["mn"] if min_row["mn"] is not None else 0
+
+            conn.execute(
+                "UPDATE download_queue SET priority = ? WHERE download_id = ?",
+                (min_priority - 1, download_id),
+            )
+            conn.commit()
+        return True
+
+    async def clear_queue(self, status_filter: Optional[str] = None) -> int:
+        """Remove items from the queue.
+
+        When *status_filter* is provided only items with that status are
+        deleted.  Returns the number of deleted rows.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            if status_filter is not None:
+                cursor = conn.execute(
+                    "DELETE FROM download_queue WHERE status = ?",
+                    (status_filter,),
+                )
+            else:
+                cursor = conn.execute("DELETE FROM download_queue")
+            conn.commit()
+        return cursor.rowcount
+
+    async def complete_download(
+        self,
+        download_id: str,
+        status: str = "completed",
+        error: Optional[str] = None,
+        file_path: Optional[str] = None,
+        bytes_downloaded: int = 0,
+        total_bytes: Optional[int] = None,
+        completed_at: Optional[float] = None,
+    ) -> Optional[dict[str, Any]]:
+        """Atomically move a download from the queue into the history table.
+
+        Looks up the queue record by ``download_id``, deletes it from the
+        queue, and inserts a corresponding history entry with the given
+        terminal status (``completed``, ``failed``, or ``canceled``).
+
+        When *completed_at* is provided it is used as the completion
+        timestamp; otherwise ``time.time()`` is used.
+
+        Returns the original queue record (before deletion) on success,
+        or ``None`` if the download was not found in the queue.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                "SELECT * FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            ).fetchone()
+            if row is None:
+                return None
+
+            now = completed_at if completed_at is not None else time.time()
+            conn.execute(
+                "DELETE FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            )
+            conn.execute(
+                """
+                INSERT INTO download_history (
+                    download_id, model_id, model_version_id, model_name,
+                    version_name, thumbnail_url, status, error, file_path,
+                    bytes_downloaded, total_bytes, completed_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    row["download_id"],
+                    row["model_id"],
+                    row["model_version_id"],
+                    row["model_name"],
+                    row["version_name"],
+                    row["thumbnail_url"],
+                    status,
+                    error,
+                    file_path,
+                    bytes_downloaded,
+                    total_bytes,
+                    now,
+                ),
+            )
+            conn.commit()
+        return dict(row)
+
+    async def pop_next_download(self) -> Optional[dict[str, Any]]:
+        """Atomically fetch and mark the next queued item as ``downloading``.
+
+        The item with the highest priority (and earliest ``added_at``
+        among ties) whose status is ``'queued'`` is selected, set to
+        ``'downloading'``, and returned as a dict.  Returns ``None`` if
+        the queue is empty.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                """
+                SELECT * FROM download_queue
+                WHERE status = 'queued'
+                ORDER BY priority DESC, added_at ASC
+                LIMIT 1
+                """
+            ).fetchone()
+            if row is None:
+                return None
+
+            download_id = row["download_id"]
+            now = time.time()
+            conn.execute(
+                "UPDATE download_queue SET status = 'downloading', "
+                "started_at = COALESCE(started_at, ?) "
+                "WHERE download_id = ?",
+                (now, download_id),
+            )
+            conn.commit()
+            updated = conn.execute(
+                "SELECT * FROM download_queue WHERE download_id = ?",
+                (download_id,),
+            ).fetchone()
+
+        return dict(updated) if updated else None
+
+    # ------------------------------------------------------------------
+    # History methods
+    # ------------------------------------------------------------------
+
+    async def add_to_history(
+        self,
+        download_id: Optional[str] = None,
+        model_id: Optional[int] = None,
+        model_version_id: Optional[int] = None,
+        model_name: str = "",
+        version_name: str = "",
+        thumbnail_url: str = "",
+        status: str = "completed",
+        error: Optional[str] = None,
+        file_path: Optional[str] = None,
+        bytes_downloaded: int = 0,
+        total_bytes: Optional[int] = None,
+        is_already_exists: int = 0,
+    ) -> int:
+        """Insert a record into the download history.
+
+        Returns the ``id`` (AUTOINCREMENT primary key) of the newly
+        inserted row.
+        """
+        now = time.time()
+
+        async with self._lock:
+            conn = self._get_conn()
+            cursor = conn.execute(
+                """
+                INSERT INTO download_history (
+                    download_id, model_id, model_version_id, model_name,
+                    version_name, thumbnail_url, status, error, file_path,
+                    bytes_downloaded, total_bytes, completed_at, is_already_exists
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    download_id,
+                    model_id,
+                    model_version_id,
+                    model_name,
+                    version_name,
+                    thumbnail_url,
+                    status,
+                    error,
+                    file_path,
+                    bytes_downloaded,
+                    total_bytes,
+                    now,
+                    is_already_exists,
+                ),
+            )
+            conn.commit()
+        return cursor.lastrowid or 0
+
+    async def get_history(
+        self,
+        limit: int = 50,
+        offset: int = 0,
+        status_filter: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Return a page of download history entries.
+
+        Returns a dict with keys ``items``, ``total``, ``limit``, and
+        ``offset``.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+
+            if status_filter is not None:
+                count_row = conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM download_history WHERE status = ?",
+                    (status_filter,),
+                ).fetchone()
+                rows = conn.execute(
+                    "SELECT * FROM download_history WHERE status = ? "
+                    "ORDER BY completed_at DESC LIMIT ? OFFSET ?",
+                    (status_filter, limit, offset),
+                ).fetchall()
+            else:
+                count_row = conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM download_history"
+                ).fetchone()
+                rows = conn.execute(
+                    "SELECT * FROM download_history "
+                    "ORDER BY completed_at DESC LIMIT ? OFFSET ?",
+                    (limit, offset),
+                ).fetchall()
+
+        return {
+            "items": [dict(row) for row in rows],
+            "total": count_row["cnt"] if count_row else 0,
+            "limit": limit,
+            "offset": offset,
+        }
+
+    async def delete_history_item(self, id: int) -> bool:
+        """Delete a single history entry by its *id*.
+
+        Returns ``True`` if a row was deleted.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            cursor = conn.execute(
+                "DELETE FROM download_history WHERE id = ?",
+                (id,),
+            )
+            conn.commit()
+        return cursor.rowcount > 0
+
+    async def clear_history(
+        self,
+        status_filter: Optional[str] = None,
+        before_timestamp: Optional[float] = None,
+    ) -> int:
+        """Remove history entries matching the optional filters.
+
+        Both ``status_filter`` and ``before_timestamp`` can be combined
+        (AND logic).  Returns the number of deleted rows.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+
+            clauses: list[str] = []
+            params: list[Any] = []
+
+            if status_filter is not None:
+                clauses.append("status = ?")
+                params.append(status_filter)
+            if before_timestamp is not None:
+                clauses.append("completed_at < ?")
+                params.append(before_timestamp)
+
+            where = ""
+            if clauses:
+                where = " WHERE " + " AND ".join(clauses)
+
+            cursor = conn.execute(
+                f"DELETE FROM download_history{where}",
+                params,
+            )
+            conn.commit()
+        return cursor.rowcount
+
+    async def get_history_count(self, status_filter: Optional[str] = None) -> int:
+        """Return the number of history entries, optionally filtered by status."""
+        async with self._lock:
+            conn = self._get_conn()
+            if status_filter is not None:
+                row = conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM download_history WHERE status = ?",
+                    (status_filter,),
+                ).fetchone()
+            else:
+                row = conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM download_history"
+                ).fetchone()
+        return row["cnt"] if row else 0
+
+    # ------------------------------------------------------------------
+    # Retry
+    # ------------------------------------------------------------------
+
+    async def retry_from_history(self, item_id: int) -> Optional[dict[str, Any]]:
+        """Re-queue a failed or canceled download from history.
+
+        Looks up the history record by its primary key.  If the status is
+        ``failed`` or ``canceled`` a new queue entry is created with the
+        same model metadata and a fresh download id, and the original
+        history entry is **deleted** to prevent exponential growth when
+        the retried item is later canceled or fails again and re-retried.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            row = conn.execute(
+                "SELECT * FROM download_history WHERE id = ?",
+                (item_id,),
+            ).fetchone()
+            if row is None:
+                return None
+            status = str(row["status"])
+            if status not in ("failed", "canceled"):
+                return None
+
+            import uuid
+
+            new_id = str(uuid.uuid4())
+            now = time.time()
+            conn.execute(
+                """
+                INSERT INTO download_queue (
+                    download_id, model_id, model_version_id, model_name,
+                    version_name, thumbnail_url, source, file_params,
+                    status, priority, added_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 'queued', 0, ?)
+                """,
+                (
+                    new_id,
+                    row["model_id"],
+                    row["model_version_id"],
+                    row["model_name"],
+                    row["version_name"],
+                    row["thumbnail_url"],
+                    "retry",
+                    now,
+                ),
+            )
+            conn.execute(
+                "DELETE FROM download_history WHERE id = ?",
+                (item_id,),
+            )
+            conn.commit()
+            queued = conn.execute(
+                "SELECT * FROM download_queue WHERE download_id = ?",
+                (new_id,),
+            ).fetchone()
+
+        return dict(queued) if queued else None
+
+    async def retry_all_failed(self) -> int:
+        """Re-queue all failed and canceled downloads from history.
+
+        Each history entry is **deleted** after being re-queued so that
+        repeated retry-all calls do not cause exponential growth.
+
+        Returns the number of items that were re-queued.
+        """
+        async with self._lock:
+            conn = self._get_conn()
+            rows = conn.execute(
+                "SELECT * FROM download_history WHERE status IN ('failed', 'canceled')"
+            ).fetchall()
+            if not rows:
+                return 0
+
+            import uuid
+
+            now = time.time()
+            count = 0
+            for row in rows:
+                new_id = str(uuid.uuid4())
+                conn.execute(
+                    """
+                    INSERT INTO download_queue (
+                        download_id, model_id, model_version_id, model_name,
+                        version_name, thumbnail_url, source, file_params,
+                        status, priority, added_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 'queued', 0, ?)
+                    """,
+                    (
+                        new_id,
+                        row["model_id"],
+                        row["model_version_id"],
+                        row["model_name"],
+                        row["version_name"],
+                        row["thumbnail_url"],
+                        "retry",
+                        now,
+                    ),
+                )
+                conn.execute(
+                    "DELETE FROM download_history WHERE id = ?",
+                    (row["id"],),
+                )
+                count += 1
+            conn.commit()
+
+        return count
+
+    # ------------------------------------------------------------------
+    # Stats
+    # ------------------------------------------------------------------
+
+    async def get_stats(self) -> dict[str, int]:
+        """Return aggregate counts across both tables.
+
+        Returns a dict with keys ``queued``, ``downloading``, ``paused``
+        (all from the queue table) and ``completed``, ``failed``,
+        ``canceled`` (all from the history table).
+        """
+        async with self._lock:
+            conn = self._get_conn()
+
+            queue_rows = conn.execute(
+                "SELECT status, COUNT(*) AS cnt FROM download_queue GROUP BY status"
+            ).fetchall()
+            queue_stats: dict[str, int] = {}
+            for row in queue_rows:
+                queue_stats[str(row["status"])] = row["cnt"]
+
+            history_rows = conn.execute(
+                "SELECT status, COUNT(*) AS cnt FROM download_history GROUP BY status"
+            ).fetchall()
+            history_stats: dict[str, int] = {}
+            for row in history_rows:
+                history_stats[str(row["status"])] = row["cnt"]
+
+        return {
+            "queued": queue_stats.get("queued", 0),
+            "downloading": queue_stats.get("downloading", 0),
+            "paused": queue_stats.get("paused", 0),
+            "completed": history_stats.get("completed", 0),
+            "failed": history_stats.get("failed", 0),
+            "canceled": history_stats.get("canceled", 0),
+        }
+
+    # ------------------------------------------------------------------
+    # Deduplication (one-time cleanup for bug #980)
+    # ------------------------------------------------------------------
+
+    async def deduplicate(self) -> dict[str, int]:
+        """Remove duplicate entries caused by the retry-amplification bug.
+
+        The bug (issue #980) caused the same download to appear N times in
+        both the queue and history tables when ``retry_all_failed`` was
+        called repeatedly without deleting the original history rows.
+
+        This method is called **once** when the singleton is first created.
+        It is idempotent — after the first run there will be no duplicates
+        to remove, so subsequent calls are a no-op.
+
+        Returns a dict with the count of removed rows per table.
+        """
+        result: dict[str, int] = {
+            "removed_history": 0,
+            "removed_queue": 0,
+            "removed_orphan_queue": 0,
+        }
+
+        async with self._lock:
+            conn = self._get_conn()
+
+            # 1. History: for each (model_id, model_version_id, status) triplet
+            #    keep only the row with the highest id (most recently inserted).
+            conn.execute("""
+                DELETE FROM download_history
+                WHERE id NOT IN (
+                    SELECT MAX(id)
+                    FROM download_history
+                    GROUP BY model_id, model_version_id, status
+                )
+            """)
+            result["removed_history"] = conn.execute(
+                "SELECT changes()"
+            ).fetchone()[0]
+
+            # 2. Cross-status dedup: for each (model_id, model_version_id),
+            #    keep only the entry with the highest-priority terminal status.
+            #    Priority: completed (3) > failed (2) > canceled (1).
+            #    This prevents the same model version from having both a
+            #    'failed' and a 'canceled' entry (or a 'completed' alongside
+            #    either) after the bug-created duplicates are removed.
+            conn.execute("""
+                DELETE FROM download_history
+                WHERE id NOT IN (
+                    SELECT dh.id
+                    FROM download_history dh
+                    INNER JOIN (
+                        SELECT model_id, model_version_id,
+                               MAX(CASE status
+                                   WHEN 'completed' THEN 3
+                                   WHEN 'failed' THEN 2
+                                   WHEN 'canceled' THEN 1
+                                   ELSE 0
+                               END) AS best_prio
+                        FROM download_history
+                        GROUP BY model_id, model_version_id
+                    ) best
+                    ON dh.model_id = best.model_id
+                   AND dh.model_version_id = best.model_version_id
+                   AND CASE dh.status
+                           WHEN 'completed' THEN 3
+                           WHEN 'failed' THEN 2
+                           WHEN 'canceled' THEN 1
+                           ELSE 0
+                       END = best.best_prio
+                    GROUP BY dh.model_id, dh.model_version_id
+                    HAVING dh.id = MAX(dh.id)
+                )
+            """)
+            result["removed_history"] += conn.execute(
+                "SELECT changes()"
+            ).fetchone()[0]
+
+            # 3. Queue: for each (model_id, model_version_id) keep only the
+            #    row with the latest added_at (most recently enqueued).
+            conn.execute("""
+                DELETE FROM download_queue
+                WHERE rowid NOT IN (
+                    SELECT MAX(rowid)
+                    FROM download_queue
+                    WHERE status IN ('queued', 'downloading', 'paused', 'waiting')
+                    GROUP BY model_id, model_version_id
+                )
+                AND status IN ('queued', 'downloading', 'paused', 'waiting')
+            """)
+            result["removed_queue"] = conn.execute(
+                "SELECT changes()"
+            ).fetchone()[0]
+
+            # 4. Remove orphaned queue entries — items that were re-queued
+            #    (source='retry') but whose model version already has a
+            #    terminal history entry. These are artifacts of the buggy
+            #    retry cycle that were never cleaned up.
+            conn.execute("""
+                DELETE FROM download_queue
+                WHERE source = 'retry'
+                AND (model_id, model_version_id) IN (
+                    SELECT model_id, model_version_id
+                    FROM download_history
+                    WHERE status IN ('failed', 'canceled')
+                )
+                AND status IN ('queued', 'waiting')
+            """)
+            result["removed_orphan_queue"] = conn.execute(
+                "SELECT changes()"
+            ).fetchone()[0]
+
+            conn.commit()
+
+        logger.info(
+            "Deduplicate: removed %s history rows, %s queue rows, "
+            "%s orphaned queue rows",
+            result["removed_history"],
+            result["removed_queue"],
+            result["removed_orphan_queue"],
+        )
+        return result

py/services/downloaded_version_history_service.py

@@ -96,6 +96,21 @@ class DownloadedVersionHistoryService:
     def get_database_path(self) -> str:
         return self._db_path
 
+    def close(self) -> None:
+        """Close the persistent SQLite connection, if open.
+
+        This is called before plugin update operations to release the
+        database file lock on Windows, allowing ``shutil.rmtree()`` to
+        succeed when the cache resides inside the plugin directory.
+        """
+        if self._conn is not None:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+            finally:
+                self._conn = None
+
     def _get_active_library_name(self) -> str | None:
         try:
             value = self._settings.get_active_library_name()
@@ -206,7 +221,7 @@ class DownloadedVersionHistoryService:
             )
             conn.commit()
 
-    async def mark_not_downloaded(self, model_type: str, version_id: int) -> None:
+    async def mark_as_deleted(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:

py/services/downloader.py

@@ -13,6 +13,7 @@ This module provides a centralized download service with:
 import os
 import logging
 import asyncio
+import ssl
 import aiohttp
 from collections import deque
 from dataclasses import dataclass
@@ -31,6 +32,20 @@ from .errors import RateLimitError
 logger = logging.getLogger(__name__)
 
 
+def is_ssl_cert_verify_error(exc: BaseException) -> bool:
+    """Check if an exception represents an SSL certificate verification failure.
+
+    Matches ``ssl.SSLCertVerificationError``, ``aiohttp.ClientConnectorCertificateError``
+    (which wraps the former), and falls back to the standard OpenSSL error text.
+    """
+    if isinstance(exc, ssl.SSLCertVerificationError):
+        return True
+    cert_error = getattr(exc, "certificate_error", None)
+    if isinstance(cert_error, ssl.SSLCertVerificationError):
+        return True
+    return "CERTIFICATE_VERIFY_FAILED" in str(exc)
+
+
 @dataclass(frozen=True)
 class DownloadProgress:
     """Snapshot of a download transfer at a moment in time."""
@@ -241,7 +256,9 @@ class Downloader:
                 self._session = None
 
         # Check for app-level proxy settings
-        proxy_url = None
+        proxy_url = None  # http(s) proxy, passed via the per-request `proxy=` kwarg
+        socks_proxy_url = None  # SOCKS proxy, handled via aiohttp-socks connector
+        app_proxy_active = False
         settings_manager = get_settings_manager()
         if settings_manager.get("proxy_enabled", False):
             proxy_host = settings_manager.get("proxy_host", "").strip()
@@ -253,9 +270,19 @@ class Downloader:
             if proxy_host and proxy_port:
                 # Build proxy URL
                 if proxy_username and proxy_password:
-                    proxy_url = f"{proxy_type}://{proxy_username}:{proxy_password}@{proxy_host}:{proxy_port}"
+                    full_proxy_url = f"{proxy_type}://{proxy_username}:{proxy_password}@{proxy_host}:{proxy_port}"
                 else:
-                    proxy_url = f"{proxy_type}://{proxy_host}:{proxy_port}"
+                    full_proxy_url = f"{proxy_type}://{proxy_host}:{proxy_port}"
+
+                app_proxy_active = True
+                # aiohttp cannot tunnel SOCKS via the per-request `proxy=` kwarg
+                # (it would send HTTP to the SOCKS port and fail parsing the
+                # SOCKS handshake reply). SOCKS must be handled by an
+                # aiohttp-socks ProxyConnector instead.
+                if proxy_type.startswith("socks"):
+                    socks_proxy_url = full_proxy_url
+                else:
+                    proxy_url = full_proxy_url
 
                 logger.debug(
                     f"Using app-level proxy: {proxy_type}://{proxy_host}:{proxy_port}"
@@ -265,14 +292,41 @@ class Downloader:
             logger.debug(
                 "Proxy mode: system-level proxy (trust_env) will be used if configured in environment."
             )
+        # Build SSL context: prefer certifi's CA bundle for broader
+        # CA coverage across different Python environments (especially
+        # embedded/compatibility Python builds).
+        try:
+            import certifi  # type: ignore[import-untyped]
+
+            ca_path = certifi.where()
+            ssl_context = ssl.create_default_context(cafile=ca_path)
+            logger.debug("SSL: using certifi CA bundle at %s", ca_path)
+        except (ImportError, FileNotFoundError, ValueError, OSError):
+            ssl_context = ssl.create_default_context()
+            logger.debug("SSL: certifi unavailable; using system default CA bundle")
+
         # Optimize TCP connection parameters
-        connector = aiohttp.TCPConnector(
-            ssl=True,
+        connector_kwargs = dict(
+            ssl=ssl_context,
             limit=8,  # Concurrent connections
             ttl_dns_cache=300,  # DNS cache timeout
             force_close=False,  # Keep connections for reuse
             enable_cleanup_closed=True,
         )
+        if socks_proxy_url:
+            # Route all traffic through the SOCKS proxy via aiohttp-socks. The
+            # connector tunnels every connection, so no per-request `proxy=` is
+            # used (and must not be — see self._proxy_url below).
+            try:
+                from aiohttp_socks import ProxyConnector
+            except ImportError as e:  # pragma: no cover
+                raise RuntimeError(
+                    "A SOCKS proxy is configured but the 'aiohttp-socks' package "
+                    "is not installed. Install it with: pip install aiohttp-socks"
+                ) from e
+            connector = ProxyConnector.from_url(socks_proxy_url, **connector_kwargs)
+        else:
+            connector = aiohttp.TCPConnector(**connector_kwargs)
 
         # Configure timeout parameters
         timeout = aiohttp.ClientTimeout(
@@ -283,12 +337,14 @@ class Downloader:
 
         self._session = aiohttp.ClientSession(
             connector=connector,
-            trust_env=proxy_url
-            is None,  # Only use system proxy if no app-level proxy is set
+            # Only fall back to system/env proxy when no app-level proxy is active
+            trust_env=not app_proxy_active,
             timeout=timeout,
         )
 
-        # Store proxy URL for use in requests
+        # Store proxy URL for per-request use. Stays None for SOCKS because the
+        # ProxyConnector already tunnels everything; passing proxy= for SOCKS
+        # would re-trigger the original aiohttp parse error.
         self._proxy_url = proxy_url
         self._session_created_at = datetime.now()
 
@@ -736,6 +792,17 @@ class Downloader:
                 DownloadRestartRequested,
             ) as e:
                 retry_count += 1
+
+                if is_ssl_cert_verify_error(e):
+                    logger.error(
+                        "SSL certificate verification failed when connecting to %s. "
+                        "This is usually caused by an outdated CA certificate bundle "
+                        "in the Python environment. Recommended fixes:\n"
+                        "  1. pip install --upgrade certifi\n"
+                        "  2. pip install pip-system-certs",
+                        url,
+                    )
+
                 logger.warning(
                     f"Network error during download (attempt {retry_count}/{self.max_retries + 1}): {e}"
                 )

py/services/embedding_service.py

@@ -1,8 +1,9 @@
 import os
 import logging
-from typing import Dict
+from typing import Dict, Optional
 
 from .base_model_service import BaseModelService
+from .auto_tag_service import extract_auto_tags
 from ..utils.models import EmbeddingMetadata
 from ..config import config
 
@@ -20,20 +21,37 @@ class EmbeddingService(BaseModelService):
         """
         super().__init__("embedding", scanner, EmbeddingMetadata, update_service=update_service)
     
-    async def format_response(self, embedding_data: Dict) -> Dict:
-        """Format Embedding data for API response"""
+    async def format_response(self, embedding_data: Dict) -> Optional[Dict]:
+        """Format Embedding data for API response.
+
+        Returns None when the entry is missing critical fields (corrupted cache
+        row), so the handler layer can filter it out. See issue #730.
+        """
+        # Guard against corrupted cache entries missing critical fields
+        file_path = embedding_data.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            logger.warning(
+                "Skipping corrupted embedding entry (missing file_path): %s",
+                embedding_data.get("file_name", "<unknown>"),
+            )
+            return None
+
         # Get sub_type from cache entry (new canonical field)
         sub_type = embedding_data.get("sub_type", "embedding")
-        
+
+        file_name = embedding_data.get("file_name") or ""
+        model_name = embedding_data.get("model_name") or file_name
+        folder = embedding_data.get("folder") or ""
+
         return {
-            "model_name": embedding_data["model_name"],
-            "file_name": embedding_data["file_name"],
+            "model_name": model_name,
+            "file_name": file_name,
             "preview_url": config.get_preview_static_url(embedding_data.get("preview_url", "")),
             "preview_nsfw_level": embedding_data.get("preview_nsfw_level", 0),
             "base_model": embedding_data.get("base_model", ""),
-            "folder": embedding_data["folder"],
+            "folder": folder,
             "sha256": embedding_data.get("sha256", ""),
-            "file_path": embedding_data["file_path"].replace(os.sep, "/"),
+            "file_path": file_path.replace(os.sep, "/"),
             "file_size": embedding_data.get("size", 0),
             "modified": embedding_data.get("modified", ""),
             "tags": embedding_data.get("tags", []),
@@ -45,7 +63,10 @@ class EmbeddingService(BaseModelService):
             "exclude": bool(embedding_data.get("exclude", False)),
             "update_available": bool(embedding_data.get("update_available", False)),
             "skip_metadata_refresh": bool(embedding_data.get("skip_metadata_refresh", False)),
-            "civitai": self.filter_civitai_data(embedding_data.get("civitai", {}), minimal=True)
+            "civitai": self.filter_civitai_data(embedding_data.get("civitai", {}), minimal=True),
+            "auto_tags": embedding_data.get("auto_tags") or extract_auto_tags(embedding_data),
+            "version_count": embedding_data.get("version_count"),
+            "hf_url": embedding_data.get("hf_url", ""),
         }
     
     def find_duplicate_hashes(self) -> Dict:

py/services/errors.py

@@ -25,3 +25,21 @@ class ResourceNotFoundError(RuntimeError):
 
     pass
 
+
+class LLMNotConfiguredError(RuntimeError):
+    """Raised when an LLM-dependent operation is attempted but no provider is configured."""
+
+    pass
+
+
+class LLMRateLimitError(RateLimitError):
+    """Raised when the LLM provider rejects a request due to rate limiting."""
+
+    pass
+
+
+class LLMResponseError(RuntimeError):
+    """Raised when the LLM returns an unparseable or schema-invalid response."""
+
+    pass
+

py/services/llm_service.py

@@ -0,0 +1,321 @@
+"""Centralized LLM API client with BYOK (bring-your-own-key) provider support.
+
+Reads provider configuration from :class:`SettingsManager` and makes
+OpenAI-compatible ``/chat/completions`` calls.  Supports any provider that
+implements the OpenAI Chat Completions API surface area (OpenAI, Ollama,
+vLLM, LM Studio, etc.).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+
+from .errors import LLMNotConfiguredError, LLMRateLimitError, LLMResponseError
+
+logger = logging.getLogger(__name__)
+
+# Default API base URLs per provider
+_PROVIDER_DEFAULTS: Dict[str, str] = {
+    "openai": "https://api.openai.com/v1",
+    "ollama": "http://localhost:11434/v1",
+    # "custom" requires an explicit llm_api_base from the user
+}
+
+# Request timeout for LLM calls (seconds)
+_LLM_TIMEOUT = aiohttp.ClientTimeout(total=120)
+
+
+class LLMService:
+    """Centralized LLM API client.
+
+    All agent skills call LLMs through this service so that BYOK config,
+    retry logic, and error handling live in one place.
+    """
+
+    _instance: Optional["LLMService"] = None
+    _lock: asyncio.Lock = asyncio.Lock()
+
+    def __init__(self, settings_service) -> None:
+        self._settings = settings_service
+
+    # ------------------------------------------------------------------
+    # Singleton access
+    # ------------------------------------------------------------------
+
+    @classmethod
+    async def get_instance(cls) -> "LLMService":
+        """Return the lazily-initialised global ``LLMService`` instance."""
+
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    from .settings_manager import get_settings_manager
+
+                    cls._instance = cls(get_settings_manager())
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset the cached singleton — primarily for tests."""
+
+        cls._instance = None
+
+    # ------------------------------------------------------------------
+    # Configuration helpers
+    # ------------------------------------------------------------------
+
+    def _get_config(self) -> Dict[str, Any]:
+        """Read the current LLM configuration from settings."""
+
+        return {
+            "provider": self._settings.get("llm_provider", "openai"),
+            "api_key": self._settings.get("llm_api_key", ""),
+            "api_base": self._settings.get("llm_api_base", ""),
+            "model": self._settings.get("llm_model", ""),
+        }
+
+    def is_configured(self) -> bool:
+        """Return ``True`` when the LLM provider is minimally configured.
+
+        A provider is considered configured when ``llm_model`` is set and
+        (for non-Ollama) an API key is configured.
+        """
+
+        cfg = self._get_config()
+        has_model = bool(cfg["model"])
+        has_key = bool(cfg["api_key"]) or cfg["provider"] == "ollama"
+        return has_model and has_key
+
+    def _resolve_api_base(self, provider: str, api_base: str) -> str:
+        """Resolve the API base URL for the given provider."""
+
+        if api_base:
+            return api_base.rstrip("/")
+        return _PROVIDER_DEFAULTS.get(provider, "").rstrip("/")
+
+    def _build_headers(self, api_key: str) -> Dict[str, str]:
+        """Build HTTP headers for the LLM API request."""
+
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        return headers
+
+    def _ensure_configured(self) -> Dict[str, Any]:
+        """Validate configuration and return it, or raise.
+
+        A provider is considered configured when ``llm_model`` is set and
+        (for non-Ollama) an API key is configured.
+        """
+
+        cfg = self._get_config()
+        has_model = bool(cfg["model"])
+        has_key = bool(cfg["api_key"]) or cfg["provider"] == "ollama"
+        if not (has_model and has_key):
+            parts = []
+            if not has_model:
+                parts.append("No LLM model specified")
+            if not has_key and cfg["provider"] != "ollama":
+                parts.append("No LLM API key configured")
+            detail = "; ".join(parts) if parts else "LLM provider is not configured"
+            raise LLMNotConfiguredError(
+                f"{detail}. Configure it in Settings → AI Provider."
+            )
+        return cfg
+
+    # ------------------------------------------------------------------
+    # Core API call
+    # ------------------------------------------------------------------
+
+    async def chat_completion(
+        self,
+        *,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        temperature: float = 0.3,
+        response_format: Optional[Dict[str, Any]] = None,
+        max_tokens: Optional[int] = None,
+        retry_on_rate_limit: bool = True,
+    ) -> Dict[str, Any]:
+        """Call the configured LLM provider's ``/chat/completions`` endpoint.
+
+        Args:
+            messages: OpenAI-format message list
+            model: Override the configured model name
+            temperature: Sampling temperature
+            response_format: Optional ``{"type": "json_object"}`` for structured output
+            max_tokens: Optional max output tokens
+            retry_on_rate_limit: Retry once after a 429 with backoff
+
+        Returns:
+            Dict with ``content`` (str), ``usage`` (dict), ``model`` (str)
+
+        Raises:
+            LLMNotConfiguredError: Provider not enabled / missing config
+            LLMRateLimitError: Rate limited and retry exhausted
+            LLMResponseError: Non-200 response or parse failure
+        """
+
+        cfg = self._ensure_configured()
+        api_base = self._resolve_api_base(cfg["provider"], cfg["api_base"])
+        url = f"{api_base}/chat/completions"
+        model_name = model or cfg["model"]
+
+        payload: Dict[str, Any] = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temperature,
+        }
+        if response_format is not None:
+            payload["response_format"] = response_format
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
+
+        headers = self._build_headers(cfg["api_key"])
+
+        attempt = 0
+        max_attempts = 2 if retry_on_rate_limit else 1
+        while attempt < max_attempts:
+            attempt += 1
+            try:
+                async with aiohttp.ClientSession(timeout=_LLM_TIMEOUT) as session:
+                    async with session.post(
+                        url, json=payload, headers=headers
+                    ) as resp:
+                        if resp.status == 429:
+                            if attempt < max_attempts:
+                                retry_after = float(
+                                    resp.headers.get("Retry-After", "5")
+                                )
+                                logger.warning(
+                                    "LLM rate limited, retrying after %.1fs",
+                                    retry_after,
+                                )
+                                await asyncio.sleep(retry_after)
+                                continue
+                            raise LLMRateLimitError(
+                                f"LLM provider rate limited (HTTP 429)",
+                                provider=cfg["provider"],
+                            )
+
+                        if resp.status != 200:
+                            body = await resp.text()
+                            raise LLMResponseError(
+                                f"LLM API returned HTTP {resp.status}: "
+                                f"{body[:500]}"
+                            )
+
+                        data = await resp.json()
+
+            except aiohttp.ClientError as exc:
+                raise LLMResponseError(f"Network error calling LLM API: {exc}") from exc
+
+            # Parse response
+            try:
+                content = data["choices"][0]["message"]["content"]
+                usage = data.get("usage", {})
+                return {
+                    "content": content,
+                    "usage": usage,
+                    "model": data.get("model", model_name),
+                }
+            except (KeyError, IndexError) as exc:
+                raise LLMResponseError(
+                    f"Unexpected LLM response structure: {json.dumps(data)[:500]}"
+                ) from exc
+
+        # Should not reach here, but satisfy type checker
+        raise LLMRateLimitError("Rate limit retry exhausted", provider=cfg["provider"])
+
+    # ------------------------------------------------------------------
+    # Structured output convenience
+    # ------------------------------------------------------------------
+
+    async def chat_completion_json(
+        self,
+        *,
+        system_prompt: str,
+        user_prompt: str,
+        model: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Call the LLM and return parsed JSON.
+
+        Sends ``response_format: {"type": "json_object"}`` when the provider
+        supports it, and parses the response content as JSON.  If parsing
+        fails, retries once with a clarifying system message.
+
+        Args:
+            system_prompt: System-level instructions
+            user_prompt: User-level query
+            model: Override the configured model name
+            temperature: Sampling temperature
+            max_tokens: Optional max output tokens
+
+        Returns:
+            Parsed JSON dict from the LLM response
+
+        Raises:
+            LLMNotConfiguredError: Provider not configured
+            LLMRateLimitError: Rate limited
+            LLMResponseError: JSON parse failure after retry
+        """
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+
+        # First attempt with JSON mode
+        result = await self.chat_completion(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            response_format={"type": "json_object"},
+            max_tokens=max_tokens,
+        )
+
+        try:
+            return json.loads(result["content"])
+        except (json.JSONDecodeError, TypeError) as exc:
+            logger.warning(
+                "LLM JSON parse failed on first attempt: %s. Retrying.", exc
+            )
+
+        # Retry with explicit instruction to return valid JSON
+        retry_messages = messages + [
+            {
+                "role": "assistant",
+                "content": result["content"],
+            },
+            {
+                "role": "user",
+                "content": (
+                    "The previous response could not be parsed as JSON. "
+                    "Please respond with ONLY a valid JSON object, no "
+                    "markdown fences or extra text."
+                ),
+            },
+        ]
+
+        result = await self.chat_completion(
+            messages=retry_messages,
+            model=model,
+            temperature=0.0,  # More deterministic for retry
+            response_format={"type": "json_object"},
+            max_tokens=max_tokens,
+        )
+
+        try:
+            return json.loads(result["content"])
+        except (json.JSONDecodeError, TypeError) as exc:
+            raise LLMResponseError(
+                f"LLM response could not be parsed as JSON after retry: {exc}\n"
+                f"Raw content: {result['content'][:500]}"
+            ) from exc

py/services/lora_service.py

@@ -5,6 +5,7 @@ from typing import Dict, List, Optional
 
 from .base_model_service import BaseModelService
 from .model_query import resolve_sub_type
+from .auto_tag_service import extract_auto_tags
 from ..utils.models import LoraMetadata
 from ..config import config
 
@@ -23,23 +24,41 @@ class LoraService(BaseModelService):
         """
         super().__init__("lora", scanner, LoraMetadata, update_service=update_service)
 
-    async def format_response(self, lora_data: Dict) -> Dict:
-        """Format LoRA data for API response"""
+    async def format_response(self, lora_data: Dict) -> Optional[Dict]:
+        """Format LoRA data for API response.
+
+        Returns None when the entry is missing critical fields (corrupted cache
+        row), so the handler layer can filter it out instead of crashing the
+        whole listing request. See issue #730.
+        """
+        # Guard against corrupted cache entries missing critical fields
+        file_path = lora_data.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            logger.warning(
+                "Skipping corrupted LoRA entry (missing file_path): %s",
+                lora_data.get("file_name", "<unknown>"),
+            )
+            return None
+
         # Resolve sub_type using priority: sub_type > model_type > civitai.model.type > default
         # Normalize to lowercase for consistent API responses
         sub_type = resolve_sub_type(lora_data).lower()
 
+        file_name = lora_data.get("file_name") or ""
+        model_name = lora_data.get("model_name") or file_name
+        folder = lora_data.get("folder") or ""
+
         return {
-            "model_name": lora_data["model_name"],
-            "file_name": lora_data["file_name"],
+            "model_name": model_name,
+            "file_name": file_name,
             "preview_url": config.get_preview_static_url(
                 lora_data.get("preview_url", "")
             ),
             "preview_nsfw_level": lora_data.get("preview_nsfw_level", 0),
             "base_model": lora_data.get("base_model", ""),
-            "folder": lora_data["folder"],
+            "folder": folder,
             "sha256": lora_data.get("sha256", ""),
-            "file_path": lora_data["file_path"].replace(os.sep, "/"),
+            "file_path": file_path.replace(os.sep, "/"),
             "file_size": lora_data.get("size", 0),
             "modified": lora_data.get("modified", ""),
             "tags": lora_data.get("tags", []),
@@ -57,6 +76,9 @@ class LoraService(BaseModelService):
             "civitai": self.filter_civitai_data(
                 lora_data.get("civitai", {}), minimal=True
             ),
+            "auto_tags": lora_data.get("auto_tags") or extract_auto_tags(lora_data),
+            "version_count": lora_data.get("version_count"),
+            "hf_url": lora_data.get("hf_url", ""),
         }
 
     async def _apply_specific_filters(self, data: List[Dict], **kwargs) -> List[Dict]:
@@ -310,8 +332,23 @@ class LoraService(BaseModelService):
         """Return cached raw metadata for a LoRA matching the given filename."""
         cache = await self.scanner.get_cached_data(force_refresh=False)
 
+        fn_normalized = filename.replace("\\", "/")
+        fn_no_ext = fn_normalized
+        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+            if fn_no_ext.lower().endswith(ext):
+                fn_no_ext = fn_no_ext[: -len(ext)]
+                break
+
         for lora in cache.raw_data if cache else []:
-            if lora.get("file_name") == filename:
+            file_name = lora.get("file_name", "")
+            folder = lora.get("folder", "")
+            file_name_no_ext = file_name
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if file_name_no_ext.lower().endswith(ext):
+                    file_name_no_ext = file_name_no_ext[: -len(ext)]
+                    break
+            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+            if fn_no_ext in (file_name_no_ext, path_name):
                 return lora
 
         return None
@@ -399,7 +436,10 @@ class LoraService(BaseModelService):
             locked_loras = locked_loras[:target_count]
 
         # Filter out locked LoRAs from available pool
-        locked_names = {lora["name"] for lora in locked_loras}
+        locked_names = {
+            os.path.basename(lora["name"]) if "/" in str(lora.get("name", "")) else lora["name"]
+            for lora in locked_loras
+        }
         available_pool = [
             l for l in available_loras if l["file_name"] not in locked_names
         ]
@@ -454,7 +494,7 @@ class LoraService(BaseModelService):
 
             result_loras.append(
                 {
-                    "name": lora["file_name"],
+                    "name": f"{lora['folder']}/{lora['file_name']}" if lora.get("folder") else lora["file_name"],
                     "strength": model_str,
                     "clipStrength": clip_str,
                     "active": True,
@@ -670,8 +710,9 @@ class LoraService(BaseModelService):
         # Return minimal data needed for cycling
         return [
             {
-                "file_name": lora["file_name"],
+                "file_name": f"{lora['folder']}/{lora['file_name']}" if lora.get("folder") else lora["file_name"],
                 "model_name": lora.get("model_name", lora["file_name"]),
+                "folder": lora.get("folder", ""),
             }
             for lora in available_loras
         ]

py/services/metadata_sync_service.py

@@ -216,13 +216,19 @@ class MetadataSyncService:
             provider_used: Optional[str] = None
             last_error: Optional[str] = None
             civitai_api_not_found = False
+            any_rate_limited = False
 
             for provider_name, provider in provider_attempts:
                 try:
                     civitai_metadata_candidate, error = await provider.get_model_by_hash(sha256)
                 except RateLimitError as exc:
-                    exc.provider = exc.provider or (provider_name or provider.__class__.__name__)
-                    raise
+                    logger.warning(
+                        "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                        provider_name or provider.__class__.__name__,
+                        exc.retry_after or 0,
+                    )
+                    any_rate_limited = True
+                    continue
                 except Exception as exc:  # pragma: no cover - defensive logging
                     logger.error("Provider %s failed for hash %s: %s", provider_name, sha256, exc)
                     civitai_metadata_candidate, error = None, str(exc)
@@ -258,6 +264,14 @@ class MetadataSyncService:
                     model_data["last_checked_at"] = datetime.now().timestamp()
                     needs_save = True
 
+                # When the model was already classified as "not on CivitAI" via
+                # .metadata.json (civitai_deleted=True) but the SQLite cache is
+                # stale (because the pre-fix code never persisted these flags),
+                # ensure the flags are written to the scanner cache + SQLite.
+                if not needs_save and model_data.get("civitai_deleted") is True:
+                    model_data["last_checked_at"] = datetime.now().timestamp()
+                    needs_save = True
+
                 # Save metadata if any state was updated
                 if needs_save:
                     data_to_save = model_data.copy()
@@ -266,6 +280,7 @@ class MetadataSyncService:
                     if "last_checked_at" not in data_to_save:
                         data_to_save["last_checked_at"] = datetime.now().timestamp()
                     await self._metadata_manager.save_metadata(file_path, data_to_save)
+                    await update_cache_func(file_path, file_path, data_to_save)
 
                 default_error = (
                     "CivitAI model is deleted and metadata archive DB is not enabled"
@@ -276,17 +291,18 @@ class MetadataSyncService:
                 )
 
                 resolved_error = last_error or default_error
+                if any_rate_limited and "Rate limited" not in resolved_error:
+                    resolved_error = "Rate limited"
                 if is_expected_offline_error(resolved_error):
                     resolved_error = OFFLINE_FRIENDLY_MESSAGE
 
                 error_msg = (
                     f"Error fetching metadata: {resolved_error} "
-                    f"(model_name={model_data.get('model_name', '')})"
+                    f"(file={os.path.basename(file_path)}, sha256={sha256})"
                 )
-                if is_expected_offline_error(resolved_error):
-                    logger.info(error_msg)
-                else:
-                    logger.error(error_msg)
+                # Use case layer (BulkMetadataRefreshUseCase) logs failed models at WARNING level,
+                # so this level is demoted to DEBUG to avoid duplicate user-visible logging.
+                logger.debug(error_msg)
                 return False, error_msg
 
             model_data["from_civitai"] = True
@@ -411,7 +427,18 @@ class MetadataSyncService:
         metadata = await metadata_loader(metadata_path)
 
         for key, value in updates.items():
-            if isinstance(value, dict) and isinstance(metadata.get(key), dict):
+            if key == "tags" and isinstance(value, list):
+                # Normalize tags: trim, lowercase, deduplicate
+                normalized = []
+                seen = set()
+                for tag in value:
+                    if isinstance(tag, str):
+                        t = tag.strip().lower()
+                        if t and t not in seen:
+                            normalized.append(t)
+                            seen.add(t)
+                metadata[key] = normalized
+            elif isinstance(value, dict) and isinstance(metadata.get(key), dict):
                 metadata[key].update(value)
             else:
                 metadata[key] = value

py/services/model_cache.py

@@ -18,6 +18,8 @@ SUPPORTED_SORT_MODES = [
     ('size', 'desc'),
     ('usage', 'asc'),
     ('usage', 'desc'),
+    ('versions_count', 'asc'),
+    ('versions_count', 'desc'),
 ]
 # Is this in use?
 
@@ -263,6 +265,17 @@ class ModelCache:
                 ),
                 reverse=reverse
             )
+        elif sort_key == 'versions_count':
+            # Pre-dedup sort: fall back to name sort.
+            # Actual re-sort by version_count happens in get_paginated_data after dedup.
+            result = natsorted(
+                data,
+                key=lambda x: (
+                    self._get_display_name(x).lower(),
+                    x.get('file_path', '').lower()
+                ),
+                reverse=reverse
+            )
         else:
             # Fallback: no sort
             result = list(data)

py/services/model_hash_index.py

@@ -7,6 +7,7 @@ class ModelHashIndex:
     def __init__(self):
         self._hash_to_path: Dict[str, str] = {}
         self._filename_to_hash: Dict[str, str] = {}
+        self._autov2_to_path: Dict[str, str] = {}
         # New data structures for tracking duplicates
         self._duplicate_hashes: Dict[str, List[str]] = {}  # sha256 -> list of paths
         self._duplicate_filenames: Dict[str, List[str]] = {}  # filename -> list of paths
@@ -63,6 +64,9 @@ class ModelHashIndex:
         # Add new mappings
         self._hash_to_path[sha256] = file_path
         self._filename_to_hash[filename] = sha256
+        # AutoV2 = first 10 chars of SHA256
+        if len(sha256) >= 10:
+            self._autov2_to_path[sha256[:10]] = file_path
     
     def _get_filename_from_path(self, file_path: str) -> str:
         """Extract filename without extension from path"""
@@ -157,7 +161,12 @@ class ModelHashIndex:
                 del self._duplicate_filenames[filename]
                 if filename in self._filename_to_hash:
                     del self._filename_to_hash[filename]
-    
+
+        # Remove from AutoV2 index
+        autov2_keys_to_remove = [k for k, v in self._autov2_to_path.items() if v == file_path]
+        for k in autov2_keys_to_remove:
+            del self._autov2_to_path[k]
+
     def remove_by_hash(self, sha256: str) -> None:
         """Remove entry by hash"""
         sha256 = sha256.lower()
@@ -177,6 +186,10 @@ class ModelHashIndex:
         # Remove hash-to-path mapping
         del self._hash_to_path[sha256]
         
+        autov2_key = sha256[:10]
+        if autov2_key in self._autov2_to_path:
+            del self._autov2_to_path[autov2_key]
+        
         # Update filename-to-hash and duplicate filenames for all paths
         for path_to_remove in paths_to_remove:
             fname = self._get_filename_from_path(path_to_remove)
@@ -195,13 +208,24 @@ class ModelHashIndex:
                     # If only one entry remains, it's no longer a duplicate
                     del self._duplicate_filenames[fname]
     
-    def has_hash(self, sha256: str) -> bool:
-        """Check if hash exists in index"""
-        return sha256.lower() in self._hash_to_path
-    
-    def get_path(self, sha256: str) -> Optional[str]:
-        """Get file path for a hash"""
-        return self._hash_to_path.get(sha256.lower())
+    def has_hash(self, hash_value: str) -> bool:
+        """Check if hash exists in index (SHA256 or AutoV2)"""
+        normalized = hash_value.lower()
+        if normalized in self._hash_to_path:
+            return True
+        if len(normalized) == 10:
+            return normalized in self._autov2_to_path
+        return False
+
+    def get_path(self, hash_value: str) -> Optional[str]:
+        """Get file path for a hash (SHA256 or AutoV2)"""
+        normalized = hash_value.lower()
+        path = self._hash_to_path.get(normalized)
+        if path is not None:
+            return path
+        if len(normalized) == 10:
+            return self._autov2_to_path.get(normalized)
+        return None
     
     def get_hash(self, file_path: str) -> Optional[str]:
         """Get hash for a file path"""
@@ -209,13 +233,16 @@ class ModelHashIndex:
         return self._filename_to_hash.get(filename)
     
     def get_hash_by_filename(self, filename: str) -> Optional[str]:
-        """Get hash for a filename without extension"""
+        """Get hash for a filename (bare basename or path-prefixed name)"""
+        if "/" in filename or "\\" in filename:
+            filename = os.path.splitext(os.path.basename(filename.replace("\\", "/")))[0]
         return self._filename_to_hash.get(filename)
     
     def clear(self) -> None:
         """Clear all entries"""
         self._hash_to_path.clear()
         self._filename_to_hash.clear()
+        self._autov2_to_path.clear()
         self._duplicate_hashes.clear()
         self._duplicate_filenames.clear()
     

py/services/model_lifecycle_service.py

@@ -111,6 +111,11 @@ class ModelLifecycleService:
             self._scanner._hash_index.remove_by_path(file_path)
 
         await self._sync_update_for_model(model_id)
+
+        persist_current_cache = getattr(self._scanner, "_persist_current_cache", None)
+        if callable(persist_current_cache):
+            await persist_current_cache()
+
         return {"success": True, "deleted_files": deleted_files}
 
     @staticmethod

py/services/model_metadata_provider.py

@@ -5,7 +5,7 @@ import logging
 import random
 from typing import Optional, Dict, Tuple, Any, List, Sequence
 from .downloader import get_downloader
-from .errors import RateLimitError
+from .errors import RateLimitError, ResourceNotFoundError
 
 try:
     from bs4 import BeautifulSoup
@@ -65,7 +65,14 @@ class _RateLimitRetryHelper:
                 return await func(*args, **kwargs)
             except RateLimitError as exc:
                 attempt += 1
-                if attempt >= self._retry_limit:
+
+                # Determine effective retry limit based on rate-limit magnitude
+                effective_retry_limit = self._retry_limit  # default: 3
+                if exc.retry_after is not None and exc.retry_after >= 120.0:
+                    # Long rate-limit window (>=2 min) — retries are futile
+                    effective_retry_limit = 1  # total 1 attempt = 0 retries
+
+                if attempt >= effective_retry_limit:
                     exc.provider = exc.provider or label
                     raise
 
@@ -81,7 +88,11 @@ class _RateLimitRetryHelper:
 
     def _calculate_delay(self, retry_after: Optional[float], attempt: int) -> float:
         if retry_after is not None:
-            return min(self._max_delay, max(0.0, retry_after))
+            # Cap at 1800s (30 min) as a safety ceiling. The old 30s cap was
+            # too low — CivArchive can return retry_after ~1500s, causing all
+            # retries to fail. A generous ceiling protects against pathological
+            # server values while still respecting the server's guidance.
+            return min(1800.0, max(0.0, retry_after))
 
         base_delay = self._base_delay * (2 ** max(0, attempt - 1))
         jitter_span = base_delay * self._jitter_ratio
@@ -474,14 +485,19 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 if result:
                     return result, error
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
             except Exception as e:
                 logger.debug("Provider %s failed for get_model_by_hash: %s", label, e)
                 continue
         return None, "Model not found"
 
     async def get_model_versions(self, model_id: str) -> Optional[Dict]:
+        not_found_confirmed = False
         for provider, label in self._iter_providers():
             try:
                 result = await self._call_with_rate_limit(
@@ -492,8 +508,20 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 if result:
                     return result
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
+            except ResourceNotFoundError:
+                not_found_confirmed = True
+                logger.debug(
+                    "Provider %s reports model %s as not found",
+                    label,
+                    model_id,
+                )
+                continue
             except Exception as e:
                 logger.debug("Provider %s failed for get_model_versions: %s", label, e)
                 continue
@@ -511,8 +539,12 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 if result:
                     return result
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
             except Exception as e:
                 logger.debug("Provider %s failed for get_model_version: %s", label, e)
                 continue
@@ -529,8 +561,12 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 if result:
                     return result, error
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
             except Exception as e:
                 logger.debug("Provider %s failed for get_model_version_info: %s", label, e)
                 continue
@@ -551,8 +587,12 @@ class FallbackMetadataProvider(ModelMetadataProvider):
             except NotImplementedError:
                 continue
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
             except Exception as e:
                 logger.debug(
                     "Provider %s failed for get_model_versions_by_hashes: %s",
@@ -573,8 +613,12 @@ class FallbackMetadataProvider(ModelMetadataProvider):
                 if result is not None:
                     return result
             except RateLimitError as exc:
-                exc.provider = exc.provider or label
-                raise exc
+                logger.warning(
+                    "Provider %s is rate-limited (retry_after=%.0fs); skipping to next provider",
+                    label,
+                    exc.retry_after or 0,
+                )
+                continue
             except Exception as e:
                 logger.debug("Provider %s failed for get_user_models: %s", label, e)
                 continue

py/services/model_query.py

@@ -96,6 +96,7 @@ class FilterCriteria:
     folder_exclude: Optional[Sequence[str]] = None
     base_models: Optional[Sequence[str]] = None
     tags: Optional[Dict[str, str]] = None
+    auto_tags: Optional[Dict[str, str]] = None
     favorites_only: bool = False
     search_options: Optional[Dict[str, Any]] = None
     model_types: Optional[Sequence[str]] = None
@@ -293,12 +294,14 @@ class ModelFilterSet:
                 for tag, state in tag_filters.items():
                     if not tag:
                         continue
+                    # Normalize to lowercase for case-insensitive matching
+                    normalized = tag.strip().lower()
                     if state == "exclude":
-                        exclude_tags.add(tag)
+                        exclude_tags.add(normalized)
                     else:
-                        include_tags.add(tag)
+                        include_tags.add(normalized)
             else:
-                include_tags = {tag for tag in tag_filters if tag}
+                include_tags = {tag.strip().lower() for tag in tag_filters if tag}
 
             if include_tags:
                 tag_logic = criteria.tag_logic.lower() if criteria.tag_logic else "any"
@@ -317,13 +320,17 @@ class ModelFilterSet:
                                 return True
                             # Otherwise, check if all non-special tags match
                             if non_special_tags:
-                                return all(tag in (item_tags or []) for tag in non_special_tags)
+                                # Case-insensitive: normalize item tags too
+                                normalized_item_tags = {t.strip().lower() for t in (item_tags or []) if isinstance(t, str)}
+                                return all(tag in normalized_item_tags for tag in non_special_tags)
                             return True
-                        # Normal case: all tags must match
-                        return all(tag in (item_tags or []) for tag in non_special_tags)
+                        # Normal case: all tags must match (case-insensitive)
+                        normalized_item_tags = {t.strip().lower() for t in (item_tags or []) if isinstance(t, str)}
+                        return all(tag in normalized_item_tags for tag in non_special_tags)
                     else:
-                        # OR logic (default): item must have ANY include tag
-                        return any(tag in include_tags for tag in (item_tags or []))
+                        # OR logic (default): item must have ANY include tag (case-insensitive)
+                        normalized_item_tags = {t.strip().lower() for t in (item_tags or []) if isinstance(t, str)}
+                        return bool(normalized_item_tags & include_tags)
 
                 items = [item for item in items if matches_include(item.get("tags"))]
 
@@ -332,7 +339,9 @@ class ModelFilterSet:
                 def matches_exclude(item_tags):
                     if not item_tags and "__no_tags__" in exclude_tags:
                         return True
-                    return any(tag in exclude_tags for tag in (item_tags or []))
+                    # Case-insensitive: normalize item tags
+                    normalized_item_tags = {t.strip().lower() for t in (item_tags or []) if isinstance(t, str)}
+                    return bool(normalized_item_tags & exclude_tags)
 
                 items = [
                     item for item in items if not matches_exclude(item.get("tags"))
@@ -359,10 +368,37 @@ class ModelFilterSet:
                 ]
             model_types_duration = time.perf_counter() - t0
 
+        auto_tags_duration = 0
+        auto_tag_filters = criteria.auto_tags or {}
+        if auto_tag_filters:
+            t0 = time.perf_counter()
+            include_at = set()
+            exclude_at = set()
+            for tag, state in auto_tag_filters.items():
+                if not tag:
+                    continue
+                if state == "exclude":
+                    exclude_at.add(tag)
+                else:
+                    include_at.add(tag)
+
+            if include_at:
+                items = [
+                    item for item in items
+                    if any(tag in include_at for tag in (item.get("auto_tags") or []))
+                ]
+
+            if exclude_at:
+                items = [
+                    item for item in items
+                    if not any(tag in exclude_at for tag in (item.get("auto_tags") or []))
+                ]
+            auto_tags_duration = time.perf_counter() - t0
+
         duration = time.perf_counter() - overall_start
         if duration > 0.1:  # Only log if it's potentially slow
             logger.debug(
-                "ModelFilterSet.apply took %.3fs (sfw: %.3fs, fav: %.3fs, folder: %.3fs, base: %.3fs, tags: %.3fs, types: %.3fs). "
+                "ModelFilterSet.apply took %.3fs (sfw: %.3fs, fav: %.3fs, folder: %.3fs, base: %.3fs, tags: %.3fs, types: %.3fs, auto_tags: %.3fs). "
                 "Count: %d -> %d",
                 duration,
                 sfw_duration,
@@ -371,6 +407,7 @@ class ModelFilterSet:
                 base_models_duration,
                 tags_duration,
                 model_types_duration,
+                auto_tags_duration,
                 initial_count,
                 len(items),
             )

py/services/model_scanner.py

@@ -9,7 +9,7 @@ from typing import Any, Awaitable, Callable, Dict, List, Mapping, Optional, Set,
 
 from ..utils.models import BaseModelMetadata
 from ..config import config
-from ..utils.file_utils import find_preview_file, get_preview_extension
+from ..utils.file_utils import find_preview_file, get_preview_extension, calculate_sha256
 from ..utils.metadata_manager import MetadataManager
 from ..utils.civitai_utils import resolve_license_info
 from .model_cache import ModelCache
@@ -248,6 +248,7 @@ class ModelScanner:
             'civitai': civitai_slim,
             'civitai_deleted': bool(get_value('civitai_deleted', False)),
             'skip_metadata_refresh': bool(get_value('skip_metadata_refresh', False)),
+            'hf_url': get_value('hf_url', '') or '',
         }
 
         license_source: Dict[str, Any] = {}
@@ -476,11 +477,20 @@ class ModelScanner:
             for tag in adjusted_item.get('tags') or []:
                 tags_count[tag] = tags_count.get(tag, 0) + 1
 
-        # Validate cache entries and check health
+        # Validate cache entries and check health.
+        # Always use the validated/repaired entries — even when there are no
+        # invalid entries, auto_repair may have filled in missing optional
+        # fields (model_name, file_name, folder) with safe defaults on a copied
+        # working_entry.  Without this unconditional replacement the repaired
+        # copies are discarded and None values propagate to format_response.
+        # See issue #730.
         valid_entries, invalid_entries = CacheEntryValidator.validate_batch(
             adjusted_raw_data, auto_repair=True
         )
 
+        # Always use the validated entries (repaired copies)
+        adjusted_raw_data = valid_entries
+
         if invalid_entries:
             monitor = CacheHealthMonitor()
             report = monitor.check_health(adjusted_raw_data, auto_repair=True)
@@ -532,6 +542,13 @@ class ModelScanner:
         if not scan_result or not getattr(self, '_persistent_cache', None):
             return
 
+        if self.is_cancelled():
+            logger.info(
+                f"{self.model_type.capitalize()} Scanner: Skipping _save_persistent_cache "
+                "after cancellation"
+            )
+            return
+
         hash_snapshot = self._build_hash_index_snapshot(scan_result.hash_index)
         loop = asyncio.get_event_loop()
         try:
@@ -705,14 +722,20 @@ class ModelScanner:
             # Determine the page type based on model type
             # Scan for new data
             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')
+            if not self.is_cancelled():
+                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, "
-                f"found {len(scan_result.raw_data)} models"
-            )
+                logger.info(
+                    f"{self.model_type.capitalize()} Scanner: Cache initialization completed in {time.time() - start_time:.2f} seconds, "
+                    f"found {len(scan_result.raw_data)} models"
+                )
+            else:
+                logger.info(
+                    f"{self.model_type.capitalize()} Scanner: Cache initialization cancelled "
+                    f"after {time.time() - start_time:.2f} seconds"
+                )
         except Exception as e:
             logger.error(f"{self.model_type.capitalize()} Scanner: Error initializing cache: {e}")
             # Ensure cache is at least an empty structure on error
@@ -1067,6 +1090,22 @@ class ModelScanner:
 
         model_data = self._build_cache_entry(metadata, folder=normalized_folder)
 
+        # Compute SHA256 hash when metadata provided none (e.g., CivitAI API response has empty hashes).
+        # Respect hash_status='pending' (set by CheckpointScanner for large models) to defer
+        # hash calculation until on-demand — avoids reading entire checkpoint files at startup.
+        hash_status = model_data.get('hash_status', '')
+        if not model_data.get('sha256') and hash_status != 'pending' and file_path:
+            try:
+                logger.info(f"Computing SHA256 hash for {file_path} (was empty from metadata)")
+                sha256 = await calculate_sha256(file_path)
+                if sha256:
+                    model_data['sha256'] = sha256.lower()
+                    if isinstance(metadata, BaseModelMetadata):
+                        metadata.sha256 = sha256.lower()
+                    await MetadataManager.save_metadata(file_path, metadata)
+            except Exception as e:
+                logger.error(f"Failed to compute SHA256 for {file_path}: {e}")
+
         # Skip excluded models
         if model_data.get('exclude', False):
             excluded_models.append(model_data['file_path'])
@@ -1080,6 +1119,13 @@ class ModelScanner:
         if scan_result is None:
             return
 
+        if self.is_cancelled():
+            logger.info(
+                f"{self.model_type.capitalize()} Scanner: Skipping _apply_scan_result "
+                "after cancellation"
+            )
+            return
+
         self._hash_index = scan_result.hash_index
         self._tags_count = dict(scan_result.tags_count)
         self._excluded_models = list(scan_result.excluded_models)
@@ -1101,7 +1147,15 @@ class ModelScanner:
 
     def _log_duplicate_filename_summary(self) -> None:
         """Log a batched summary of duplicate filename conflicts once per scan."""
-        if self._hash_index is None:
+        # Duplicate filename detection is only relevant for LoRAs, which use
+        # basename-only syntax (<lora:name:strength>). Checkpoints and embeddings
+        # use full relative paths for resolution, so conflicts are not ambiguous.
+        if self._hash_index is None or self.model_type != "lora":
+            return
+
+        # When full path syntax is active, duplicate filenames across subfolders
+        # are fully qualified, so there is no ambiguity — skip the warning.
+        if get_settings_manager().get("lora_syntax_format", "legacy") == "full":
             return
 
         duplicates = self._hash_index.get_duplicate_filenames()
@@ -1473,6 +1527,15 @@ class ModelScanner:
                 file_path_override=normalized_new_path,
             )
 
+            # Ensure sha256 is populated even when metadata doesn't have it
+            if not cache_entry.get('sha256') and normalized_new_path and os.path.exists(normalized_new_path):
+                try:
+                    sha256 = await calculate_sha256(normalized_new_path)
+                    if sha256:
+                        cache_entry['sha256'] = sha256.lower()
+                except Exception as e:
+                    logger.error(f"Failed to compute SHA256 for {normalized_new_path}: {e}")
+
             if recalculate_type:
                 cache_entry = self.adjust_cached_entry(cache_entry)
 
@@ -1572,12 +1635,39 @@ class ModelScanner:
         """Get model information by name"""
         try:
             cache = await self.get_cached_data()
-            
+
+            name_normalized = name.replace("\\", "/")
+            name_no_ext = name_normalized
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if name_no_ext.lower().endswith(ext):
+                    name_no_ext = name_no_ext[: -len(ext)]
+                    break
+
+            has_path = "/" in name_no_ext
+            basename = os.path.basename(name_no_ext) if has_path else name_no_ext
+            best_fallback = None
+
             for model in cache.raw_data:
-                if model.get("file_name") == name:
+                file_name = model.get("file_name", "")
+                folder = model.get("folder", "")
+                file_name_no_ext = file_name
+                for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                    if file_name_no_ext.lower().endswith(ext):
+                        file_name_no_ext = file_name_no_ext[: -len(ext)]
+                        break
+                path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+
+                if name_no_ext == file_name_no_ext or name_no_ext == path_name:
                     return model
-                    
-            return None
+
+                if has_path and file_name_no_ext == basename:
+                    if folder and name_no_ext.startswith(folder.replace("\\", "/") + "/"):
+                        best_fallback = model
+                    elif best_fallback is None:
+                        best_fallback = model
+
+            return best_fallback
+
         except Exception as e:
             logger.error(f"Error getting model info by name: {e}", exc_info=True)
             return None
@@ -1704,6 +1794,13 @@ class ModelScanner:
         """
         if not file_paths or self._cache is None:
             return False
+
+        if self.is_cancelled():
+            logger.info(
+                f"{self.model_type.capitalize()} Scanner: Skipping cache update "
+                "after cancelled bulk delete"
+            )
+            return False
             
         try:
             # Get all models that need to be removed from cache

py/services/model_update_service.py

@@ -689,6 +689,7 @@ class ModelUpdateService:
         *,
         force_refresh: bool = False,
         target_model_ids: Optional[Sequence[int]] = None,
+        folder_path: Optional[str] = None,
     ) -> Dict[int, ModelUpdateRecord]:
         """Refresh update information for every model present in the cache."""
         scanner.reset_cancellation()
@@ -703,6 +704,7 @@ class ModelUpdateService:
         local_versions = await self._collect_local_versions(
             scanner,
             target_model_ids=target_filter,
+            folder_path=folder_path,
         )
         total_models = len(local_versions)
         if total_models == 0:
@@ -722,6 +724,16 @@ class ModelUpdateService:
             "Refreshing update metadata for %d %s models", total_models, model_type
         )
 
+        # When filtering by folder, also collect the cross-folder version set
+        # so that versions already present in other folders are not reported
+        # as available updates. See issue #997.
+        all_local_versions: Optional[Dict[int, List[int]]] = None
+        if folder_path is not None:
+            all_local_versions = await self._collect_local_versions(
+                scanner,
+                target_model_ids=target_filter,
+            )
+
         results: Dict[int, ModelUpdateRecord] = {}
         prefetched: Dict[int, Mapping] = {}
 
@@ -760,6 +772,12 @@ class ModelUpdateService:
         for index, (model_id, version_ids) in enumerate(
             local_versions.items(), start=1
         ):
+            # Use cross-folder version IDs for is_in_library if available
+            all_vids: Sequence[int] = (
+                all_local_versions.get(model_id, [])
+                if all_local_versions is not None
+                else version_ids
+            )
             record = await self._refresh_single_model(
                 model_type,
                 model_id,
@@ -767,6 +785,7 @@ class ModelUpdateService:
                 metadata_provider,
                 force_refresh=force_refresh,
                 prefetched_response=prefetched.get(model_id),
+                all_local_version_ids=all_vids,
             )
             if scanner.is_cancelled():
                 logger.info(f"{model_type.capitalize()} Update Service: Refresh cancelled by user")
@@ -962,8 +981,16 @@ class ModelUpdateService:
         *,
         force_refresh: bool = False,
         prefetched_response: Optional[Mapping] = None,
+        all_local_version_ids: Optional[Sequence[int]] = None,
     ) -> Optional[ModelUpdateRecord]:
         normalized_local = self._normalize_sequence(local_versions)
+        # When folder-filtering, this carries the cross-folder version set
+        # for is_in_library; otherwise it falls back to normalized_local.
+        normalized_all = (
+            self._normalize_sequence(all_local_version_ids)
+            if all_local_version_ids is not None
+            else normalized_local
+        )
         now = time.time()
         async with self._lock:
             existing = self._get_record(model_type, model_id)
@@ -971,6 +998,7 @@ class ModelUpdateService:
                 record = self._merge_with_local_versions(
                     existing,
                     normalized_local,
+                    all_local_version_ids=normalized_all,
                 )
                 self._upsert_record(record)
                 return record
@@ -1000,12 +1028,11 @@ class ModelUpdateService:
                     fallback_error_message = str(exc) or "resource not found"
                     mark_model_as_ignored = True
                 except Exception as exc:  # pragma: no cover - defensive log
-                    logger.error(
+                    logger.warning(
                         "Failed to fetch versions for model %s (%s): %s",
                         model_id,
                         model_type,
                         exc,
-                        exc_info=True,
                     )
                     fallback_error_message = str(exc)
             if response is not None:
@@ -1047,6 +1074,7 @@ class ModelUpdateService:
                 record = self._merge_with_local_versions(
                     existing,
                     normalized_local,
+                    all_local_version_ids=normalized_all,
                 )
                 self._upsert_record(record)
                 return record
@@ -1058,6 +1086,7 @@ class ModelUpdateService:
                     model_type=model_type,
                     model_id=model_id,
                     last_checked_at=now,
+                    all_local_version_ids=normalized_all,
                 )
                 record = replace(record, should_ignore_model=True)
                 self._upsert_record(record)
@@ -1076,6 +1105,7 @@ class ModelUpdateService:
                     fetched_versions,
                     existing,
                     now,
+                    all_local_version_ids=normalized_all,
                 )
             else:
                 record = self._merge_with_local_versions(
@@ -1084,6 +1114,7 @@ class ModelUpdateService:
                     model_type=model_type,
                     model_id=model_id,
                     last_checked_at=existing.last_checked_at if existing else None,
+                    all_local_version_ids=normalized_all,
                 )
             self._upsert_record(record)
             return record
@@ -1277,6 +1308,7 @@ class ModelUpdateService:
         scanner,
         *,
         target_model_ids: Optional[Sequence[int]] = None,
+        folder_path: Optional[str] = None,
     ) -> Dict[int, List[int]]:
         cache = await scanner.get_cached_data()
         mapping: Dict[int, set[int]] = {}
@@ -1289,7 +1321,19 @@ class ModelUpdateService:
             if not target_set:
                 return {}
 
+        normalized_folder = None
+        if folder_path is not None:
+            normalized_folder = folder_path.replace("\\", "/").strip("/")
+
         for item in cache.raw_data:
+            # Apply folder filter first (cheapest check)
+            if normalized_folder is not None:
+                if not isinstance(item, dict):
+                    continue
+                item_folder = (item.get("folder") or "").replace("\\", "/").strip("/")
+                if item_folder != normalized_folder and not item_folder.startswith(normalized_folder + "/"):
+                    continue
+
             civitai = item.get("civitai") if isinstance(item, dict) else None
             if not isinstance(civitai, dict):
                 continue
@@ -1308,12 +1352,20 @@ class ModelUpdateService:
         existing: Optional[ModelUpdateRecord],
         normalized_local: Sequence[int],
         *,
+        all_local_version_ids: Optional[Sequence[int]] = None,
         model_type: Optional[str] = None,
         model_id: Optional[int] = None,
         last_checked_at: Optional[float] = None,
         version_info: Optional[Mapping] = None,
     ) -> ModelUpdateRecord:
         local_set = set(normalized_local)
+        # When folder-filtering, also consider versions in other folders
+        # as in-library so they are not reported as available updates.
+        effective_local_set: set[int] = (
+            local_set | set(all_local_version_ids)
+            if all_local_version_ids is not None
+            else local_set
+        )
         versions: List[ModelVersionRecord] = []
         ignore_map: Dict[int, bool] = {}
         if existing:
@@ -1325,7 +1377,7 @@ class ModelUpdateService:
                 versions.append(
                     replace(
                         version,
-                        is_in_library=version.version_id in local_set,
+                        is_in_library=version.version_id in effective_local_set,
                     )
                 )
         elif model_type is None or model_id is None:
@@ -1372,8 +1424,17 @@ class ModelUpdateService:
         remote_versions: Sequence[ModelVersionRecord],
         existing: Optional[ModelUpdateRecord],
         timestamp: float,
+        *,
+        all_local_version_ids: Optional[Sequence[int]] = None,
     ) -> ModelUpdateRecord:
         local_set = set(local_versions)
+        # When folder-filtering, also consider versions in other folders
+        # as in-library so they are not reported as available updates.
+        effective_local_set: set[int] = (
+            local_set | set(all_local_version_ids)
+            if all_local_version_ids is not None
+            else local_set
+        )
         ignore_map = {version.version_id: version.should_ignore for version in existing.versions} if existing else {}
         preview_map = {version.version_id: version.preview_url for version in existing.versions} if existing else {}
         sort_map = {version.version_id: version.sort_index for version in existing.versions} if existing else {}
@@ -1392,7 +1453,7 @@ class ModelUpdateService:
                     released_at=remote_version.released_at,
                     size_bytes=remote_version.size_bytes,
                     preview_url=remote_version.preview_url or preview_map.get(version_id),
-                    is_in_library=version_id in local_set,
+                    is_in_library=version_id in effective_local_set,
                     should_ignore=ignore_map.get(version_id, remote_version.should_ignore),
                     sort_index=sort_map.get(version_id, index),
                     early_access_ends_at=remote_version.early_access_ends_at,

py/services/persistent_model_cache.py

@@ -57,6 +57,7 @@ class PersistentModelCache:
         "db_checked",
         "last_checked_at",
         "hash_status",
+        "hf_url",
     )
     _MODEL_UPDATE_COLUMNS: Tuple[str, ...] = _MODEL_COLUMNS[2:]
     _instances: Dict[str, "PersistentModelCache"] = {}
@@ -165,8 +166,8 @@ class PersistentModelCache:
 
             item = {
                 "file_path": file_path,
-                "file_name": row["file_name"],
-                "model_name": row["model_name"],
+                "file_name": row["file_name"] or "",
+                "model_name": row["model_name"] or "",
                 "folder": row["folder"] or "",
                 "size": row["size"] or 0,
                 "modified": row["modified"] or 0.0,
@@ -188,6 +189,7 @@ class PersistentModelCache:
                 "skip_metadata_refresh": bool(row["skip_metadata_refresh"]),
                 "license_flags": int(license_value),
                 "hash_status": row["hash_status"] or "completed",
+                "hf_url": row["hf_url"] or "",
             }
             raw_data.append(item)
 
@@ -452,6 +454,7 @@ class PersistentModelCache:
                             db_checked INTEGER,
                             last_checked_at REAL,
                             hash_status TEXT,
+                            hf_url TEXT DEFAULT '',
                             PRIMARY KEY (model_type, file_path)
                         );
 
@@ -500,6 +503,7 @@ class PersistentModelCache:
             # Persisting without explicit flags should assume CivitAI's documented defaults (0b111001 == 57).
             "license_flags": f"INTEGER DEFAULT {DEFAULT_LICENSE_FLAGS}",
             "hash_status": "TEXT DEFAULT 'completed'",
+            "hf_url": "TEXT DEFAULT ''",
         }
 
         for column, definition in required_columns.items():
@@ -548,19 +552,19 @@ class PersistentModelCache:
         return (
             model_type,
             item.get("file_path"),
-            item.get("file_name"),
-            item.get("model_name"),
-            item.get("folder"),
+            item.get("file_name") or "",
+            item.get("model_name") or "",
+            item.get("folder") or "",
             int(item.get("size") or 0),
             float(item.get("modified") or 0.0),
             (item.get("sha256") or "").lower() or None,
-            item.get("base_model"),
-            item.get("preview_url"),
+            item.get("base_model") or "",
+            item.get("preview_url") or "",
             int(item.get("preview_nsfw_level") or 0),
             1 if item.get("from_civitai", True) else 0,
             1 if item.get("favorite") else 0,
-            item.get("notes"),
-            item.get("usage_tips"),
+            item.get("notes") or "",
+            item.get("usage_tips") or "",
             metadata_source,
             civitai.get("id"),
             civitai.get("modelId"),
@@ -575,6 +579,7 @@ class PersistentModelCache:
             1 if item.get("db_checked") else 0,
             float(item.get("last_checked_at") or 0.0),
             item.get("hash_status", "completed"),
+            item.get("hf_url") or "",
         )
 
     def _insert_model_sql(self) -> str:

py/services/persistent_recipe_cache.py

@@ -12,7 +12,7 @@ import logging
 import os
 import sqlite3
 import threading
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Set, Tuple
 
 from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
@@ -26,6 +26,8 @@ class PersistedRecipeData:
 
     raw_data: List[Dict]
     file_stats: Dict[str, Tuple[float, int]]  # json_path -> (mtime, size)
+    image_id_map: Dict[str, str] = field(default_factory=dict)
+    """Precomputed mapping of civitai image_id → recipe_id."""
 
 
 class PersistentRecipeCache:
@@ -38,6 +40,7 @@ class PersistentRecipeCache:
         "json_path",
         "title",
         "folder",
+        "source_path",
         "base_model",
         "fingerprint",
         "created_date",
@@ -115,6 +118,20 @@ class PersistentRecipeCache:
                     if not rows:
                         return None
 
+                    # Restore precomputed image_id_map if available
+                    image_id_map: Dict[str, str] = {}
+                    try:
+                        meta_row = conn.execute(
+                            "SELECT value FROM cache_metadata WHERE key = ?",
+                            ("image_id_map",),
+                        ).fetchone()
+                        if meta_row:
+                            parsed = json.loads(meta_row["value"])
+                            if isinstance(parsed, dict):
+                                image_id_map = parsed
+                    except Exception:
+                        pass  # missing or corrupt — rebuilt on next cache refresh
+
                 finally:
                     conn.close()
         except FileNotFoundError:
@@ -137,14 +154,24 @@ class PersistentRecipeCache:
                     row["file_size"] or 0,
                 )
 
-        return PersistedRecipeData(raw_data=raw_data, file_stats=file_stats)
+        return PersistedRecipeData(
+            raw_data=raw_data,
+            file_stats=file_stats,
+            image_id_map=image_id_map,
+        )
 
-    def save_cache(self, recipes: List[Dict], json_paths: Optional[Dict[str, str]] = None) -> None:
+    def save_cache(
+        self,
+        recipes: List[Dict],
+        json_paths: Optional[Dict[str, str]] = None,
+        image_id_map: Optional[Dict[str, str]] = None,
+    ) -> None:
         """Save all recipes to SQLite cache.
 
         Args:
             recipes: List of recipe dictionaries to persist.
             json_paths: Optional mapping of recipe_id -> json_path for file stats.
+            image_id_map: Optional precomputed civitai image_id → recipe_id mapping.
         """
         if not self.is_enabled():
             return
@@ -185,6 +212,12 @@ class PersistentRecipeCache:
                             recipe_rows,
                         )
 
+                    # Persist image_id_map for O(1) lookups on cache load
+                    conn.execute(
+                        "INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)",
+                        ("image_id_map", json.dumps(image_id_map or {})),
+                    )
+
                     conn.commit()
                     logger.debug("Persisted %d recipes to cache", len(recipe_rows))
                 finally:
@@ -272,6 +305,29 @@ class PersistentRecipeCache:
         except Exception as exc:
             logger.debug("Failed to remove recipe %s from cache: %s", recipe_id, exc)
 
+    def save_image_id_map(self, image_id_map: Dict[str, str]) -> None:
+        """Persist the image_id_map to cache_metadata without rewriting the full cache.
+
+        This is called after ``add_recipe`` / ``remove_recipe`` mutations so
+        the persistent copy does not go stale between full ``save_cache`` calls.
+        """
+        if not self.is_enabled() or not self._schema_initialized:
+            return
+
+        try:
+            with self._db_lock:
+                conn = self._connect()
+                try:
+                    conn.execute(
+                        "INSERT OR REPLACE INTO cache_metadata (key, value) VALUES (?, ?)",
+                        ("image_id_map", json.dumps(image_id_map)),
+                    )
+                    conn.commit()
+                finally:
+                    conn.close()
+        except Exception as exc:
+            logger.debug("Failed to persist image_id_map: %s", exc)
+
     def get_indexed_recipe_ids(self) -> Set[str]:
         """Return all recipe IDs in the cache.
 
@@ -334,6 +390,7 @@ class PersistentRecipeCache:
                             json_path TEXT,
                             title TEXT,
                             folder TEXT,
+                            source_path TEXT,
                             base_model TEXT,
                             fingerprint TEXT,
                             created_date REAL,
@@ -358,6 +415,13 @@ class PersistentRecipeCache:
                         );
                         """
                     )
+                    # Migration: add source_path column to existing databases
+                    try:
+                        conn.execute(
+                            "ALTER TABLE recipes ADD COLUMN source_path TEXT"
+                        )
+                    except Exception:
+                        pass  # column already exists
                     conn.commit()
                 self._schema_initialized = True
             except Exception as exc:
@@ -406,6 +470,7 @@ class PersistentRecipeCache:
             json_path,
             recipe.get("title"),
             recipe.get("folder"),
+            recipe.get("source_path"),
             recipe.get("base_model"),
             recipe.get("fingerprint"),
             float(recipe.get("created_date") or 0.0),
@@ -456,6 +521,7 @@ class PersistentRecipeCache:
             "file_path": row["file_path"] or "",
             "title": row["title"] or "",
             "folder": row["folder"] or "",
+            "source_path": row["source_path"] or "",
             "base_model": row["base_model"] or "",
             "fingerprint": row["fingerprint"] or "",
             "created_date": row["created_date"] or 0.0,

py/services/recipe_cache.py

@@ -1,6 +1,6 @@
 import asyncio
 from typing import Iterable, List, Dict, Optional
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from operator import itemgetter
 from natsort import natsorted
 
@@ -14,6 +14,15 @@ class RecipeCache:
     sorted_by_date: List[Dict]
     folders: List[str] | None = None
     folder_tree: Dict | None = None
+    image_id_map: Dict[str, str] = field(default_factory=dict)
+    """Mapping of civitai image_id → recipe_id, precomputed at cache build time.
+
+    Built once during cache initialization (O(n)) so that
+    ``check_image_exists`` and ``import_from_url`` duplicate checks
+    can look up image_id in O(1) instead of scanning all recipes.
+    Recipes imported from local files have no valid civitai image_id
+    and are naturally excluded from this map.
+    """
 
     def __post_init__(self):
         self._lock = asyncio.Lock()

py/services/recipe_scanner.py

@@ -20,6 +20,7 @@ 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.civitai_utils import extract_civitai_image_id
 from ..utils.utils import calculate_recipe_fingerprint, fuzzy_match
 from natsort import natsorted
 import sys
@@ -65,7 +66,7 @@ class RecipeScanner:
             cls._instance._civitai_client = None  # Will be lazily initialized
         return cls._instance
 
-    REPAIR_VERSION = 3
+    REPAIR_VERSION = 4
 
     def __init__(
         self,
@@ -292,6 +293,32 @@ class RecipeScanner:
         if recipe.get("repair_version", 0) >= self.REPAIR_VERSION:
             return False
 
+        # 1.5 Detect and clear corrupted checkpoint (LoRA data saved as checkpoint).
+        #     A checkpoint whose modelVersionId also appears in a LoRA entry is
+        #     definitely wrong — the CivitAI import code used to pick
+        #     modelVersionIds[0] as the checkpoint, which was often a LoRA.
+        #     Clearing it lets the enrichment flow re-resolve the correct
+        #     checkpoint from CivitAI image metadata.
+        cp = recipe.get("checkpoint")
+        lora_mvids = {
+            l.get("modelVersionId")
+            for l in recipe.get("loras", [])
+            if l.get("modelVersionId")
+        }
+        if cp and cp.get("modelVersionId") and cp["modelVersionId"] in lora_mvids:
+            cp_mvid = cp["modelVersionId"]
+            logger.info(
+                "Recipe %s: checkpoint modelVersionId %s matches a LoRA — "
+                "clearing corrupted checkpoint and removing matching LoRA entry",
+                recipe.get("id"),
+                cp_mvid,
+            )
+            recipe["checkpoint"] = None
+            recipe["loras"] = [
+                l for l in recipe.get("loras", [])
+                if l.get("modelVersionId") != cp_mvid
+            ]
+
         # 2. Identification: Is repair needed?
         has_checkpoint = (
             "checkpoint" in recipe
@@ -504,6 +531,23 @@ class RecipeScanner:
                     self._cache.raw_data = recipes
                     self._update_folder_metadata(self._cache)
                     self._sort_cache_sync()
+                    # Backfill source_path from JSON files if missing (schema migration)
+                    if self._backfill_source_path_if_needed(recipes, json_paths):
+                        self._cache.image_id_map = self._build_image_id_map()
+                        self._persistent_cache.save_cache(
+                            recipes, json_paths, self._cache.image_id_map
+                        )
+                    else:
+                        # Use persisted map, or rebuild if empty (e.g. first startup
+                        # after deploying the image_id_map feature).
+                        if persisted.image_id_map:
+                            self._cache.image_id_map = dict(persisted.image_id_map)
+                        else:
+                            self._cache.image_id_map = self._build_image_id_map()
+                            if self._cache.image_id_map:
+                                self._persistent_cache.save_image_id_map(
+                                    self._cache.image_id_map
+                                )
                     return self._cache
                 else:
                     # Partial update: some files changed
@@ -514,8 +558,13 @@ class RecipeScanner:
                     self._cache.raw_data = recipes
                     self._update_folder_metadata(self._cache)
                     self._sort_cache_sync()
+                    # Backfill source_path from JSON files if missing (schema migration)
+                    self._backfill_source_path_if_needed(recipes, json_paths)
+                    self._cache.image_id_map = self._build_image_id_map()
                     # Persist updated cache
-                    self._persistent_cache.save_cache(recipes, json_paths)
+                    self._persistent_cache.save_cache(
+                        recipes, json_paths, self._cache.image_id_map
+                    )
                     return self._cache
 
             # Fall back to full directory scan
@@ -527,9 +576,12 @@ class RecipeScanner:
             self._cache.raw_data = recipes
             self._update_folder_metadata(self._cache)
             self._sort_cache_sync()
+            self._cache.image_id_map = self._build_image_id_map()
 
             # Persist for next startup
-            self._persistent_cache.save_cache(recipes, json_paths)
+            self._persistent_cache.save_cache(
+                recipes, json_paths, self._cache.image_id_map
+            )
 
             return self._cache
         except Exception as e:
@@ -642,6 +694,34 @@ class RecipeScanner:
 
         return recipes, changed, json_paths
 
+    def _backfill_source_path_if_needed(
+        self,
+        recipes: List[Dict],
+        json_paths: Dict[str, str],
+    ) -> bool:
+        """Backfill source_path from recipe JSON files if missing from cache.
+
+        Returns True if any recipes were updated (caller should persist cache).
+        """
+        updated = False
+        for recipe in recipes:
+            if recipe.get("source_path"):
+                continue
+            recipe_id = str(recipe.get("id", ""))
+            json_path = json_paths.get(recipe_id)
+            if not json_path or not os.path.exists(json_path):
+                continue
+            try:
+                with open(json_path, "r", encoding="utf-8") as f:
+                    json_data = json.load(f)
+                file_source_path = json_data.get("source_path")
+                if file_source_path:
+                    recipe["source_path"] = file_source_path
+                    updated = True
+            except Exception:
+                pass
+        return updated
+
     def _full_directory_scan_sync(
         self, recipes_dir: str
     ) -> Tuple[List[Dict], Dict[str, str]]:
@@ -773,6 +853,28 @@ class RecipeScanner:
         except Exception as e:
             logger.error(f"Error sorting recipe cache: {e}")
 
+    def _build_image_id_map(self) -> Dict[str, str]:
+        """Build civitai image_id → recipe_id mapping from cached recipes.
+
+        Only recipes with a valid CivitAI image URL source_path produce an
+        entry.  Recipes imported from local files are naturally excluded.
+        """
+        mapping: Dict[str, str] = {}
+        if not self._cache:
+            return mapping
+        for recipe in getattr(self._cache, "raw_data", []):
+            if not isinstance(recipe, dict):
+                continue
+            source = recipe.get("source_path")
+            if not source:
+                continue
+            image_id = extract_civitai_image_id(source)
+            if image_id and image_id not in mapping:
+                recipe_id = recipe.get("id")
+                if recipe_id is not None:
+                    mapping[image_id] = str(recipe_id)
+        return mapping
+
     async def _wait_for_lora_scanner(self) -> None:
         """Ensure the LoRA scanner has initialized before recipe enrichment."""
 
@@ -1237,11 +1339,20 @@ class RecipeScanner:
         # Update FTS index
         self._update_fts_index_for_recipe(recipe_data, "add")
 
+        source = recipe_data.get("source_path")
+        if source:
+            image_id = extract_civitai_image_id(source)
+            if image_id:
+                recipe_id_value = recipe_data.get("id")
+                if recipe_id_value is not None:
+                    cache.image_id_map[image_id] = str(recipe_id_value)
+
         # Persist to SQLite cache
         if self._persistent_cache:
             recipe_id = str(recipe_data.get("id", ""))
             json_path = self._json_path_map.get(recipe_id, "")
             self._persistent_cache.update_recipe(recipe_data, json_path)
+            self._persistent_cache.save_image_id_map(cache.image_id_map)
 
     async def remove_recipe(self, recipe_id: str) -> bool:
         """Remove a recipe from the cache by ID."""
@@ -1260,9 +1371,15 @@ class RecipeScanner:
         # Update FTS index
         self._update_fts_index_for_recipe(recipe_id, "remove")
 
+        # Remove any image_id entry pointing to this recipe
+        stale = [k for k, v in cache.image_id_map.items() if v == recipe_id]
+        for k in stale:
+            del cache.image_id_map[k]
+
         # Remove from SQLite cache
         if self._persistent_cache:
             self._persistent_cache.remove_recipe(recipe_id)
+            self._persistent_cache.save_image_id_map(cache.image_id_map)
             self._json_path_map.pop(recipe_id, None)
 
         return True
@@ -1273,14 +1390,21 @@ class RecipeScanner:
         cache = await self.get_cached_data()
         removed = await cache.bulk_remove(recipe_ids, resort=False)
         if removed:
+            removed_ids = {str(r.get("id", "")) for r in removed}
+            stale = [k for k, v in cache.image_id_map.items() if v in removed_ids]
+            for k in stale:
+                del cache.image_id_map[k]
+
             self._schedule_resort()
-            # Update FTS index and persistent cache for each removed recipe
             for recipe in removed:
                 recipe_id = str(recipe.get("id", ""))
                 self._update_fts_index_for_recipe(recipe_id, "remove")
                 if self._persistent_cache:
                     self._persistent_cache.remove_recipe(recipe_id)
                     self._json_path_map.pop(recipe_id, None)
+
+            if self._persistent_cache:
+                self._persistent_cache.save_image_id_map(cache.image_id_map)
         return len(removed)
 
     async def scan_all_recipes(self) -> List[Dict]:
@@ -2484,6 +2608,7 @@ class RecipeScanner:
                 continue
 
             file_name = None
+            folder = ""
             hash_value = (lora.get("hash") or "").lower()
             if (
                 hash_value
@@ -2493,6 +2618,11 @@ class RecipeScanner:
                 file_path = self._lora_scanner._hash_index.get_path(hash_value)
                 if file_path:
                     file_name = os.path.splitext(os.path.basename(file_path))[0]
+                    if lora_cache is not None:
+                        for cached_lora in getattr(lora_cache, "raw_data", []):
+                            if cached_lora.get("file_path") == file_path:
+                                folder = cached_lora.get("folder", "")
+                                break
 
             if not file_name and lora.get("modelVersionId") and lora_cache is not None:
                 for cached_lora in getattr(lora_cache, "raw_data", []):
@@ -2507,13 +2637,16 @@ class RecipeScanner:
                             file_name = os.path.splitext(os.path.basename(cached_path))[
                                 0
                             ]
+                            folder = cached_lora.get("folder", "")
                         break
 
             if not file_name:
                 file_name = lora.get("file_name", "unknown-lora")
+                folder = lora.get("folder", "")
 
+            lora_name = f"{folder}/{file_name}" if folder else file_name
             strength = lora.get("strength", 1.0)
-            syntax_parts.append(f"<lora:{file_name}:{strength}>")
+            syntax_parts.append(f"<lora:{lora_name}:{strength}>")
 
         return syntax_parts
 

py/services/recipes/analysis_service.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import base64
 import io
 import os
@@ -14,6 +15,7 @@ from PIL import Image
 
 from ...utils.utils import calculate_recipe_fingerprint
 from ...utils.civitai_utils import extract_civitai_image_id, rewrite_preview_url
+from ...recipes.enrichment import RecipeEnricher
 from .errors import (
     RecipeDownloadError,
     RecipeNotFoundError,
@@ -144,11 +146,38 @@ class RecipeAnalysisService:
                 ):
                     metadata = metadata["meta"]
 
-                # Include modelVersionIds from root level if available
-                # Civitai API returns modelVersionIds at root level, not in meta
+                # Include modelVersionIds from root level if available.
+                # CivitAI API returns modelVersionIds at root level, not in meta.
+                # When meta is null (None), create a minimal dict so downstream
+                # parsers can still discover LoRAs and checkpoints.
                 model_version_ids = image_info.get("modelVersionIds")
-                if model_version_ids and isinstance(metadata, dict):
-                    metadata["modelVersionIds"] = model_version_ids
+                if model_version_ids:
+                    if isinstance(metadata, dict):
+                        metadata["modelVersionIds"] = model_version_ids
+                    else:
+                        metadata = {"modelVersionIds": model_version_ids}
+
+                # Inject browsingLevel (canonical integer) so the recipe's
+                # preview_nsfw_level can be set, enabling proper NSFW blur
+                # of the preview image.  Fall back to nsfwLevel (string)
+                # when browsingLevel is absent.
+                if isinstance(metadata, dict):
+                    browsing_level = image_info.get("browsingLevel")
+                    nsfw_level_str = image_info.get("nsfwLevel")
+                    if isinstance(browsing_level, int) and browsing_level > 0:
+                        metadata["browsingLevel"] = browsing_level
+                    elif (
+                        isinstance(nsfw_level_str, str)
+                        and nsfw_level_str
+                        in (
+                            "PG", "PG13", "R", "X", "XXX", "Blocked",
+                        )
+                    ):
+                        from ...utils.constants import NSFW_LEVELS
+
+                        metadata["browsingLevel"] = NSFW_LEVELS.get(
+                            nsfw_level_str, 0
+                        )
 
                 # Validate that metadata contains meaningful recipe fields
                 # If not, treat as None to trigger EXIF extraction from downloaded image
@@ -169,17 +198,116 @@ class RecipeAnalysisService:
                 temp_path = self._create_temp_path(suffix=extension)
                 await self._download_image(url, temp_path)
 
-            if metadata is None and not is_video:
-                metadata = self._exif_utils.extract_image_metadata(temp_path)
+            # Always extract EXIF from the downloaded image for generation
+            # params (prompt, negative prompt, sampler, steps, etc.).
+            # Previously this was gated on ``metadata is None``, but that
+            # skipped EXIF entirely when API metadata (modelVersionIds,
+            # browsingLevel) is present, losing all generation parameters.
+            exif_metadata = None
+            if not is_video:
+                exif_metadata = await asyncio.to_thread(
+                    self._exif_utils.extract_image_metadata, temp_path
+                )
 
-            return await self._parse_metadata(
-                metadata or {},
+            # Fallback: try the original (non-optimized) image for EXIF data
+            if not exif_metadata and civitai_image_id and image_info:
+                original_url = image_info.get("url")
+                if original_url:
+                    self._logger.debug(
+                        "Optimized image lacks embedded metadata, "
+                        "falling back to original image: %s",
+                        original_url,
+                    )
+                    orig_temp_path = self._create_temp_path(suffix=".png")
+                    try:
+                        await self._download_image(original_url, orig_temp_path)
+                        exif_metadata = await asyncio.to_thread(
+                            self._exif_utils.extract_image_metadata,
+                            orig_temp_path,
+                        )
+                    finally:
+                        self._safe_cleanup(orig_temp_path)
+
+            # Parse EXIF data (typically a string like parameters/prompt/workflow)
+            # and API metadata (dict with modelVersionIds, browsingLevel) separately,
+            # then merge: API loras/checkpoint override, EXIF gen_params fill in gaps.
+            # This mirrors the two-pass approach in _do_import_from_url.
+            exif_parsed_result = None
+            if isinstance(exif_metadata, str):
+                exif_parser = self._recipe_parser_factory.create_parser(exif_metadata)
+                if exif_parser:
+                    exif_data = await exif_parser.parse_metadata(
+                        exif_metadata, recipe_scanner=recipe_scanner,
+                    )
+                    if exif_data and not exif_data.get("error"):
+                        exif_parsed_result = exif_data
+
+            # Merge API metadata (dict) with EXIF data (if dict) for the
+            # CivitaiApiMetadataParser.  If EXIF data is a string it was
+            # parsed above — don't try to merge a string into a dict.
+            merged = {}
+            if isinstance(exif_metadata, dict):
+                merged.update(exif_metadata)
+            if isinstance(metadata, dict):
+                merged.update(metadata)
+
+            result = await self._parse_metadata(
+                merged,
                 recipe_scanner=recipe_scanner,
                 image_path=temp_path,
                 include_image_base64=True,
                 is_video=is_video,
                 extension=extension,
             )
+
+            # Merge EXIF string-parsed gen_params into the API result.
+            # API gen_params take priority (they come later via update).
+            if exif_parsed_result and not result.payload.get("error"):
+                exif_gp = exif_parsed_result.get("gen_params") or {}
+                result_gp = result.payload.get("gen_params") or {}
+                merged_gp = {**exif_gp, **result_gp}
+                if merged_gp:
+                    result.payload["gen_params"] = merged_gp
+
+            if civitai_image_id and image_info and not result.payload.get("error"):
+                # Use the metadata dict we built (may contain modelVersionIds
+                # and browsingLevel from the API root level).  Do NOT pass
+                # image_info.get("meta") — it is null for images whose meta
+                # lives at the root level only.  Also do NOT derive
+                # model_version_id from modelVersionIds[0] — that array mixes
+                # checkpoints, LoRAs, and other types without ordering
+                # guarantees; the parser already resolved them correctly.
+                recipe_for_enrich = {
+                    "gen_params": result.payload.get("gen_params", {}),
+                    "loras": result.payload.get("loras", []),
+                    "base_model": result.payload.get("base_model", "") or "",
+                    "checkpoint": result.payload.get("checkpoint") or result.payload.get("model"),
+                    "source_path": url,
+                }
+
+                await RecipeEnricher.enrich_recipe(
+                    recipe=recipe_for_enrich,
+                    civitai_client=civitai_client,
+                    request_params=None,
+                    prefetched_civitai_meta_raw=(
+                        metadata if isinstance(metadata, dict) else None
+                    ),
+                    prefetched_model_version_id=None,
+                )
+
+                result.payload["gen_params"] = recipe_for_enrich["gen_params"]
+                if recipe_for_enrich.get("checkpoint"):
+                    result.payload["checkpoint"] = recipe_for_enrich["checkpoint"]
+                if recipe_for_enrich.get("base_model"):
+                    result.payload["base_model"] = recipe_for_enrich["base_model"]
+
+                # Extract browsingLevel from our constructed metadata for NSFW blur
+                if isinstance(metadata, dict):
+                    bl = metadata.get("browsingLevel")
+                    if isinstance(bl, int) and bl > 0:
+                        result.payload["preview_nsfw_level"] = bl
+
+            return result
         finally:
             if temp_path:
                 self._safe_cleanup(temp_path)
@@ -199,7 +327,9 @@ class RecipeAnalysisService:
         if not os.path.isfile(normalized_path):
             raise RecipeNotFoundError("File not found")
 
-        metadata = self._exif_utils.extract_image_metadata(normalized_path)
+        metadata = await asyncio.to_thread(
+            self._exif_utils.extract_image_metadata, normalized_path
+        )
         if not metadata:
             return self._metadata_not_found_response(normalized_path)
 
@@ -259,6 +389,10 @@ class RecipeAnalysisService:
             "prompt_type",
             "positive",
             "negative",
+            # modelVersionIds is injected at the root level by CivitAI's image
+            # API when meta is null. It carries the version IDs of ALL models
+            # (checkpoint + LoRAs) used to generate the image.
+            "modelVersionIds",
         }
         return any(field in metadata for field in recipe_fields)
 

py/services/recipes/persistence_service.py

@@ -49,8 +49,18 @@ class RecipePersistenceService:
         tags: Iterable[str],
         metadata: Optional[dict[str, Any]],
         extension: str | None = None,
+        recipe_id: str | None = None,
+        target_dir: str | None = None,
     ) -> PersistenceResult:
-        """Persist a user uploaded recipe."""
+        """Persist a user uploaded recipe.
+
+        Args:
+            recipe_id: If provided, reuse this ID instead of generating a new
+                UUID. Used by re-import to preserve the original recipe identity.
+            target_dir: If provided, save recipe files to this directory instead
+                of the default recipes_dir. Used by re-import to preserve the
+                original folder location.
+        """
 
         missing_fields = []
         if not name:
@@ -63,10 +73,10 @@ class RecipePersistenceService:
             )
 
         resolved_image_bytes = self._resolve_image_bytes(image_bytes, image_base64)
-        recipes_dir = recipe_scanner.recipes_dir
+        recipes_dir = target_dir or recipe_scanner.recipes_dir
         os.makedirs(recipes_dir, exist_ok=True)
 
-        recipe_id = str(uuid.uuid4())
+        recipe_id = recipe_id or str(uuid.uuid4())
         
         # Handle video formats by bypassing optimization and metadata embedding
         is_video = extension in [".mp4", ".webm"]
@@ -115,6 +125,22 @@ class RecipePersistenceService:
         if metadata.get("source_path"):
             recipe_data["source_path"] = metadata.get("source_path")
 
+        nsfw_level = metadata.get("preview_nsfw_level")
+        if nsfw_level is not None and isinstance(nsfw_level, int):
+            recipe_data["preview_nsfw_level"] = nsfw_level
+
+        # Compute recipe folder relative to recipes root, mirroring
+        # RecipeScanner._calculate_folder() which is only called during scan/load.
+        if recipe_scanner.recipes_dir:
+            recipe_file_dir = os.path.dirname(normalized_image_path)
+            try:
+                relative_folder = os.path.relpath(recipe_file_dir, recipe_scanner.recipes_dir)
+                if relative_folder in (".", ""):
+                    relative_folder = ""
+                recipe_data["folder"] = relative_folder.replace(os.path.sep, "/")
+            except Exception:
+                recipe_data["folder"] = ""
+
         json_filename = f"{recipe_id}.recipe.json"
         json_path = os.path.join(recipes_dir, json_filename)
         json_path = os.path.normpath(json_path)

py/services/service_registry.py

@@ -188,6 +188,25 @@ class ServiceRegistry:
             logger.debug(f"Created and registered {service_name}")
             return service
 
+    @classmethod
+    async def get_download_queue_service(cls):
+        """Get or create the download queue service."""
+        service_name = "download_queue_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 .download_queue_service import DownloadQueueService
+
+            service = await DownloadQueueService.get_instance()
+            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."""

py/services/settings_manager.py

@@ -91,20 +91,27 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "autoplay_on_hover": False,
     "display_density": "default",
     "card_info_display": "always",
-    "show_folder_sidebar": True,
     "include_trigger_words": False,
     "compact_mode": False,
     "priority_tags": DEFAULT_PRIORITY_TAG_CONFIG.copy(),
     "model_name_display": "model_name",
+    "lora_syntax_format": "legacy",
     "model_card_footer_action": "replace_preview",
     "show_version_on_card": True,
-    "update_flag_strategy": "same_base",
+    "version_grouping": "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,
+    "use_new_license_icons": True,
+    "group_by_model": False,
+    # AI / LLM provider configuration (BYOK)
+    "llm_provider": "openai",  # "openai" | "ollama" | "custom"
+    "llm_api_key": "",
+    "llm_api_base": "",  # empty = provider default
+    "llm_model": "",  # e.g. "gpt-4o-mini"
 }
 
 
@@ -133,6 +140,9 @@ class SettingsManager:
         self._template_path = (
             Path(__file__).resolve().parents[2] / "settings.json.example"
         )
+        # Known placeholder value in settings.json.example; any file containing
+        # this value should be treated as "not configured".
+        self._TEMPLATE_PLACEHOLDER_API_KEY = "your_civitai_api_key_here"
         self.settings = self._load_settings()
         self._migrate_setting_keys()
         self._ensure_default_settings()
@@ -164,6 +174,12 @@ class SettingsManager:
                     self._original_disk_payload = copy.deepcopy(data)
                     if self._matches_template_payload(data):
                         self._preserve_disk_template = True
+                    # Clean up the template placeholder so it is not treated
+                    # as a real key (affects both the frontend boolean and
+                    # the downloader's Authorization header).
+                    placeholder = self._TEMPLATE_PLACEHOLDER_API_KEY
+                    if data.get("civitai_api_key") == placeholder:
+                        data["civitai_api_key"] = ""
                 return data
             except json.JSONDecodeError as exc:
                 logger.error("Failed to parse settings.json: %s", exc)
@@ -734,6 +750,7 @@ class SettingsManager:
             "includeTriggerWords": "include_trigger_words",
             "compactMode": "compact_mode",
             "modelCardFooterAction": "model_card_footer_action",
+            "update_flag_strategy": "version_grouping",
         }
 
         updated = False
@@ -861,6 +878,23 @@ class SettingsManager:
             self.settings["civitai_api_key"] = env_api_key
             self._save_settings()
 
+        # LLM provider overrides
+        llm_env_map = {
+            "LLM_API_KEY": "llm_api_key",
+            "LLM_MODEL": "llm_model",
+            "LLM_API_BASE": "llm_api_base",
+            "LLM_PROVIDER": "llm_provider",
+        }
+        llm_changed = False
+        for env_var, settings_key in llm_env_map.items():
+            env_val = os.environ.get(env_var)
+            if env_val:
+                logger.info("Found %s environment variable", env_var)
+                self.settings[settings_key] = env_val
+                llm_changed = True
+        if llm_changed:
+            self._save_settings()
+
     def _default_settings_actions(self) -> List[Dict[str, Any]]:
         return [
             {
@@ -1556,7 +1590,7 @@ class SettingsManager:
         previous_dir = os.path.dirname(previous_path) or target_dir
 
         if os.path.abspath(previous_path) != os.path.abspath(target_path):
-            self._copy_model_cache_directory(previous_dir, target_dir)
+            self._migrate_settings_directory_content(previous_dir, target_dir)
             logger.info("Switching settings file to: %s", target_path)
 
         self._pending_portable_switch = {"other_path": other_path}
@@ -1591,46 +1625,52 @@ class SettingsManager:
         finally:
             self._pending_portable_switch = None
 
-    def _copy_model_cache_directory(self, source_dir: str, target_dir: str) -> None:
-        """Copy model_cache artifacts when switching storage locations."""
+    def _migrate_settings_directory_content(
+        self, source_dir: str, target_dir: str
+    ) -> None:
+        """Migrate settings directory subdirectories when switching storage locations.
+
+        Copies the canonical subdirectories (cache, backups, logs, stats, wildcards)
+        from the old settings directory to the new one. Legacy cache artifacts
+        (model_cache, recipe_cache, etc.) are migrated lazily by
+        ``resolve_cache_path_with_migration`` on first access.
+
+        Args:
+            source_dir: The previous settings directory path.
+            target_dir: The new settings directory path.
+        """
 
         if not source_dir or not target_dir:
             return
 
-        source_cache_dir = os.path.join(source_dir, "model_cache")
-        target_cache_dir = os.path.join(target_dir, "model_cache")
-        if os.path.isdir(source_cache_dir) and os.path.abspath(
-            source_cache_dir
-        ) != os.path.abspath(target_cache_dir):
-            try:
-                shutil.copytree(
-                    source_cache_dir,
-                    target_cache_dir,
-                    dirs_exist_ok=True,
-                    ignore=shutil.ignore_patterns("*.sqlite-shm", "*.sqlite-wal"),
-                )
-            except Exception as exc:
-                logger.warning(
-                    "Failed to copy model_cache directory from %s to %s: %s",
-                    source_cache_dir,
-                    target_cache_dir,
-                    exc,
-                )
+        def _copy_dir(name: str) -> None:
+            source = os.path.join(source_dir, name)
+            target = os.path.join(target_dir, name)
+            if os.path.isdir(source) and os.path.abspath(source) != os.path.abspath(
+                target
+            ):
+                try:
+                    shutil.copytree(
+                        source,
+                        target,
+                        dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns("*.sqlite-shm", "*.sqlite-wal"),
+                    )
+                except Exception as exc:
+                    logger.warning(
+                        "Failed to copy directory %s from %s to %s: %s",
+                        name,
+                        source,
+                        target,
+                        exc,
+                    )
 
-        source_cache_file = os.path.join(source_dir, "model_cache.sqlite")
-        target_cache_file = os.path.join(target_dir, "model_cache.sqlite")
-        if os.path.isfile(source_cache_file) and os.path.abspath(
-            source_cache_file
-        ) != os.path.abspath(target_cache_file):
-            try:
-                shutil.copy2(source_cache_file, target_cache_file)
-            except Exception as exc:
-                logger.warning(
-                    "Failed to copy model_cache.sqlite from %s to %s: %s",
-                    source_cache_file,
-                    target_cache_file,
-                    exc,
-                )
+        # Managed subdirectories under settings_dir
+        _copy_dir("cache")
+        _copy_dir("backups")
+        _copy_dir("logs")
+        _copy_dir("stats")
+        _copy_dir("wildcards")
 
     def _get_user_config_directory(self) -> str:
         """Return the user configuration directory, falling back to ~/.config."""

py/services/tag_update_service.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 import os
 
-from typing import Awaitable, Callable, Dict, List, Sequence
+from typing import Awaitable, Callable, Dict, List, Sequence, Tuple
+
+from .auto_tag_service import extract_auto_tags
 
 
 class TagUpdateService:
@@ -20,9 +22,8 @@ class TagUpdateService:
         new_tags: Sequence[str],
         metadata_loader: Callable[[str], Awaitable[Dict[str, object]]],
         update_cache: Callable[[str, str, Dict[str, object]], Awaitable[bool]],
-    ) -> List[str]:
-        """Add tags to a metadata entry while keeping case-insensitive uniqueness."""
-
+    ) -> Tuple[List[str], List[str]]:
+        """Add tags to a metadata entry and return updated tags and auto_tags."""
         base, _ = os.path.splitext(file_path)
         metadata_path = f"{base}.metadata.json"
         metadata = await metadata_loader(metadata_path)
@@ -35,14 +36,15 @@ class TagUpdateService:
             if isinstance(tag, str) and tag.strip():
                 # Convert all tags to lowercase to avoid case sensitivity issues on Windows
                 normalized = tag.strip().lower()
-                if normalized.lower() not in existing_lower:
+                if normalized not in existing_lower:
                     existing_tags.append(normalized)
-                    existing_lower.append(normalized.lower())
+                    existing_lower.append(normalized)
                     tags_added.append(normalized)
 
         metadata["tags"] = existing_tags
         await self._metadata_manager.save_metadata(file_path, metadata)
         await update_cache(file_path, file_path, metadata)
 
-        return existing_tags
+        auto_tags = extract_auto_tags(metadata)
+        return existing_tags, auto_tags
 

py/services/use_cases/bulk_metadata_refresh_use_case.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import time
 from typing import Any, Dict, List, Optional, Protocol, Sequence
 
 from ..metadata_sync_service import MetadataSyncService
@@ -62,26 +63,48 @@ class BulkMetadataRefreshUseCase:
         ]
 
         total_to_process = len(to_process)
+        initial_skipped = total_models - total_to_process  # models excluded from fetch queue
         processed = 0
         success = 0
+        skipped_count = initial_skipped
+        handled_count = initial_skipped
         needs_resort = False
+        start_time = time.monotonic()
+        failures: List[Dict[str, str]] = []
 
         self._service.scanner.reset_cancellation()
 
         async def emit(status: str, **extra: Any) -> None:
             if progress_callback is None:
                 return
-            payload = {"status": status, "total": total_to_process, "processed": processed, "success": success}
+            payload = {
+                "status": status,
+                "total": total_models,
+                "processed": processed,
+                "success": success,
+                "failure_count": len(failures),
+                "skipped_count": skipped_count,
+                "handled": handled_count,
+                "elapsed_seconds": int(time.monotonic() - start_time),
+            }
+            # Only include full failure details in terminal emits (completed,
+            # cancelled, rate_limited) to avoid serializing the list on every
+            # per-model progress update.
+            if failures and status in ("completed", "cancelled", "rate_limited"):
+                payload["failures"] = failures
             payload.update(extra)
             await progress_callback.on_progress(payload)
 
         await emit("started")
 
+        RATE_LIMIT_ABORT_THRESHOLD = 3
+        consecutive_rate_limits = 0
+
         for model in to_process:
             if self._service.scanner.is_cancelled():
                 self._logger.info("Bulk metadata refresh cancelled by user")
                 await emit("cancelled", processed=processed, success=success)
-                return {"success": False, "message": "Operation cancelled", "processed": processed, "updated": success, "total": total_models}
+                return {"success": False, "message": "Operation cancelled", "processed": processed, "updated": success, "total": total_models, "failures": failures, "failure_count": len(failures), "skipped_count": skipped_count, "elapsed_seconds": int(time.monotonic() - start_time)}
             try:
                 original_name = model.get("model_name")
 
@@ -101,31 +124,76 @@ class BulkMetadataRefreshUseCase:
                             model["hash_status"] = "completed"
                         else:
                             self._logger.error(f"Failed to calculate hash for {file_path}")
+                            failures.append({"name": model.get("model_name", file_path or "Unknown"), "error": "Failed to calculate hash"})
                             processed += 1
+                            handled_count += 1
                             continue
                     else:
                         self._logger.warning(f"Scanner does not support lazy hash calculation for {file_path}")
+                        skipped_count += 1
                         processed += 1
+                        handled_count += 1
                         continue
 
                 # Skip models without valid hash
                 if not model.get("sha256"):
                     self._logger.warning(f"Skipping model without hash: {file_path}")
+                    skipped_count += 1
                     processed += 1
+                    handled_count += 1
                     continue
 
                 await MetadataManager.hydrate_model_data(model)
-                result, _ = await self._metadata_sync.fetch_and_update_model(
+                result, error_msg = await self._metadata_sync.fetch_and_update_model(
                     sha256=model["sha256"],
                     file_path=model["file_path"],
                     model_data=model,
                     update_cache_func=self._service.scanner.update_single_model_cache,
                 )
+
+                if not result and error_msg and "Rate limited" in error_msg:
+                    consecutive_rate_limits += 1
+                else:
+                    consecutive_rate_limits = 0
+
+                if not result:
+                    current_name = model.get("model_name", file_path or "Unknown")
+                    failures.append({"name": current_name, "error": error_msg or "Unknown error"})
+                    self._logger.warning("Failed to fetch metadata for %s: %s", current_name, error_msg)
+
+                if consecutive_rate_limits >= RATE_LIMIT_ABORT_THRESHOLD:
+                    # The current model was attempted and failed due to rate limiting;
+                    # count it before aborting so the summary is consistent.
+                    processed += 1
+                    handled_count += 1
+                    self._logger.warning(
+                        "Bulk metadata refresh aborted: %d consecutive rate limits detected. "
+                        "Processed %d/%d models.",
+                        consecutive_rate_limits,
+                        processed,
+                        total_to_process,
+                    )
+                    await emit(
+                        "rate_limited",
+                    )
+                    return {
+                        "success": False,
+                        "message": f"Rate limit detected; {total_to_process - processed} models skipped",
+                        "processed": processed,
+                        "updated": success,
+                        "total": total_models,
+                        "failures": failures,
+                        "failure_count": len(failures),
+                        "skipped_count": skipped_count,
+                        "elapsed_seconds": int(time.monotonic() - start_time),
+                    }
+
                 if result:
                     success += 1
                     if original_name != model.get("model_name"):
                         needs_resort = True
                 processed += 1
+                handled_count += 1
                 await emit(
                     "processing",
                     processed=processed,
@@ -134,6 +202,9 @@ class BulkMetadataRefreshUseCase:
                 )
             except Exception as exc:  # pragma: no cover - logging path
                 processed += 1
+                handled_count += 1
+                current_name = model.get("model_name", model.get("file_path", "Unknown"))
+                failures.append({"name": current_name, "error": str(exc)})
                 self._logger.error(
                     "Error fetching CivitAI data for %s: %s",
                     model.get("file_path"),
@@ -150,7 +221,7 @@ class BulkMetadataRefreshUseCase:
             f"{success} of {processed} processed {self._service.model_type}s (total: {total_models})"
         )
 
-        return {"success": True, "message": message, "processed": processed, "updated": success, "total": total_models}
+        return {"success": True, "message": message, "processed": processed, "updated": success, "total": total_models, "failures": failures, "failure_count": len(failures), "skipped_count": skipped_count, "elapsed_seconds": int(time.monotonic() - start_time)}
 
     @staticmethod
     def _is_in_skip_path(folder: str, skip_paths: List[str]) -> bool:

py/utils/civitai_utils.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Iterable, Mapping, Sequence
 from urllib.parse import parse_qs, urlparse, urlunparse
 
 
-_SUPPORTED_CIVITAI_PAGE_HOSTS = frozenset({"civitai.com", "civitai.red"})
+_SUPPORTED_CIVITAI_PAGE_HOSTS = frozenset({"civitai.com", "civitai.red", "civitai.green"})
 DEFAULT_CIVITAI_PAGE_HOST = "civitai.com"
 _DEFAULT_ALLOW_COMMERCIAL_USE: Sequence[str] = ("Sell",)
 _LICENSE_DEFAULTS: Dict[str, Any] = {
@@ -66,6 +66,46 @@ def build_civitai_model_page_url(
     return None
 
 
+_RE_CDN_IMAGE_ID = re.compile(r"/(\d+)\.(?:jpeg|jpg|png|webp|gif)(?:\?|#|$)")
+
+
+def extract_civitai_image_id_from_cdn_url(url: str | None) -> str | None:
+    """Extract the numeric image ID from a Cloudflare CDN image URL.
+
+    CivitAI image CDN URLs follow the pattern::
+
+        https://image.civitai.com/{cf_uuid}/{params}/{image_id}.{ext}
+
+    The image database ID is always the last path segment (minus extension)
+    because ``getEdgeUrl(…, name=id.toString())`` embeds it explicitly
+    in the model-versions REST API response.
+    """
+    if not url:
+        return None
+    match = _RE_CDN_IMAGE_ID.search(url)
+    return match.group(1) if match else None
+
+
+def build_civitai_image_page_url(
+    image_id: str | int | None,
+    *,
+    host: str | None = None,
+) -> str | None:
+    """Build a Civitai image page URL.
+
+    Returns something like ``https://civitai.com/images/12345``.
+    The host is resolved through :func:`normalize_civitai_page_host` and
+    therefore respects the user's ``civitai_host`` setting.
+    """
+    if not image_id:
+        return None
+    normalized_host = normalize_civitai_page_host(host)
+    normalized_id = str(image_id).strip()
+    if not normalized_id:
+        return None
+    return urlunparse(("https", normalized_host, f"/images/{normalized_id}", "", "", ""))
+
+
 def _parse_supported_civitai_page_url(url: str | None):
     if not url:
         return None
@@ -239,9 +279,9 @@ def _resolve_commercial_bits(values: Sequence[str]) -> int:
             normalized_values.add(normalized)
 
     has_sell = "sell" in normalized_values
-    has_rent = has_sell or "rent" in normalized_values
-    has_rentcivit = has_rent or "rentcivit" in normalized_values
-    has_image = has_sell or "image" in normalized_values
+    has_rent = "rent" in normalized_values
+    has_rentcivit = "rentcivit" in normalized_values
+    has_image = "image" in normalized_values
 
     commercial_bits = (
         (1 if has_sell else 0) << 3
@@ -328,8 +368,10 @@ def rewrite_preview_url(
 
 
 __all__ = [
+    "build_civitai_image_page_url",
     "build_license_flags",
     "extract_civitai_image_id",
+    "extract_civitai_image_id_from_cdn_url",
     "extract_civitai_page_host",
     "extract_civitai_model_url_parts",
     "is_supported_civitai_page_host",

py/utils/constants.py

@@ -31,6 +31,8 @@ PREVIEW_EXTENSIONS = [
     ".mp4",
     ".gif",
     ".webm",
+    ".avif",
+    ".jxl",
 ]
 
 # Card preview image width
@@ -41,10 +43,24 @@ EXAMPLE_IMAGE_WIDTH = 832
 
 # Supported media extensions for example downloads
 SUPPORTED_MEDIA_EXTENSIONS = {
-    "images": [".jpg", ".jpeg", ".png", ".webp", ".gif"],
+    "images": [".jpg", ".jpeg", ".png", ".webp", ".gif", ".avif", ".jxl"],
     "videos": [".mp4", ".webm"],
 }
 
+# Model weight file extensions recognised by scanners.
+# This is the union of all scanner extensions (lora, checkpoint, embedding).
+MODEL_FILE_EXTENSIONS = {
+    ".safetensors",
+    ".ckpt",
+    ".pt",
+    ".pt2",
+    ".bin",
+    ".pth",
+    ".pkl",
+    ".sft",
+    ".gguf",
+}
+
 # Valid sub-types for each scanner type
 VALID_LORA_SUB_TYPES = ["lora", "locon", "dora"]
 VALID_CHECKPOINT_SUB_TYPES = ["checkpoint", "diffusion_model"]
@@ -101,8 +117,34 @@ DEFAULT_PRIORITY_TAG_CONFIG = {
 DIFFUSION_MODEL_BASE_MODELS = frozenset(
     [
         "Anima",
-        "ZImageTurbo",
-        "ZImageBase",
+        # Flux series — DiT architecture, loaded via UNETLoader in ComfyUI
+        "Flux.1 D",
+        "Flux.1 S",
+        "Flux.1 Krea",
+        "Flux.1 Kontext",
+        "Flux.2 D",
+        "Flux.2 Klein 9B",
+        "Flux.2 Klein 9B-base",
+        "Flux.2 Klein 4B",
+        "Flux.2 Klein 4B-base",
+        # Non-UNet / DiT image diffusion models
+        "AuraFlow",
+        "Chroma",
+        "HiDream",
+        "Hunyuan 1",
+        "Kolors",
+        "Lumina",
+        "PixArt a",
+        "PixArt E",
+        # Video diffusion models
+        "CogVideoX",
+        "Hunyuan Video",
+        "LTXV",
+        "LTXV2",
+        "LTXV 2.3",
+        "Mochi",
+        "SVD",
+        "Wan Video",
         "Wan Video 1.3B t2v",
         "Wan Video 14B t2v",
         "Wan Video 14B i2v 480p",
@@ -112,9 +154,15 @@ DIFFUSION_MODEL_BASE_MODELS = frozenset(
         "Wan Video 2.2 T2V-A14B",
         "Wan Video 2.5 T2V",
         "Wan Video 2.5 I2V",
-        "CogVideoX",
-        "Mochi",
+        # Other diffusion models
+        "Ernie",
+        "Ernie Turbo",
+        "Nucleus",
         "Qwen",
+        "ZImageBase",
+        "ZImageTurbo",
+        # Krea 2 — loaded via UNETLoader in ComfyUI
+        "Krea 2",
     ]
 )
 
@@ -181,5 +229,6 @@ SUPPORTED_DOWNLOAD_SKIP_BASE_MODELS = frozenset(
         "Ernie",
         "Ernie Turbo",
         "Nucleus",
+        "Krea 2",
     ]
 )

py/utils/example_images_download_manager.py

@@ -397,13 +397,12 @@ class DownloadManager:
 
             models_with_hash = len(all_models_with_hash)
 
-            # Calculate pending count: check which models actually need processing
-            # A model is pending if it has a hash, is not in processed_models,
-            # and its folder doesn't exist or is empty
+            # Calculate pending count: check which models actually need processing.
+            # A model is pending if it has a hash, is not already processed or known-failed,
+            # and its folder doesn't exist or is empty.
             pending_hashes = set()
             for model_hash, model_name in all_models_with_hash:
-                if model_hash not in processed_models:
-                    # Check if model folder exists with files
+                if model_hash not in processed_models and model_hash not in failed_models:
                     model_dir = ExampleImagePathResolver.get_model_folder(
                         model_hash, active_library
                     )

py/utils/example_images_metadata.py

@@ -452,3 +452,111 @@ class MetadataUpdater:
         except Exception as e:
             logger.error(f"Error parsing image metadata: {e}", exc_info=True)
             return None
+
+    @staticmethod
+    async def prune_stale_example_images(metadata) -> bool:
+        """Remove example-image metadata entries whose files no longer exist on disk.
+
+        Checks ``civitai.customImages`` (by ``id``) and ``civitai.images`` entries
+        that have an empty ``url`` (no remote fallback) against actual files in
+        the model's example-image folder.  Stale entries are removed in-place so
+        the caller can persist the cleaned metadata afterwards.
+
+        Args:
+            metadata: A ``BaseModelMetadata`` instance (modified in place).
+
+        Returns:
+            True if at least one entry was removed.
+        """
+        from ..utils.example_images_paths import get_model_folder
+
+        model_hash = getattr(metadata, "sha256", None)
+        if not model_hash:
+            return False
+
+        model_folder = get_model_folder(model_hash)
+        if not model_folder:
+            return False
+
+        civitai = getattr(metadata, "civitai", None)
+        if not isinstance(civitai, dict):
+            return False
+
+        has_changes = False
+
+        custom_images = civitai.get("customImages")
+        if isinstance(custom_images, list) and custom_images:
+            stale: list[int] = []
+
+            for idx, img in enumerate(custom_images):
+                img_id = img.get("id", "")
+                if not img_id:
+                    continue
+
+                if not os.path.isdir(model_folder):
+                    stale.append(idx)
+                else:
+                    found = False
+                    try:
+                        prefix = f"custom_{img_id}"
+                        for fname in os.listdir(model_folder):
+                            if fname.startswith(prefix) and os.path.isfile(
+                                os.path.join(model_folder, fname)
+                            ):
+                                found = True
+                                break
+                    except OSError:
+                        stale.append(idx)
+                        continue
+
+                    if not found:
+                        stale.append(idx)
+
+            if stale:
+                for idx in reversed(stale):
+                    custom_images.pop(idx)
+                has_changes = True
+                logger.info(
+                    "Pruned %d stale custom image(s) for %s",
+                    len(stale),
+                    getattr(metadata, "model_name", model_hash),
+                )
+
+        images = civitai.get("images")
+        if isinstance(images, list) and images:
+            stale: list[int] = []
+
+            for idx, img in enumerate(images):
+                if img.get("url", ""):
+                    # Has a remote fallback – keep it even if the local copy
+                    # is gone.
+                    continue
+
+                if not os.path.isdir(model_folder):
+                    stale.append(idx)
+                else:
+                    found = False
+                    try:
+                        prefix = f"image_{idx}."
+                        for fname in os.listdir(model_folder):
+                            if fname.startswith(prefix):
+                                found = True
+                                break
+                    except OSError:
+                        stale.append(idx)
+                        continue
+
+                    if not found:
+                        stale.append(idx)
+
+            if stale:
+                for idx in reversed(stale):
+                    images.pop(idx)
+                has_changes = True
+                logger.info(
+                    "Pruned %d stale image entry(ies) for %s",
+                    len(stale),
+                    getattr(metadata, "model_name", model_hash),
+                )
+
+        return has_changes

py/utils/example_images_paths.py

@@ -12,6 +12,18 @@ from ..services.settings_manager import get_settings_manager
 
 _HEX_PATTERN = re.compile(r"[a-fA-F0-9]{64}")
 
+# Filesystem/metadata files that are never created by the example images system
+# and are safe to ignore during validation. The cleanup service only operates on
+# directories, so these files pose no data-loss risk.
+_SAFE_FILENAMES: frozenset[str] = frozenset({
+    ".DS_Store",       # macOS folder metadata
+    "Thumbs.db",       # Windows thumbnail cache
+    "desktop.ini",     # Windows folder customization
+    ".localized",      # macOS folder name localization
+    ".gitkeep",        # Placeholder to keep empty dirs in git
+    ".gitignore",      # Git ignore rules
+})
+
 logger = logging.getLogger(__name__)
 
 
@@ -180,6 +192,22 @@ def is_hash_folder(name: str) -> bool:
     return bool(_HEX_PATTERN.fullmatch(name or ""))
 
 
+def _is_safe_ignorable_entry(item: str, item_path: str) -> bool:
+    """Return True if *item* is a harmless system/hidden file we can skip.
+
+    These files are never created by the example images system and are safe to
+    ignore because the cleanup/delete operations only act on **directories**,
+    never on individual files (other than ``.download_progress.json``).
+    """
+    if item in _SAFE_FILENAMES:
+        return True
+    # Hide Unix hidden files (dotfiles) that are regular files,
+    # since the cleanup system never deletes or moves files.
+    if item.startswith(".") and os.path.isfile(item_path):
+        return True
+    return False
+
+
 def is_valid_example_images_root(folder_path: str) -> bool:
     """Check whether a folder looks like a dedicated example images root."""
 
@@ -190,9 +218,16 @@ def is_valid_example_images_root(folder_path: str) -> bool:
 
     for item in items:
         item_path = os.path.join(folder_path, item)
+
+        # .download_progress.json is an expected metadata file — check before
+        # the generic dotfile rule so it stays explicitly documented.
         if item == ".download_progress.json" and os.path.isfile(item_path):
             continue
 
+        # Skip harmless system/hidden files — cleanup only touches directories
+        if _is_safe_ignorable_entry(item, item_path):
+            continue
+
         if os.path.isdir(item_path):
             if is_hash_folder(item):
                 continue
@@ -211,6 +246,41 @@ def is_valid_example_images_root(folder_path: str) -> bool:
     return True
 
 
+def find_non_compliant_items_in_example_images_root(folder_path: str) -> list[str]:
+    """Return the names of items that prevent *folder_path* from being a valid
+    example images root, or an empty list if the folder is valid.
+
+    This mirrors ``is_valid_example_images_root`` but **returns** the offending
+    names instead of a boolean, so callers can produce actionable error messages.
+    """
+    try:
+        items = os.listdir(folder_path)
+    except OSError as exc:
+        return [f"<cannot list directory: {exc}>"]
+
+    offending: list[str] = []
+
+    for item in items:
+        item_path = os.path.join(folder_path, item)
+
+        # Same skip rules as is_valid_example_images_root
+        if item == ".download_progress.json" and os.path.isfile(item_path):
+            continue
+        if _is_safe_ignorable_entry(item, item_path):
+            continue
+        if os.path.isdir(item_path):
+            if is_hash_folder(item):
+                continue
+            if item == "_deleted":
+                continue
+            if _library_folder_has_only_hash_dirs(item_path):
+                continue
+
+        offending.append(item)
+
+    return offending
+
+
 def _library_folder_has_only_hash_dirs(path: str) -> bool:
     """Return True when a library subfolder only contains hash folders or metadata files."""
 

py/utils/example_images_processor.py

@@ -62,6 +62,10 @@ class ExampleImagesProcessor:
                 return '.gif'
             elif content.startswith(b'RIFF') and b'WEBP' in content[:12]:
                 return '.webp'
+            elif len(content) >= 12 and content[4:8] == b'ftyp' and b'avif' in content[8:24]:
+                return '.avif'
+            elif content.startswith(b'\x00\x00\x00\x0cJXL \x0d\x0a\x87\x0a'):
+                return '.jxl'
             elif content.startswith(b'\x00\x00\x00\x18ftypmp4') or content.startswith(b'\x00\x00\x00\x20ftypmp4'):
                 return '.mp4'
             elif content.startswith(b'\x1A\x45\xDF\xA3'):
@@ -75,6 +79,8 @@ class ExampleImagesProcessor:
                 'image/png': '.png',
                 'image/gif': '.gif',
                 'image/webp': '.webp',
+                'image/avif': '.avif',
+                'image/jxl': '.jxl',
                 'video/mp4': '.mp4',
                 'video/webm': '.webm',
                 'video/quicktime': '.mov'

py/utils/exif_utils.py

@@ -1,17 +1,125 @@
 import json
 import logging
 import os
+import struct
 from io import BytesIO
 from typing import Any, Optional
 
 import piexif
 from PIL import Image, PngImagePlugin
 
+try:
+    import brotli
+    _BROTLI_AVAILABLE = True
+except ImportError:
+    brotli = None
+    _BROTLI_AVAILABLE = False
+
 logger = logging.getLogger(__name__)
 
 class ExifUtils:
     """Utility functions for working with EXIF data in images"""
 
+    @staticmethod
+    def _parse_isobmff_boxes(data: bytes, offset: int = 0) -> list[dict]:
+        boxes = []
+        while offset + 8 <= len(data):
+            size = struct.unpack('>I', data[offset:offset + 4])[0]
+            box_type = data[offset + 4:offset + 8]
+            if size == 0:
+                break
+            if size < 8 or offset + size > len(data):
+                break
+            box_data = data[offset + 8:offset + size]
+            boxes.append({'type': box_type, 'data': box_data, 'size': size})
+            offset += size
+        return boxes
+
+    @staticmethod
+    def _is_jxl_container(data: bytes) -> bool:
+        if len(data) < 32:
+            return False
+        return (
+            struct.unpack('>I', data[:4])[0] == 12
+            and data[4:8] == b'JXL '
+            and data[8:12] == bytes([0x0d, 0x0a, 0x87, 0x0a])
+            and struct.unpack('>I', data[12:16])[0] >= 16
+            and data[16:20] == b'ftyp'
+            and data[20:24] == b'jxl '
+        )
+
+    @staticmethod
+    def _is_avif_container(data: bytes) -> bool:
+        if len(data) < 16:
+            return False
+        for box in ExifUtils._parse_isobmff_boxes(data):
+            if box['type'] == b'ftyp' and b'avif' in box['data']:
+                return True
+        return False
+
+    # Max decompressed size for brotli metadata (2 MB)
+    _BROTLI_MAX_DECOMPRESSED = 2 * 1024 * 1024
+
+    @staticmethod
+    def _extract_isobmff_brotli(image_path: str) -> Optional[dict]:
+        try:
+            with open(image_path, 'rb') as f:
+                data = f.read()
+        except Exception:
+            return None
+
+        if ExifUtils._is_jxl_container(data):
+            boxes = ExifUtils._parse_isobmff_boxes(data, offset=12)
+        elif ExifUtils._is_avif_container(data):
+            boxes = ExifUtils._parse_isobmff_boxes(data)
+        else:
+            return None
+
+        brob = None
+        for box in boxes:
+            if box['type'] == b'brob':
+                brob = box
+                break
+        if brob is None:
+            return None
+
+        payload = brob['data']
+        if payload[:4] != b'comf':
+            return None
+        compressed = payload[4:]
+
+        if _BROTLI_AVAILABLE:
+            try:
+                decompressed = brotli.decompress(compressed)
+                if len(decompressed) > ExifUtils._BROTLI_MAX_DECOMPRESSED:
+                    logger.warning(
+                        "Brotli metadata too large (%d bytes, max %d), ignoring",
+                        len(decompressed),
+                        ExifUtils._BROTLI_MAX_DECOMPRESSED,
+                    )
+                    decompressed = None
+            except Exception:
+                decompressed = None
+        else:
+            decompressed = None
+
+        raw = decompressed if decompressed is not None else compressed
+        try:
+            meta = json.loads(raw.decode('utf-8'))
+        except Exception:
+            return None
+
+        result = {"parameters": None, "prompt": None, "workflow": None, "comment": None}
+        if isinstance(meta.get("prompt"), (dict, list)):
+            result["prompt"] = json.dumps(meta["prompt"])
+        elif isinstance(meta.get("prompt"), str):
+            result["prompt"] = meta["prompt"]
+        if isinstance(meta.get("workflow"), (dict, list)):
+            result["workflow"] = json.dumps(meta["workflow"])
+        elif isinstance(meta.get("workflow"), str):
+            result["workflow"] = meta["workflow"]
+        return result
+
     @staticmethod
     def _decode_user_comment(user_comment: Any) -> Optional[str]:
         if user_comment is None:
@@ -43,6 +151,12 @@ class ExifUtils:
             "comment": None,
         }
 
+        ext = os.path.splitext(image_path)[1].lower()
+        if ext in ('.avif', '.jxl'):
+            brotli_meta = ExifUtils._extract_isobmff_brotli(image_path)
+            if brotli_meta:
+                return brotli_meta
+
         with Image.open(image_path) as img:
             info = getattr(img, "info", {}) or {}
 
@@ -149,7 +263,6 @@ class ExifUtils:
             Optional[str]: Extracted metadata or None if not found
         """
         try:
-            # Skip for video files
             if image_path:
                 ext = os.path.splitext(image_path)[1].lower()
                 if ext in ['.mp4', '.webm']:
@@ -177,10 +290,9 @@ class ExifUtils:
             str: Path to the updated image
         """
         try:
-            # Skip for video files
             if image_path:
                 ext = os.path.splitext(image_path)[1].lower()
-                if ext in ['.mp4', '.webm']:
+                if ext in ['.mp4', '.webm', '.avif', '.jxl']:
                     return image_path
 
             metadata_fields = ExifUtils._load_structured_metadata(image_path)
@@ -212,10 +324,9 @@ class ExifUtils:
     def append_recipe_metadata(image_path, recipe_data) -> str:
         """Append recipe metadata to an image's EXIF data"""
         try:
-            # Skip for video files
             if image_path:
                 ext = os.path.splitext(image_path)[1].lower()
-                if ext in ['.mp4', '.webm']:
+                if ext in ['.mp4', '.webm', '.avif', '.jxl']:
                     return image_path
 
             # First, extract existing metadata
@@ -327,10 +438,9 @@ class ExifUtils:
             Tuple of (optimized_image_data, extension)
         """
         try:
-            # Skip for video files early if it's a file path
             if isinstance(image_data, str) and os.path.exists(image_data):
                 ext = os.path.splitext(image_data)[1].lower()
-                if ext in ['.mp4', '.webm']:
+                if ext in ['.mp4', '.webm', '.avif', '.jxl']:
                     try:
                         with open(image_data, 'rb') as f:
                             return f.read(), ext

py/utils/file_utils.py

@@ -1,7 +1,10 @@
 
 import hashlib
+import json
 import logging
 import os
+import struct
+from typing import Any
 
 from .constants import (
     CARD_PREVIEW_WIDTH,
@@ -31,14 +34,101 @@ def _get_hash_chunk_size_bytes() -> int:
 
 
 async def calculate_sha256(file_path: str) -> str:
-    """Calculate SHA256 hash of a file"""
+    """Calculate SHA256 hash of a file (full file content).
+
+    Uses ``posix_fadvise`` with ``POSIX_FADV_DONTNEED`` to avoid polluting the OS page
+    cache — critical on WSL where cached file pages live inside the VM and are not
+    accounted for in guest ``used`` memory, causing VmmemWSL to balloon.
+
+    On Windows/macOS where ``posix_fadvise`` is not available the hint is silently
+    skipped.
+    """
     sha256_hash = hashlib.sha256()
     chunk_size = _get_hash_chunk_size_bytes()
     with open(file_path, "rb") as f:
+        fd = f.fileno()
         for byte_block in iter(lambda: f.read(chunk_size), b""):
             sha256_hash.update(byte_block)
+        # Evict pages after reading so the data doesn't linger in the kernel page
+        # cache — on WSL this otherwise appears as unreclaimable VmmemWSL growth.
+        # Guard against platforms (Windows, macOS) that lack posix_fadvise.
+        if hasattr(os, "posix_fadvise") and hasattr(os, "POSIX_FADV_DONTNEED"):
+            os.posix_fadvise(fd, 0, 0, os.POSIX_FADV_DONTNEED)
     return sha256_hash.hexdigest()
 
+
+def calculate_autov2(file_path: str) -> str:
+    """Calculate CivitAI AutoV2 hash.
+
+    AutoV2 is the first 10 characters of the full file SHA256.
+    Used by CivitAI as a shortened file identifier.
+
+    Reference: https://developer.civitai.com/site/reference/model-versions
+    """
+    full_hash = hashlib.sha256()
+    chunk_size = _get_hash_chunk_size_bytes()
+    with open(file_path, "rb") as f:
+        for byte_block in iter(lambda: f.read(chunk_size), b""):
+            full_hash.update(byte_block)
+    return full_hash.hexdigest()[:10]
+
+
+def read_safetensors_metadata(file_path: str) -> dict[str, Any]:
+    """Read the ``__metadata__`` dict from a safetensors file header.
+
+    Safetensors file format:
+      - 8 bytes: header length (little-endian 64-bit)
+      - N bytes: UTF-8 JSON header
+      - The header JSON contains a ``__metadata__`` key holding arbitrary metadata.
+
+    Returns an empty dict if the file is not a valid safetensors file or has no
+    metadata.
+    """
+    try:
+        with open(file_path, "rb") as f:
+            header_len_bytes = f.read(8)
+            if len(header_len_bytes) < 8:
+                return {}
+            header_len = struct.unpack("<Q", header_len_bytes)[0]
+            header_bytes = f.read(header_len)
+            if len(header_bytes) < header_len:
+                return {}
+            header = json.loads(header_bytes.decode("utf-8"))
+            return header.get("__metadata__", {})
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError, struct.error, MemoryError, Exception):
+        return {}
+
+
+def calculate_autov3(file_path: str) -> str | None:
+    """Calculate CivitAI AutoV3 hash from a safetensors file.
+
+    AutoV3 is extracted from the safetensors file's embedded metadata, not
+    computed from the file bytes directly. The orchestrator reads the
+    ``sshs_model_hash`` (kohya-ss format) or ``modelspec.hash_sha256`` field
+    from the safetensors header and stores the first 12 characters.
+
+    The embedded hash itself is the SHA256 of the file after skipping the
+    8-byte header length + JSON header (a.k.a. the addnet hash / tensor-only
+    hash).
+
+    Reference:
+      - CivitAI DB trigger: ``SUBSTRING(NEW.hash FROM 1 FOR 12)``
+      - https://developer.civitai.com/site/reference/model-versions
+
+    Returns ``None`` when no AutoV3 hash can be determined (e.g. the file is
+    not safetensors, or the metadata doesn't contain a recognised hash field).
+    """
+    metadata = read_safetensors_metadata(file_path)
+    if not metadata:
+        return None
+
+    embedded_hash = metadata.get("sshs_model_hash") or metadata.get("modelspec.hash_sha256")
+    if embedded_hash and isinstance(embedded_hash, str) and len(embedded_hash) >= 12:
+        return embedded_hash[:12]
+
+    return None
+
+
 def find_preview_file(base_name: str, dir_path: str) -> str:
     """Find preview file for given base name in directory.
 

py/utils/models.py

@@ -35,6 +35,9 @@ class BaseModelMetadata:
     metadata_source: Optional[str] = None  # Last provider that supplied metadata
     last_checked_at: float = 0  # Last checked timestamp
     hash_status: str = "completed"  # Hash calculation status: pending | calculating | completed | failed
+    trainedWords: List[str] = field(
+        default_factory=list
+    )  # Trigger words / activation prompts (source-agnostic)
     _unknown_fields: Dict[str, Any] = field(
         default_factory=dict, repr=False, compare=False
     )  # Store unknown fields
@@ -47,6 +50,9 @@ class BaseModelMetadata:
         if self.tags is None:
             self.tags = []
 
+        if self.trainedWords is None:
+            self.trainedWords = []
+
     @classmethod
     def from_dict(cls, data: Dict) -> "BaseModelMetadata":
         """Create instance from dictionary"""

py/utils/session_logging.py

@@ -64,6 +64,27 @@ def _build_log_file_path(settings_file: str | None, started_at: datetime) -> str
     return os.path.join(log_dir, f"standalone-session-{timestamp}.log")
 
 
+_KEEP_LOG_COUNT = 3
+
+
+def _prune_old_logs(log_dir: str) -> None:
+    """Remove older session log files, keeping only the ``_KEEP_LOG_COUNT`` newest."""
+    try:
+        files = [
+            os.path.join(log_dir, name)
+            for name in os.listdir(log_dir)
+            if name.startswith("standalone-session-") and name.endswith(".log")
+        ]
+    except OSError:
+        return
+    files.sort(key=os.path.getmtime, reverse=True)
+    for path in files[_KEEP_LOG_COUNT:]:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
 def setup_standalone_session_logging(settings_file: str | None) -> StandaloneSessionLogState:
     global _session_state
 
@@ -90,6 +111,7 @@ def setup_standalone_session_logging(settings_file: str | None) -> StandaloneSes
             file_handler.set_name(_FILE_HANDLER_NAME)
             file_handler.setFormatter(formatter)
             root_logger.addHandler(file_handler)
+            _prune_old_logs(os.path.dirname(log_file_path))
 
         _session_state = StandaloneSessionLogState(
             started_at=started_at,

py/utils/usage_stats.py

@@ -1,4 +1,5 @@
 import os
+import re
 import json
 import time
 import asyncio
@@ -9,6 +10,7 @@ from typing import Dict, Set
 
 from ..config import config
 from ..services.service_registry import ServiceRegistry
+from ..utils.settings_paths import get_settings_dir
 
 # Check if running in standalone mode
 standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.environ.get("HF_HUB_DISABLE_TELEMETRY", "0") == "0"
@@ -16,14 +18,18 @@ standalone_mode = os.environ.get("LORA_MANAGER_STANDALONE", "0") == "1" or os.en
 # Define constants locally to avoid dependency on conditional imports
 MODELS = "models"
 LORAS = "loras"
+EMBEDDINGS = "embeddings"
+PROMPTS = "prompts"
 
 if not standalone_mode:
     from ..metadata_collector.metadata_registry import MetadataRegistry
     # Import constants from metadata_collector to ensure consistency, but we have fallbacks defined above
     try:
-        from ..metadata_collector.constants import MODELS as _MODELS, LORAS as _LORAS
+        from ..metadata_collector.constants import MODELS as _MODELS, LORAS as _LORAS, EMBEDDINGS as _EMBEDDINGS, PROMPTS as _PROMPTS
         MODELS = _MODELS
         LORAS = _LORAS
+        EMBEDDINGS = _EMBEDDINGS
+        PROMPTS = _PROMPTS
     except ImportError:
         pass  # Use the local definitions
 
@@ -65,6 +71,7 @@ class UsageStats:
         self.stats = {
             "checkpoints": {},  # sha256 -> { total: count, history: { date: count } }
             "loras": {},        # sha256 -> { total: count, history: { date: count } }
+            "embeddings": {},   # sha256 -> { total: count, history: { date: count } }
             "total_executions": 0,
             "last_save_time": 0
         }
@@ -77,6 +84,7 @@ class UsageStats:
         
         # Load existing stats if available
         self._stats_file_path = self._get_stats_file_path()
+        self._migrate_from_old_location()
         self._load_stats()
         
         # Save interval in seconds
@@ -89,14 +97,38 @@ class UsageStats:
         logger.debug("Usage statistics tracker initialized")
     
     def _get_stats_file_path(self) -> str:
-        """Get the path to the stats JSON file"""
+        """Get the path to the stats JSON file in the settings directory."""
+        settings_dir = get_settings_dir(create=True)
+        return os.path.join(settings_dir, "stats", self.STATS_FILENAME)
+
+    @staticmethod
+    def _get_old_stats_file_path() -> str:
+        """Get the legacy stats file path in the first lora root directory."""
         if not config.loras_roots or len(config.loras_roots) == 0:
-            # If no lora roots are available, we can't save stats
-            # This will be handled by the caller
-            raise RuntimeError("No LoRA root directories configured. Cannot initialize usage statistics.")
-        
-        # Use the first lora root
-        return os.path.join(config.loras_roots[0], self.STATS_FILENAME)
+            return ""
+        return os.path.join(config.loras_roots[0], UsageStats.STATS_FILENAME)
+
+    def _migrate_from_old_location(self) -> None:
+        """Migrate stats file from old location (first lora root) to new location (settings_dir/stats/)."""
+        new_path = self._stats_file_path
+        if os.path.exists(new_path):
+            return
+
+        old_path = self._get_old_stats_file_path()
+        if not old_path or not os.path.exists(old_path):
+            return
+
+        try:
+            os.makedirs(os.path.dirname(new_path), exist_ok=True)
+            shutil.copy2(old_path, new_path)
+            logger.info("Migrated usage stats from %s to %s", old_path, new_path)
+            try:
+                os.remove(old_path)
+                logger.info("Cleaned up old stats file: %s", old_path)
+            except Exception as e:
+                logger.warning("Failed to remove old stats file %s: %s", old_path, e)
+        except Exception as e:
+            logger.error("Failed to migrate usage stats from %s to %s: %s", old_path, new_path, e)
     
     def _backup_old_stats(self):
         """Backup the old stats file before conversion"""
@@ -115,6 +147,7 @@ class UsageStats:
         new_stats = {
             "checkpoints": {},
             "loras": {},
+            "embeddings": {},
             "total_executions": old_stats.get("total_executions", 0),
             "last_save_time": old_stats.get("last_save_time", time.time())
         }
@@ -142,21 +175,27 @@ class UsageStats:
                     }
                 }
         
+        # Convert embedding stats (if present in old format)
+        if "embeddings" in old_stats and isinstance(old_stats["embeddings"], dict):
+            for hash_id, count in old_stats["embeddings"].items():
+                new_stats["embeddings"][hash_id] = {
+                    "total": count,
+                    "history": {
+                        today: count
+                    }
+                }
+        
         logger.info("Successfully converted stats from old format to new format with history")
         return new_stats
     
     def _is_old_format(self, stats):
         """Check if the stats are in the old format (direct count values)"""
         # Check if any lora or checkpoint entry is a direct number instead of an object
-        if "loras" in stats and isinstance(stats["loras"], dict):
-            for hash_id, data in stats["loras"].items():
-                if isinstance(data, (int, float)):
-                    return True
-                
-        if "checkpoints" in stats and isinstance(stats["checkpoints"], dict):
-            for hash_id, data in stats["checkpoints"].items():
-                if isinstance(data, (int, float)):
-                    return True
+        for category in ("loras", "checkpoints", "embeddings"):
+            if category in stats and isinstance(stats[category], dict):
+                for hash_id, data in stats[category].items():
+                    if isinstance(data, (int, float)):
+                        return True
         
         return False
     
@@ -182,6 +221,9 @@ class UsageStats:
                         if "loras" in loaded_stats and isinstance(loaded_stats["loras"], dict):
                             self.stats["loras"] = loaded_stats["loras"]
                         
+                        if "embeddings" in loaded_stats and isinstance(loaded_stats["embeddings"], dict):
+                            self.stats["embeddings"] = loaded_stats["embeddings"]
+                        
                         if "total_executions" in loaded_stats:
                             self.stats["total_executions"] = loaded_stats["total_executions"]
                         
@@ -304,6 +346,10 @@ class UsageStats:
         if LORAS in metadata and isinstance(metadata[LORAS], dict):
             await self._process_loras(metadata[LORAS], today)
 
+        # Process embeddings — parse prompt text for embedding:name references
+        if PROMPTS in metadata and isinstance(metadata[PROMPTS], dict):
+            await self._process_embeddings(metadata[PROMPTS], 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]:
@@ -510,6 +556,55 @@ class UsageStats:
         except Exception as e:
             logger.error(f"Error processing LoRA usage: {e}", exc_info=True)
     
+    @staticmethod
+    def _extract_embedding_names(prompt_text: str) -> set:
+        """Parse embedding:name references from prompt text.
+
+        ComfyUI's SDTokenizer resolves ``embedding:<name>`` during tokenization
+        (see ``sd1_clip.py _try_get_embedding``).  This mirrors the same pattern
+        to extract embedding file names from the captured prompt strings.
+        """
+        if not prompt_text:
+            return set()
+        # Matches ``embedding:name`` where name is alphanumeric plus _ . - /
+        names = re.findall(r"embedding:([a-zA-Z0-9_.\-/]+)", prompt_text)
+        return set(names)
+
+    async def _process_embeddings(self, prompts_data, today_date):
+        """Extract embedding usage from prompt texts and record it.
+
+        Iterates every prompt node's text field captured by the metadata
+        collector, extracts ``embedding:<name>`` references, resolves each
+        name to its SHA256 hash via the embedding scanner, and increments
+        usage counters.
+        """
+        try:
+            embedding_scanner = await ServiceRegistry.get_embedding_scanner()
+            if not embedding_scanner:
+                logger.warning("Embedding scanner not available for usage tracking")
+                return
+
+            seen_names = set()
+            for _node_id, prompt_data in prompts_data.items():
+                if not isinstance(prompt_data, dict):
+                    continue
+                for text_field in ("text", "positive_text", "negative_text"):
+                    text = prompt_data.get(text_field)
+                    if isinstance(text, str):
+                        seen_names.update(self._extract_embedding_names(text))
+
+            for emb_name in seen_names:
+                emb_hash = embedding_scanner.get_hash_by_filename(emb_name)
+                if emb_hash:
+                    self._increment_usage_counter("embeddings", emb_hash, today_date)
+                else:
+                    logger.debug(
+                        "No hash found for embedding '%s', skipping usage tracking",
+                        emb_name,
+                    )
+        except Exception as e:
+            logger.error("Error processing embedding usage: %s", e, exc_info=True)
+
     async def get_stats(self):
         """Get current usage statistics"""
         return self.stats
@@ -522,6 +617,9 @@ class UsageStats:
         elif model_type == "lora":
             if sha256 in self.stats["loras"]:
                 return self.stats["loras"][sha256]["total"]
+        elif model_type == "embedding":
+            if sha256 in self.stats["embeddings"]:
+                return self.stats["embeddings"][sha256]["total"]
         return 0
     
     async def process_execution(self, prompt_id):

py/utils/utils.py

@@ -15,30 +15,64 @@ def get_lora_info(lora_name):
         scanner = await ServiceRegistry.get_lora_scanner()
         cache = await scanner.get_cached_data()
 
+        lora_name_normalized = lora_name.replace("\\", "/")
+        lora_name_no_ext = lora_name_normalized
+        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+            if lora_name_no_ext.lower().endswith(ext):
+                lora_name_no_ext = lora_name_no_ext[: -len(ext)]
+                break
+
+        has_path = "/" in lora_name_no_ext
+        basename = os.path.basename(lora_name_no_ext) if has_path else lora_name_no_ext
+        best_fallback = None
+
         for item in cache.raw_data:
-            if item.get("file_name") == lora_name:
-                file_path = item.get("file_path")
-                if file_path:
-                    # Check all lora roots including extra paths
-                    all_roots = list(config.loras_roots or []) + list(
-                        config.extra_loras_roots or []
+            file_name = item.get("file_name", "")
+            folder = item.get("folder", "")
+            file_name_no_ext = file_name
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if file_name_no_ext.lower().endswith(ext):
+                    file_name_no_ext = file_name_no_ext[: -len(ext)]
+                    break
+            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+
+            if lora_name_no_ext not in (file_name_no_ext, path_name):
+                if has_path and file_name_no_ext == basename:
+                    if folder and lora_name_no_ext.startswith(folder.replace("\\", "/") + "/"):
+                        best_fallback = item
+                    elif best_fallback is None:
+                        best_fallback = item
+                continue
+
+            file_path = item.get("file_path")
+            if not file_path:
+                continue
+
+            all_roots = list(config.loras_roots or []) + list(
+                config.extra_loras_roots or []
+            )
+            for root in all_roots:
+                root = root.replace(os.sep, "/")
+                if file_path.startswith(root):
+                    relative_path = os.path.relpath(file_path, root).replace(
+                        os.sep, "/"
                     )
-                    for root in all_roots:
-                        root = root.replace(os.sep, "/")
-                        if file_path.startswith(root):
-                            relative_path = os.path.relpath(file_path, root).replace(
-                                os.sep, "/"
-                            )
-                            # Get trigger words from civitai metadata
-                            civitai = item.get("civitai", {})
-                            trigger_words = (
-                                civitai.get("trainedWords", []) if civitai else []
-                            )
-                            return relative_path, trigger_words
-                    # If not found in any root, return path with trigger words from cache
                     civitai = item.get("civitai", {})
-                    trigger_words = civitai.get("trainedWords", []) if civitai else []
-                    return file_path, trigger_words
+                    trigger_words = (
+                        civitai.get("trainedWords", []) if civitai else []
+                    )
+                    return relative_path, trigger_words
+            civitai = item.get("civitai", {})
+            trigger_words = civitai.get("trainedWords", []) if civitai else []
+            return file_path, trigger_words
+
+        if best_fallback:
+            file_path = best_fallback.get("file_path")
+            if file_path:
+                civitai = best_fallback.get("civitai", {})
+                trigger_words = civitai.get("trainedWords", []) if civitai else []
+                return file_path, trigger_words
+
         return lora_name, []
 
     try:
@@ -77,15 +111,54 @@ def get_lora_info_absolute(lora_name):
         scanner = await ServiceRegistry.get_lora_scanner()
         cache = await scanner.get_cached_data()
 
+        lora_name_normalized = lora_name.replace("\\", "/")
+        lora_name_no_ext = lora_name_normalized
+        for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+            if lora_name_no_ext.lower().endswith(ext):
+                lora_name_no_ext = lora_name_no_ext[: -len(ext)]
+                break
+
+        has_path = "/" in lora_name_no_ext
+        basename = os.path.basename(lora_name_no_ext) if has_path else lora_name_no_ext
+        best_fallback = None
+
         for item in cache.raw_data:
-            if item.get("file_name") == lora_name:
+            file_name = item.get("file_name", "")
+            folder = item.get("folder", "")
+            file_name_no_ext = file_name
+            for ext in (".safetensors", ".ckpt", ".pt", ".bin"):
+                if file_name_no_ext.lower().endswith(ext):
+                    file_name_no_ext = file_name_no_ext[: -len(ext)]
+                    break
+            path_name = f"{folder}/{file_name_no_ext}".replace("\\", "/") if folder else file_name_no_ext
+
+            if lora_name_no_ext == file_name_no_ext:
                 file_path = item.get("file_path")
                 if file_path:
-                    # Return absolute path directly
-                    # Get trigger words from civitai metadata
                     civitai = item.get("civitai", {})
                     trigger_words = civitai.get("trainedWords", []) if civitai else []
                     return file_path, trigger_words
+
+            if lora_name_no_ext == path_name:
+                file_path = item.get("file_path")
+                if file_path:
+                    civitai = item.get("civitai", {})
+                    trigger_words = civitai.get("trainedWords", []) if civitai else []
+                    return file_path, trigger_words
+
+            if has_path and file_name_no_ext == basename:
+                if folder and lora_name_no_ext.startswith(folder.replace("\\", "/") + "/"):
+                    best_fallback = item
+                elif best_fallback is None:
+                    best_fallback = item
+
+        if best_fallback:
+            file_path = best_fallback.get("file_path")
+            if file_path:
+                civitai = best_fallback.get("civitai", {})
+                trigger_words = civitai.get("trainedWords", []) if civitai else []
+                return file_path, trigger_words
+
         return lora_name, []
 
     try: