chore(release): bump version to v1.2.1

feat(recipes): add toolbar toggle and settings preview for masonry layout
feat(metadata): collect generation params from Krea two/three stage samplers
2026-09-22 03:24:09 -03:00 · 2026-08-16 19:47:15 +08:00 · 2026-08-16 15:23:30 +08:00 · 2026-08-16 09:53:08 +08:00 · 2026-08-16 09:17:59 +08:00 · 2026-08-15 22:03:54 +08:00
156 changed files with 22255 additions and 918 deletions
@@ -1,47 +1,145 @@
 ---
 name: lora-manager-e2e
-description: End-to-end testing and validation for LoRa Manager features. Use when performing automated E2E validation of LoRa Manager standalone mode, including starting/restarting the server, using Chrome DevTools MCP to interact with the web UI at http://127.0.0.1:8188/loras, and verifying frontend-to-backend functionality. Covers workflow validation, UI interaction testing, and integration testing between the standalone Python backend and the browser frontend.
+description: End-to-end testing and validation for LoRa Manager features. Use when performing automated E2E validation of LoRa Manager standalone mode in a SANDBOXED, disposable configuration: check the port, start/restart the standalone server on a free port, use Chrome DevTools MCP to interact with the web UI (http://127.0.0.1:{PORT}/loras), and verify frontend-to-backend functionality. Covers workflow validation, UI interaction testing, and integration testing between the standalone Python backend and the browser frontend. Trigger keywords: E2E, standalone, Chrome DevTools MCP, lora-manager-e2e, sandbox.
 ---

 # LoRa Manager E2E Testing

 This skill provides workflows and utilities for end-to-end testing of LoRa Manager using Chrome DevTools MCP.

+## Conventions Used in This Document
+
+- **`{PORT}`**: The server port. The default candidate is `8188`, but **`8188` is commonly occupied by a live ComfyUI process** and MUST NOT be assumed to be free. Always check availability first (see [Port Selection](#port-selection)) and use a free port (e.g. `8199`) for the E2E run. Substitute the actual port for every `{PORT}` in the commands below.
+- **`<repo-root>`**: The repository/worktree root. Always run commands from the repo or worktree root; never assume a specific absolute path (paths such as `/home/<user>/...` differ per machine). The E2E scripts resolve the project root themselves, but fixture/settings paths are relative to `<repo-root>`.
+
+## SANDBOX (MANDATORY)
+
+> **Read this section before running anything.** Every E2E run MUST target a throwaway sandbox, never the real user data. A fresh subagent that skips this section WILL permanently mutate real user recipes.
+
+1. **Portable settings**: create `<repo-root>/settings.json` (gitignored) with `"use_portable_settings": true` plus sandboxed `folder_paths` (lora/checkpoint roots) and `recipes_path`. This keeps the configuration inside the repo instead of the real user config dir (`~/.config/ComfyUI-LoRA-Manager/settings.json`).
+2. **Sandboxed paths**: point `folder_paths` / `recipes_path` / `example_images_path` at disposable dirs — e.g. under `/tmp/opencode/<plan-name>-e2e/` (or worktree-local dirs). NEVER point the E2E at the real library (`~/models/...`), real recipe dir, or real settings.
+3. **Never touch the real config**: the real user config at `~/.config/ComfyUI-LoRA-Manager/settings.json` and the real recipe dir must remain byte-identical before and after the run.
+4. **Record real-data protection proof** before starting and after finishing:
+   ```bash
+   # BEFORE: snapshot real config + recipe library state
+   sha256sum ~/.config/ComfyUI-LoRA-Manager/settings.json > /tmp/opencode/<plan>-e2e/settings.before.sha256
+   ls ~/models/recipes/*.recipe.json 2>/dev/null | wc -l > /tmp/opencode/<plan>-e2e/recipes-count.before.txt
+   find ~/models/recipes -name '*.recipe.json' -newermt "$(date -Iseconds)" | head   # expect empty after run
+   # AFTER: record again, then diff the two snapshots. Any change = the run leaked into real data.
+   ```
+   Also confirm `<repo-root>/git status` stays clean for `settings.json`/`cache/` (both are gitignored).
+
+### Portable Settings Example
+
+```json
+{
+  "use_portable_settings": true,
+  "folder_paths": {
+    "loras": ["/tmp/opencode/<plan>-e2e/models/loras"],
+    "checkpoints": ["/tmp/opencode/<plan>-e2e/models/checkpoints"],
+    "unet": ["/tmp/opencode/<plan>-e2e/models/checkpoints"],
+    "diffusers": []
+  },
+  "recipes_path": "/tmp/opencode/<plan>-e2e/recipes",
+  "example_images_path": "/tmp/opencode/<plan>-e2e/example_images"
+}
+```
+
+The scanner computes and persists model hashes during the library scan, so the sandbox model dirs just need the model files + `.metadata.json` sidecars (see [Fixture + Fresh-State Guidance](#fixture--fresh-state-guidance)).
+
+## Time Budgets & Abort Guidance
+
+A fresh subagent should complete a sandboxed standalone E2E **in well under 30 minutes**. Budget each phase:
+
+| Phase | Expected duration | Abort if |
+| --- | --- | --- |
+| Port check + sandbox setup | < 2 min | — |
+| Server start (detached) + readiness | < 30 s | > 60 s (2x) → stop |
+| Chrome DevTools MCP connect | < 1 min | > 2 min → stop |
+| Per entry-point run (after fixtures ready) | < 5 min | > 10 min (2x) → stop |
+| Fixture reset + cache clear between runs | < 1 min | > 2 min → stop |
+
+**Abort rule**: if a phase exceeds ~2x its budget, OR any single tool call fails/retries 3+ times in a row, **STOP**. Do not loop or retry blindly. Report `BLOCKED` with: the phase, the last observed state (server PID + `ss -tlnp` output, page snapshot, last API response), and the suspected cause. Record the partial state as evidence; a clean BLOCKED report is more valuable than an hour of retries.
+
 ## Prerequisites

- LoRa Manager project cloned and dependencies installed (`pip install -r requirements.txt`)
+- LoRa Manager project cloned and dependencies installed (`pip install -r requirements.txt`) — run everything from `<repo-root>`
 - Chrome browser available for debugging
 - Chrome DevTools MCP connected
+- `ss` (or `lsof`/`netstat`) available for port checks: `ss -tlnp`

-## Quick Start Workflow
+## Port Selection

-### 1. Start LoRa Manager Standalone
-
-```python
-# Use the provided script to start the server
-python .agents/skills/lora-manager-e2e/scripts/start_server.py --port 8188
-```
-
-Or manually:
-```bash
-cd /home/miao/workspace/ComfyUI/custom_nodes/ComfyUI-Lora-Manager
-python standalone.py --port 8188
-```
-
-Wait for server ready message before proceeding.
-
-### 2. Open Chrome Debug Mode
+`8188` is only the *default candidate*. Verify it is actually free before every run:

 ```bash
-# Chrome with remote debugging on port 9222
-google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:8188/loras
+# Is anything listening on 8188?
+ss -tlnp | grep ':8188' || echo "8188 is free"
 ```

-### 3. Connect Chrome DevTools MCP
+- If a process holds `8188` (e.g. a live ComfyUI — pid 6575 on this machine), pick a different free port, e.g. `8199`:
+  ```bash
+  ss -tlnp | grep ':8199' || echo "8199 is free"
+  ```
+- **Never** kill a process you did not start for this E2E. The live ComfyUI is off-limits. Pick a free port instead.
+- Use your chosen port for **all** subsequent commands (server, Chrome launch, browser URLs).

-Ensure the MCP server is connected to Chrome at `http://localhost:9222`.
+## Quick Start Workflow (sandboxed)

-### 4. Navigate and Interact
+### 1. Prepare the sandbox
+
+```bash
+cd <repo-root>                       # ALWAYS run from the repo/worktree root
+mkdir -p /tmp/opencode/<plan>-e2e/models/{loras,checkpoints}
+mkdir -p /tmp/opencode/<plan>-e2e/{recipes,example_images,recipes-before}
+# write <repo-root>/settings.json per the portable-settings example above
+# record real-data protection proof (see SANDBOX section)
+```
+
+### 2. Check port availability
+
+```bash
+ss -tlnp | grep ':{PORT}' || echo "port {PORT} is free"
+```
+
+If `{PORT}` is occupied by an unrelated process, pick a free one and use it everywhere below. When in doubt use `8199`.
+
+### 3. Start LoRa Manager Standalone (detached)
+
+The standalone server **dies with the shell unless launched fully detached** — a plain background `&` from the bash tool is killed when the tool call returns. Launch via the helper script:
+
+```bash
+python .agents/skills/lora-manager-e2e/scripts/start_server.py --port {PORT} --wait --timeout 30 --detach
+```
+
+Or manually (equivalent detached form):
+
+```bash
+setsid nohup python standalone.py --port {PORT} --host 127.0.0.1 < /dev/null \
+  >> /tmp/opencode/<plan>-e2e/server.log 2>&1 &
+echo "started"   # record the printed/pidfile PID for cleanup
+```
+
+Verify it is listening **before** proceeding (readiness poll is not a substitute for this):
+
+```bash
+ss -tlnp | grep ':{PORT}'
+```
+
+Record the server PID for cleanup: the helper script writes it to `/tmp/lora-manager-e2e-server-{PORT}.pid`; a manual `setsid` launch has no pidfile, so capture it explicitly (e.g. from `ss -tlnp`).
+
+### 4. Open Chrome Debug Mode
+
+```bash
+# Chrome with remote debugging on port 9222 (note the {PORT} URL)
+google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:{PORT}/loras
+```
+
+### 5. Connect Chrome DevTools MCP
+
+Ensure the MCP server is connected to Chrome at `http://localhost:9222`. Verify with `list_pages` — if it fails with "browser is already running", see [Chrome DevTools MCP Troubleshooting](#chrome-devtools-mcp-troubleshooting).
+
+### 6. Navigate and Interact

 Use Chrome DevTools MCP tools to:
 - Take snapshots: `take_snapshot`
@@ -56,7 +154,7 @@ Use Chrome DevTools MCP tools to:

 ```python
 # Navigate to LoRA list page
-navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+navigate_page(type="url", url="http://127.0.0.1:{PORT}/loras")

 # Wait for page to load
 wait_for(text="LoRAs", timeout=10000)
@@ -68,9 +166,10 @@ snapshot = take_snapshot()
 ### Pattern: Restart Server for Configuration Changes

 ```python
-# Stop current server (if running)
-# Start with new configuration
-python .agents/skills/lora-manager-e2e/scripts/start_server.py --port 8188 --restart
+# Stop current server (if running), start with new configuration.
+# --restart only kills the E2E server this script started before (via its pidfile);
+# it refuses to blindly kill unrelated processes on the port.
+python .agents/skills/lora-manager-e2e/scripts/start_server.py --port {PORT} --restart --wait --detach

 # Wait and refresh browser
 navigate_page(type="reload", ignoreCache=True)
@@ -130,24 +229,96 @@ click(uid="modal-submit-button")
 wait_for(text="Success", timeout=5000)
 ```

+## Fixture + Fresh-State Guidance
+
+For rematch/repair E2E runs, seed the **sandboxed** `recipes_path` with hand-written fixture recipes. Rules (validated by the task-8 E2E):
+
+1. **Filename constraint**: each file MUST be named `f"{id}.recipe.json"` **and** the in-JSON `id` field MUST equal the filename. Discovery accepts any `*.recipe.json`, but persistence resolves the path via `get_recipe_json_path` and `_save_recipe_persistently` returns `False` on a mismatch → the fixture would be counted as an error.
+   - `recipe-a.recipe.json` → in-JSON `"id": "recipe-a"`
+2. **File format**: mirror an existing recipe JSON — top-level `id`, `file_path`, `title`, `loras`, `fingerprint`, `gen_params`; lora entries per the persistence conventions (`hash`, `file_name`, `modelVersionId`, `isDeleted`, ...).
+3. **Companion image**: each recipe needs an image (e.g. a `.webp` generated with PIL) referenced by `file_path`, used for EXIF verification (`ExifUtils.append_recipe_metadata` writes a `"Recipe metadata: ..."` marker; a freshly generated `.webp` with no marker is the clean "untouched" control).
+4. **autov3 three-state contract**: for L3 (autov3-only, renamed-file) fixtures the local model's `.metadata.json` sidecar MUST have the `autov3` key **ABSENT** (the "unchecked" state), NOT `""` — `""` is the TERMINAL "checked but unavailable" state that L3 deliberately skips. The scanner computes + persists `autov3` from the file header during the normal library scan (`model_scanner.py` `_process_model_file`), so the live L3 match resolves through the local autov3/hash cache; the computed-autov3 branch for unchecked items is covered by the unit suite.
+5. **Fixture design for a rematch run** (mirrors the task-8 E2E):
+   - `recipe-a`: lora entry `isDeleted=True`, `hash` = 12-char autov3 computed from the local model (`calculate_autov3`, `py/utils/file_utils.py`), whose local model file was RENAMED after the recipe was written so `file_name` differs (proves L3 match without filename).
+   - `recipe-b`: parser-convention checkpoint entry (uses `id`, no `modelVersionId`) matching a local checkpoint via L2 — the local checkpoint's `.metadata.json` MUST carry civitai version data with that `id` so `version_index` contains it (L2 cannot match otherwise).
+   - `recipe-c`: healthy recipe (no deleted entries) → must remain untouched.
+
+### Fresh state between entry-point runs
+
+Each entry point (global / per-recipe / selection-bulk) must start from the same deleted state. Between runs:
+
+```bash
+# 1. Reset fixtures to the before-state snapshot (copy back from recipes-before/)
+cp /tmp/opencode/<plan>-e2e/recipes-before/*.recipe.json /tmp/opencode/<plan>-e2e/recipes/
+# 2. Clear the recipe/FTS caches so the stale in-memory/library state is gone
+rm -f <repo-root>/cache/recipe/*.sqlite
+rm -rf <repo-root>/cache/fts/*
+# 3. Restart the server (fresh process, fresh scan)
+python .agents/skills/lora-manager-e2e/scripts/start_server.py --port {PORT} --restart --wait --timeout 30 --detach
+# 4. Re-verify server listening + reload the browser page
+```
+
+## Server Lifecycle
+
+- **Detached launch is mandatory**: the standalone server dies with the shell unless launched via `setsid` (or the helper script's `--detach`). Use `setsid nohup python standalone.py --port {PORT} --host 127.0.0.1 ... < /dev/null &`.
+- **Verify with `ss -tlnp`** after every (re)start; do not proceed on a blind "server starting" message.
+- **Never kill pre-existing processes** — only kill the E2E server PID you started (`start_server.py --restart` kills only PIDs it manages via its pidfile). The live ComfyUI or a stale QA Chrome must never be killed as part of cleanup unless explicitly identified as such (see Chrome troubleshooting).
+- **Record your PID for cleanup**: note the PID printed/pidfile, and stop exactly that PID at the end (`kill <PID>`, then confirm with `ss -tlnp` that `{PORT}` is released).
+
+## Chrome DevTools MCP Troubleshooting
+
+### Stale profile lock ("browser is already running" / `list_pages` fails)
+
+A Chrome profile can be held by a stale Chrome from a prior MCP session, which makes `list_pages` fail with "browser is already running":
+
+1. Identify the stale Chrome — it owns the profile dir in `--user-data-dir` (e.g. `~/.config/chrome-dev-profile`). Find its process:
+   ```bash
+   ps -ef | grep -i '[c]hrome.*user-data-dir'
+   ```
+2. Confirm it is a QA Chrome from a completed task (its parent is an old MCP/browser process, it is NOT the live ComfyUI server, and it is NOT your current MCP instance).
+3. Kill ONLY that stale Chrome:
+   ```bash
+   kill <stale-chrome-pid>
+   ```
+   Never kill the live server or unrelated processes.
+4. Retry `list_pages`. The current MCP will spawn a fresh browser.
+
+### Screenshot-write restrictions
+
+The chrome-devtools MCP may refuse to write into paths outside its configured workspace roots (e.g. the worktree `.omo/evidence/...` canonicalizing to an unmapped path). Workaround:
+
+```bash
+# 1. Save the screenshot to /tmp via the MCP
+#    take_screenshot(filePath="/tmp/<plan>-e2e/recipe-b-after.png", format="png")
+# 2. Copy it into the evidence dir from the shell
+mkdir -p <repo-root>/.omo/evidence/screenshots
+cp /tmp/<plan>-e2e/recipe-b-after.png <repo-root>/.omo/evidence/screenshots/
+```
+
+## Cancellation Testing (KNOWN GAP)
+
+Testing the rematch-cancel path E2E requires a run long enough to cancel mid-flight. A tiny 3-recipe fixture set completes in **seconds** — too fast to reliably cancel. The cancel path is currently **unit-covered only** (`rematch_all_recipes` cancellation tests); do not block an E2E run on cancel-path verification. If you must attempt it, you would need an artificially large/deferred fixture set to create a cancellable window — treat this as a research task, not part of the standard E2E.
+
 ## Available Scripts

 ### scripts/start_server.py

-Starts or restarts the LoRa Manager standalone server.
+Starts or restarts the LoRa Manager standalone server for E2E testing.

 ```bash
-python scripts/start_server.py [--port PORT] [--restart] [--wait]
+python scripts/start_server.py [--port PORT] [--restart] [--wait] [--timeout SECONDS] [--detach]
 ```

 Options:
- `--port`: Server port (default: 8188)
- `--restart`: Kill existing server before starting
- `--wait`: Wait for server to be ready before exiting
+- `--port`: Server port (default: 8188). The script exits early with a clear message if the port is already in use by an unrelated process.
+- `--restart`: Kill the E2E server this script previously managed (tracked via `/tmp/lora-manager-e2e-server-{PORT}.pid`) before starting. If unrelated processes still hold the port after that, the script reports them and aborts instead of killing them.
+- `--wait`: Wait for the server to be ready before exiting.
+- `--timeout`: Readiness wait timeout in seconds (default: 30).
+- `--detach`: Launch the server fully detached (`setsid`-style, survives shell death — REQUIRED for E2E). Default off: a normal background process that dies with the shell.

 ### scripts/wait_for_server.py

-Polls server until ready or timeout.
+Polls the server until ready or timeout.

 ```bash
 python scripts/wait_for_server.py [--port PORT] [--timeout SECONDS]
@@ -196,6 +367,7 @@ results = performance_stop_trace()
 ## Cleanup

 Always ensure proper cleanup after tests:
-1. Stop the standalone server
-2. Close browser pages (keep at least one open)
-3. Clear temporary data if needed
+1. Stop the standalone server: `kill <recorded-pid>` (only the PID you started), then confirm `ss -tlnp | grep ':{PORT}'` is empty.
+2. Close browser pages (keep at least one open).
+3. Remove the sandbox: `rm -rf /tmp/opencode/<plan>-e2e` and `<repo-root>/settings.json` + `<repo-root>/cache` (both gitignored).
+4. Re-run the real-data protection check from the SANDBOX section and record the result in your evidence.
@@ -2,11 +2,13 @@

 Quick reference for common MCP commands used in LoRa Manager E2E testing.

+> **Port convention**: `{PORT}` is the port chosen for the E2E run (default candidate `8188`, but only if actually free — see the SKILL.md Port Selection section; use e.g. `8199` when `8188` is occupied by a live ComfyUI). Always run against the **sandboxed** standalone server, never a live instance.
+
 ## Navigation

 ```python
 # Navigate to LoRA list page
-navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+navigate_page(type="url", url="http://127.0.0.1:{PORT}/loras")

 # Reload page with cache clear
 navigate_page(type="reload", ignoreCache=True)
@@ -179,7 +181,7 @@ pages = list_pages()
 select_page(pageId=0, bringToFront=True)

 # Create new page
-new_page(url="http://127.0.0.1:8188/loras")
+new_page(url="http://127.0.0.1:{PORT}/loras")

 # Close page (keep at least one open!)
 close_page(pageId=1)
@@ -261,7 +263,7 @@ drag(from_uid="draggable-item", to_uid="drop-zone")
 ### Verify LoRA Cards Loaded

 ```python
-navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+navigate_page(type="url", url="http://127.0.0.1:{PORT}/loras")
 wait_for(text="LoRAs", timeout=10000)

 # Check if cards loaded
@@ -322,3 +324,37 @@ navigate_page(type="reload")
 errors = list_console_messages(types=["error"])
 assert len(errors) == 0, f"Console errors: {errors}"
 ```
+
+## Troubleshooting
+
+### Stale profile lock ("browser is already running" / `list_pages` fails)
+
+A Chrome profile held by a stale Chrome from a prior MCP session makes `list_pages`
+fail with "browser is already running". Fix:
+
+1. Find the stale Chrome that owns the profile dir (e.g. `~/.config/chrome-dev-profile`):
+   ```bash
+   ps -ef | grep -i '[c]hrome.*user-data-dir'
+   ```
+2. Confirm it is a QA Chrome from a completed task (NOT the live ComfyUI server, NOT
+   your current MCP instance).
+3. Kill ONLY that stale Chrome (`kill <stale-pid>`), then retry `list_pages`.
+
+### Screenshot-write restrictions
+
+The MCP may refuse to write into paths outside its configured workspace roots
+(e.g. `.omo/evidence/screenshots/` under a worktree that canonicalizes to an unmapped
+path). Save the screenshot to `/tmp` via the MCP, then copy it into the evidence dir:
+
+```bash
+# MCP:  take_screenshot(filePath="/tmp/<plan>-e2e/recipe-b-after.png", format="png")
+# Shell:
+mkdir -p <repo-root>/.omo/evidence/screenshots
+cp /tmp/<plan>-e2e/recipe-b-after.png <repo-root>/.omo/evidence/screenshots/
+```
+
+### Time budgets & abort rule
+
+See SKILL.md "Time Budgets & Abort Guidance": if a phase exceeds ~2x its budget or a
+tool call retries 3+ times in a row, STOP and report BLOCKED with the last observed
+state (server PID + `ss -tlnp`, page snapshot, last API response). Do not loop.
@@ -2,6 +2,14 @@

 This document provides detailed test scenarios for end-to-end validation of LoRa Manager features.

+> **Run preconditions (from SKILL.md)**: every run uses the **sandboxed** standalone
+> server on a free port `{PORT}` (default candidate `8188`, only if actually free — pick
+> e.g. `8199` when `8188` is occupied by a live ComfyUI). Fixtures live in the sandboxed
+> `recipes_path` as `f"{id}.recipe.json"` files with matching in-JSON `id`; the real user
+> config and real library are never touched (record protection proof before/after).
+> Abort if a phase exceeds ~2x its budget or a tool call retries 3+ times (SKILL.md
+> "Time Budgets & Abort Guidance").
+
 ## Table of Contents

 1. [LoRA List Page](#lora-list-page)
@@ -19,7 +27,7 @@ This document provides detailed test scenarios for end-to-end validation of LoRa
 **Objective**: Verify the LoRA list page loads correctly and displays models.

 **Steps**:
-1. Navigate to `http://127.0.0.1:8188/loras`
+1. Navigate to `http://127.0.0.1:{PORT}/loras`
 2. Wait for page title "LoRAs" to appear
 3. Take snapshot to verify:
   - Header with "LoRAs" title is visible
@@ -134,7 +142,7 @@ evaluate_script(function="""
 **Objective**: Verify recipes page loads and displays recipes.

 **Steps**:
-1. Navigate to `http://127.0.0.1:8188/recipes`
+1. Navigate to `http://127.0.0.1:{PORT}/recipes`
 2. Wait for "Recipes" title
 3. Take snapshot

@@ -176,7 +184,7 @@ evaluate_script(function="""
 **Objective**: Verify settings page displays correctly.

 **Steps**:
-1. Navigate to `http://127.0.0.1:8188/settings`
+1. Navigate to `http://127.0.0.1:{PORT}/settings`
 2. Wait for "Settings" title
 3. Take snapshot

@@ -190,7 +198,7 @@ evaluate_script(function="""
 1. Navigate to settings page
 2. Change a setting (e.g., default view mode)
 3. Save settings
-4. Restart server: `python scripts/start_server.py --restart --wait`
+4. Restart server: `python scripts/start_server.py --port {PORT} --restart --wait --timeout 30 --detach`
 5. Refresh browser page
 6. Navigate to settings

@@ -8,186 +8,208 @@ This script shows how to:
 3. Verify functionality end-to-end

 Note: This is a template. Actual execution requires Chrome DevTools MCP.
+
+Port: pick a FREE port for the run — 8188 is commonly occupied by a live
+ComfyUI (see the skill's Port Selection section). Set PORT below to e.g. 8199
+when 8188 is taken. Always run against a SANDBOXED standalone server.
 """

 import subprocess
 import sys
-import time
+
+# Choose the E2E port. 8188 is only the default candidate; use 8199 (or any
+# free port checked with `ss -tlnp`) when 8188 is occupied by a live ComfyUI.
+PORT = "8188"


 def run_test():
    """Run example E2E test flow."""
-    
+
    print("=" * 60)
    print("LoRa Manager E2E Test Example")
    print("=" * 60)
-    
-    # Step 1: Start server
+
+    # Step 1: Start server (detached so it survives the shell)
    print("\n[1/5] Starting LoRa Manager standalone server...")
    result = subprocess.run(
-        [sys.executable, "start_server.py", "--port", "8188", "--wait", "--timeout", "30"],
+        [sys.executable, "start_server.py", "--port", PORT, "--wait", "--timeout", "30", "--detach"],
        capture_output=True,
-        text=True
+        text=True,
    )
    if result.returncode != 0:
        print(f"Failed to start server: {result.stderr}")
        return 1
    print("Server ready!")
-    
+
    # Step 2: Open Chrome (manual step - show command)
    print("\n[2/5] Open Chrome with debug mode:")
-    print("google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:8188/loras")
+    print(
+        f"google-chrome --remote-debugging-port=9222 "
+        f"--user-data-dir=/tmp/chrome-lora-manager http://127.0.0.1:{PORT}/loras"
+    )
    print("(In actual test, this would be automated via MCP)")
-    
+
    # Step 3: Navigate and verify page load
    print("\n[3/5] Page Load Verification:")
-    print("""
+    print(
+        f"""
    MCP Commands to execute:
-    1. navigate_page(type="url", url="http://127.0.0.1:8188/loras")
+    1. navigate_page(type="url", url="http://127.0.0.1:{PORT}/loras")
    2. wait_for(text="LoRAs", timeout=10000)
    3. snapshot = take_snapshot()
-    """)
-    
+    """
+    )
+
    # Step 4: Test search functionality
    print("\n[4/5] Search Functionality Test:")
-    print("""
+    print(
+        """
    MCP Commands to execute:
    1. fill(uid="search-input", value="test")
    2. press_key(key="Enter")
    3. wait_for(text="Results", timeout=5000)
-    4. result = evaluate_script(function="""
+    4. result = evaluate_script(function=`
        () => {
            const cards = document.querySelectorAll('.lora-card');
            return { count: cards.length };
        }
-        """)
-    """)
-    
+        `)
+    """
+    )
+
    # Step 5: Verify API
    print("\n[5/5] API Verification:")
-    print("""
+    print(
+        """
    MCP Commands to execute:
-    1. api_result = evaluate_script(function="""
+    1. api_result = evaluate_script(function=`
        async () => {
            const response = await fetch('/loras/api/list');
            const data = await response.json();
            return { count: data.length, status: response.status };
        }
-        """)
+        `)
    2. Verify api_result['status'] == 200
-    """)
-    
+    """
+    )
+
    print("\n" + "=" * 60)
    print("Test flow completed!")
    print("=" * 60)
-    
+
    return 0


 def example_restart_flow():
    """Example: Testing configuration change that requires restart."""
-    
+
    print("\n" + "=" * 60)
    print("Example: Server Restart Flow")
    print("=" * 60)
-    
-    print("""
+
+    print(
+        f"""
    Scenario: Change setting and verify after restart
-    
+
    Steps:
    1. Navigate to settings page
-       - navigate_page(type="url", url="http://127.0.0.1:8188/settings")
-    
+       - navigate_page(type="url", url="http://127.0.0.1:{PORT}/settings")
+
    2. Change a setting (e.g., theme)
       - fill(uid="theme-select", value="dark")
       - click(uid="save-settings-button")
-    
+
    3. Restart server
-       - subprocess.run([python, "start_server.py", "--restart", "--wait"])
-    
+       - subprocess.run([python, "start_server.py", "--port", "{PORT}", "--restart", "--wait", "--detach"])
+
    4. Refresh browser
       - navigate_page(type="reload", ignoreCache=True)
       - wait_for(text="LoRAs", timeout=15000)
-    
+
    5. Verify setting persisted
-       - navigate_page(type="url", url="http://127.0.0.1:8188/settings")
+       - navigate_page(type="url", url="http://127.0.0.1:{PORT}/settings")
       - theme = evaluate_script(function="() => document.querySelector('#theme-select').value")
       - assert theme == "dark"
-    """)
+    """
+    )


 def example_modal_interaction():
    """Example: Testing modal dialog interaction."""
-    
+
    print("\n" + "=" * 60)
    print("Example: Modal Dialog Interaction")
    print("=" * 60)
-    
-    print("""
+
+    print(
+        """
    Scenario: Add new LoRA via modal
-    
+
    Steps:
    1. Open modal
       - click(uid="add-lora-button")
       - wait_for(text="Add LoRA", timeout=3000)
-    
+
    2. Fill form
       - fill_form(elements=[
           {"uid": "lora-name", "value": "Test Character"},
           {"uid": "lora-path", "value": "/models/test.safetensors"},
       ])
-    
+
    3. Submit
       - click(uid="modal-submit-button")
-    
+
    4. Verify success
       - wait_for(text="Successfully added", timeout=5000)
       - snapshot = take_snapshot()
-    """)
+    """
+    )


 def example_network_monitoring():
    """Example: Network request monitoring."""
-    
+
    print("\n" + "=" * 60)
    print("Example: Network Request Monitoring")
    print("=" * 60)
-    
-    print("""
+
+    print(
+        f"""
    Scenario: Verify API calls during user interaction
-    
+
    Steps:
    1. Clear network log (implicit on navigation)
-       - navigate_page(type="url", url="http://127.0.0.1:8188/loras")
-    
+       - navigate_page(type="url", url="http://127.0.0.1:{PORT}/loras")
+
    2. Perform action that triggers API call
       - fill(uid="search-input", value="character")
       - press_key(key="Enter")
-    
+
    3. List network requests
       - requests = list_network_requests(resourceTypes=["xhr", "fetch"])
-    
+
    4. Find search API call
       - search_requests = [r for r in requests if "/api/search" in r.get("url", "")]
       - assert len(search_requests) > 0, "Search API was not called"
-    
+
    5. Get request details
       - if search_requests:
           details = get_network_request(reqid=search_requests[0]["reqid"])
           - Verify request method, response status, etc.
-    """)
+    """
+    )


 if __name__ == "__main__":
    print("LoRa Manager E2E Test Examples\n")
    print("This script demonstrates E2E testing patterns.\n")
    print("Note: Actual execution requires Chrome DevTools MCP connection.\n")
-    
+
    run_test()
    example_restart_flow()
    example_modal_interaction()
    example_network_monitoring()
-    
+
    print("\n" + "=" * 60)
    print("All examples shown!")
    print("=" * 60)
@@ -1,15 +1,78 @@
 #!/usr/bin/env python3
 """
 Start or restart LoRa Manager standalone server for E2E testing.
+
+Backward-compatible CLI: --port, --restart, --wait, --timeout all work as before.
+New options: --detach (setsid-style fully detached launch, survives shell death).
+
+Safety rules implemented here:
+- Never kill processes the script did not start. The script tracks the PIDs it
+  manages in a pidfile (/tmp/lora-manager-e2e-server-{PORT}.pid).
+- If the port is held by an unrelated process (e.g. a live ComfyUI) the script
+  reports the conflict and exits early instead of killing it.
+- --restart only kills managed PIDs; if unrelated processes still hold the port
+  afterwards, the script reports them and aborts.
 """

+from __future__ import annotations
+
 import argparse
+import os
+import signal
+import socket
 import subprocess
 import sys
 import time
-import socket
-import signal
-import os
+
+PIDFILE_PREFIX = "/tmp/lora-manager-e2e-server"
+
+
+def pidfile_path(port: int) -> str:
+    """Path of the pidfile that records PIDs this script started for a port."""
+    return f"{PIDFILE_PREFIX}-{port}.pid"
+
+
+def read_managed_pids(port: int) -> list[int]:
+    """Read PIDs this script previously managed for the port (may be stale)."""
+    path = pidfile_path(port)
+    if not os.path.exists(path):
+        return []
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return [int(line.strip()) for line in fh if line.strip().isdigit()]
+    except (OSError, ValueError):
+        return []
+
+
+def write_managed_pids(port: int, pids: list[int]) -> None:
+    """Record PIDs this script manages for the port."""
+    try:
+        with open(pidfile_path(port), "w", encoding="utf-8") as fh:
+            for pid in pids:
+                fh.write(f"{pid}\n")
+    except OSError as exc:
+        print(f"Warning: could not write pidfile for port {port}: {exc}")
+
+
+def clear_managed_pids(port: int) -> None:
+    """Remove the pidfile for the port (no longer managed)."""
+    path = pidfile_path(port)
+    try:
+        if os.path.exists(path):
+            os.remove(path)
+    except OSError as exc:
+        print(f"Warning: could not remove pidfile {path}: {exc}")
+
+
+def process_alive(pid: int) -> bool:
+    """Return True if a process with the given pid exists."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True  # exists but owned by someone else


 def find_server_process(port: int) -> list[int]:
@@ -19,7 +82,7 @@ def find_server_process(port: int) -> list[int]:
            ["lsof", "-ti", f":{port}"],
            capture_output=True,
            text=True,
-            check=False
+            check=False,
        )
        if result.returncode == 0 and result.stdout.strip():
            return [int(pid) for pid in result.stdout.strip().split("\n") if pid]
@@ -30,7 +93,7 @@ def find_server_process(port: int) -> list[int]:
                ["netstat", "-tlnp"],
                capture_output=True,
                text=True,
-                check=False
+                check=False,
            )
            pids = []
            for line in result.stdout.split("\n"):
@@ -49,30 +112,48 @@ def find_server_process(port: int) -> list[int]:
    return []


-def kill_server(port: int) -> None:
-    """Kill processes using the specified port."""
-    pids = find_server_process(port)
+def describe_processes(pids: list[int]) -> str:
+    """Human-readable description of a pid list (pid + command line)."""
+    descriptions = []
    for pid in pids:
+        cmdline = ""
+        try:
+            with open(f"/proc/{pid}/cmdline", "rb") as fh:
+                raw = fh.read().replace(b"\x00", b" ").decode("utf-8", "replace")
+                cmdline = raw.strip()
+        except OSError:
+            pass
+        descriptions.append(f"pid {pid}{' (' + cmdline + ')' if cmdline else ''}")
+    return ", ".join(descriptions) if descriptions else "none"
+
+
+def kill_pids(pids: list[int], what: str) -> None:
+    """Send SIGTERM (then SIGKILL) to the given PIDs, only after reporting."""
+    for pid in pids:
+        print(f"Sent SIGTERM to {what} pid {pid}")
        try:
            os.kill(pid, signal.SIGTERM)
-            print(f"Sent SIGTERM to process {pid}")
        except ProcessLookupError:
            pass
-    
+
    # Wait for processes to terminate
-    time.sleep(1)
-    
+    deadline = time.time() + 5
+    while time.time() < deadline:
+        if not any(process_alive(pid) for pid in pids):
+            break
+        time.sleep(0.2)
+
    # Force kill if still running
-    pids = find_server_process(port)
    for pid in pids:
-        try:
-            os.kill(pid, signal.SIGKILL)
-            print(f"Sent SIGKILL to process {pid}")
-        except ProcessLookupError:
-            pass
+        if process_alive(pid):
+            try:
+                os.kill(pid, signal.SIGKILL)
+                print(f"Sent SIGKILL to {what} pid {pid}")
+            except ProcessLookupError:
+                pass


-def is_server_ready(port: int, timeout: float = 0.5) -> bool:
+def is_server_ready(port: int, timeout: float = 2.0) -> bool:
    """Check if server is accepting connections."""
    try:
        with socket.create_connection(("127.0.0.1", port), timeout=timeout):
@@ -84,9 +165,15 @@ def is_server_ready(port: int, timeout: float = 0.5) -> bool:
 def wait_for_server(port: int, timeout: int = 30) -> bool:
    """Wait for server to become ready."""
    start = time.time()
+    last_report = 0.0
    while time.time() - start < timeout:
        if is_server_ready(port):
            return True
+        # Report progress every ~5s so a slow boot is visible, not silent.
+        elapsed = time.time() - start
+        if elapsed - last_report >= 5:
+            print(f"  ...still waiting ({int(elapsed)}s/{timeout}s)")
+            last_report = elapsed
        time.sleep(0.5)
    return False

@@ -99,68 +186,148 @@ def main() -> int:
        "--port",
        type=int,
        default=8188,
-        help="Server port (default: 8188)"
+        help="Server port (default: 8188)",
    )
    parser.add_argument(
        "--restart",
        action="store_true",
-        help="Kill existing server before starting"
+        help="Kill the E2E server previously managed by this script for the port "
+        "(tracked via pidfile) before starting; refuse to kill unrelated processes",
    )
    parser.add_argument(
        "--wait",
        action="store_true",
-        help="Wait for server to be ready before exiting"
+        help="Wait for server to be ready before exiting",
    )
    parser.add_argument(
        "--timeout",
        type=int,
        default=30,
-        help="Timeout for waiting (default: 30)"
+        help="Timeout for waiting (default: 30)",
    )
-    
+    parser.add_argument(
+        "--detach",
+        action="store_true",
+        help="Launch the server fully detached (setsid-style) so it survives shell "
+        "death. REQUIRED for E2E: a plain background process dies with the shell",
+    )
+
    args = parser.parse_args()
-    
+
    # Get project root (parent of .agents directory)
    script_dir = os.path.dirname(os.path.abspath(__file__))
    skill_dir = os.path.dirname(script_dir)
    project_root = os.path.dirname(os.path.dirname(os.path.dirname(skill_dir)))
-    
-    # Restart if requested
+
+    managed_pids = read_managed_pids(args.port)
+
+    # Restart if requested: kill ONLY managed PIDs.
    if args.restart:
-        print(f"Killing existing server on port {args.port}...")
-        kill_server(args.port)
+        alive_managed = [pid for pid in managed_pids if process_alive(pid)]
+        if alive_managed:
+            print(
+                f"Killing E2E server previously started by this script on port "
+                f"{args.port} ({describe_processes(alive_managed)})..."
+            )
+            kill_pids(alive_managed, "managed E2E server")
+        else:
+            print(
+                f"No live managed E2E server for port {args.port} "
+                f"(pidfile: {pidfile_path(args.port)})"
+            )
        time.sleep(1)
-    
-    # Check if already running
-    if is_server_ready(args.port):
-        print(f"Server already running on port {args.port}")
-        return 0
-    
+        # Refuse to kill anything the script did not manage.
+        remaining = find_server_process(args.port)
+        if remaining:
+            print(
+                f"ERROR: port {args.port} is still held by process(es) this script "
+                f"did not start: {describe_processes(remaining)}."
+            )
+            print(
+                "These may be unrelated (e.g. a live ComfyUI). The script will NOT "
+                "kill them. Pick a different --port, or stop them manually if you "
+                "are certain they are stale E2E servers."
+            )
+            return 2
+        clear_managed_pids(args.port)
+
+    # Port conflict check before starting: never blind-kill.
+    port_pids = find_server_process(args.port)
+    if port_pids:
+        alive_managed = [pid for pid in port_pids if pid in managed_pids]
+        unmanaged = [pid for pid in port_pids if pid not in managed_pids]
+        if alive_managed and not unmanaged:
+            print(
+                f"Server already running on port {args.port} "
+                f"({describe_processes(alive_managed)}, started by this script). "
+                f"Use --restart to recycle it."
+            )
+            return 0
+        print(
+            f"ERROR: port {args.port} is already in use by process(es): "
+            f"{describe_processes(port_pids)}."
+        )
+        print(
+            "This is likely an unrelated process (e.g. a live ComfyUI holding 8188). "
+            "The script will NOT kill it. Pick a free port with --port, e.g. 8199."
+        )
+        return 2
+
    # Start server
    print(f"Starting LoRa Manager standalone server on port {args.port}...")
-    cmd = [sys.executable, "standalone.py", "--port", str(args.port)]
-    
-    # Start in background
-    process = subprocess.Popen(
-        cmd,
-        cwd=project_root,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        start_new_session=True
-    )
-    
-    print(f"Server process started with PID {process.pid}")
-    
+    cmd = [
+        sys.executable,
+        "standalone.py",
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(args.port),
+    ]
+
+    if args.detach:
+        # Fully detached launch: new session (setsid), no controlling terminal,
+        # stdin from /dev/null, stdout/stderr to a log file. Survives the shell.
+        log_dir = os.path.join(script_dir, "logs")
+        os.makedirs(log_dir, exist_ok=True)
+        log_path = os.path.join(log_dir, f"server-{args.port}.log")
+        with open(log_path, "ab") as log_fh:
+            process = subprocess.Popen(
+                cmd,
+                cwd=project_root,
+                stdin=subprocess.DEVNULL,
+                stdout=log_fh,
+                stderr=subprocess.STDOUT,
+                start_new_session=True,
+                close_fds=True,
+            )
+        print(f"Detached server process started with PID {process.pid} (setsid)")
+        print(f"Log: {log_path}")
+    else:
+        # Plain background process (legacy behavior): dies with the shell.
+        process = subprocess.Popen(
+            cmd,
+            cwd=project_root,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            start_new_session=True,
+        )
+        print(f"Server process started with PID {process.pid}")
+        print(
+            "NOTE: not detached — this process dies when the launching shell exits. "
+            "For E2E use --detach."
+        )
+
+    write_managed_pids(args.port, [process.pid])
+
    # Wait for ready if requested
    if args.wait:
        print(f"Waiting for server to be ready (timeout: {args.timeout}s)...")
        if wait_for_server(args.port, args.timeout):
            print(f"Server ready at http://127.0.0.1:{args.port}/loras")
            return 0
-        else:
-            print(f"Timeout waiting for server")
-            return 1
-    
+        print(f"Timeout waiting for server on port {args.port}")
+        return 1
+
    print(f"Server starting at http://127.0.0.1:{args.port}/loras")
    return 0

@@ -1,15 +1,20 @@
 #!/usr/bin/env python3
 """
 Wait for LoRa Manager server to become ready.
+
+Timeout is configurable via --timeout (default 30s); the script polls the port
+until the server accepts connections or the timeout expires.
 """

+from __future__ import annotations
+
 import argparse
 import socket
 import sys
 import time


-def is_server_ready(port: int, timeout: float = 0.5) -> bool:
+def is_server_ready(port: int, timeout: float = 2.0) -> bool:
    """Check if server is accepting connections."""
    try:
        with socket.create_connection(("127.0.0.1", port), timeout=timeout):
@@ -21,9 +26,15 @@ def is_server_ready(port: int, timeout: float = 0.5) -> bool:
 def wait_for_server(port: int, timeout: int = 30) -> bool:
    """Wait for server to become ready."""
    start = time.time()
+    last_report = 0.0
    while time.time() - start < timeout:
        if is_server_ready(port):
            return True
+        # Report progress every ~5s so a slow boot is visible, not silent.
+        elapsed = time.time() - start
+        if elapsed - last_report >= 5:
+            print(f"  ...still waiting ({int(elapsed)}s/{timeout}s)")
+            last_report = elapsed
        time.sleep(0.5)
    return False

@@ -36,25 +47,24 @@ def main() -> int:
        "--port",
        type=int,
        default=8188,
-        help="Server port (default: 8188)"
+        help="Server port (default: 8188)",
    )
    parser.add_argument(
        "--timeout",
        type=int,
        default=30,
-        help="Timeout in seconds (default: 30)"
+        help="Timeout in seconds (default: 30)",
    )
-    
+
    args = parser.parse_args()
-    
+
    print(f"Waiting for server on port {args.port} (timeout: {args.timeout}s)...")
-    
+
    if wait_for_server(args.port, args.timeout):
        print(f"Server ready at http://127.0.0.1:{args.port}/loras")
        return 0
-    else:
-        print(f"Timeout: Server not ready after {args.timeout}s")
-        return 1
+    print(f"Timeout: Server not ready after {args.timeout}s")
+    return 1


 if __name__ == "__main__":
@@ -0,0 +1,202 @@
+---
+slug: undo-delete-staging
+status: drafting
+intent: clear
+review_required: false
+pending-action: write .omo/plans/undo-delete-staging.md
+approach: "Option B: delayed physical deletion with Undo. Backend: same-volume rename to per-root staging dir (.lm-pending-delete/) [updated 2026-08: model staging moved to a SIBLING dir inside each deleted model's own folder — see 'Symlink fix (2026-08)' under Decisions] + manifest JSON (batch_id, expires_at, staged->original map) + purge (30s TTL timer + startup sweep + opportunistic) + undo-delete endpoint + settings toggle 'skip undo'. Small files (recipes: JSON+preview) copy to global staging under settings dir instead of rename. Frontend: extend toast system with action button + 30s countdown; delete flows (single model / recipe / bulk / duplicates) consume batch_id from delete response and show Undo toast; expired undo -> 'undo expired' toast. Plus confirm-modal friction (C-friction, NO type-to-confirm): delete button delay-activation 1.5s + modal shows file size 'will free X GB' + Cancel gets initial focus. i18n keys + sync_translation_keys.py."
+---
+
+# Draft: undo-delete-staging
+
+## Components (topology ledger)
+<!-- Lock the SHAPE before depth. One row per top-level component that can succeed or fail independently. -->
+<!-- id | outcome (one line) | status: active|deferred | evidence path -->
+- backend staging module (stage/purge/undo + manifest + per-volume dir resolution) | new module, active | pending exploration: model_lifecycle_service.py delete_model / delete_model_artifacts
+- delete endpoints return batch_id (model/recipe/bulk/duplicates) | active | pending exploration: handlers + response shapes
+- undo-delete HTTP endpoint + route registration | active | pending exploration: route registrar pattern
+- purge scheduling (30s timer + startup sweep + opportunistic) | active | pending exploration: app on_startup hooks
+- settings toggle "skip undo window" | active | pending exploration: settings service read pattern
+- frontend toast extension (action button + countdown) | active | pending exploration: showToast impl
+- frontend delete flows consume batch_id + Undo toast | active | pending exploration: call sites
+- confirm-modal friction (delay-activate + size display + cancel focus) | active | pending exploration: modal focus behavior
+- i18n keys + sync_translation_keys.py | active | known
+
+## Open assumptions (announced defaults)
+<!-- Record any default you adopt instead of asking, so the user can veto it at the gate. -->
+<!-- assumption | adopted default | rationale | reversible? -->
+- Undo window TTL = 30s | 30s balances space-freeing intent vs accident recovery | yes (constant)
+- Staging dir name: `.lm-pending-delete/` under each model root; recipes: `{settings_dir}/.lm-pending-delete/` | hidden, same-volume [updated 2026-08: same-volume is now guaranteed by sibling staging inside the model's own folder, not by the root location], consistent | yes
+- Staging failure falls back to existing hard delete | user intent is delete; staging is best-effort; hard delete likely fails identically under same conditions | yes
+- Purge on startup uses expires_at (not purge-all) so a <30s restart with live tab can still undo | robust, matches client-side timer | yes
+- Settings toggle label: "Delete permanently immediately (skip undo window)" | power users freeing space | yes
+- C-friction: delete button enabled after 1.5s + modal shows freed size; NO type-to-confirm (user vetoed) | user explicitly rejected type-to-confirm | n/a
+- Bulk/duplicates delete: one batch id for whole action, one undo restores all | simplest consistent semantics | yes
+
+## Findings (cited - path:lines)
+
+### Backend
+- `delete_model_artifacts` (py/services/model_lifecycle_service.py:19-48) = physical delete via os.remove; patterns: main file + `{name}.metadata.json` + PREVIEW_EXTENSIONS (py/utils/constants.py:22-37). ALSO called by ModelScanner.bulk_delete_models (py/services/model_scanner.py:2221) - single swap point covers bulk models.
+- `ModelLifecycleService.delete_model` (model_lifecycle_service.py:101-154): fetches `cached_entry` (111-116) - SNAPSHOT available for cache restore; after delete: cache.raw_data removal + resort + bump_cache_version (136-143), `_hash_index.remove_by_path` (145-146), `_sync_update_for_model` (148; update-service only, no recipe JSON rewrites - recipe refs are hash-based, re-resolve on restore), `_persist_current_cache` (150-152), returns `{"success": True, "deleted_files": [...]}` (154).
+- Handler `delete_model` (py/routes/handlers/model_handlers.py:478-492): POST /api/lm/{prefix}/delete; response passthrough; `_broadcast_models_changed()` (57-74) after success; 400 `{"success":false,"error"}`; 500 plain text.
+- Recipe delete: handler (recipe_handlers.py:1422-1438) DELETE /api/lm/recipe/{recipe_id} -> persistence_service.delete_recipe (py/services/recipes/persistence_service.py:193-209): os.remove(recipe_json_path) + os.remove(image_path) (204-206), recipe_scanner.remove_recipe (208), returns `{"success": true, "message": ...}`. PersistenceResult dataclass (20-25).
+- Bulk models: POST /api/lm/{prefix}/bulk-delete (model_route_registrar.py:39) -> handler (model_handlers.py:974-994) -> lifecycle_service.bulk_delete_models (model_lifecycle_service.py:308-318) -> scanner.bulk_delete_models (model_scanner.py:2181-2269) which calls delete_model_artifacts per file (2221) + `_batch_update_cache_for_deleted_models` (2271-2335); response `{"success","status","total_deleted","total_attempted","cache_updated","results"}` (2254-2269).
+- Bulk recipes: POST /api/lm/recipes/bulk-delete (recipe_route_registrar.py:50) -> handler (recipe_handlers.py:1554-1573) -> persistence_service.bulk_delete (persistence_service.py:439-482): per-id os.remove x2 (464-466), recipe_scanner.bulk_remove (472); response `{"success","deleted","failed","total_deleted","total_failed"}` (474-482).
+- Duplicates: NO dedicated delete endpoints (find-only: GET /api/lm/{prefix}/find-duplicates model_route_registrar.py:59, GET /api/lm/recipes/find-duplicates recipe_route_registrar.py:49). Duplicate deletion reuses bulk-delete endpoints.
+- Startup hooks: lora_manager.py:183-187 `app.on_startup.append(lambda app: cls._initialize_services())` (ComfyUI mode, app = PromptServer.instance.app at :78); standalone.py:370-374 same (StandaloneLoraManager.add_routes). Background tasks: `asyncio.create_task(name=...)` (lora_manager.py:224-239; recipe_handlers.py:793). Singleton+asyncio.Lock pattern: model_scanner.py:40-63.
+- Settings: DEFAULT_SETTINGS (py/services/settings_manager.py:57-119), `get(key, default)` (1390-1392), get_settings_manager() (2215-2228), reset_settings_manager() (2231). Typed-bool getter example: get_skip_previously_downloaded_model_versions (1253-1262). Handlers: base_model_routes.py:70, base_recipe_routes.py:54.
+- Model roots: ModelScanner.get_model_roots base NotImplementedError (model_scanner.py:1073-1075); impls lora_scanner.py:31-45, checkpoint_scanner.py:428-441, embedding_scanner.py:24-36. `_find_root_for_file(file_path)` (model_scanner.py:1108-1124) returns containing root - for per-root staging dir computation [updated 2026-08: staging no longer uses the containing root; batches are siblings inside the model's own folder]. Business-path rule (AGENTS.md): use os.path.abspath, never realpath, for staging/undo routing.
+- Cache restore methods: ModelCache has raw_data + resort (conftest mocks: tests/conftest.py:144-154); ModelHashIndex.add_entry(sha256, file_path, autov3) (py/services/model_hash_index.py:16); RecipeScanner.add_recipe(recipe_data) (recipe_scanner.py:2136) -> recipe_cache.add_recipe (recipe_cache.py:64). No single-file incremental model rescan - use snapshot restore instead of rescan.
+- Route registrar: model_route_registrar.py:177 add_route(method, path, handler), :180 add_prefixed_route - undo endpoint can be a non-prefixed route via add_route.
+- Tests: tests/services/test_model_lifecycle_service.py (inline tmp_path files, per-test stub scanners ScannerForDelete/VersionAwareScanner etc); conftest MockScanner/MockCache/MockHashIndex (tests/conftest.py:134-212); integration fixtures tests/integration/conftest.py; lifecycle hook tests tests/routes/test_lora_manager_lifecycle.py:177-178, tests/standalone/test_standalone_server.py:83-84.
+
+### Frontend
+- 5 delete call sites:
+  a) Single model: static/js/utils/modalUtils.js confirmDelete (27-42) -> getModelApiClient().deleteModel(path); ignores return.
+  b) Recipe single: static/js/components/RecipeCard.js confirmDeleteRecipe (405-449) - RAW fetch DELETE /api/lm/recipe/{id}, checks only response.ok, showToast toast.recipes.deletedSuccessfully, state.virtualScroller.removeItemByFilePath.
+  c) Bulk: static/js/managers/BulkManager.js confirmBulkDelete (633-672) -> getActiveApiClient() (134-142) -> bulkDeleteModels(filePaths); reads result.cancelled/success/deleted_count/error.
+  d) Recipe duplicates: static/js/components/DuplicatesManager.js confirmDeleteDuplicates (457-494) - RAW fetch POST /api/lm/recipes/bulk-delete, reads data.success/data.total_deleted, exitDuplicateMode().
+  e) Model duplicates: static/js/components/ModelDuplicatesManager.js confirmDeleteDuplicates (710-776) - RAW fetch POST /api/lm/{type}/bulk-delete, reads data.total_deleted, then resetAndReload(true) + find-duplicates re-check.
+  Bonus: static/js/components/shared/ModelVersionsTab.js:1136-1144 client.deleteModel (ignores return).
+- API clients: BaseModelApiClient.deleteModel (static/js/api/baseModelApi.js:184-216) returns true/false, shows its own toasts, does removeItemByFilePath inside; bulkDeleteModels (1591-1642) returns {success, deleted_count, failed_count, errors} or {success:false, cancelled:true}; RecipeSidebarApiClient.bulkDeleteModels (recipeApi.js:623-664) returns {success, deleted_count: total_deleted, ...}. Endpoint map apiConfig.js:56,64.
+- Toast: showToast(key, params={}, type='info', fallback=null) (static/js/utils/uiHelpers.js:136-193) - textContent only, NO action/button support; durations 2000/5000ms; CSS static/css/components/toast.css (.toast flex gap:12px - button can be added). Closest action pattern: bannerService.registerBanner actions array + onRegister (static/js/managers/BannerService.js; used uiHelpers.js:18-57).
+- i18n: locales/en.json delete keys (1303-1314 bulkDelete, 1945-1948 recipes, 1987-1991 models, 2124-2130 duplicates, 2166-2170 toast.api); t()/interpolate (static/js/i18n/index.js:193-248); translate wrapper (utils/i18nHelpers.js:13-23); sync script scripts/sync_translation_keys.py (en reference, [TODO: Translate] placeholders).
+- Refresh after undo: recipes -> window.recipeManager.loadRecipes(true) (recipes.js:359; used by FilterManager.js:752 etc) or refreshRecipes (recipeApi.js:308); models -> resetAndReload(true) from modelApiFactory (used by ModelDuplicatesManager.js:740).
+- Size for modal: card.dataset.file_size (ModelCard.js:467), formatFileSize (ModelModal.js:615).
+- Tests: tests/frontend/utils/uiHelpers.dom.test.js (toast), api/recipeApi.bulk.test.js, components/duplicatesManager.test.js, components/modelDuplicatesManager.test.js, pages/*Page.test.js, i18n tests tests/i18n/test_i18n.py.
+
+## Decisions (with rationale)
+
+1. Same-volume rename staging for model files (atomic, no copy cost for multi-GB files); cross-volume rename forbidden. [CORRECTED 2026-08: "same-volume because under the containing root" was only true for plain directories — nested symlinked subdirs could cross volumes. Superseded by sibling staging: `.lm-pending-delete/<batch_id>/` inside the deleted model's own folder makes stage/undo same-device by construction; see "Symlink fix (2026-08)" below.]
+2. Copy-to-global-staging for recipes (small files; avoids recipe JSON vs preview image cross-volume problem).
+3. Manifest JSON files are the only state - no DB changes. Manifest includes model cached_entry snapshot for exact cache restore (no rescan needed).
+4. Undo endpoint returns restored paths; expired batch -> 404-style error -> frontend 'undo expired' toast.
+5. Skip-undo setting honored server-side (no batch_id in response -> no undo toast client-side).
+6. Staging failure falls back to existing hard delete (best-effort undo, never blocks delete).
+7. Undo window TTL = 30s constant (PENDING_DELETE_TTL_SECONDS); startup sweep uses expires_at (survives restart; browser-tab timer survives).
+8. Purge triple-trigger: per-batch asyncio timer task + on_startup sweep + opportunistic purge at each stage/undo.
+9. Frontend: new showActionToast (keep showToast signature untouched; extract shared createToastElement/appendToast internals); undo click -> shared handleUndoDelete(batchId, refreshFn); full list refresh after undo (recipes: window.recipeManager.loadRecipes(true); models: resetAndReload(true)).
+10. C-friction wave (NO type-to-confirm - user vetoed): delete buttons delay-activate 1.5s after modal open, initial focus on Cancel, model delete modal gains "permanently deleted from disk" warning + file size display (card.dataset.file_size + formatFileSize).
+11. Model cache restore on undo: append snapshot to cache.raw_data (dedupe by file_path) + resort + bump_cache_version + _persist_current_cache + _hash_index.add_entry + _broadcast_models_changed. Recipe restore: copy back files + recipe_scanner.add_recipe(recipe_data loaded from restored JSON).
+
+### Symlink fix (2026-08)
+
+Post-execution addendum (plan `.omo/plans/undo-delete-symlink-fix.md`, commits 5fd4946b / 0c00ee22):
+
+12. Model staging moved from `<model_root>/.lm-pending-delete/<batch_id>/` to `<model_dir>/.lm-pending-delete/<batch_id>/` (sibling of the model artifacts, inside the deleted model's own folder). Stage/undo renames are same-device BY CONSTRUCTION — EXDEV is impossible even when the business path traverses nested symlinks to other volumes (the decision-1 "containing root" guarantee covered only plain directories). EXDEV remains possible only for cross-volume merges, which keep the batch_ids-array fallback. Accepted edge: deleting the model's whole FOLDER during the 30s window destroys that batch (undo returns 404). Batch discovery uses an in-memory registry (`_known_batch_dirs`) with a startup reconciliation scan (`purge_expired(scan_roots=True)`) covering restarts and crash leftovers. Recipe batches unchanged (copy-based settings-dir staging with the `_restore_file` EXDEV fallback).
+
+## Scope IN
+
+- Model single delete (model_handlers delete_model / model_lifecycle_service)
+- Recipe delete (recipe_handlers delete_recipe / persistence_service)
+- Bulk delete (models scanner + recipes persistence) + duplicates (reuse bulk endpoints)
+- Undo endpoint POST /api/lm/undo-delete (models + recipes, one batch space)
+- Purge: timer + startup sweep + opportunistic
+- Settings toggle delete_undo_enabled + settings page checkbox
+- Frontend: showActionToast + all 5 delete flows + shared undo handler
+- C-friction modal changes (delay-activate + cancel focus + warning copy + size display)
+- i18n keys + sync_translation_keys.py
+- Backend + frontend tests
+
+## Scope OUT (Must NOT have)
+
+- NO type-to-confirm / hold-to-confirm friction (user vetoed)
+- NO OS trash integration (send2trash) in this iteration
+- NO persistent recycle-bin UI (no trash browsing page)
+- NO changes to exclude/unexclude flow
+- NO DB migrations
+- NO new dependencies (no send2trash)
+- NO changes to download flows
+- NO recipe-JSON rewriting on model undo (hash-based refs re-resolve themselves)
+
+## Open questions
+
+None - all implementation details resolved by exploration. Design decisions settled in conversation (B+C, no type-to-confirm).
+
+## Approval gate
+status: approved
+<!-- Approach approved -> rerun scaffold without --draft-only, run Metis gap analysis, APPEND todo batches, fill TL;DR last, run structural self-check, then Phase 4 handoff. -->
+
+## Review round state (ulw-plan-review-round-state-contract)
+```json
+{
+  "transition": "replace",
+  "phase": "review_round_initialized",
+  "applies_when": ["retry_after_plan_change"],
+  "atomic": true,
+  "review_required": true,
+  "plan_path": ".omo/plans/undo-delete-staging.md",
+  "plan_sha256": "8cf7c9be38a76d8ef1fb832aba043d6d7e82b60465b1bf28c6eafa7045117adc",
+  "review_round_id": "rr-undo-del-20260811-006",
+  "round_status": "active",
+  "pending-action": "review .omo/plans/undo-delete-staging.md",
+  "review": {
+    "momus": { "status": "pending", "workspace_root": "/mnt/data/reinstall-backup-2026-04-12/data/workspace/ComfyUI/custom_nodes/ComfyUI-Lora-Manager", "runtime_home": null, "target": ".omo/plans/undo-delete-staging.md", "round_id": "rr-undo-del-20260811-006", "plan_sha256": "8cf7c9be38a76d8ef1fb832aba043d6d7e82b60465b1bf28c6eafa7045117adc", "launch_id": null, "session": null, "result": null },
+    "independent": { "status": "pending", "workspace_root": "/mnt/data/reinstall-backup-2026-04-12/data/workspace/ComfyUI/custom_nodes/ComfyUI-Lora-Manager", "runtime_home": null, "target": ".omo/plans/undo-delete-staging.md", "round_id": "rr-undo-del-20260811-006", "plan_sha256": "8cf7c9be38a76d8ef1fb832aba043d6d7e82b60465b1bf28c6eafa7045117adc", "launch_id": null, "session": null, "result": null }
+  }
+}
+```
+
+## Review results + fix/retry ledger
+
+### Round 1 (rr-undo-del-20260811-001, plan sha256 6c52bf99...)
+- momus: APPROVE (non-blocking notes: todo1+7 duplicate DEFAULT_SETTINGS key -> fixed todo 7 to verify-only; "batch_ids" plural in todos 8/9 acceptance -> fixed; purge OSError note -> folded into todo 1 purge semantics)
+- independent (oracle): CHANGES_REQUESTED
+  - BLOCKING S1: scanner walks would index .lm-pending-delete staged files as ghost entries -> fixed: todo 1 now mandates scanner walk exclusion at model_scanner.py:706/:867/:1404/_process_model_file + acceptance (o) scanner-visibility test
+  - BLOCKING S2: manifest lacks model_type, undo could restore into wrong cache/hash index -> fixed: manifest now carries model_type + todo 5 resolves per-type scanner via registrar pattern + acceptance (b) checkpoint-batch test
+  - S3 merged-batch expires_at re-anchor -> fixed: merge_batches re-anchors now+TTL in todo 1 + todo 3/4 assertions
+  - S4 manifest-less dir policy -> fixed: quarantine to <batch_id>.orphaned, never delete (todo 1 + acceptance g)
+  - S5 partial-undo retry semantics -> fixed: per-entry restored flag write-through + retry test (acceptance e)
+  - S6 purge locked-file failure semantics -> fixed: skip file, keep batch, never rmtree past errors (todo 1 + acceptance i)
+  - T8 undo-after-restart test -> fixed: todo 5 acceptance (f)
+  - T9 recipe undo -> re-delete test -> fixed: todo 5 acceptance (h)
+  - T7 rescan-stale-entry test -> fixed: todo 5 acceptance (g)
+  - Route registration pinned to shared routes class per mode (NOT per-model-type registrar which registers 3x) -> fixed: todo 5 now creates py/routes/pending_delete_routes.py registered once in lora_manager.py:170-172 + standalone.py:356-358 + duplicate-route test (e)
+  - Version-index staleness on single-delete undo -> fixed: todo 5 follows bulk cache-update pattern incl. rebuild_version_index (model_scanner.py:2324)
+  - Cancelled-bulk batch_id frontend handling -> fixed: todo 9 shows action toast on cancelled+staged-subset
+  - Single-instance assumption -> added to Scope OUT
+  - Occupied-refusal loss UX -> accepted-intent documented in success criteria + modal copy
+
+### Round 2 (rr-undo-del-20260811-002, plan sha256 f3d52235...)
+- momus: APPROVE (all 12 round-1 fixes verified present; zero dead references; non-blocking nits only)
+- independent (oracle): CHANGES_REQUESTED
+  - BLOCK-1: merge_batches file-movement semantics unspecified (silent data-loss vector) -> fixed: todo 1 now specifies move-into-winner-dir + entry re-point + loser-dirs-removed-only-when-empty + abort-on-move-failure (all batches intact) + merge inside service lock + acceptance (k) file-survival assertions + acceptance (l) merge-failure abort test
+  - BLOCK-2: same-file parallel edits within waves (todo 5 vs 6 on lora_manager.py; todo 8 vs 9 on baseModelApi.js) -> fixed: waves/matrix now serialize 5->6 and 8->9 with explicit reasons; matrix updated
+  - Recommended: checkpoint_scanner.py:331 exclusion -> fixed (todo 1 + acceptance p); S5 pre-check skips restored:true entries -> fixed (todo 1); _tags_count restore on undo -> fixed (todo 5 + acceptance j); undo-blind flows documented (ModelVersionsTab + misc_handlers:2456) -> fixed (todo 8 note + Scope OUT); merge-failure no-merge fallback contract (batch_ids array) -> fixed (todos 3/4/9)
+
+### Round 3 (rr-undo-del-20260811-003, plan sha256 8f2dfd46...)
+- momus: APPROVE (all round-2 fixes verified present + spot-checked refs; no new contradictions)
+- independent (oracle): CHANGES_REQUESTED
+  - BLOCKING A: merged batches never timer-purged after re-anchor (winner's original timer no-ops at old expiry; no fresh timer for re-anchored expiry; idle server -> merged batch lingers, violating "30s purge" success criterion; affects EVERY bulk delete) -> fixed: todo 1 merge_batches now ARMS A FRESH PURGE TIMER for the winner with re-anchored expiry + acceptance (q) fresh-timer test + purge_expired must enumerate ALL scanner types' roots (explicit in todo 1)
+  - BLOCKING B: dependency matrix contradicted same-file policy for todos 8/9<->11 (5 shared files) and 12<->11 -> fixed: todo 11 now "Blocked by: 8, 9 (same files...)"; todo 12 blocked by 11 (sync after 11); wave text updated (11, then 12 AFTER 11); "Can parallelize with" columns corrected
+  - BLOCKING C: frontend batch_ids sequential-undo fallback has NO test + merge->undo loser-restore + merge->purge assertions missing -> fixed: todo 9 acceptance now tests the batch_ids fallback path; todo 1 acceptance now has (k2)/(k3)
+  - Notes folded: sub-second toast-tail expiry race accepted; EXDEV fallback = NORMAL path for cross-volume bulks [annotated 2026-08: after the sibling-staging fix, EXDEV can only arise during cross-volume MERGES, never during single stage/undo renames]
+
+### Round 4 (rr-undo-del-20260811-004, plan sha256 179e7ff7...)
+- momus: APPROVE (round-3 fixes verified; one non-blocking nit: todo 11 inline "Blocked by: —" stale -> fixed to "8, 9")
+- independent (oracle): CHANGES_REQUESTED
+  - BLOCKING GAP-1 (NEW, introduced by round-3 fix): todo 8 handleUndoDelete always-refresh/always-toast contract contradicted todo 9's sequential loop "exactly ONE final refresh" -> fixed: handleUndoDelete(batchId, refreshFn, {showToast, refresh}) suppression options; todo 9 loop uses suppressed calls + one final refresh/toast; acceptance extended (loop failure mid-way -> stop + error toast + no final refresh; 404 body discrimination expired vs occupied)
+  - BLOCKING GAP-2: no cross-type purge enumeration test -> fixed: todo 1 acceptance (r) purges expired batches across lora root + checkpoint root + recipe staging dir in one call
+  - Non-blocking folded: GAP-3 404-copy discrimination -> fixed in todo 8 (d); GAP-4 merge partial-failure rollback direction (move back + restore manifests, extended (l) asserts sequential constituent undo still restores everything) -> fixed in todo 1; GAP-5 post-restart timer-loss residual gap documented -> fixed in todo 6; GAP-6 usage_stats.py:424 walk added to exclusion mandate + todo 5 acceptance (k) embeddings undo test
+
+### Round 5 (rr-undo-del-20260811-005, plan sha256 dfaa39ea...)
+- momus: APPROVE (all round-4 fixes verified; no new contradictions)
+- independent (oracle): CHANGES_REQUESTED
+  - BLOCK-1: lock-ordering deadlock ambiguity (asyncio.Lock not re-entrant: opportunistic purge_expired called while stage/undo hold the lock would deadlock on first use) -> fixed: todo 1 now has explicit LOCK HIERARCHY (lock acquired ONLY by stage/merge/undo/purge_batch; purge_expired is lock-free and must be called BEFORE lock acquisition); todo 6 (c) updated with the same rule + acceptance (u) lock-no-deadlock test
+  - BLOCK-2: purge edge semantics unspecified -> fixed: purge_batch treats missing staged files (partially-restored batches) as already-purged (FileNotFoundError silent no-op); sweep skips `.orphaned`-suffixed dirs (quarantine is terminal); acceptance (s) partially-restored purge + (t) quarantine-terminal tests
+  - Non-blocking folded: todo 2/3 test-file collision -> todo 3's bulk tests moved to tests/services/test_model_scanner.py; todo 9 (d) DuplicatesManager refreshFn stated explicitly (recipes loadRecipes / models resetAndReload); modal-copy + bulk-count trade-offs acknowledged in success criteria; acceptance (r) extended with embeddings root
+
+### Round 6 (rr-undo-del-20260811-006, plan sha256 8cf7c9be...)
+- momus: APPROVE (all round-5 fixes verified; no new contradictions; references verified)
+- independent (oracle): APPROVE — no blocking issues; all round-5 items fixed with working, tested solutions; no new race/data-loss/consistency defects
+- Deferred optional improvements (non-blocking, recorded for executor awareness; plan file left untouched to preserve the approved digest):
+  1. Tag-count asymmetry: single delete_model never decrements _tags_count (lifecycle 101-154), bulk does (scanner 2297-2303); undo re-increment is exact for bulk, over-counts for single until rescan (cosmetic, self-healing). Optional fix riding in todo 2: decrement tags in the single-delete path to mirror bulk.
+  2. Todo 5 factual nit: ModelCache.resort() already rebuilds the version index — explicit rebuild in undo is belt-and-braces, no action needed.
+  3. Todo 8 premise nit: ModelVersionsTab call ignores deleteModel's return entirely — nothing breaks, no adaptation needed.
+  4. Todo 3's pytest command includes test_model_lifecycle_service.py which todo 2 edits in the same wave — run that file's tests after todo 2 lands.
+  5. merge_batches with a missing/quarantined constituent id: any sane fallback (abort -> batch_ids, or skip missing) acceptable — files stay staged either way.
+
+## Review lifecycle
+- rounds: 6 (rr-undo-del-20260811-001..006); final round both lanes APPROVE
+- final live-plan validation: sha256 = 8cf7c9be38a76d8ef1fb832aba043d6d7e82b60465b1bf28c6eafa7045117adc — MATCHES approved round-6 digest
+- status: APPROVED — ready for execution handoff ($start-work undo-delete-staging)
@@ -3,6 +3,8 @@ try:  # pragma: no cover - import fallback for pytest collection
    from .py.nodes.lora_loader import LoraLoaderLM, LoraTextLoaderLM
    from .py.nodes.checkpoint_loader import CheckpointLoaderLM
    from .py.nodes.unet_loader import UNETLoaderLM
+    from .py.nodes.random_checkpoint_loader import RandomCheckpointLoaderLM
+    from .py.nodes.random_unet_loader import RandomUNETLoaderLM
    from .py.nodes.trigger_word_toggle import TriggerWordToggleLM
    from .py.nodes.prompt import PromptLM
    from .py.nodes.text import TextLM
@@ -40,6 +42,12 @@ except (
        "py.nodes.checkpoint_loader"
    ).CheckpointLoaderLM
    UNETLoaderLM = importlib.import_module("py.nodes.unet_loader").UNETLoaderLM
+    RandomCheckpointLoaderLM = importlib.import_module(
+        "py.nodes.random_checkpoint_loader"
+    ).RandomCheckpointLoaderLM
+    RandomUNETLoaderLM = importlib.import_module(
+        "py.nodes.random_unet_loader"
+    ).RandomUNETLoaderLM
    TriggerWordToggleLM = importlib.import_module(
        "py.nodes.trigger_word_toggle"
    ).TriggerWordToggleLM
@@ -79,6 +87,8 @@ NODE_CLASS_MAPPINGS = {
    LoraTextLoaderLM.NAME: LoraTextLoaderLM,
    CheckpointLoaderLM.NAME: CheckpointLoaderLM,
    UNETLoaderLM.NAME: UNETLoaderLM,
+    RandomCheckpointLoaderLM.NAME: RandomCheckpointLoaderLM,
+    RandomUNETLoaderLM.NAME: RandomUNETLoaderLM,
    TriggerWordToggleLM.NAME: TriggerWordToggleLM,
    LoraStackerLM.NAME: LoraStackerLM,
    LoraStackCombinerLM.NAME: LoraStackCombinerLM,
@@ -186,6 +186,16 @@
            "cancelled": "Reparatur abgebrochen. {count} Rezepte wurden repariert.",
            "error": "Recipe-Reparatur fehlgeschlagen: {message}"
        },
+        "rematchRecipes": {
+            "label": "Rezepte lokalen Modellen neu zuordnen",
+            "loading": "Rezepte werden lokalen Modellen neu zugeordnet...",
+            "success": "{entries} Einträge in {recipes} Rezepten zugeordnet",
+            "successErrors": "{entries} Einträge in {recipes} Rezepten zugeordnet, {failures} fehlgeschlagen",
+            "allFailed": "Zuordnung fehlgeschlagen für {failures} von {total} Rezepten",
+            "noMatch": "Keine lokale Übereinstimmung für {entries} Einträge in {recipes} Rezepten gefunden",
+            "cancelled": "Zuordnung abgebrochen. {recipes} Rezepte aktualisiert ({entries} Einträge)",
+            "error": "Zuordnung der Rezepte fehlgeschlagen: {message}"
+        },
        "manageExcludedModels": {
            "label": "Ausgeschlossene Modelle verwalten"
        },
@@ -612,6 +622,10 @@
            "label": "Früher Zugriff Updates ausblenden",
            "help": "Nur Early-Access-Updates"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "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."
@@ -768,6 +782,7 @@
            "copyAll": "Alle Syntax kopieren",
            "refreshAll": "Alle Metadaten aktualisieren",
            "repairMetadata": "Metadaten der Auswahl reparieren",
+            "rematchMetadata": "Ausgewählte mit lokalen Modellen abgleichen",
            "reimportMetadata": "Aus Quelle neu importieren",
            "checkUpdates": "Auswahl auf Updates prüfen",
            "moveAll": "Alle in Ordner verschieben",
@@ -823,6 +838,7 @@
            "setContentRating": "Inhaltsbewertung festlegen",
            "moveToFolder": "In Ordner verschieben",
            "repairMetadata": "Metadaten reparieren",
+            "rematchMetadata": "Mit lokalen Modellen abgleichen",
            "reimportMetadata": "Aus Quelle neu importieren",
            "excludeModel": "Modell ausschließen",
            "restoreModel": "Modell wiederherstellen",
@@ -908,7 +924,9 @@
                "dateAsc": "Älteste",
                "lorasCount": "LoRA-Anzahl",
                "lorasCountDesc": "Meiste",
-                "lorasCountAsc": "Wenigste"
+                "lorasCountAsc": "Wenigste",
+                "opened": "Zuletzt geöffnet",
+                "openedDesc": "Zuletzt geöffnet"
            },
            "refresh": {
                "title": "Rezeptliste aktualisieren",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "Nur Favoriten anzeigen",
                "action": "Favoriten"
+            },
+            "layout": {
+                "title": "Rezepte-Layout",
+                "grid": "Raster-Layout",
+                "masonry": "Masonry-Layout (Pinterest-Stil, behält das Seitenverhältnis des Bildes bei)"
            }
        },
        "duplicates": {
            "found": "{count} Duplikat-Gruppen gefunden",
+            "noGroups": "Keine Duplikat-Gruppen mit dem aktuellen Abgleichskriterium gefunden",
            "keepLatest": "Neueste Versionen behalten",
-            "deleteSelected": "Ausgewählte löschen"
+            "deleteSelected": "Ausgewählte löschen",
+            "includePromptLabel": "Prompt beim Abgleich berücksichtigen",
+            "basis": {
+                "loraCombo": "Abgeglichen nach: LoRA-Kombination",
+                "loraComboAndPrompt": "Abgeglichen nach: LoRA-Kombination + Prompt",
+                "hintLoraCombo": "Rezepte mit denselben LoRAs bei identischen Stärken werden gruppiert.",
+                "hintPromptIncluded": "Rezepte werden nur gruppiert, wenn sie dieselben LoRAs bei identischen Stärken UND denselben Prompt verwenden."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "Gibt {size} frei",
            "title": "Modell löschen",
-            "message": "Sind Sie sicher, dass Sie dieses Modell und alle zugehörigen Dateien löschen möchten?"
+            "message": "Sind Sie sicher, dass Sie dieses Modell und alle zugehörigen Dateien löschen möchten?",
+            "recoverableWarning": "Die Datei wird nach 20 Sekunden endgültig gelöscht, sofern Sie nicht rückgängig machen."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "Diese Aktion kann 20 Sekunden lang rückgängig gemacht werden."
        },
        "excludeModel": {
            "title": "Modell ausschließen",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "Diese Version ist neuer als Ihre neueste lokale Version",
                    "earlyAccess": "Früher Zugriff",
                    "earlyAccessTooltip": "Für diese Version ist derzeit Civitai Early Access erforderlich",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "Ignoriert",
                    "ignoredTooltip": "Für diese Version sind Update-Benachrichtigungen deaktiviert",
                    "onSiteOnly": "Nur On-Site",
@@ -1532,6 +1570,7 @@
                    "download": "Herunterladen",
                    "downloadTooltip": "Diese Version herunterladen",
                    "downloadEarlyAccessTooltip": "Diese Early-Access-Version von Civitai herunterladen",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "Diese Version ist nur für die On-Site-Generierung auf Civitai verfügbar",
                    "delete": "Löschen",
                    "deleteTooltip": "Diese lokale Version löschen",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "Rezept im Workflow ersetzt",
            "recipeFailedToSend": "Fehler beim Senden des Rezepts an den Workflow",
            "noMatchingNodes": "Keine kompatiblen Knoten im aktuellen Workflow verfügbar",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "Kein Zielknoten ausgewählt",
            "modelUpdated": "Modell im Workflow aktualisiert",
            "modelFailed": "Fehler beim Aktualisieren des Modellknotens",
@@ -1951,6 +1991,12 @@
            "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}",
+            "rematchComplete": "{entries} Einträge in {recipes} Rezepten zugeordnet",
+            "rematchCompleteErrors": "{entries} Einträge in {recipes} Rezepten zugeordnet, {failures} fehlgeschlagen",
+            "rematchAllFailed": "Zuordnung fehlgeschlagen für {failures} von {total} ausgewählten Rezepten",
+            "rematchUnmatched": "Keine lokale Übereinstimmung für {entries} Einträge in {recipes} Rezepten gefunden",
+            "rematchSkipped": "Keine Zuordnung für die {total} ausgewählten Rezepte erforderlich",
+            "rematchFailed": "Zuordnung 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})",
@@ -2087,6 +2133,14 @@
            "updateFailed": "Fehler beim Aktualisieren der Trigger Words",
            "copyFailed": "Kopieren fehlgeschlagen"
        },
+        "undo": {
+            "action": "Rückgängig",
+            "deleted": "Gelöscht: {name}",
+            "deletedBulk": "{count} Element(e) gelöscht",
+            "expired": "Undo-Fenster abgelaufen. Das Element wurde endgültig gelöscht.",
+            "failed": "Rückgängig machen fehlgeschlagen: {error}",
+            "restored": "Element wiederhergestellt"
+        },
        "virtual": {
            "loadFailed": "Fehler beim Laden der Elemente",
            "loadMoreFailed": "Fehler beim Laden weiterer Elemente",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "Fehler beim Umbenennen der Datei: {error}",
            "previewUpdated": "Vorschau erfolgreich aktualisiert",
            "previewUploadFailed": "Fehler beim Hochladen des Vorschaubilds",
+            "previewDropInvalid": "Nicht unterstützter Dateityp: {name}. Ziehen Sie stattdessen ein Bild oder ein MP4-Video hinein.",
            "refreshComplete": "{action} abgeschlossen",
            "refreshFailed": "Fehler beim {action} der {type}s",
            "metadataRefreshed": "Metadaten erfolgreich aktualisiert",
@@ -186,6 +186,16 @@
      "cancelled": "Repair cancelled. {count} recipes were repaired.",
      "error": "Recipe repair failed: {message}"
    },
+    "rematchRecipes": {
+      "label": "Rematch recipes to local models",
+      "loading": "Rematching recipes to local models...",
+      "success": "Matched {entries} entries across {recipes} recipes",
+      "successErrors": "Matched {entries} entries across {recipes} recipes, {failures} failed",
+      "allFailed": "Rematch failed for {failures} of {total} recipes",
+      "noMatch": "No local match found for {entries} entries in {recipes} recipes",
+      "cancelled": "Rematch cancelled. {recipes} recipes updated ({entries} entries).",
+      "error": "Recipe rematch failed: {message}"
+    },
    "manageExcludedModels": {
      "label": "Manage Excluded Models"
    },
@@ -612,6 +622,10 @@
      "label": "Hide Early Access Updates",
      "help": "When enabled, models with only early access updates will not show 'Update available' badge"
    },
+    "hidePaidUpdates": {
+      "label": "Hide Paid Updates",
+      "help": "When enabled, models with only paid updates will not show 'Update available' badge"
+    },
    "licenseIcons": {
      "useNewStyle": "Use updated license icons",
      "useNewStyleHelp": "Display license permissions with colored indicators (new style) or restriction-only icons (classic style). Mirroring the current CivitAI design."
@@ -768,6 +782,7 @@
      "copyAll": "Copy Selected Syntax",
      "refreshAll": "Refresh Selected Metadata",
      "repairMetadata": "Repair Metadata for Selected",
+      "rematchMetadata": "Rematch Selected to Local Models",
      "reimportMetadata": "Re-import from Source",
      "checkUpdates": "Check Updates for Selected",
      "moveAll": "Move Selected to Folder",
@@ -823,6 +838,7 @@
      "setContentRating": "Set Content Rating",
      "moveToFolder": "Move to Folder",
      "repairMetadata": "Repair metadata",
+      "rematchMetadata": "Rematch to local models",
      "reimportMetadata": "Re-import from Source",
      "excludeModel": "Exclude Model",
      "restoreModel": "Restore Model",
@@ -908,7 +924,9 @@
        "dateAsc": "Oldest",
        "lorasCount": "LoRA Count",
        "lorasCountDesc": "Most",
-        "lorasCountAsc": "Least"
+        "lorasCountAsc": "Least",
+        "opened": "Recently Opened",
+        "openedDesc": "Recently opened"
      },
      "refresh": {
        "title": "Refresh recipe list",
@@ -919,12 +937,25 @@
      "favorites": {
        "title": "Show Favorites Only",
        "action": "Favorites"
+      },
+      "layout": {
+        "title": "Recipes Layout",
+        "grid": "Grid layout",
+        "masonry": "Masonry layout (Pinterest-style, preserves image aspect ratio)"
      }
    },
    "duplicates": {
      "found": "Found {count} duplicate groups",
+      "noGroups": "No duplicate groups found with the current matching basis",
      "keepLatest": "Keep Latest Versions",
-      "deleteSelected": "Delete Selected"
+      "deleteSelected": "Delete Selected",
+      "includePromptLabel": "Include prompt in matching",
+      "basis": {
+        "loraCombo": "Matched by: LoRA combination",
+        "loraComboAndPrompt": "Matched by: LoRA combination + prompt",
+        "hintLoraCombo": "Recipes with the same LoRAs at identical strengths are grouped.",
+        "hintPromptIncluded": "Recipes are grouped only when they use the same LoRAs at identical strengths AND have the same prompt."
+      }
    },
    "contextMenu": {
      "copyRecipe": {
@@ -1257,8 +1288,13 @@
      }
    },
    "deleteModel": {
+      "freesSpace": "Frees {size}",
      "title": "Delete Model",
-      "message": "Are you sure you want to delete this model and all associated files?"
+      "message": "Are you sure you want to delete this model and all associated files?",
+      "recoverableWarning": "This will permanently delete the file after 20 seconds unless you undo."
+    },
+    "deleteRecipe": {
+      "recoverableWarning": "This action can be undone for 20 seconds."
    },
    "excludeModel": {
      "title": "Exclude Model",
@@ -1523,6 +1559,8 @@
          "newerTooltip": "This version is newer than your latest local version",
          "earlyAccess": "Early Access",
          "earlyAccessTooltip": "This version currently requires Civitai early access",
+          "paid": "Paid",
+          "paidTooltip": "This version requires payment to download",
          "ignored": "Ignored",
          "ignoredTooltip": "Update notifications are disabled for this version",
          "onSiteOnly": "On-Site Only",
@@ -1532,6 +1570,7 @@
          "download": "Download",
          "downloadTooltip": "Download this version",
          "downloadEarlyAccessTooltip": "Download this early access version from Civitai",
+          "downloadPaidTooltip": "Download this paid version from Civitai",
          "downloadNotAllowedTooltip": "This version is only available for on-site generation on Civitai",
          "delete": "Delete",
          "deleteTooltip": "Delete this local version",
@@ -1701,6 +1740,7 @@
      "recipeReplaced": "Recipe replaced in workflow",
      "recipeFailedToSend": "Failed to send recipe to workflow",
      "noMatchingNodes": "No compatible nodes available in the current workflow",
+      "noPromptTargets": "No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
      "noTargetNodeSelected": "No target node selected",
      "modelUpdated": "Model updated in workflow",
      "modelFailed": "Failed to update model node",
@@ -1951,6 +1991,12 @@
      "repairBulkComplete": "Repair complete: {repaired} repaired, {skipped} skipped (of {total})",
      "repairBulkSkipped": "No repair needed for any of the {total} selected recipes",
      "repairBulkFailed": "Failed to repair selected recipes: {message}",
+      "rematchComplete": "Matched {entries} entries across {recipes} recipes",
+      "rematchCompleteErrors": "Matched {entries} entries across {recipes} recipes, {failures} failed",
+      "rematchAllFailed": "Rematch failed for {failures} of {total} selected recipes",
+      "rematchUnmatched": "No local match found for {entries} entries in {recipes} recipes",
+      "rematchSkipped": "No rematch needed for any of the {total} selected recipes",
+      "rematchFailed": "Failed to rematch selected recipes: {message}",
      "reimporting": "Re-importing recipe from source...",
      "reimportSuccess": "Recipe re-imported successfully",
      "reimportBulkComplete": "Re-import complete: {completed} re-imported, {failed} failed (of {total})",
@@ -2087,6 +2133,14 @@
      "updateFailed": "Failed to update trigger words",
      "copyFailed": "Copy failed"
    },
+    "undo": {
+      "action": "Undo",
+      "deleted": "Deleted {name}",
+      "deletedBulk": "Deleted {count} item(s)",
+      "expired": "Undo window expired. The item was permanently deleted.",
+      "failed": "Undo failed: {error}",
+      "restored": "Item restored"
+    },
    "virtual": {
      "loadFailed": "Failed to load items",
      "loadMoreFailed": "Failed to load more items",
@@ -2150,6 +2204,7 @@
      "fileRenameFailed": "Failed to rename file: {error}",
      "previewUpdated": "Preview updated successfully",
      "previewUploadFailed": "Failed to upload preview image",
+      "previewDropInvalid": "Unsupported file type: {name}. Drop an image or MP4 video instead.",
      "refreshComplete": "{action} complete",
      "refreshFailed": "Failed to {action} {type}s",
      "metadataRefreshed": "Metadata refreshed successfully",
@@ -186,6 +186,16 @@
            "cancelled": "Reparación cancelada. {count} recetas fueron reparadas.",
            "error": "Error al reparar recetas: {message}"
        },
+        "rematchRecipes": {
+            "label": "Reasociar recetas con modelos locales",
+            "loading": "Reasociando recetas con modelos locales...",
+            "success": "{entries} entradas asociadas en {recipes} recetas",
+            "successErrors": "{entries} entradas asociadas en {recipes} recetas, {failures} fallidas",
+            "allFailed": "Falló la reasociación de {failures} de {total} recetas",
+            "noMatch": "No se encontró coincidencia local para {entries} entradas en {recipes} recetas",
+            "cancelled": "Reasociación cancelada. {recipes} recetas actualizadas ({entries} entradas)",
+            "error": "Falló la reasociación de recetas: {message}"
+        },
        "manageExcludedModels": {
            "label": "Gestionar modelos excluidos"
        },
@@ -612,6 +622,10 @@
            "label": "Ocultar actualizaciones de acceso temprano",
            "help": "Solo actualizaciones de acceso temprano"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "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."
@@ -768,6 +782,7 @@
            "copyAll": "Copiar toda la sintaxis",
            "refreshAll": "Actualizar todos los metadatos",
            "repairMetadata": "Reparar metadatos de la selección",
+            "rematchMetadata": "Reasociar los seleccionados con modelos locales",
            "reimportMetadata": "Reimportar desde origen",
            "checkUpdates": "Comprobar actualizaciones para la selección",
            "moveAll": "Mover todos a carpeta",
@@ -823,6 +838,7 @@
            "setContentRating": "Establecer clasificación de contenido",
            "moveToFolder": "Mover a carpeta",
            "repairMetadata": "Reparar metadatos",
+            "rematchMetadata": "Reasociar con modelos locales",
            "reimportMetadata": "Reimportar desde origen",
            "excludeModel": "Excluir modelo",
            "restoreModel": "Restaurar modelo",
@@ -908,7 +924,9 @@
                "dateAsc": "Más antiguo",
                "lorasCount": "Cant. de LoRAs",
                "lorasCountDesc": "Más",
-                "lorasCountAsc": "Menos"
+                "lorasCountAsc": "Menos",
+                "opened": "Abiertos recientemente",
+                "openedDesc": "Abiertos recientemente"
            },
            "refresh": {
                "title": "Actualizar lista de recetas",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "Mostrar solo favoritos",
                "action": "Favoritos"
+            },
+            "layout": {
+                "title": "Diseño de recetas",
+                "grid": "Vista de cuadrícula",
+                "masonry": "Vista masonry (estilo Pinterest, conserva la proporción de aspecto de la imagen)"
            }
        },
        "duplicates": {
            "found": "Se encontraron {count} grupos de duplicados",
+            "noGroups": "No se encontraron grupos de duplicados con el criterio de coincidencia actual",
            "keepLatest": "Mantener versiones más recientes",
-            "deleteSelected": "Eliminar seleccionados"
+            "deleteSelected": "Eliminar seleccionados",
+            "includePromptLabel": "Incluir prompt en la coincidencia",
+            "basis": {
+                "loraCombo": "Coincidencia por: combinación de LoRA",
+                "loraComboAndPrompt": "Coincidencia por: combinación de LoRA + prompt",
+                "hintLoraCombo": "Se agrupan las recetas con los mismos LoRAs y las mismas intensidades.",
+                "hintPromptIncluded": "Las recetas solo se agrupan cuando usan los mismos LoRAs con intensidades idénticas Y tienen el mismo prompt."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "Libera {size}",
            "title": "Eliminar modelo",
-            "message": "¿Estás seguro de que quieres eliminar este modelo y todos los archivos asociados?"
+            "message": "¿Estás seguro de que quieres eliminar este modelo y todos los archivos asociados?",
+            "recoverableWarning": "El archivo se eliminará permanentemente después de 20 segundos a menos que deshaga la acción."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "Esta acción se puede deshacer durante 20 segundos."
        },
        "excludeModel": {
            "title": "Excluir modelo",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "Esta versión es más reciente que tu última versión local",
                    "earlyAccess": "Acceso temprano",
                    "earlyAccessTooltip": "Esta versión requiere actualmente acceso temprano de Civitai",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "Ignorada",
                    "ignoredTooltip": "Las notificaciones de actualización están desactivadas para esta versión",
                    "onSiteOnly": "Solo en Sitio",
@@ -1532,6 +1570,7 @@
                    "download": "Descargar",
                    "downloadTooltip": "Descargar esta versión",
                    "downloadEarlyAccessTooltip": "Descargar esta versión de acceso temprano desde Civitai",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "Esta versión solo está disponible para generación en el sitio de Civitai",
                    "delete": "Eliminar",
                    "deleteTooltip": "Eliminar esta versión local",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "Receta reemplazada en el flujo de trabajo",
            "recipeFailedToSend": "Error al enviar receta al flujo de trabajo",
            "noMatchingNodes": "No hay nodos compatibles disponibles en el flujo de trabajo actual",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "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",
@@ -1951,6 +1991,12 @@
            "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}",
+            "rematchComplete": "{entries} entradas asociadas en {recipes} recetas",
+            "rematchCompleteErrors": "{entries} entradas asociadas en {recipes} recetas, {failures} fallidas",
+            "rematchAllFailed": "Falló la reasociación de {failures} de {total} recetas seleccionadas",
+            "rematchUnmatched": "No se encontró coincidencia local para {entries} entradas en {recipes} recetas",
+            "rematchSkipped": "Ninguna de las {total} recetas seleccionadas necesita reasociación",
+            "rematchFailed": "Falló la reasociación de las recetas seleccionadas: {message}",
            "reimporting": "Reimportando receta desde origen...",
            "reimportSuccess": "Receta reimportada exitosamente",
            "reimportBulkComplete": "Reimportación completa: {completed} reimportadas, {failed} fallidas (de {total})",
@@ -2087,6 +2133,14 @@
            "updateFailed": "Error al actualizar palabras clave",
            "copyFailed": "Error al copiar"
        },
+        "undo": {
+            "action": "Deshacer",
+            "deleted": "Eliminado: {name}",
+            "deletedBulk": "{count} elemento(s) eliminado(s)",
+            "expired": "La ventana de deshacer ha caducado. El elemento se eliminó permanentemente.",
+            "failed": "No se pudo deshacer: {error}",
+            "restored": "Elemento restaurado"
+        },
        "virtual": {
            "loadFailed": "Error al cargar elementos",
            "loadMoreFailed": "Error al cargar más elementos",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "Error al renombrar archivo: {error}",
            "previewUpdated": "Vista previa actualizada exitosamente",
            "previewUploadFailed": "Error al subir imagen de vista previa",
+            "previewDropInvalid": "Tipo de archivo no admitido: {name}. Arrastra una imagen o un video MP4 en su lugar.",
            "refreshComplete": "{action} completada",
            "refreshFailed": "Error al {action} {type}s",
            "metadataRefreshed": "Metadatos actualizados exitosamente",
@@ -186,6 +186,16 @@
            "cancelled": "Réparation annulée. {count} recettes ont été réparées.",
            "error": "Échec de la réparation des recettes : {message}"
        },
+        "rematchRecipes": {
+            "label": "Réassocier les recettes aux modèles locaux",
+            "loading": "Réassociation des recettes aux modèles locaux...",
+            "success": "{entries} entrées associées dans {recipes} recettes",
+            "successErrors": "{entries} entrées associées dans {recipes} recettes, {failures} échecs",
+            "allFailed": "Échec de la réassociation de {failures} recettes sur {total}",
+            "noMatch": "Aucune correspondance locale trouvée pour {entries} entrées dans {recipes} recettes",
+            "cancelled": "Réassociation annulée. {recipes} recettes mises à jour ({entries} entrées)",
+            "error": "Échec de la réassociation des recettes : {message}"
+        },
        "manageExcludedModels": {
            "label": "Gérer les modèles exclus"
        },
@@ -612,6 +622,10 @@
            "label": "Masquer les mises à jour en accès anticipé",
            "help": "Seulement les mises à jour en accès anticipé"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "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."
@@ -768,6 +782,7 @@
            "copyAll": "Copier toute la syntaxe",
            "refreshAll": "Actualiser toutes les métadonnées",
            "repairMetadata": "Réparer les métadonnées de la sélection",
+            "rematchMetadata": "Réassocier la sélection aux modèles locaux",
            "reimportMetadata": "Ré-importer depuis la source",
            "checkUpdates": "Vérifier les mises à jour pour la sélection",
            "moveAll": "Déplacer tout vers un dossier",
@@ -823,6 +838,7 @@
            "setContentRating": "Définir la classification du contenu",
            "moveToFolder": "Déplacer vers un dossier",
            "repairMetadata": "Réparer les métadonnées",
+            "rematchMetadata": "Réassocier aux modèles locaux",
            "reimportMetadata": "Ré-importer depuis la source",
            "excludeModel": "Exclure le modèle",
            "restoreModel": "Restaurer le modèle",
@@ -908,7 +924,9 @@
                "dateAsc": "Plus ancien",
                "lorasCount": "Nombre de LoRAs",
                "lorasCountDesc": "Plus",
-                "lorasCountAsc": "Moins"
+                "lorasCountAsc": "Moins",
+                "opened": "Récemment ouverts",
+                "openedDesc": "Récemment ouverts"
            },
            "refresh": {
                "title": "Actualiser la liste des recipes",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "Afficher uniquement les favoris",
                "action": "Favoris"
+            },
+            "layout": {
+                "title": "Disposition des recettes",
+                "grid": "Disposition en grille",
+                "masonry": "Disposition masonry (style Pinterest, préserve le rapport d'aspect de l'image)"
            }
        },
        "duplicates": {
            "found": "Trouvé {count} groupes de doublons",
+            "noGroups": "Aucun groupe de doublons trouvé avec le critère de correspondance actuel",
            "keepLatest": "Garder les dernières versions",
-            "deleteSelected": "Supprimer la sélection"
+            "deleteSelected": "Supprimer la sélection",
+            "includePromptLabel": "Inclure le prompt dans la correspondance",
+            "basis": {
+                "loraCombo": "Correspondance : combinaison de LoRA",
+                "loraComboAndPrompt": "Correspondance : combinaison de LoRA + prompt",
+                "hintLoraCombo": "Les recettes avec les mêmes LoRAs et des forces identiques sont regroupées.",
+                "hintPromptIncluded": "Les recettes ne sont regroupées que si elles utilisent les mêmes LoRAs avec des forces identiques ET ont le même prompt."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "Libère {size}",
            "title": "Supprimer le modèle",
-            "message": "Êtes-vous sûr de vouloir supprimer ce modèle et tous les fichiers associés ?"
+            "message": "Êtes-vous sûr de vouloir supprimer ce modèle et tous les fichiers associés ?",
+            "recoverableWarning": "Le fichier sera définitivement supprimé après 20 secondes, sauf si vous annulez."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "Cette action peut être annulée pendant 20 secondes."
        },
        "excludeModel": {
            "title": "Exclure le modèle",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "Cette version est plus récente que votre dernière version locale",
                    "earlyAccess": "Accès anticipé",
                    "earlyAccessTooltip": "Cette version nécessite actuellement l'accès anticipé Civitai",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "Ignorée",
                    "ignoredTooltip": "Les notifications de mise à jour sont désactivées pour cette version",
                    "onSiteOnly": "Uniquement sur Site",
@@ -1532,6 +1570,7 @@
                    "download": "Télécharger",
                    "downloadTooltip": "Télécharger cette version",
                    "downloadEarlyAccessTooltip": "Télécharger cette version en accès anticipé depuis Civitai",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "Cette version n'est disponible que pour la génération sur le site Civitai",
                    "delete": "Supprimer",
                    "deleteTooltip": "Supprimer cette version locale",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "Recipe remplacée dans le workflow",
            "recipeFailedToSend": "Échec de l'envoi de la recipe au workflow",
            "noMatchingNodes": "Aucun nœud compatible disponible dans le workflow actuel",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "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",
@@ -1951,6 +1991,12 @@
            "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}",
+            "rematchComplete": "{entries} entrées associées dans {recipes} recettes",
+            "rematchCompleteErrors": "{entries} entrées associées dans {recipes} recettes, {failures} échecs",
+            "rematchAllFailed": "Échec de la réassociation de {failures} recettes sélectionnées sur {total}",
+            "rematchUnmatched": "Aucune correspondance locale trouvée pour {entries} entrées dans {recipes} recettes",
+            "rematchSkipped": "Aucune des {total} recettes sélectionnées ne nécessite de réassociation",
+            "rematchFailed": "Échec de la réassociation 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})",
@@ -2087,6 +2133,14 @@
            "updateFailed": "Échec de la mise à jour des mots-clés",
            "copyFailed": "Échec de la copie"
        },
+        "undo": {
+            "action": "Annuler",
+            "deleted": "Supprimé : {name}",
+            "deletedBulk": "{count} élément(s) supprimé(s)",
+            "expired": "La fenêtre d'annulation a expiré. L'élément a été définitivement supprimé.",
+            "failed": "Échec de l'annulation : {error}",
+            "restored": "Élément restauré"
+        },
        "virtual": {
            "loadFailed": "Échec du chargement des éléments",
            "loadMoreFailed": "Échec du chargement de plus d'éléments",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "Échec du renommage du fichier : {error}",
            "previewUpdated": "Aperçu mis à jour avec succès",
            "previewUploadFailed": "Échec du téléchargement de l'image d'aperçu",
+            "previewDropInvalid": "Type de fichier non pris en charge : {name}. Déposez plutôt une image ou une vidéo MP4.",
            "refreshComplete": "{action} terminé",
            "refreshFailed": "Échec de {action} des {type}s",
            "metadataRefreshed": "Métadonnées actualisées avec succès",
@@ -186,6 +186,16 @@
            "cancelled": "תיקון בוטל. {count} מתכונים תוקנו.",
            "error": "תיקון המתכונים נכשל: {message}"
        },
+        "rematchRecipes": {
+            "label": "התאמה מחדש של מתכונים למודלים מקומיים",
+            "loading": "מתבצעת התאמה מחדש של מתכונים למודלים מקומיים...",
+            "success": "הותאמו {entries} פריטים ב־{recipes} מתכונים",
+            "successErrors": "הותאמו {entries} פריטים ב־{recipes} מתכונים, {failures} נכשלו",
+            "allFailed": "ההתאמה נכשלה עבור {failures} מתוך {total} מתכונים",
+            "noMatch": "לא נמצאה התאמה מקומית עבור {entries} פריטים ב־{recipes} מתכונים",
+            "cancelled": "ההתאמה בוטלה. עודכנו {recipes} מתכונים ({entries} פריטים)",
+            "error": "ההתאמה מחדש של המתכונים נכשלה: {message}"
+        },
        "manageExcludedModels": {
            "label": "ניהול מודלים מוחרגים"
        },
@@ -612,6 +622,10 @@
            "label": "הסתר עדכוני גישה מוקדמת",
            "help": "רק עדכוני גישה מוקדמת"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "השתמש בסמלי רישיון מעודכנים",
            "useNewStyleHelp": "הצג הרשאות רישיון עם מחוונים צבעוניים (סגנון חדש) או סמלי הגבלה בלבד (סגנון קלאסי). משקף את העיצוב העדכני של CivitAI."
@@ -768,6 +782,7 @@
            "copyAll": "העתק את כל התחבירים",
            "refreshAll": "רענן את כל המטא-דאטה",
            "repairMetadata": "תקן מטא-דאטה עבור הנבחרים",
+            "rematchMetadata": "התאמה מחדש של הנבחרים למודלים מקומיים",
            "reimportMetadata": "ייבא מחדש ממקור",
            "checkUpdates": "בדוק עדכונים לבחירה",
            "moveAll": "העבר הכל לתיקייה",
@@ -823,6 +838,7 @@
            "setContentRating": "הגדר דירוג תוכן",
            "moveToFolder": "העבר לתיקייה",
            "repairMetadata": "תיקון מטא-דאטה",
+            "rematchMetadata": "התאמה מחדש למודלים מקומיים",
            "reimportMetadata": "ייבא מחדש ממקור",
            "excludeModel": "החרג מודל",
            "restoreModel": "שחזור מודל",
@@ -908,7 +924,9 @@
                "dateAsc": "הכי ישן",
                "lorasCount": "מספר LoRAs",
                "lorasCountDesc": "הכי הרבה",
-                "lorasCountAsc": "הכי פחות"
+                "lorasCountAsc": "הכי פחות",
+                "opened": "נפתחו לאחרונה",
+                "openedDesc": "נפתחו לאחרונה"
            },
            "refresh": {
                "title": "רענן רשימת מתכונים",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "הצג מועדפים בלבד",
                "action": "מועדפים"
+            },
+            "layout": {
+                "title": "פריסת מתכונים",
+                "grid": "פריסת רשת",
+                "masonry": "פריסת Masonry (בסגנון Pinterest, שומרת על יחס הגובה-רוחב של התמונה)"
            }
        },
        "duplicates": {
            "found": "נמצאו {count} קבוצות כפולות",
+            "noGroups": "לא נמצאו קבוצות כפולות לפי קריטריון ההתאמה הנוכחי",
            "keepLatest": "שמור גרסאות אחרונות",
-            "deleteSelected": "מחק נבחרים"
+            "deleteSelected": "מחק נבחרים",
+            "includePromptLabel": "כלול הנחיה בהתאמה",
+            "basis": {
+                "loraCombo": "התאמה לפי: שילוב LoRA",
+                "loraComboAndPrompt": "התאמה לפי: שילוב LoRA + הנחיה",
+                "hintLoraCombo": "מתכונים עם אותם LoRAs בעוצמות זהות מקובצים יחד.",
+                "hintPromptIncluded": "מתכונים מקובצים רק כאשר הם משתמשים באותם LoRAs בעוצמות זהות ויש להם אותה הנחיה."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "מפנה {size}",
            "title": "מחק מודל",
-            "message": "האם אתה בטוח שברצונך למחוק מודל זה וכל הקבצים הנלווים?"
+            "message": "האם אתה בטוח שברצונך למחוק מודל זה וכל הקבצים הנלווים?",
+            "recoverableWarning": "הקובץ יימחק לצמיתות לאחר 20 שניות, אלא אם תבטלו את הפעולה."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "ניתן לבטל פעולה זו תוך 20 שניות."
        },
        "excludeModel": {
            "title": "החרג מודל",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "גרסה זו חדשה יותר מהגרסה המקומית האחרונה שלך",
                    "earlyAccess": "גישה מוקדמת",
                    "earlyAccessTooltip": "גרסה זו דורשת כרגע גישת Early Access של Civitai",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "התעלם",
                    "ignoredTooltip": "התראות העדכון מושבתות עבור גרסה זו",
                    "onSiteOnly": "רק באתר",
@@ -1532,6 +1570,7 @@
                    "download": "הורדה",
                    "downloadTooltip": "הורד את הגרסה הזו",
                    "downloadEarlyAccessTooltip": "הורד את גרסת ה-Early Access הזו מ-Civitai",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "גרסה זו זמינה רק ליצירה באתר Civitai",
                    "delete": "מחיקה",
                    "deleteTooltip": "מחק את הגרסה המקומית הזו",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "מתכון הוחלף ב-workflow",
            "recipeFailedToSend": "שליחת מתכון ל-workflow נכשלה",
            "noMatchingNodes": "אין צמתים תואמים זמינים ב-workflow הנוכחי",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "לא נבחר צומת יעד",
            "modelUpdated": "מודל עודכן ב-workflow",
            "modelFailed": "עדכון צומת המודל נכשל",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "התיקון הושלם: {repaired} תוקנו, {skipped} דולגו (מתוך {total})",
            "repairBulkSkipped": "אין צורך בתיקון עבור {total} המתכונים הנבחרים",
            "repairBulkFailed": "תיקון המתכונים הנבחרים נכשל: {message}",
+            "rematchComplete": "הותאמו {entries} פריטים ב־{recipes} מתכונים",
+            "rematchCompleteErrors": "הותאמו {entries} פריטים ב־{recipes} מתכונים, {failures} נכשלו",
+            "rematchAllFailed": "ההתאמה נכשלה עבור {failures} מתוך {total} מתכונים שנבחרו",
+            "rematchUnmatched": "לא נמצאה התאמה מקומית עבור {entries} פריטים ב־{recipes} מתכונים",
+            "rematchSkipped": "אין צורך בהתאמה עבור {total} המתכונים שנבחרו",
+            "rematchFailed": "ההתאמה מחדש של המתכונים שנבחרו נכשלה: {message}",
            "reimporting": "מייבא מתכון מחדש מהמקור...",
            "reimportSuccess": "המתכון יובא מחדש בהצלחה",
            "reimportBulkComplete": "ייבוא מחדש הושלם: {completed} יובאו, {failed} נכשלו (מתוך {total})",
@@ -2087,6 +2133,14 @@
            "updateFailed": "עדכון מילות הטריגר נכשל",
            "copyFailed": "ההעתקה נכשלה"
        },
+        "undo": {
+            "action": "בטל",
+            "deleted": "נמחק: {name}",
+            "deletedBulk": "{count} פריטים נמחקו",
+            "expired": "חלון הביטול פג. הפריט נמחק לצמיתות.",
+            "failed": "הביטול נכשל: {error}",
+            "restored": "הפריט שוחזר"
+        },
        "virtual": {
            "loadFailed": "טעינת הפריטים נכשלה",
            "loadMoreFailed": "טעינת פריטים נוספים נכשלה",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "שינוי שם הקובץ נכשל: {error}",
            "previewUpdated": "התצוגה המקדימה עודכנה בהצלחה",
            "previewUploadFailed": "העלאת תמונת התצוגה המקדימה נכשלה",
+            "previewDropInvalid": "סוג קובץ לא נתמך: {name}. גרור במקום זאת תמונה או סרטון MP4.",
            "refreshComplete": "{action} הושלם",
            "refreshFailed": "{action} של {type}s נכשל",
            "metadataRefreshed": "המטא-דאטה רועננה בהצלחה",
@@ -186,6 +186,16 @@
            "cancelled": "修復がキャンセルされました。{count}個のレシピが修復されました。",
            "error": "レシピの修復に失敗しました: {message}"
        },
+        "rematchRecipes": {
+            "label": "レシピをローカルモデルに再マッチング",
+            "loading": "レシピをローカルモデルに再マッチングしています...",
+            "success": "{recipes} 件のレシピで {entries} エントリをマッチングしました",
+            "successErrors": "{recipes} 件のレシピで {entries} エントリをマッチングしました（{failures} 件失敗）",
+            "allFailed": "{total} 件中 {failures} 件のレシピの再マッチングに失敗しました",
+            "noMatch": "{recipes} 件のレシピで {entries} エントリのローカルマッチが見つかりませんでした",
+            "cancelled": "再マッチングをキャンセルしました。{recipes} 件のレシピを更新（{entries} エントリ）",
+            "error": "レシピの再マッチングに失敗しました：{message}"
+        },
        "manageExcludedModels": {
            "label": "除外モデルを管理"
        },
@@ -612,6 +622,10 @@
            "label": "早期アクセス更新を非表示",
            "help": "早期アクセスのみの更新"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "更新されたライセンスアイコンを使用",
            "useNewStyleHelp": "カラーインジケーター付きでライセンス許可を表示（新スタイル）するか、制限のみのアイコンを表示（クラシックスタイル）します。現在のCivitAIデザインを反映しています。"
@@ -768,6 +782,7 @@
            "copyAll": "すべての構文をコピー",
            "refreshAll": "すべてのメタデータを更新",
            "repairMetadata": "選択したレシピのメタデータを修復",
+            "rematchMetadata": "選択したモデルをローカルモデルに再マッチング",
            "reimportMetadata": "ソースから再インポート",
            "checkUpdates": "選択項目の更新を確認",
            "moveAll": "すべてをフォルダに移動",
@@ -823,6 +838,7 @@
            "setContentRating": "コンテンツレーティングを設定",
            "moveToFolder": "フォルダに移動",
            "repairMetadata": "メタデータを修復",
+            "rematchMetadata": "ローカルモデルに再マッチング",
            "reimportMetadata": "ソースから再インポート",
            "excludeModel": "モデルを除外",
            "restoreModel": "モデルを復元",
@@ -908,7 +924,9 @@
                "dateAsc": "古い順",
                "lorasCount": "LoRA数",
                "lorasCountDesc": "多い順",
-                "lorasCountAsc": "少ない順"
+                "lorasCountAsc": "少ない順",
+                "opened": "最近開いた",
+                "openedDesc": "最近開いた"
            },
            "refresh": {
                "title": "レシピリストを更新",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "お気に入りのみ表示",
                "action": "お気に入り"
+            },
+            "layout": {
+                "title": "レシピのレイアウト",
+                "grid": "グリッドレイアウト",
+                "masonry": "メイソンリーレイアウト（Pinterest スタイル、画像のアスペクト比を保持）"
            }
        },
        "duplicates": {
            "found": "{count} 個の重複グループが見つかりました",
+            "noGroups": "現在の一致基準では重複グループが見つかりませんでした",
            "keepLatest": "最新バージョンを保持",
-            "deleteSelected": "選択したものを削除"
+            "deleteSelected": "選択したものを削除",
+            "includePromptLabel": "一致判定にプロンプトを含める",
+            "basis": {
+                "loraCombo": "一致基準: LoRA の組み合わせ",
+                "loraComboAndPrompt": "一致基準: LoRA の組み合わせ + プロンプト",
+                "hintLoraCombo": "同じ LoRA を同じ強度で使用するレシピがグループ化されます。",
+                "hintPromptIncluded": "レシピは、同じ LoRA を同じ強度で使用し、かつプロンプトが同じ場合にのみグループ化されます。"
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "{size} を解放します",
            "title": "モデルを削除",
-            "message": "このモデルと関連するすべてのファイルを削除してもよろしいですか？"
+            "message": "このモデルと関連するすべてのファイルを削除してもよろしいですか？",
+            "recoverableWarning": "元に戻さない場合、このファイルは20秒後に完全に削除されます。"
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "この操作は20秒以内であれば元に戻せます。"
        },
        "excludeModel": {
            "title": "モデルを除外",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "このバージョンはローカルの最新バージョンより新しいです",
                    "earlyAccess": "早期アクセス",
                    "earlyAccessTooltip": "このバージョンは現在 Civitai の早期アクセスが必要です",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "無視中",
                    "ignoredTooltip": "このバージョンの更新通知は無効です",
                    "onSiteOnly": "サイト内のみ",
@@ -1532,6 +1570,7 @@
                    "download": "ダウンロード",
                    "downloadTooltip": "このバージョンをダウンロード",
                    "downloadEarlyAccessTooltip": "Civitai からこの早期アクセス版をダウンロード",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "このバージョンはCivitaiサイト内でのみ利用可能で、ダウンロードはできません",
                    "delete": "削除",
                    "deleteTooltip": "このローカルバージョンを削除",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "レシピがワークフローで置換されました",
            "recipeFailedToSend": "レシピをワークフローに送信できませんでした",
            "noMatchingNodes": "現在のワークフローには互換性のあるノードがありません",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "ターゲットノードが選択されていません",
            "modelUpdated": "モデルがワークフローで更新されました",
            "modelFailed": "モデルノードの更新に失敗しました",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "修復完了：{repaired} 件修復、{skipped} 件スキップ（合計 {total} 件）",
            "repairBulkSkipped": "選択した {total} 件のレシピは修復不要です",
            "repairBulkFailed": "選択したレシピの修復に失敗しました：{message}",
+            "rematchComplete": "{recipes} 件のレシピで {entries} エントリをマッチングしました",
+            "rematchCompleteErrors": "{recipes} 件のレシピで {entries} エントリをマッチングしました（{failures} 件失敗）",
+            "rematchAllFailed": "選択した {total} 件中 {failures} 件のレシピの再マッチングに失敗しました",
+            "rematchUnmatched": "{recipes} 件のレシピで {entries} エントリのローカルマッチが見つかりませんでした",
+            "rematchSkipped": "選択した {total} 件のレシピは再マッチングの必要がありませんでした",
+            "rematchFailed": "選択したレシピの再マッチングに失敗しました：{message}",
            "reimporting": "ソースからレシピを再インポート中...",
            "reimportSuccess": "レシピの再インポートが完了しました",
            "reimportBulkComplete": "再インポート完了：{completed} 件成功、{failed} 件失敗（合計 {total} 件）",
@@ -2087,6 +2133,14 @@
            "updateFailed": "トリガーワードの更新に失敗しました",
            "copyFailed": "コピーに失敗しました"
        },
+        "undo": {
+            "action": "元に戻す",
+            "deleted": "{name} を削除しました",
+            "deletedBulk": "{count} 個のアイテムを削除しました",
+            "expired": "元に戻せる時間が経過しました。アイテムは完全に削除されました。",
+            "failed": "元に戻せませんでした: {error}",
+            "restored": "アイテムを復元しました"
+        },
        "virtual": {
            "loadFailed": "アイテムの読み込みに失敗しました",
            "loadMoreFailed": "追加アイテムの読み込みに失敗しました",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "ファイル名の変更に失敗しました：{error}",
            "previewUpdated": "プレビューが正常に更新されました",
            "previewUploadFailed": "プレビュー画像のアップロードに失敗しました",
+            "previewDropInvalid": "サポートされていないファイル形式：{name}。画像またはMP4ビデオをドロップしてください。",
            "refreshComplete": "{action} 完了",
            "refreshFailed": "{type}の{action}に失敗しました",
            "metadataRefreshed": "メタデータが正常に更新されました",
@@ -186,6 +186,16 @@
            "cancelled": "수리가 취소되었습니다. {count}개의 레시피가 수리되었습니다.",
            "error": "레시피 복구 실패: {message}"
        },
+        "rematchRecipes": {
+            "label": "레시피를 로컬 모델에 다시 매칭",
+            "loading": "레시피를 로컬 모델에 다시 매칭하는 중...",
+            "success": "{recipes}개 레시피에서 {entries}개 항목이 매칭되었습니다",
+            "successErrors": "{recipes}개 레시피에서 {entries}개 항목이 매칭되었습니다. {failures}개 실패",
+            "allFailed": "{total}개 레시피 중 {failures}개 재매칭 실패",
+            "noMatch": "{recipes}개 레시피에서 {entries}개 항목의 로컬 매칭을 찾지 못했습니다",
+            "cancelled": "재매칭이 취소되었습니다. {recipes}개 레시피 업데이트됨({entries}개 항목)",
+            "error": "레시피 재매칭 실패: {message}"
+        },
        "manageExcludedModels": {
            "label": "제외된 모델 관리"
        },
@@ -612,6 +622,10 @@
            "label": "얼리 액세스 업데이트 숨기기",
            "help": "얼리 액세스 업데이트만"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "업데이트된 라이선스 아이콘 사용",
            "useNewStyleHelp": "색상 표시기가 있는 라이선스 권한(새 스타일) 또는 제한 전용 아이콘(클래식 스타일)을 표시합니다. 현재 CivitAI 디자인을 반영합니다."
@@ -768,6 +782,7 @@
            "copyAll": "모든 문법 복사",
            "refreshAll": "모든 메타데이터 새로고침",
            "repairMetadata": "선택한 레시피 메타데이터 복구",
+            "rematchMetadata": "선택 항목을 로컬 모델에 다시 매칭",
            "reimportMetadata": "소스에서 다시 가져오기",
            "checkUpdates": "선택 항목 업데이트 확인",
            "moveAll": "모두 폴더로 이동",
@@ -823,6 +838,7 @@
            "setContentRating": "콘텐츠 등급 설정",
            "moveToFolder": "폴더로 이동",
            "repairMetadata": "메타데이터 복구",
+            "rematchMetadata": "로컬 모델에 다시 매칭",
            "reimportMetadata": "소스에서 다시 가져오기",
            "excludeModel": "모델 제외",
            "restoreModel": "모델 복원",
@@ -908,7 +924,9 @@
                "dateAsc": "오래된순",
                "lorasCount": "LoRA 수",
                "lorasCountDesc": "많은순",
-                "lorasCountAsc": "적은순"
+                "lorasCountAsc": "적은순",
+                "opened": "최근에 연",
+                "openedDesc": "최근에 연"
            },
            "refresh": {
                "title": "레시피 목록 새로고침",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "즐겨찾기만 표시",
                "action": "즐겨찾기"
+            },
+            "layout": {
+                "title": "레시피 레이아웃",
+                "grid": "그리드 레이아웃",
+                "masonry": "메이슨리 레이아웃 (Pinterest 스타일, 이미지 종횡비 유지)"
            }
        },
        "duplicates": {
            "found": "{count}개의 중복 그룹 발견",
+            "noGroups": "현재 일치 기준으로 중복 그룹을 찾을 수 없습니다",
            "keepLatest": "최신 버전 유지",
-            "deleteSelected": "선택된 항목 삭제"
+            "deleteSelected": "선택된 항목 삭제",
+            "includePromptLabel": "일치 항목에 프롬프트 포함",
+            "basis": {
+                "loraCombo": "일치 기준: LoRA 조합",
+                "loraComboAndPrompt": "일치 기준: LoRA 조합 + 프롬프트",
+                "hintLoraCombo": "동일한 LoRA를 동일한 강도로 사용하는 레시피가 그룹화됩니다.",
+                "hintPromptIncluded": "동일한 LoRA를 동일한 강도로 사용하고 프롬프트도 동일한 경우에만 레시피가 그룹화됩니다."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "{size} 확보",
            "title": "모델 삭제",
-            "message": "이 모델과 모든 관련 파일을 삭제하시겠습니까?"
+            "message": "이 모델과 모든 관련 파일을 삭제하시겠습니까?",
+            "recoverableWarning": "실행 취소하지 않으면 20초 후에 파일이 영구적으로 삭제됩니다."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "이 작업은 20초 이내에 실행 취소할 수 있습니다."
        },
        "excludeModel": {
            "title": "모델 제외",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "이 버전은 로컬의 최신 버전보다 더 새롭습니다",
                    "earlyAccess": "얼리 액세스",
                    "earlyAccessTooltip": "이 버전은 현재 Civitai 얼리 액세스가 필요합니다",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "무시됨",
                    "ignoredTooltip": "이 버전은 업데이트 알림이 비활성화되어 있습니다",
                    "onSiteOnly": "사이트 내 전용",
@@ -1532,6 +1570,7 @@
                    "download": "다운로드",
                    "downloadTooltip": "이 버전 다운로드",
                    "downloadEarlyAccessTooltip": "Civitai에서 이 얼리 액세스 버전 다운로드",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "이 버전은 Civitai 사이트 내에서만 사용 가능하며 다운로드할 수 없습니다",
                    "delete": "삭제",
                    "deleteTooltip": "이 로컬 버전 삭제",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "레시피가 워크플로에서 교체되었습니다",
            "recipeFailedToSend": "레시피를 워크플로로 전송하지 못했습니다",
            "noMatchingNodes": "현재 워크플로에서 호환되는 노드가 없습니다",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "대상 노드가 선택되지 않았습니다",
            "modelUpdated": "모델이 워크플로에서 업데이트되었습니다",
            "modelFailed": "모델 노드 업데이트 실패",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "복구 완료: {repaired}개 복구, {skipped}개 건너뜀 (총 {total}개)",
            "repairBulkSkipped": "선택한 {total}개 레시피는 복구가 필요하지 않습니다",
            "repairBulkFailed": "선택한 레시피 복구 실패: {message}",
+            "rematchComplete": "{recipes}개 레시피에서 {entries}개 항목이 매칭되었습니다",
+            "rematchCompleteErrors": "{recipes}개 레시피에서 {entries}개 항목이 매칭되었습니다. {failures}개 실패",
+            "rematchAllFailed": "선택한 {total}개 레시피 중 {failures}개 재매칭 실패",
+            "rematchUnmatched": "{recipes}개 레시피에서 {entries}개 항목의 로컬 매칭을 찾지 못했습니다",
+            "rematchSkipped": "선택한 {total}개 레시피는 재매칭이 필요하지 않습니다",
+            "rematchFailed": "선택한 레시피 재매칭 실패: {message}",
            "reimporting": "소스에서 레시피를 다시 가져오는 중...",
            "reimportSuccess": "레시피를 다시 가져왔습니다",
            "reimportBulkComplete": "다시 가져오기 완료: {completed}개 성공, {failed}개 실패 (총 {total}개)",
@@ -2087,6 +2133,14 @@
            "updateFailed": "트리거 단어 업데이트에 실패했습니다",
            "copyFailed": "복사 실패"
        },
+        "undo": {
+            "action": "실행 취소",
+            "deleted": "{name} 삭제됨",
+            "deletedBulk": "{count}개 항목 삭제됨",
+            "expired": "실행 취소 기간이 만료되었습니다. 항목이 영구적으로 삭제되었습니다.",
+            "failed": "실행 취소 실패: {error}",
+            "restored": "항목이 복원되었습니다"
+        },
        "virtual": {
            "loadFailed": "항목 로딩 실패",
            "loadMoreFailed": "더 많은 항목 로딩 실패",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "파일 이름 변경 실패: {error}",
            "previewUpdated": "미리보기가 성공적으로 업데이트되었습니다",
            "previewUploadFailed": "미리보기 이미지 업로드 실패",
+            "previewDropInvalid": "지원되지 않는 파일 형식: {name}. 이미지 또는 MP4 동영상을 드롭하세요.",
            "refreshComplete": "{action} 완료",
            "refreshFailed": "{type} {action} 실패",
            "metadataRefreshed": "메타데이터가 성공적으로 새로고침되었습니다",
@@ -186,6 +186,16 @@
            "cancelled": "Восстановление отменено. {count} рецептов было восстановлено.",
            "error": "Ошибка восстановления рецептов: {message}"
        },
+        "rematchRecipes": {
+            "label": "Повторное сопоставление рецептов с локальными моделями",
+            "loading": "Повторное сопоставление рецептов с локальными моделями...",
+            "success": "Сопоставлено записей: {entries} в рецептах: {recipes}",
+            "successErrors": "Сопоставлено записей: {entries} в рецептах: {recipes}, ошибок: {failures}",
+            "allFailed": "Не удалось сопоставить: {failures} из {total} рецептов",
+            "noMatch": "Не найдено локального сопоставления для {entries} записей в {recipes} рецептах",
+            "cancelled": "Сопоставление отменено. Обновлено рецептов: {recipes} (записей: {entries})",
+            "error": "Не удалось выполнить сопоставление рецептов: {message}"
+        },
        "manageExcludedModels": {
            "label": "Управление исключёнными моделями"
        },
@@ -612,6 +622,10 @@
            "label": "Скрыть обновления раннего доступа",
            "help": "Только обновления раннего доступа"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "Использовать обновлённые значки лицензии",
            "useNewStyleHelp": "Отображать разрешения лицензии с цветными индикаторами (новый стиль) или только значки ограничений (классический стиль). Соответствует текущему дизайну CivitAI."
@@ -768,6 +782,7 @@
            "copyAll": "Копировать весь синтаксис",
            "refreshAll": "Обновить все метаданные",
            "repairMetadata": "Восстановить метаданные для выбранных",
+            "rematchMetadata": "Сопоставить выбранные с локальными моделями",
            "reimportMetadata": "Переимпортировать из источника",
            "checkUpdates": "Проверить обновления для выбранных",
            "moveAll": "Переместить все в папку",
@@ -823,6 +838,7 @@
            "setContentRating": "Установить рейтинг контента",
            "moveToFolder": "Переместить в папку",
            "repairMetadata": "Восстановить метаданные",
+            "rematchMetadata": "Сопоставить с локальными моделями",
            "reimportMetadata": "Переимпортировать из источника",
            "excludeModel": "Исключить модель",
            "restoreModel": "Восстановить модель",
@@ -908,7 +924,9 @@
                "dateAsc": "Сначала старые",
                "lorasCount": "Кол-во LoRA",
                "lorasCountDesc": "Больше всего",
-                "lorasCountAsc": "Меньше всего"
+                "lorasCountAsc": "Меньше всего",
+                "opened": "Недавно открытые",
+                "openedDesc": "Недавно открытые"
            },
            "refresh": {
                "title": "Обновить список рецептов",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "Только избранные",
                "action": "Избранное"
+            },
+            "layout": {
+                "title": "Макет рецептов",
+                "grid": "Макет сеткой",
+                "masonry": "Masonry-макет (в стиле Pinterest, сохраняет пропорции изображения)"
            }
        },
        "duplicates": {
            "found": "Найдено {count} групп дубликатов",
+            "noGroups": "Дубликатов с текущим критерием не найдено",
            "keepLatest": "Оставить последние версии",
-            "deleteSelected": "Удалить выбранные"
+            "deleteSelected": "Удалить выбранные",
+            "includePromptLabel": "Учитывать запрос при поиске дубликатов",
+            "basis": {
+                "loraCombo": "Критерий: комбинация LoRA",
+                "loraComboAndPrompt": "Критерий: комбинация LoRA + запрос",
+                "hintLoraCombo": "Рецепты с одинаковыми LoRA и одинаковой силой группируются вместе.",
+                "hintPromptIncluded": "Рецепты группируются только при одинаковых LoRA с одинаковой силой И одинаковом запросе."
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "Освобождает {size}",
            "title": "Удалить модель",
-            "message": "Вы уверены, что хотите удалить эту модель и все связанные файлы?"
+            "message": "Вы уверены, что хотите удалить эту модель и все связанные файлы?",
+            "recoverableWarning": "Файл будет удалён навсегда через 20 секунд, если вы не отмените действие."
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "Это действие можно отменить в течение 20 секунд."
        },
        "excludeModel": {
            "title": "Исключить модель",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "Эта версия новее вашей последней локальной версии",
                    "earlyAccess": "Ранний доступ",
                    "earlyAccessTooltip": "Для этой версии сейчас требуется ранний доступ Civitai",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "Игнорируется",
                    "ignoredTooltip": "Уведомления об обновлениях для этой версии отключены",
                    "onSiteOnly": "Только на Сайте",
@@ -1532,6 +1570,7 @@
                    "download": "Скачать",
                    "downloadTooltip": "Скачать эту версию",
                    "downloadEarlyAccessTooltip": "Скачать эту версию раннего доступа с Civitai",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "Эта версия доступна только для генерации на сайте Civitai",
                    "delete": "Удалить",
                    "deleteTooltip": "Удалить эту локальную версию",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "Рецепт заменён в workflow",
            "recipeFailedToSend": "Не удалось отправить рецепт в workflow",
            "noMatchingNodes": "В текущем workflow нет совместимых узлов",
+            "noPromptTargets": "[TODO: Translate] No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "Целевой узел не выбран",
            "modelUpdated": "Модель обновлена в workflow",
            "modelFailed": "Не удалось обновить узел модели",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "Восстановление завершено: {repaired} восстановлено, {skipped} пропущено (из {total})",
            "repairBulkSkipped": "Ни один из {total} выбранных рецептов не требует восстановления",
            "repairBulkFailed": "Не удалось восстановить выбранные рецепты: {message}",
+            "rematchComplete": "Сопоставлено записей: {entries} в рецептах: {recipes}",
+            "rematchCompleteErrors": "Сопоставлено записей: {entries} в рецептах: {recipes}, ошибок: {failures}",
+            "rematchAllFailed": "Не удалось сопоставить: {failures} из {total} выбранных рецептов",
+            "rematchUnmatched": "Не найдено локального сопоставления для {entries} записей в {recipes} рецептах",
+            "rematchSkipped": "Ни один из {total} выбранных рецептов не требует сопоставления",
+            "rematchFailed": "Не удалось сопоставить выбранные рецепты: {message}",
            "reimporting": "Переимпорт рецепта из источника...",
            "reimportSuccess": "Рецепт успешно переимпортирован",
            "reimportBulkComplete": "Переимпорт завершён: {completed} переимпортировано, {failed} ошибок (из {total})",
@@ -2087,6 +2133,14 @@
            "updateFailed": "Не удалось обновить триггерные слова",
            "copyFailed": "Копирование не удалось"
        },
+        "undo": {
+            "action": "Отменить",
+            "deleted": "Удалено: {name}",
+            "deletedBulk": "Удалено: {count} шт.",
+            "expired": "Время отмены истекло. Элемент был удалён навсегда.",
+            "failed": "Не удалось отменить: {error}",
+            "restored": "Элемент восстановлен"
+        },
        "virtual": {
            "loadFailed": "Не удалось загрузить элементы",
            "loadMoreFailed": "Не удалось загрузить больше элементов",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "Не удалось переименовать файл: {error}",
            "previewUpdated": "Превью успешно обновлено",
            "previewUploadFailed": "Не удалось загрузить превью изображение",
+            "previewDropInvalid": "Неподдерживаемый тип файла: {name}. Перетащите вместо этого изображение или видео MP4.",
            "refreshComplete": "{action} завершено",
            "refreshFailed": "Не удалось {action} {type}s",
            "metadataRefreshed": "Метаданные успешно обновлены",
@@ -186,6 +186,16 @@
            "cancelled": "修复已取消。已修复 {count} 个配方。",
            "error": "配方修复失败：{message}"
        },
+        "rematchRecipes": {
+            "label": "将食谱重新匹配到本地模型",
+            "loading": "正在将食谱重新匹配到本地模型...",
+            "success": "已匹配 {entries} 个条目，涉及 {recipes} 个食谱",
+            "successErrors": "已匹配 {entries} 个条目，涉及 {recipes} 个食谱，{failures} 个失败",
+            "allFailed": "{failures}/{total} 个食谱重新匹配失败",
+            "noMatch": "在 {recipes} 个食谱中未找到 {entries} 个条目的本地匹配",
+            "cancelled": "已取消重新匹配。{recipes} 个食谱已更新（{entries} 个条目）。",
+            "error": "食谱重新匹配失败：{message}"
+        },
        "manageExcludedModels": {
            "label": "管理已排除的模型"
        },
@@ -612,6 +622,10 @@
            "label": "隐藏抢先体验更新",
            "help": "抢先体验更新"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "使用新版许可协议图标",
            "useNewStyleHelp": "以彩色指示器显示许可权限（新样式），或仅显示限制图标（经典样式）。与当前 CivitAI 设计保持一致。"
@@ -768,6 +782,7 @@
            "copyAll": "复制所选中语法",
            "refreshAll": "刷新所选中元数据",
            "repairMetadata": "修复所选中元数据",
+            "rematchMetadata": "将所选中重新匹配到本地模型",
            "reimportMetadata": "从源重新导入",
            "checkUpdates": "检查所选更新",
            "moveAll": "移动所选中到文件夹",
@@ -823,6 +838,7 @@
            "setContentRating": "设置内容评级",
            "moveToFolder": "移动到文件夹",
            "repairMetadata": "修复元数据",
+            "rematchMetadata": "重新匹配到本地模型",
            "reimportMetadata": "从源重新导入",
            "excludeModel": "排除模型",
            "restoreModel": "恢复模型",
@@ -908,7 +924,9 @@
                "dateAsc": "最早",
                "lorasCount": "LoRA 数量",
                "lorasCountDesc": "最多",
-                "lorasCountAsc": "最少"
+                "lorasCountAsc": "最少",
+                "opened": "最近打开",
+                "openedDesc": "最近打开"
            },
            "refresh": {
                "title": "刷新配方列表",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "仅显示收藏",
                "action": "收藏"
+            },
+            "layout": {
+                "title": "配方布局",
+                "grid": "网格布局",
+                "masonry": "瀑布流布局（Pinterest 风格，保留图片原始宽高比）"
            }
        },
        "duplicates": {
            "found": "发现 {count} 个重复组",
+            "noGroups": "按当前判重依据未找到重复组",
            "keepLatest": "保留最新版本",
-            "deleteSelected": "删除已选"
+            "deleteSelected": "删除已选",
+            "includePromptLabel": "将提示词纳入判重",
+            "basis": {
+                "loraCombo": "判重依据：LoRA 组合",
+                "loraComboAndPrompt": "判重依据：LoRA 组合 + 提示词",
+                "hintLoraCombo": "使用相同 LoRA（强度一致）的配方会被分组。",
+                "hintPromptIncluded": "仅当配方使用相同的 LoRA（强度一致）且提示词相同时才会被分组。"
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "释放 {size}",
            "title": "删除模型",
-            "message": "你确定要删除此模型及所有相关文件吗？"
+            "message": "你确定要删除此模型及所有相关文件吗？",
+            "recoverableWarning": "如果不撤销，文件将在 20 秒后被永久删除。"
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "此操作可在 20 秒内撤销。"
        },
        "excludeModel": {
            "title": "排除模型",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "此版本比你本地的最新版本更新",
                    "earlyAccess": "抢先体验",
                    "earlyAccessTooltip": "此版本当前需要 Civitai 抢先体验权限",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "已忽略",
                    "ignoredTooltip": "此版本已关闭更新通知",
                    "onSiteOnly": "仅站内生成",
@@ -1532,6 +1570,7 @@
                    "download": "下载",
                    "downloadTooltip": "下载此版本",
                    "downloadEarlyAccessTooltip": "从 Civitai 下载此抢先体验版本",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "此版本仅在 Civitai 站内可用，无法下载",
                    "delete": "删除",
                    "deleteTooltip": "删除此本地版本",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "配方已替换到工作流",
            "recipeFailedToSend": "发送配方到工作流失败",
            "noMatchingNodes": "当前工作流中没有兼容的节点",
+            "noPromptTargets": "工作流中没有兼容的 prompt 目标节点。\n在 ComfyUI 中右键节点 → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "未选择目标节点",
            "modelUpdated": "模型已更新到工作流",
            "modelFailed": "更新模型节点失败",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "修复完成：{repaired} 个已修复，{skipped} 个已跳过（共 {total} 个）",
            "repairBulkSkipped": "所选 {total} 个配方无需修复",
            "repairBulkFailed": "修复所选配方失败：{message}",
+            "rematchComplete": "已匹配 {entries} 个条目，涉及 {recipes} 个食谱",
+            "rematchCompleteErrors": "已匹配 {entries} 个条目，涉及 {recipes} 个食谱，{failures} 个失败",
+            "rematchAllFailed": "{failures}/{total} 个所选食谱重新匹配失败",
+            "rematchUnmatched": "在 {recipes} 个食谱中未找到 {entries} 个条目的本地匹配",
+            "rematchSkipped": "{total} 个所选食谱均无需重新匹配",
+            "rematchFailed": "重新匹配所选食谱失败：{message}",
            "reimporting": "正在从源重新导入配方...",
            "reimportSuccess": "配方已从源重新导入成功",
            "reimportBulkComplete": "重新导入完成：{completed} 个已导入，{failed} 个失败（共 {total} 个）",
@@ -2087,6 +2133,14 @@
            "updateFailed": "触发词更新失败",
            "copyFailed": "复制失败"
        },
+        "undo": {
+            "action": "撤销",
+            "deleted": "已删除 {name}",
+            "deletedBulk": "已删除 {count} 个项目",
+            "expired": "撤销窗口已过期，项目已被永久删除。",
+            "failed": "撤销失败：{error}",
+            "restored": "项目已恢复"
+        },
        "virtual": {
            "loadFailed": "加载项目失败",
            "loadMoreFailed": "加载更多项目失败",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "重命名文件失败：{error}",
            "previewUpdated": "预览图片更新成功",
            "previewUploadFailed": "上传预览图片失败",
+            "previewDropInvalid": "不支持的文件类型：{name}。请拖入图片或 MP4 视频。",
            "refreshComplete": "{action} 完成",
            "refreshFailed": "{action} {type} 失败",
            "metadataRefreshed": "元数据刷新成功",
@@ -186,6 +186,16 @@
            "cancelled": "修復已取消。已修復 {count} 個配方。",
            "error": "配方修復失敗：{message}"
        },
+        "rematchRecipes": {
+            "label": "將食譜重新匹配到本地模型",
+            "loading": "正在將食譜重新匹配到本地模型...",
+            "success": "已匹配 {entries} 個條目，涉及 {recipes} 個食譜",
+            "successErrors": "已匹配 {entries} 個條目，涉及 {recipes} 個食譜，{failures} 個失敗",
+            "allFailed": "{failures}/{total} 個食譜重新匹配失敗",
+            "noMatch": "在 {recipes} 個食譜中找不到 {entries} 個條目的本地匹配",
+            "cancelled": "已取消重新匹配。{recipes} 個食譜已更新（{entries} 個條目）。",
+            "error": "食譜重新匹配失敗：{message}"
+        },
        "manageExcludedModels": {
            "label": "管理已排除的模型"
        },
@@ -612,6 +622,10 @@
            "label": "隱藏搶先體驗更新",
            "help": "搶先體驗更新"
        },
+        "hidePaidUpdates": {
+            "label": "[TODO: Translate] Hide Paid Updates",
+            "help": "[TODO: Translate] When enabled, models with only paid updates will not show 'Update available' badge"
+        },
        "licenseIcons": {
            "useNewStyle": "使用新版許可協議圖標",
            "useNewStyleHelp": "以彩色指示器顯示許可權限（新樣式），或僅顯示限制圖標（經典樣式）。與當前 CivitAI 設計保持一致。"
@@ -768,6 +782,7 @@
            "copyAll": "複製全部語法",
            "refreshAll": "刷新全部 metadata",
            "repairMetadata": "修復所選中元數據",
+            "rematchMetadata": "將所選中重新匹配到本地模型",
            "reimportMetadata": "從來源重新匯入",
            "checkUpdates": "檢查所選更新",
            "moveAll": "全部移動到資料夾",
@@ -823,6 +838,7 @@
            "setContentRating": "設定內容分級",
            "moveToFolder": "移動到資料夾",
            "repairMetadata": "修復元數據",
+            "rematchMetadata": "重新匹配到本地模型",
            "reimportMetadata": "從來源重新匯入",
            "excludeModel": "排除模型",
            "restoreModel": "還原模型",
@@ -908,7 +924,9 @@
                "dateAsc": "最舊",
                "lorasCount": "LoRA 數量",
                "lorasCountDesc": "最多",
-                "lorasCountAsc": "最少"
+                "lorasCountAsc": "最少",
+                "opened": "最近開啟",
+                "openedDesc": "最近開啟"
            },
            "refresh": {
                "title": "重新整理配方列表",
@@ -919,12 +937,25 @@
            "favorites": {
                "title": "僅顯示收藏",
                "action": "收藏"
+            },
+            "layout": {
+                "title": "配方版面",
+                "grid": "網格版面",
+                "masonry": "瀑布流版面（Pinterest 風格，保留圖片原始寬高比）"
            }
        },
        "duplicates": {
            "found": "發現 {count} 組重複項",
+            "noGroups": "按目前判重依據未找到重複組",
            "keepLatest": "保留最新版本",
-            "deleteSelected": "刪除所選"
+            "deleteSelected": "刪除所選",
+            "includePromptLabel": "將提示詞納入判重",
+            "basis": {
+                "loraCombo": "判重依據：LoRA 組合",
+                "loraComboAndPrompt": "判重依據：LoRA 組合 + 提示詞",
+                "hintLoraCombo": "使用相同 LoRA（強度一致）的配方會被分組。",
+                "hintPromptIncluded": "僅當配方使用相同的 LoRA（強度一致）且提示詞相同時才會被分組。"
+            }
        },
        "contextMenu": {
            "copyRecipe": {
@@ -1257,8 +1288,13 @@
            }
        },
        "deleteModel": {
+            "freesSpace": "釋放 {size}",
            "title": "刪除模型",
-            "message": "您確定要刪除此模型及所有相關檔案嗎？"
+            "message": "您確定要刪除此模型及所有相關檔案嗎？",
+            "recoverableWarning": "如果未復原，檔案將在 20 秒後被永久刪除。"
+        },
+        "deleteRecipe": {
+            "recoverableWarning": "此操作可在 20 秒內復原。"
        },
        "excludeModel": {
            "title": "排除模型",
@@ -1523,6 +1559,8 @@
                    "newerTooltip": "此版本比你本地的最新版本更新",
                    "earlyAccess": "搶先體驗",
                    "earlyAccessTooltip": "此版本目前需要 Civitai 搶先體驗權限",
+                    "paid": "[TODO: Translate] Paid",
+                    "paidTooltip": "[TODO: Translate] This version requires payment to download",
                    "ignored": "已忽略",
                    "ignoredTooltip": "此版本已關閉更新通知",
                    "onSiteOnly": "僅站內生成",
@@ -1532,6 +1570,7 @@
                    "download": "下載",
                    "downloadTooltip": "下載此版本",
                    "downloadEarlyAccessTooltip": "從 Civitai 下載此搶先體驗版本",
+                    "downloadPaidTooltip": "[TODO: Translate] Download this paid version from Civitai",
                    "downloadNotAllowedTooltip": "此版本僅在 Civitai 站內可用，無法下載",
                    "delete": "刪除",
                    "deleteTooltip": "刪除此本地版本",
@@ -1701,6 +1740,7 @@
            "recipeReplaced": "配方已取代於工作流",
            "recipeFailedToSend": "傳送配方到工作流失敗",
            "noMatchingNodes": "目前工作流程中沒有相容的節點",
+            "noPromptTargets": "工作流中沒有相容的 prompt 目標節點。\n在 ComfyUI 中右鍵節點 → Mark as → Send Prompt Target",
            "noTargetNodeSelected": "未選擇目標節點",
            "modelUpdated": "模型已更新到工作流",
            "modelFailed": "更新模型節點失敗",
@@ -1951,6 +1991,12 @@
            "repairBulkComplete": "修復完成：{repaired} 個已修復，{skipped} 個已跳過（共 {total} 個）",
            "repairBulkSkipped": "所選 {total} 個配方無需修復",
            "repairBulkFailed": "修復所選配方失敗：{message}",
+            "rematchComplete": "已匹配 {entries} 個條目，涉及 {recipes} 個食譜",
+            "rematchCompleteErrors": "已匹配 {entries} 個條目，涉及 {recipes} 個食譜，{failures} 個失敗",
+            "rematchAllFailed": "{failures}/{total} 個所選食譜重新匹配失敗",
+            "rematchUnmatched": "在 {recipes} 個食譜中找不到 {entries} 個條目的本地匹配",
+            "rematchSkipped": "{total} 個所選食譜均無需重新匹配",
+            "rematchFailed": "重新匹配所選食譜失敗：{message}",
            "reimporting": "正在從來源重新匯入配方...",
            "reimportSuccess": "配方已從來源重新匯入成功",
            "reimportBulkComplete": "重新匯入完成：{completed} 個已匯入，{failed} 個失敗（共 {total} 個）",
@@ -2087,6 +2133,14 @@
            "updateFailed": "更新觸發詞失敗",
            "copyFailed": "複製失敗"
        },
+        "undo": {
+            "action": "復原",
+            "deleted": "已刪除 {name}",
+            "deletedBulk": "已刪除 {count} 個項目",
+            "expired": "復原視窗已過期，項目已被永久刪除。",
+            "failed": "復原失敗：{error}",
+            "restored": "項目已還原"
+        },
        "virtual": {
            "loadFailed": "載入項目失敗",
            "loadMoreFailed": "載入更多項目失敗",
@@ -2150,6 +2204,7 @@
            "fileRenameFailed": "重新命名檔案失敗：{error}",
            "previewUpdated": "預覽圖片已成功更新",
            "previewUploadFailed": "上傳預覽圖片失敗",
+            "previewDropInvalid": "不支援的檔案類型：{name}。請拖入圖片或 MP4 影片。",
            "refreshComplete": "{action} 完成",
            "refreshFailed": "{action} {type} 失敗",
            "metadataRefreshed": "metadata 已成功刷新",
@@ -25,10 +25,12 @@ from .routes.recipe_routes import RecipeRoutes
 from .routes.stats_routes import StatsRoutes
 from .routes.update_routes import UpdateRoutes
 from .routes.misc_routes import MiscRoutes
+from .routes.pending_delete_routes import PendingDeleteRoutes
 from .routes.preview_routes import PreviewRoutes
 from .routes.example_images_routes import ExampleImagesRoutes
 from .services.service_registry import ServiceRegistry
 from .services.settings_manager import get_settings_manager
+from .services.pending_delete_service import get_pending_delete_service
 from .utils.example_images_migration import ExampleImagesMigration
 from .services.websocket_manager import ws_manager
 from .services.example_images_cleanup_service import ExampleImagesCleanupService
@@ -170,6 +172,7 @@ class LoraManager:
        RecipeRoutes.setup_routes(app)
        UpdateRoutes.setup_routes(app)
        MiscRoutes.setup_routes(app)
+        PendingDeleteRoutes.setup_routes(app)
        ExampleImagesRoutes.setup_routes(app, ws_manager=ws_manager)
        PreviewRoutes.setup_routes(app)

@@ -245,6 +248,20 @@ class LoraManager:
                cls._run_post_initialization_tasks(init_tasks), name="post_init_tasks"
            )

+            # Startup sweep: purge pending-delete batches that expired during a
+            # previous run. Non-blocking (fire-and-forget); purge_expired only
+            # removes already-expired batches, so a staged undo that survived a
+            # restart stays restorable. scan_roots=True runs the reconciliation
+            # pass first so leftover batches (the in-process registry is empty
+            # after a restart) are re-discovered on disk. Covers both plugin
+            # and standalone modes (StandaloneLoraManager reuses this
+            # classmethod).
+            pending_delete_service = await get_pending_delete_service()
+            asyncio.create_task(
+                pending_delete_service.purge_expired(scan_roots=True),
+                name="pending_delete_startup_sweep",
+            )
+
            logger.debug(
                "LoRA Manager: All services initialized and background tasks scheduled"
            )
@@ -214,6 +214,24 @@ class MetadataProcessor:
                    max_denoise = denoise
                    primary_sampler = sampler_info
                    primary_sampler_id = node_id
+
+        # Last resort: any registered sampler. Samplers without a denoise or
+        # add_noise parameter (e.g. multi-stage samplers like KreaTwoStageSampler)
+        # are not caught by the criteria above. Prefer execution order so the
+        # first executed sampler wins, matching the downstream_id branch.
+        if primary_sampler is None:
+            sampler_ids = [
+                node_id
+                for node_id, sampler_info in metadata.get(SAMPLING, {}).items()
+                if sampler_info.get(IS_SAMPLER, False)
+            ]
+            if sampler_ids:
+                if downstream_id and "execution_order" in metadata:
+                    for node_id in metadata["execution_order"]:
+                        if node_id in sampler_ids:
+                            return node_id, metadata[SAMPLING][node_id]
+                primary_sampler_id = sampler_ids[0]
+                primary_sampler = metadata[SAMPLING][sampler_ids[0]]
                
        return primary_sampler_id, primary_sampler
    
@@ -40,7 +40,7 @@ class GenericNodeExtractor(NodeMetadataExtractor):
    * ``MODEL`` output: common input fields (ckpt_name, unet_name, etc.)
      are checked for a model file name and stored as checkpoint metadata.
    * ``CONDITIONING`` output: common text input fields are checked for
-      prompt text and stored as prompt metadata.
+      prompt text, and conditioning inputs are tracked through transforms.
    """

    # Input field names that carry a model path in loader-style nodes.
@@ -73,7 +73,7 @@ class GenericNodeExtractor(NodeMetadataExtractor):
                    _store_checkpoint_metadata(metadata, node_id, name)
                    return

-        # — CONDITIONING encoder detection (CLIPTextEncode, Flux, custom) —
+        # — CONDITIONING encoder / transform detection —
        if "CONDITIONING" in return_types or any("CONDITIONING" in str(t) for t in return_types):
            text = None
            for field in GenericNodeExtractor._TEXT_FIELDS:
@@ -81,12 +81,14 @@ class GenericNodeExtractor(NodeMetadataExtractor):
                if val and isinstance(val, str) and val.strip():
                    text = val.strip()
                    break
-            if text:
-                prompt_data = metadata.setdefault(PROMPTS, {})
-                prompt_data[node_id] = {
-                    "text": text,
-                    "node_id": node_id,
-                }
+
+            input_conditionings = _collect_conditioning_inputs(inputs)
+            if text or input_conditionings:
+                prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
+                if text:
+                    prompt_metadata["text"] = text
+                if input_conditionings:
+                    prompt_metadata["orig_conditionings"] = input_conditionings

    @staticmethod
    def update(node_id, outputs, metadata, return_types=None):
@@ -98,11 +100,26 @@ class GenericNodeExtractor(NodeMetadataExtractor):
            return
        if node_id not in metadata.get(PROMPTS, {}):
            return
-        if outputs and isinstance(outputs, list) and len(outputs) > 0:
-            if isinstance(outputs[0], tuple) and len(outputs[0]) > 0:
-                cond = outputs[0][0]
-                if cond is not None:
-                    metadata[PROMPTS][node_id]["conditioning"] = cond
+        output_tuple = _first_output_tuple(outputs)
+        if not output_tuple or len(output_tuple) < 1:
+            return
+
+        conditioning_index = _first_conditioning_index(return_types)
+        if conditioning_index is None or len(output_tuple) <= conditioning_index:
+            return
+
+        output_conditioning = output_tuple[conditioning_index]
+        if output_conditioning is None:
+            return
+
+        prompt_metadata = metadata[PROMPTS][node_id]
+        prompt_metadata["conditioning"] = output_conditioning
+        _record_conditioning_source(
+            metadata,
+            node_id,
+            output_conditioning,
+            prompt_metadata.get("orig_conditionings", []),
+        )

 class CheckpointLoaderExtractor(NodeMetadataExtractor):
    @staticmethod
@@ -417,6 +434,34 @@ def _first_output_tuple(outputs):
    return None


+def _first_conditioning_index(return_types):
+    """Return the index of the first CONDITIONING output slot, or None."""
+    if not return_types:
+        return None
+    for index, return_type in enumerate(return_types):
+        if "CONDITIONING" in str(return_type):
+            return index
+    return None
+
+
+def _collect_conditioning_inputs(inputs):
+    """Collect conditioning object inputs (``conditioning*`` keys).
+
+    Primitive values (None, str, int, float, bool) are excluded so scalar
+    fields like ``conditioning_strength`` are not mistaken for conditioning
+    objects during provenance tracking.
+    """
+    if not inputs:
+        return []
+    return [
+        value
+        for input_name, value in inputs.items()
+        if input_name.startswith("conditioning")
+        and value is not None
+        and not isinstance(value, (str, int, float, bool))
+    ]
+
+
 def _record_conditioning_source(
    metadata, node_id, output_conditioning, input_conditionings
 ):
@@ -429,6 +474,14 @@ def _record_conditioning_source(
    if not sources:
        return

+    # Identity-preserving selectors return one of their inputs unchanged:
+    # only that input contributed to the output, so record it alone instead
+    # of treating every input as a combination source.
+    for conditioning in sources:
+        if id(conditioning) == id(output_conditioning):
+            sources = [conditioning]
+            break
+
    prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
    prompt_metadata.setdefault("conditioning_sources", []).append(
        {
@@ -508,13 +561,7 @@ class ConditioningCombineExtractor(NodeMetadataExtractor):
        if not inputs:
            return

-        input_conditionings = []
-        for input_name in inputs:
-            if (
-                input_name.startswith("conditioning")
-                and inputs[input_name] is not None
-            ):
-                input_conditionings.append(inputs[input_name])
+        input_conditionings = _collect_conditioning_inputs(inputs)

        if input_conditionings:
            prompt_metadata = _ensure_prompt_metadata(metadata, node_id)
@@ -814,6 +861,65 @@ class TSCKSamplerAdvancedExtractor(KSamplerAdvancedExtractor, TSCSamplerBaseExtr

    # Update method is inherited from TSCSamplerBaseExtractor

+class KreaTwoStageSamplerExtractor(BaseSamplerExtractor):
+    """Extractor for Krea Two/Three Stage Samplers (Auryg/Krea-2-Two-Stage-Sampler).
+
+    The node samples in two (or three) stages with per-stage settings
+    (stage1_steps/stage2_steps, stage1_cfg/stage2_cfg, ...). The canonical
+    metadata fields consumed by ``extract_generation_params`` (steps, cfg,
+    sampler_name, scheduler) are derived from the base stage (stage 1; the
+    three-stage variant reuses stage 1 settings for stage 3), while the full
+    per-stage breakdown is preserved in the raw parameters.
+    """
+
+    # All per-stage parameter keys present on both node variants.
+    _STAGE_PARAM_KEYS = (
+        "stage1_steps", "stage1_cfg", "stage1_sampler_name", "stage1_scheduler",
+        "stage2_steps", "stage2_cfg", "stage2_sampler_name", "stage2_scheduler",
+    )
+
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+
+        BaseSamplerExtractor.extract_sampling_params(
+            node_id,
+            inputs,
+            metadata,
+            ("seed", "handoff_percent", "stage3_handoff_percent")
+            + KreaTwoStageSamplerExtractor._STAGE_PARAM_KEYS,
+        )
+
+        # Derive the canonical fields expected by extract_generation_params.
+        sampling_params = metadata[SAMPLING][node_id]["parameters"]
+        if "stage1_steps" in sampling_params or "stage2_steps" in sampling_params:
+            sampling_params["steps"] = (
+                (sampling_params.get("stage1_steps") or 0)
+                + (sampling_params.get("stage2_steps") or 0)
+            )
+        if "stage1_cfg" in sampling_params:
+            sampling_params["cfg"] = sampling_params["stage1_cfg"]
+        if "stage1_sampler_name" in sampling_params:
+            sampling_params["sampler_name"] = sampling_params["stage1_sampler_name"]
+        if "stage1_scheduler" in sampling_params:
+            sampling_params["scheduler"] = sampling_params["stage1_scheduler"]
+
+        BaseSamplerExtractor.extract_conditioning(node_id, inputs, metadata)
+
+        # Prefer the final generation resolution; latent dims are the fallback.
+        BaseSamplerExtractor.extract_latent_dimensions(node_id, inputs, metadata)
+        final_width = inputs.get("final_width")
+        final_height = inputs.get("final_height")
+        if final_width and final_height:
+            if SIZE not in metadata:
+                metadata[SIZE] = {}
+            metadata[SIZE][node_id] = {
+                "width": final_width,
+                "height": final_height,
+                "node_id": node_id,
+            }
+
 class LoraLoaderExtractor(NodeMetadataExtractor):
    @staticmethod
    def extract(node_id, inputs, outputs, metadata):
@@ -854,6 +960,37 @@ class ImageSizeExtractor(NodeMetadataExtractor):
            "node_id": node_id
        }

+class KreaDualResolutionSelectorExtractor(NodeMetadataExtractor):
+    """Extract base resolution from Krea Dual Resolution Selector outputs
+    (Auryg/Krea-2-Two-Stage-Sampler).
+
+    The node computes base/final dimensions at runtime from aspect ratio and
+    megapixel settings, so the values are only available in the update phase
+    (outputs: base_width, base_height, final_width, final_height, seed).
+    """
+
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        # Dimensions are computed at runtime; nothing to do here.
+        pass
+
+    @staticmethod
+    def update(node_id, outputs, metadata):
+        output_tuple = _first_output_tuple(outputs)
+        if not output_tuple or len(output_tuple) < 2:
+            return
+        width, height = output_tuple[0], output_tuple[1]
+        if not isinstance(width, int) or not isinstance(height, int):
+            return
+
+        if SIZE not in metadata:
+            metadata[SIZE] = {}
+        metadata[SIZE][node_id] = {
+            "width": width,
+            "height": height,
+            "node_id": node_id,
+        }
+
 class RgthreePowerLoraLoaderExtractor(NodeMetadataExtractor):
    """Extract LoRA metadata from rgthree Power Lora Loader.

@@ -1255,6 +1392,8 @@ NODE_EXTRACTORS = {
    "ClownsharKSampler_Beta": SamplerExtractor,
    "TSC_KSampler": TSCKSamplerExtractor,   # Efficient Nodes
    "TSC_KSamplerAdvanced": TSCKSamplerAdvancedExtractor,  # Efficient Nodes
+    "KreaTwoStageSampler": KreaTwoStageSamplerExtractor,  # Auryg/Krea-2-Two-Stage-Sampler
+    "KreaThreeStageSampler": KreaTwoStageSamplerExtractor,  # Auryg/Krea-2-Two-Stage-Sampler
    "KSamplerBasicPipe": KSamplerBasicPipeExtractor,    # comfyui-impact-pack
    "KSamplerAdvancedBasicPipe": KSamplerAdvancedBasicPipeExtractor,    # comfyui-impact-pack
    "KSampler_inspire_pipe": KSamplerBasicPipeExtractor,    # comfyui-inspire-pack
@@ -1306,6 +1445,7 @@ NODE_EXTRACTORS = {
    "GetNode": GetNodeExtractor,
    # Latent
    "EmptyLatentImage": ImageSizeExtractor,
+    "KreaDualResolutionSelector": KreaDualResolutionSelectorExtractor,  # Auryg/Krea-2-Two-Stage-Sampler
    # Flux
    "FluxGuidance": FluxGuidanceExtractor,      # Add FluxGuidance
    "CFGGuider": CFGGuiderExtractor,            # Add CFGGuider
@@ -8,7 +8,7 @@ cannot drift between the two paths.
 import logging
 from typing import Any, Dict

-from ..utils.utils import model_patcher_to_name
+from ..utils.utils import model_patcher_to_name, sampler_object_to_name
 from .constants import CLIP_SKIP_SENTINEL, METADATA_OVERWRITE_FIELDS

 logger = logging.getLogger(__name__)
@@ -22,7 +22,9 @@ def collect_overwrite_params(values: Dict[str, Any]) -> Dict[str, Any]:
    of 0 is preserved.  The ``model`` field accepts either a manual string or
    a wired MODEL (ModelPatcher) connection; in the latter case the source
    model name is extracted from the patcher's ``cached_patcher_init`` and
-    stored as a ComfyUI-style relative path.
+    stored as a ComfyUI-style relative path.  The ``sampler`` field likewise
+    accepts a manual string or a wired SAMPLER (KSAMPLER) connection, from
+    which the sampler name is extracted via the sampler function's name.
    """
    result: Dict[str, Any] = {}
    for key in METADATA_OVERWRITE_FIELDS:
@@ -34,6 +36,13 @@ def collect_overwrite_params(values: Dict[str, Any]) -> Dict[str, Any]:
                    "Could not extract model name from wired MODEL input "
                    "(no cached_patcher_init); model metadata overwrite skipped"
                )
+        elif key == "sampler" and not isinstance(value, str):
+            value = sampler_object_to_name(value)
+            if value is None:
+                logger.warning(
+                    "Could not extract sampler name from wired SAMPLER input "
+                    "(unrecognized sampler function); sampler metadata overwrite skipped"
+                )
        if key == "clip_skip":
            if value != CLIP_SKIP_SENTINEL:
                result[key] = value
@@ -1,4 +1,5 @@
 import logging
+import os
 from typing import Any, List, Tuple
 import comfy.sd  # pyright: ignore[reportMissingImports]
 import folder_paths  # pyright: ignore[reportMissingImports]
@@ -58,7 +59,10 @@ class CheckpointLoaderLM:
                for item in cache.raw_data:
                    if item.get("sub_type") == "checkpoint":
                        file_path = item.get("file_path", "")
-                        if file_path:
+                        # Only offer models that still exist on disk so ComfyUI
+                        # flags missing checkpoints at queue time via
+                        # "value not in list" (the scanner cache can be stale).
+                        if file_path and os.path.exists(file_path):
                            # Format using relative path with OS-native separator
                            formatted_name = _format_model_name_for_comfyui(
                                file_path, model_roots
@@ -15,6 +15,7 @@ from .utils import (
    any_type,
    apply_lora_syntax_format,
    get_loras_list,
+    validate_lora_entries,
 )

 logger = logging.getLogger(__name__)
@@ -42,6 +43,11 @@ class CreateHookLoraLM:
            "optional": FlexibleOptionalInputType(any_type),
        }

+    @classmethod
+    def VALIDATE_INPUTS(cls, loras=None):
+        """Queue-time validation: reject missing local LoRAs before execution."""
+        return validate_lora_entries({"loras": loras}) or True
+
    RETURN_TYPES = ("HOOKS", "STRING", "STRING")
    RETURN_NAMES = ("HOOKS", "trigger_words", "active_loras")
    FUNCTION = "create_hook"
@@ -14,6 +14,7 @@ from .utils import (
    get_loras_list,
    nunchaku_load_lora,
    parse_lora_syntax,
+    validate_lora_entries,
 )

 logger = logging.getLogger(__name__)
@@ -142,6 +143,11 @@ class LoraLoaderLM:
            "optional": FlexibleOptionalInputType(any_type),
        }

+    @classmethod
+    def VALIDATE_INPUTS(cls, loras=None):
+        """Queue-time validation: reject missing local LoRAs before execution."""
+        return validate_lora_entries({"loras": loras}) or True
+
    RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING")
    RETURN_NAMES = ("MODEL", "CLIP", "trigger_words", "loaded_loras")
    FUNCTION = "load_loras"
@@ -9,6 +9,7 @@ and tracks the last used combination for reuse.
 import logging
 import os
 from ..utils.utils import get_lora_info
+from .utils import validate_lora_entries

 logger = logging.getLogger(__name__)

@@ -31,6 +32,11 @@ class LoraRandomizerLM:
            },
        }

+    @classmethod
+    def VALIDATE_INPUTS(cls, loras=None):
+        """Queue-time validation: reject missing local LoRAs before execution."""
+        return validate_lora_entries({"loras": loras}) or True
+
    RETURN_TYPES = ("LORA_STACK",)
    RETURN_NAMES = ("LORA_STACK",)

@@ -1,6 +1,6 @@
 import os
 from ..utils.utils import get_lora_info
-from .utils import FlexibleOptionalInputType, any_type, apply_lora_syntax_format, extract_lora_name, get_loras_list
+from .utils import FlexibleOptionalInputType, any_type, apply_lora_syntax_format, extract_lora_name, get_loras_list, validate_lora_entries

 import logging

@@ -22,6 +22,11 @@ class LoraStackerLM:
            "optional": FlexibleOptionalInputType(any_type),
        }

+    @classmethod
+    def VALIDATE_INPUTS(cls, loras=None):
+        """Queue-time validation: reject missing local LoRAs before execution."""
+        return validate_lora_entries({"loras": loras}) or True
+
    RETURN_TYPES = ("LORA_STACK", "STRING", "STRING")
    RETURN_NAMES = ("LORA_STACK", "trigger_words", "active_loras")
    FUNCTION = "stack_loras"
@@ -71,10 +71,18 @@ class MetadataOverwriteLM:
                    },
                ),
                "sampler": (
-                    "STRING",
+                    "STRING,SAMPLER",
                    {
                        "default": "",
-                        "tooltip": "Sampler name. Only overwrites when non-empty.",
+                        "widgetType": "STRING",
+                        "tooltip": (
+                            "Sampler name. Fill in the name manually or "
+                            "connect a SAMPLER output (e.g. KSamplerSelect) "
+                            "— the sampler name is then extracted "
+                            "automatically. Note: ddim is recorded as "
+                            "euler (ComfyUI internal representation). "
+                            "Only overwrites when non-empty."
+                        ),
                    },
                ),
                "scheduler": (
@@ -164,6 +172,8 @@ class MetadataOverwriteLM:
        The ``model`` field accepts either a manual string or a wired MODEL
        (ModelPatcher) connection; in the latter case the underlying model
        name is extracted from the patcher's ``cached_patcher_init`` and
-        stored as a ComfyUI-style relative path.
+        stored as a ComfyUI-style relative path.  The ``sampler`` field
+        likewise accepts a manual string or a wired SAMPLER (KSAMPLER)
+        connection, from which the sampler name is extracted automatically.
        """
        return (collect_overwrite_params(kwargs),)
@@ -0,0 +1,214 @@
+import logging
+import os
+import random
+from typing import Any, List, Optional, Tuple
+import comfy.sd  # pyright: ignore[reportMissingImports]
+import folder_paths  # pyright: ignore[reportMissingImports]
+from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
+
+logger = logging.getLogger(__name__)
+
+
+class RandomCheckpointLoaderLM:
+    """Checkpoint Loader that can randomly pick a checkpoint from the pool
+
+    Loads checkpoints from both standard ComfyUI folders and LoRA Manager's
+    extra folder paths. When select_at_random is enabled, ignores ckpt_name
+    and picks a random checkpoint (optionally filtered by base_model) on
+    every run.
+    """
+
+    NAME = "Random Checkpoint Loader (LoraManager)"
+    CATEGORY = "Lora Manager/loaders"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        # Get list of checkpoint names from scanner (includes extra folder paths)
+        checkpoint_names = cls._get_checkpoint_names()
+        base_models = cls._get_available_base_models()
+        return {
+            "required": {
+                "ckpt_name": (
+                    checkpoint_names,
+                    {"tooltip": "The name of the checkpoint (model) to load."},
+                ),
+                "select_at_random": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": (
+                            "Ignore ckpt_name and pick a random checkpoint from the "
+                            "pool (optionally filtered by base_model) on every run."
+                        ),
+                    },
+                ),
+                "base_model": (
+                    base_models,
+                    {
+                        "default": "Any",
+                        "tooltip": "Restrict random selection to this base model. 'Any' uses the full pool.",
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP", "VAE", "STRING")
+    RETURN_NAMES = ("MODEL", "CLIP", "VAE", "model_name")
+    OUTPUT_TOOLTIPS = (
+        "The model used for denoising latents.",
+        "The CLIP model used for encoding text prompts.",
+        "The VAE model used for encoding and decoding images to and from latent space.",
+        "The name of the checkpoint that was loaded (useful when select_at_random is enabled).",
+    )
+    FUNCTION = "load_checkpoint"
+
+    @classmethod
+    def IS_CHANGED(cls, ckpt_name, select_at_random=False, base_model="Any"):
+        # Force re-execution on every run while randomizing, since the widget
+        # values themselves don't change between queue runs.
+        if select_at_random:
+            return float("nan")
+        return ckpt_name
+
+    @staticmethod
+    def _run_async(coro_fn):
+        """Run an async fetcher, handling the case where an event loop is already running."""
+        import asyncio
+
+        try:
+            asyncio.get_running_loop()
+            import concurrent.futures
+
+            def run_in_thread():
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    return new_loop.run_until_complete(coro_fn())
+                finally:
+                    new_loop.close()
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(run_in_thread)
+                return future.result()
+        except RuntimeError:
+            return asyncio.run(coro_fn())
+
+    @classmethod
+    def _get_checkpoint_names(cls, base_model: Optional[str] = None) -> List[str]:
+        """Get list of checkpoint names from scanner cache in ComfyUI format (relative path with extension)
+
+        Args:
+            base_model: If given (and not "Any"), only include checkpoints matching this base model.
+        """
+        try:
+            from ..services.service_registry import ServiceRegistry
+
+            async def _get_names():
+                scanner = await ServiceRegistry.get_checkpoint_scanner()
+                cache = await scanner.get_cached_data()
+
+                # Get all model roots for calculating relative paths
+                model_roots = scanner.get_model_roots()
+
+                # Filter only checkpoint type (not diffusion_model) and format names
+                names = []
+                for item in cache.raw_data:
+                    if item.get("sub_type") != "checkpoint":
+                        continue
+                    if (
+                        base_model
+                        and base_model != "Any"
+                        and item.get("base_model") != base_model
+                    ):
+                        continue
+                    file_path = item.get("file_path", "")
+                    # Only offer models that still exist on disk so ComfyUI
+                    # flags missing checkpoints at queue time via
+                    # "value not in list" (the scanner cache can be stale).
+                    if file_path and os.path.exists(file_path):
+                        # Format using relative path with OS-native separator
+                        formatted_name = _format_model_name_for_comfyui(
+                            file_path, model_roots
+                        )
+                        if formatted_name:
+                            names.append(formatted_name)
+
+                return sorted(names)
+
+            return cls._run_async(_get_names)
+        except Exception as e:
+            logger.error(f"Error getting checkpoint names: {e}")
+            return []
+
+    @classmethod
+    def _get_available_base_models(cls) -> List[str]:
+        """Get distinct base_model values present among indexed checkpoints, for the random-selection filter."""
+        try:
+            from ..services.service_registry import ServiceRegistry
+
+            async def _get_base_models():
+                scanner = await ServiceRegistry.get_checkpoint_scanner()
+                cache = await scanner.get_cached_data()
+
+                base_models = set()
+                for item in cache.raw_data:
+                    if item.get("sub_type") != "checkpoint":
+                        continue
+                    base_model = item.get("base_model")
+                    file_path = item.get("file_path", "")
+                    if base_model and file_path and os.path.exists(file_path):
+                        base_models.add(base_model)
+
+                return sorted(base_models)
+
+            return ["Any"] + cls._run_async(_get_base_models)
+        except Exception as e:
+            logger.error(f"Error getting available base models: {e}")
+            return ["Any"]
+
+    def load_checkpoint(
+        self,
+        ckpt_name: str,
+        select_at_random: bool = False,
+        base_model: str = "Any",
+    ) -> Tuple[Any, Any, Any, str]:
+        """Load a checkpoint by name, supporting extra folder paths
+
+        Args:
+            ckpt_name: The name of the checkpoint to load (relative path with extension)
+            select_at_random: If True, ignore ckpt_name and pick randomly from the pool
+            base_model: Restricts random selection to this base model ("Any" = no filter)
+
+        Returns:
+            Tuple of (MODEL, CLIP, VAE, model_name)
+        """
+        if select_at_random:
+            pool = self._get_checkpoint_names(base_model)
+            if not pool:
+                raise FileNotFoundError(
+                    f"No checkpoints found for base model '{base_model}'. "
+                    "Pick a different base model or disable 'select_at_random'."
+                )
+            ckpt_name = random.choice(pool)
+            logger.info(
+                f"[RandomCheckpointLoaderLM] Randomly selected checkpoint: {ckpt_name}"
+            )
+
+        # Get absolute path from cache using ComfyUI-style name
+        ckpt_path, metadata = get_checkpoint_info_absolute(ckpt_name)
+
+        if metadata is None:
+            raise FileNotFoundError(
+                f"Checkpoint '{ckpt_name}' not found in LoRA Manager cache. "
+                "Make sure the checkpoint is indexed and try again."
+            )
+
+        # Load regular checkpoint using ComfyUI's API
+        logger.info(f"Loading checkpoint from: {ckpt_path}")
+        out = comfy.sd.load_checkpoint_guess_config(
+            ckpt_path,
+            output_vae=True,
+            output_clip=True,
+            embedding_directory=folder_paths.get_folder_paths("embeddings"),
+        )
+        return out[:3] + (ckpt_name,)
@@ -0,0 +1,326 @@
+import logging
+import os
+import random
+from typing import Any, List, Optional, Tuple
+import comfy.sd  # pyright: ignore[reportMissingImports]
+from ..utils.utils import get_checkpoint_info_absolute, _format_model_name_for_comfyui
+
+logger = logging.getLogger(__name__)
+
+
+def _reload_gguf_unet(
+    unet_path: str, weight_dtype: str, disable_dynamic: bool = False
+) -> object:
+    """Reload a GGUF diffusion model from disk (cached_patcher_init factory).
+
+    Mirrors the GGUF branch of RandomUNETLoaderLM.load_unet so ModelPatcher
+    deepclone/dynamic machinery can rebuild GGUF models with the correct
+    GGMLOps. ``disable_dynamic`` is accepted for signature compatibility
+    with core ComfyUI loaders.
+    """
+    loader = RandomUNETLoaderLM()
+    model, _unet_name = loader._load_gguf_unet(unet_path, unet_path, weight_dtype)
+    return model
+
+
+class RandomUNETLoaderLM:
+    """UNET Loader that can randomly pick a diffusion model from the pool
+
+    Loads diffusion models/UNets from both standard ComfyUI folders and LoRA
+    Manager's extra folder paths. Supports both regular diffusion models and
+    GGUF format models. When select_at_random is enabled, ignores unet_name
+    and picks a random diffusion model (optionally filtered by base_model)
+    on every run.
+    """
+
+    NAME = "Random Unet Loader (LoraManager)"
+    CATEGORY = "Lora Manager/loaders"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        # Get list of unet names from scanner (includes extra folder paths)
+        unet_names = cls._get_unet_names()
+        base_models = cls._get_available_base_models()
+        return {
+            "required": {
+                "unet_name": (
+                    unet_names,
+                    {"tooltip": "The name of the diffusion model to load."},
+                ),
+                "weight_dtype": (
+                    ["default", "fp8_e4m3fn", "fp8_e4m3fn_fast", "fp8_e5m2"],
+                    {"tooltip": "The dtype to use for the model weights."},
+                ),
+                "select_at_random": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": (
+                            "Ignore unet_name and pick a random diffusion model from "
+                            "the pool (optionally filtered by base_model) on every run."
+                        ),
+                    },
+                ),
+                "base_model": (
+                    base_models,
+                    {
+                        "default": "Any",
+                        "tooltip": "Restrict random selection to this base model. 'Any' uses the full pool.",
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "STRING")
+    RETURN_NAMES = ("MODEL", "model_name")
+    OUTPUT_TOOLTIPS = (
+        "The model used for denoising latents.",
+        "The name of the diffusion model that was loaded (useful when select_at_random is enabled).",
+    )
+    FUNCTION = "load_unet"
+
+    @classmethod
+    def IS_CHANGED(
+        cls, unet_name, weight_dtype, select_at_random=False, base_model="Any"
+    ):
+        # Force re-execution on every run while randomizing, since the widget
+        # values themselves don't change between queue runs.
+        if select_at_random:
+            return float("nan")
+        return unet_name
+
+    @staticmethod
+    def _run_async(coro_fn):
+        """Run an async fetcher, handling the case where an event loop is already running."""
+        import asyncio
+
+        try:
+            asyncio.get_running_loop()
+            import concurrent.futures
+
+            def run_in_thread():
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    return new_loop.run_until_complete(coro_fn())
+                finally:
+                    new_loop.close()
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(run_in_thread)
+                return future.result()
+        except RuntimeError:
+            return asyncio.run(coro_fn())
+
+    @classmethod
+    def _get_unet_names(cls, base_model: Optional[str] = None) -> List[str]:
+        """Get list of diffusion model names from scanner cache in ComfyUI format (relative path with extension)
+
+        Args:
+            base_model: If given (and not "Any"), only include models matching this base model.
+        """
+        try:
+            from ..services.service_registry import ServiceRegistry
+
+            async def _get_names():
+                scanner = await ServiceRegistry.get_checkpoint_scanner()
+                cache = await scanner.get_cached_data()
+
+                # Get all model roots for calculating relative paths
+                model_roots = scanner.get_model_roots()
+
+                # Filter only diffusion_model type and format names
+                names = []
+                for item in cache.raw_data:
+                    if item.get("sub_type") != "diffusion_model":
+                        continue
+                    if (
+                        base_model
+                        and base_model != "Any"
+                        and item.get("base_model") != base_model
+                    ):
+                        continue
+                    file_path = item.get("file_path", "")
+                    # Only offer models that still exist on disk so ComfyUI
+                    # flags missing diffusion models at queue time via
+                    # "value not in list" (the scanner cache can be stale).
+                    if file_path and os.path.exists(file_path):
+                        # Format using relative path with OS-native separator
+                        formatted_name = _format_model_name_for_comfyui(
+                            file_path, model_roots
+                        )
+                        if formatted_name:
+                            names.append(formatted_name)
+
+                return sorted(names)
+
+            return cls._run_async(_get_names)
+        except Exception as e:
+            logger.error(f"Error getting unet names: {e}")
+            return []
+
+    @classmethod
+    def _get_available_base_models(cls) -> List[str]:
+        """Get distinct base_model values present among indexed diffusion models, for the random-selection filter."""
+        try:
+            from ..services.service_registry import ServiceRegistry
+
+            async def _get_base_models():
+                scanner = await ServiceRegistry.get_checkpoint_scanner()
+                cache = await scanner.get_cached_data()
+
+                base_models = set()
+                for item in cache.raw_data:
+                    if item.get("sub_type") != "diffusion_model":
+                        continue
+                    base_model = item.get("base_model")
+                    file_path = item.get("file_path", "")
+                    if base_model and file_path and os.path.exists(file_path):
+                        base_models.add(base_model)
+
+                return sorted(base_models)
+
+            return ["Any"] + cls._run_async(_get_base_models)
+        except Exception as e:
+            logger.error(f"Error getting available base models: {e}")
+            return ["Any"]
+
+    def load_unet(
+        self,
+        unet_name: str,
+        weight_dtype: str,
+        select_at_random: bool = False,
+        base_model: str = "Any",
+    ) -> Tuple[Any, ...]:
+        """Load a diffusion model by name, supporting extra folder paths
+
+        Args:
+            unet_name: The name of the diffusion model to load (relative path with extension)
+            weight_dtype: The dtype to use for model weights
+            select_at_random: If True, ignore unet_name and pick randomly from the pool
+            base_model: Restricts random selection to this base model ("Any" = no filter)
+
+        Returns:
+            Tuple of (MODEL, model_name)
+        """
+        import torch
+
+        if select_at_random:
+            pool = self._get_unet_names(base_model)
+            if not pool:
+                raise FileNotFoundError(
+                    f"No diffusion models found for base model '{base_model}'. "
+                    "Pick a different base model or disable 'select_at_random'."
+                )
+            unet_name = random.choice(pool)
+            logger.info(
+                f"[RandomUNETLoaderLM] Randomly selected diffusion model: {unet_name}"
+            )
+
+        # Get absolute path from cache using ComfyUI-style name
+        unet_path, metadata = get_checkpoint_info_absolute(unet_name)
+
+        if metadata is None:
+            raise FileNotFoundError(
+                f"Diffusion model '{unet_name}' not found in LoRA Manager cache. "
+                "Make sure the model is indexed and try again."
+            )
+
+        # Check if it's a GGUF model
+        if unet_path.endswith(".gguf"):
+            return self._load_gguf_unet(unet_path, unet_name, weight_dtype)
+
+        # Load regular diffusion model using ComfyUI's API
+        logger.info(f"Loading diffusion model from: {unet_path}")
+
+        # Build model options based on weight_dtype
+        model_options = {}
+        if weight_dtype == "fp8_e4m3fn":
+            model_options["dtype"] = torch.float8_e4m3fn
+        elif weight_dtype == "fp8_e4m3fn_fast":
+            model_options["dtype"] = torch.float8_e4m3fn
+            model_options["fp8_optimizations"] = True
+        elif weight_dtype == "fp8_e5m2":
+            model_options["dtype"] = torch.float8_e5m2
+
+        model = comfy.sd.load_diffusion_model(unet_path, model_options=model_options)
+        return (model, unet_name)
+
+    def _load_gguf_unet(
+        self, unet_path: str, unet_name: str, weight_dtype: str
+    ) -> Tuple[Any, ...]:
+        """Load a GGUF format diffusion model
+
+        Args:
+            unet_path: Absolute path to the GGUF file
+            unet_name: Name of the model for error messages
+            weight_dtype: The dtype to use for model weights
+
+        Returns:
+            Tuple of (MODEL, model_name)
+        """
+        import torch
+        from .gguf_import_helper import get_gguf_modules
+
+        # Get ComfyUI-GGUF modules using helper (handles various import scenarios)
+        try:
+            loader_module, ops_module, nodes_module = get_gguf_modules()
+            gguf_sd_loader = getattr(loader_module, "gguf_sd_loader")
+            GGMLOps = getattr(ops_module, "GGMLOps")
+            GGUFModelPatcher = getattr(nodes_module, "GGUFModelPatcher")
+        except RuntimeError as e:
+            raise RuntimeError(f"Cannot load GGUF model '{unet_name}'. {str(e)}")
+
+        logger.info(f"Loading GGUF diffusion model from: {unet_path}")
+
+        try:
+            # Load GGUF state dict
+            sd, extra = gguf_sd_loader(unet_path)
+
+            # Prepare kwargs for metadata if supported
+            kwargs = {}
+            import inspect
+
+            valid_params = inspect.signature(
+                comfy.sd.load_diffusion_model_state_dict
+            ).parameters
+            if "metadata" in valid_params:
+                kwargs["metadata"] = extra.get("metadata", {})
+
+            # Setup custom operations with GGUF support
+            ops = GGMLOps()
+
+            # Handle weight_dtype for GGUF models
+            if weight_dtype in ("default", None):
+                ops.Linear.dequant_dtype = None
+            elif weight_dtype in ["target"]:
+                ops.Linear.dequant_dtype = weight_dtype
+            else:
+                ops.Linear.dequant_dtype = getattr(torch, weight_dtype, None)
+
+            # Load the model
+            model = comfy.sd.load_diffusion_model_state_dict(
+                sd, model_options={"custom_operations": ops}, **kwargs
+            )
+
+            if model is None:
+                raise RuntimeError(
+                    f"Could not detect model type for GGUF diffusion model: {unet_path}"
+                )
+
+            # Wrap with GGUFModelPatcher
+            model = GGUFModelPatcher.clone(model)
+
+            # Register a reload factory so the MODEL carries its source path
+            # (cached_patcher_init) like core ComfyUI loaders do — required
+            # for model-name extraction downstream and for ModelPatcher
+            # deepclone/dynamic machinery.
+            model.cached_patcher_init = (_reload_gguf_unet, (unet_path, weight_dtype))
+
+            return (model, unet_name)
+
+        except Exception as e:
+            logger.error(f"Error loading GGUF diffusion model '{unet_name}': {e}")
+            raise RuntimeError(
+                f"Failed to load GGUF diffusion model '{unet_name}': {str(e)}"
+            )
@@ -74,7 +74,10 @@ class UNETLoaderLM:
                for item in cache.raw_data:
                    if item.get("sub_type") == "diffusion_model":
                        file_path = item.get("file_path", "")
-                        if file_path:
+                        # Only offer models that still exist on disk so ComfyUI
+                        # flags missing diffusion models at queue time via
+                        # "value not in list" (the scanner cache can be stale).
+                        if file_path and os.path.exists(file_path):
                            # Format using relative path with OS-native separator
                            formatted_name = _format_model_name_for_comfyui(
                                file_path, model_roots
@@ -44,6 +44,7 @@ import re
 import logging
 import copy
 import sys
+import asyncio
 import folder_paths  # pyright: ignore[reportMissingImports]

 logger = logging.getLogger(__name__)
@@ -111,6 +112,157 @@ def get_loras_list(kwargs):
        return []


+_LORA_EXTENSIONS = (".safetensors", ".ckpt", ".pt", ".bin")
+
+
+def _strip_lora_extension(name: str) -> str:
+    """Strip a known LoRA model extension from a name (case-insensitive)."""
+    lowered = name.lower()
+    for ext in _LORA_EXTENSIONS:
+        if lowered.endswith(ext):
+            return name[: -len(ext)]
+    return name
+
+
+def _find_missing_loras(names: list[str]) -> list[str]:
+    """Return the names that cannot be resolved to an existing local LoRA file.
+
+    Mirrors the matching semantics of ``get_lora_info_absolute``
+    (py/utils/utils.py): after stripping the extension, a name matches a cached
+    LoRA when it equals the cached file name or the ``folder/file`` path. As a
+    fallback, a name containing a folder that only matches by basename resolves
+    to the first basename match (same behavior as the runtime resolver). Raw
+    absolute paths that exist on disk are always considered available.
+
+    The scanner cache is fetched once for all names; the cache may be stale, so
+    resolved paths are additionally verified with ``os.path.isfile``.
+    """
+    if not names:
+        return []
+
+    async def _check() -> list[str]:
+        from ..services.service_registry import ServiceRegistry
+
+        scanner = await ServiceRegistry.get_lora_scanner()
+        # The scanner cache may not be hydrated yet (startup, library path
+        # change). An empty cache is not authoritative — treat it as "cannot
+        # verify" and skip validation instead of flagging every active LoRA
+        # as missing.
+        if getattr(scanner, "_cache", None) is None or getattr(
+            scanner, "_is_initializing", False
+        ):
+            return []
+        cache = await scanner.get_cached_data()
+
+        lookup = {}
+        basename_candidates = {}
+        for item in cache.raw_data:
+            file_path = item.get("file_path")
+            if not file_path:
+                continue
+            file_name = item.get("file_name", "")
+            folder = item.get("folder", "")
+            file_name_no_ext = _strip_lora_extension(file_name)
+            path_name_no_ext = (
+                f"{folder}/{file_name_no_ext}".replace("\\", "/")
+                if folder
+                else file_name_no_ext
+            )
+            lookup.setdefault(file_name_no_ext, file_path)
+            lookup.setdefault(path_name_no_ext, file_path)
+            basename_candidates.setdefault(file_name_no_ext, []).append(
+                (folder, file_path)
+            )
+
+        missing = []
+        for name in names:
+            if not name:
+                continue
+            normalized = name.replace("\\", "/")
+            # Raw absolute paths (outside the library) are usable as-is.
+            if os.path.isfile(normalized):
+                continue
+            no_ext = _strip_lora_extension(normalized)
+            file_path = lookup.get(no_ext)
+            if file_path is None and "/" in no_ext:
+                # A name with a folder that matches only by basename resolves
+                # at runtime like get_lora_info_absolute's fallback does:
+                # prefer a candidate whose folder prefixes the name, else the
+                # first basename match.
+                folder, basename = no_ext.rsplit("/", 1)
+                candidates = basename_candidates.get(basename, [])
+                file_path = next(
+                    (
+                        fp
+                        for fld, fp in candidates
+                        if fld and no_ext.startswith(fld + "/")
+                    ),
+                    None,
+                )
+                if file_path is None and candidates:
+                    file_path = candidates[0][1]
+            if file_path is None or not os.path.isfile(file_path):
+                missing.append(name)
+        return missing
+
+    try:
+        # Check if we're already in an event loop
+        loop = asyncio.get_running_loop()
+        # If we're in a running loop, run the async check in a separate thread
+        import concurrent.futures
+
+        def run_in_thread():
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(_check())
+            finally:
+                new_loop.close()
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(run_in_thread)
+            return future.result()
+    except RuntimeError:
+        # No event loop is running, we can use asyncio.run()
+        return asyncio.run(_check())
+
+
+def validate_lora_entries(kwargs):
+    """Validate active LoRA widget entries against the local library.
+
+    Used by node ``VALIDATE_INPUTS`` implementations so ComfyUI rejects the
+    prompt at queue time (``custom_validation_failed``) when an active entry
+    references a LoRA that is not available locally — mirroring how built-in
+    loader nodes flag missing models before execution starts.
+
+    Returns:
+        None when every active entry resolves to an existing local file,
+        otherwise a descriptive error string listing the missing LoRAs.
+        Verification failures (e.g. scanner not ready) are treated as valid
+        so queueing is never blocked by validation machinery itself.
+    """
+    # Missing/empty loras input is always valid; skip get_loras_list so it
+    # does not log a warning for the None case on every queue.
+    if not kwargs.get("loras"):
+        return None
+    loras = get_loras_list(kwargs)
+    active_names = []
+    for lora in loras:
+        if not isinstance(lora, dict):
+            continue
+        if not lora.get("active", False):
+            continue
+        active_names.append(apply_lora_syntax_format(str(lora.get("name") or "")))
+    try:
+        missing = _find_missing_loras(active_names)
+    except Exception:
+        logger.exception("Failed to validate LoRA entries against the local library")
+        return None
+    if not missing:
+        return None
+    return "Missing LoRA(s) in local library: " + ", ".join(missing)
+
+
 def load_state_dict_in_safetensors(path, device="cpu", filter_prefix=""):
    """Simplified version of load_state_dict_in_safetensors that just loads from a local path"""
    import safetensors.torch
@@ -1,7 +1,7 @@
 import os
 from ..utils.utils import get_lora_info_absolute
 from ..config import config
-from .utils import FlexibleOptionalInputType, any_type, get_loras_list
+from .utils import FlexibleOptionalInputType, any_type, get_loras_list, validate_lora_entries
 import logging

 logger = logging.getLogger(__name__)
@@ -35,6 +35,11 @@ class WanVideoLoraSelectLM:
            "optional": FlexibleOptionalInputType(any_type),
        }

+    @classmethod
+    def VALIDATE_INPUTS(cls, loras=None):
+        """Queue-time validation: reject missing local LoRAs before execution."""
+        return validate_lora_entries({"loras": loras}) or True
+
    RETURN_TYPES = ("WANVIDLORA", "STRING", "STRING")
    RETURN_NAMES = ("lora", "trigger_words", "active_loras")
    FUNCTION = "process_loras"
@@ -11,7 +11,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, VALID_CHECKPOINT_SUB_TYPES
+from ..utils.constants import MODEL_WEIGHT_FILE_TYPES, VALID_LORA_TYPES, VALID_CHECKPOINT_SUB_TYPES
 from ..utils.civitai_utils import rewrite_preview_url

 logger = logging.getLogger(__name__)
@@ -155,9 +155,9 @@ class RecipeMetadataParser(ABC):
            
            # Process file information if available
            if 'files' in civitai_info:
-                # Find the primary model file (type="Model" and primary=true) in the files list
+                # Find the primary model file (weights-type and primary=true) in the files list
                model_file = next((file for file in civitai_info.get('files', []) 
-                                    if file.get('type') == 'Model' and file.get('primary') == True), None)
+                                    if file.get('type') in MODEL_WEIGHT_FILE_TYPES and file.get('primary') == True), None)
                
                if model_file:
                    # Get size
@@ -261,11 +261,21 @@ class RecipeMetadataParser(ABC):
            checkpoint['id'] = civitai_data.get('id', 0)

            if 'files' in civitai_data:
+                # Prefer the file CivitAI marked primary; fall back to any
+                # weights-type file (providers without primary flags).
                model_file = next(
                    (
                        file
                        for file in civitai_data.get('files', [])
-                        if file.get('type') == 'Model'
+                        if file.get('type') in MODEL_WEIGHT_FILE_TYPES
+                        and file.get('primary') is True
+                    ),
+                    None,
+                ) or next(
+                    (
+                        file
+                        for file in civitai_data.get('files', [])
+                        if file.get('type') in MODEL_WEIGHT_FILE_TYPES
                    ),
                    None,
                )
@@ -30,6 +30,7 @@ from ..services.websocket_progress_callback import (
    WebSocketProgressCallback,
 )
 from ..utils.exif_utils import ExifUtils
+from ..utils.constants import MODEL_WEIGHT_FILE_TYPES
 from ..utils.metadata_manager import MetadataManager
 from .model_route_registrar import COMMON_ROUTE_DEFINITIONS, ModelRouteRegistrar
 from .handlers.model_handlers import (
@@ -251,7 +252,7 @@ class BaseModelRoutes(ABC):

    def _find_model_file(self, files):
        """Find the appropriate model file from the files list - can be overridden by subclasses."""
-        return next((file for file in files if file.get("type") in ("Model", "Diffusion Model") and file.get("primary") is True), None)
+        return next((file for file in files if file.get("type") in MODEL_WEIGHT_FILE_TYPES and file.get("primary") is True), None)

    def get_handler(self, name: str) -> Callable[[web.Request], Awaitable[web.StreamResponse]]:
        """Expose handlers for subclasses or tests."""
@@ -51,6 +51,29 @@ LICENSE_FIELDS = (
 )


+_broadcast_models_changed_tasks: set = set()
+
+
+def _broadcast_models_changed() -> None:
+    """Notify connected clients that the local model library changed.
+
+    The ComfyUI graph page listens for this event to invalidate its cached
+    model availability data (loras widget missing-model cues / error flags)
+    without waiting for the cache TTL to expire.
+    """
+    try:
+        from ...services.websocket_manager import ws_manager
+
+        task = asyncio.create_task(ws_manager.broadcast({"type": "models_changed"}))
+        # Keep a reference so the task is not garbage-collected mid-await.
+        _broadcast_models_changed_tasks.add(task)
+        task.add_done_callback(_broadcast_models_changed_tasks.discard)
+    except Exception:
+        logging.getLogger(__name__).debug(
+            "Failed to broadcast models_changed", exc_info=True
+        )
+
+
 class ModelPageView:
    """Render the HTML view for model listings."""

@@ -460,6 +483,7 @@ class ModelManagementHandler:
                return web.Response(text="Model path is required", status=400)

            result = await self._lifecycle_service.delete_model(file_path)
+            _broadcast_models_changed()
            return web.json_response(result)
        except ValueError as exc:
            return web.json_response({"success": False, "error": str(exc)}, status=400)
@@ -931,6 +955,8 @@ class ModelManagementHandler:
                file_path=file_path, new_file_name=new_file_name
            )

+            _broadcast_models_changed()
+
            return web.json_response(
                {
                    **result,
@@ -959,6 +985,7 @@ class ModelManagementHandler:
                )

            result = await self._lifecycle_service.bulk_delete_models(file_paths)
+            _broadcast_models_changed()
            return web.json_response(result)
        except ValueError as exc:
            return web.json_response({"success": False, "error": str(exc)}, status=400)
@@ -1061,6 +1088,7 @@ class ModelQueryHandler:
            await self._service.scan_models(
                force_refresh=True, rebuild_cache=full_rebuild
            )
+            _broadcast_models_changed()
            if self._service.scanner.is_cancelled():
                return web.json_response(
                    {
@@ -2235,6 +2263,8 @@ class ModelMoveHandler:
            result = await self._move_service.move_model(
                file_path, target_path, use_default_paths=use_default_paths
            )
+            if result.get("success"):
+                _broadcast_models_changed()
            status = 200 if result.get("success") else 500
            return web.json_response(result, status=status)
        except Exception as exc:
@@ -2254,6 +2284,8 @@ class ModelMoveHandler:
            result = await self._move_service.move_models_bulk(
                file_paths, target_path, use_default_paths=use_default_paths
            )
+            if result.get("success"):
+                _broadcast_models_changed()
            return web.json_response(result)
        except Exception as exc:
            self._logger.error("Error moving models in bulk: %s", exc, exc_info=True)
@@ -2299,6 +2331,7 @@ class ModelAutoOrganizeHandler:
                progress_callback=self._progress_callback,
                exclusion_patterns=exclusion_patterns,
            )
+            _broadcast_models_changed()
            return web.json_response(result.to_dict())
        except AutoOrganizeInProgressError:
            return web.json_response(
@@ -2502,6 +2535,7 @@ class ModelUpdateHandler:
            return web.json_response({"success": False, "error": str(exc)}, status=500)

        hide_early_access = False
+        hide_paid = False
        if self._settings is not None:
            try:
                hide_early_access = bool(
@@ -2509,12 +2543,17 @@ class ModelUpdateHandler:
                )
            except Exception:
                pass
+            try:
+                hide_paid = bool(self._settings.get("hide_paid_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(
-                hide_early_access=hide_early_access
+                hide_early_access=hide_early_access,
+                hide_paid=hide_paid,
            ):
                serialized_records.append(self._serialize_record(record))

@@ -2668,10 +2707,16 @@ class ModelUpdateHandler:
        if not record or not record.versions:
            return record

-        # Find versions that need enrichment
+        # Find versions that need enrichment. Permanent paid versions are not
+        # early access (mirror _is_early_access_active) and never carry an end
+        # time, so skip them to avoid pointless per-version API calls.
        versions_needing_update = []
        for version in record.versions:
-            if version.is_early_access and not version.early_access_ends_at:
+            if (
+                version.is_early_access
+                and not version.early_access_ends_at
+                and not getattr(version, "is_paid", False)
+            ):
                versions_needing_update.append(version)

        if not versions_needing_update:
@@ -2901,6 +2946,7 @@ class ModelUpdateHandler:
        context = version_context or {}
        # Check user setting for hiding early access versions
        hide_early_access = False
+        hide_paid = False
        if self._settings is not None:
            try:
                hide_early_access = bool(
@@ -2908,6 +2954,10 @@ class ModelUpdateHandler:
                )
            except Exception:
                pass
+            try:
+                hide_paid = bool(self._settings.get("hide_paid_updates", False))
+            except Exception:
+                pass
        return {
            "modelType": record.model_type,
            "modelId": record.model_id,
@@ -2916,7 +2966,10 @@ class ModelUpdateHandler:
            "inLibraryVersionIds": record.in_library_version_ids,
            "lastCheckedAt": record.last_checked_at,
            "shouldIgnore": record.should_ignore_model,
-            "hasUpdate": record.has_update(hide_early_access=hide_early_access),
+            "hasUpdate": record.has_update(
+                hide_early_access=hide_early_access,
+                hide_paid=hide_paid,
+            ),
            "versions": [
                self._serialize_version(version, context.get(version.version_id))
                for version in record.versions
@@ -2935,8 +2988,11 @@ class ModelUpdateHandler:

        # Determine if version is currently in early access
        # Two-phase detection: use exact end time if available, otherwise fallback to basic flag
+        # Mirror _is_early_access_active: permanent paid versions (no end time) are NOT early access
        is_early_access = False
-        if version.early_access_ends_at:
+        if getattr(version, "is_paid", False) and not version.early_access_ends_at:
+            is_early_access = False
+        elif version.early_access_ends_at:
            try:
                from datetime import datetime, timezone

@@ -2951,6 +3007,13 @@ class ModelUpdateHandler:
            # Fallback to basic EA flag from bulk API
            is_early_access = True

+        paid_access_payload = None
+        if getattr(version, "paid_access", None):
+            try:
+                paid_access_payload = json.loads(version.paid_access)
+            except (TypeError, ValueError):
+                paid_access_payload = None
+
        return {
            "versionId": version.version_id,
            "name": version.name,
@@ -2964,6 +3027,8 @@ class ModelUpdateHandler:
            "earlyAccessEndsAt": version.early_access_ends_at,
            "isEarlyAccess": is_early_access,
            "usageControl": version.usage_control,
+            "isPaid": bool(getattr(version, "is_paid", False)),
+            "paidAccess": paid_access_payload,
            "filePath": context.get("file_path"),
            "fileName": context.get("file_name"),
        }
@@ -0,0 +1,323 @@
+"""Handler for the pending-delete undo endpoint.
+
+Restores a staged delete batch (models or recipes) via
+``PendingDeleteService.undo`` and then repairs the affected library caches:
+the model cache entry is restored from the manifest's ``model_snapshot``
+(including the version index and hash index), tag counts are re-incremented,
+and the recipe cache is re-populated via ``RecipeScanner.add_recipe``.
+
+The per-type scanner is resolved from the manifest's ``model_type`` page value
+through the SAME ServiceRegistry getters the model route registrars use
+(lora/checkpoint/embedding) - never a hardcoded lora scanner.
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import logging
+import os
+import re
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, cast
+
+from aiohttp import web
+
+from ...services.pending_delete_service import get_pending_delete_service
+from .model_handlers import _broadcast_models_changed
+
+logger = logging.getLogger(__name__)
+
+# Manifest ``model_type`` page values -> ServiceRegistry scanner getter names.
+# The model route registrars resolve per-type scanners via these getters
+# (lora_routes / checkpoint_routes / embedding_routes); undo must do the same
+# so the CORRECT cache is restored for the deleted model's type.
+_MODEL_TYPE_GETTER_NAMES: Dict[str, str] = {
+    "loras": "get_lora_scanner",
+    "checkpoints": "get_checkpoint_scanner",
+    "embeddings": "get_embedding_scanner",
+}
+
+# Staged batch ids are ``uuid.uuid4().hex`` (32 lowercase hex chars). The id is
+# joined into filesystem paths by ``_find_batch_dir``, so reject anything that
+# does not match this exact shape (blocks path-traversal via batch_id).
+_BATCH_ID_RE = re.compile(r"^[0-9a-f]{32}$")
+
+
+class PendingDeleteHandler:
+    """Handle undo requests for staged model/recipe deletions."""
+
+    def __init__(
+        self,
+        *,
+        service_factory: Callable[[], Awaitable[Any]] = get_pending_delete_service,
+        scanner_getter: Optional[Callable[[str], Awaitable[Any]]] = None,
+        recipe_scanner_getter: Optional[Callable[[], Awaitable[Any]]] = None,
+    ) -> None:
+        self._service_factory: Callable[[], Awaitable[Any]] = service_factory
+        self._scanner_getter: Callable[[str], Awaitable[Any]] = (
+            scanner_getter or self._resolve_scanner
+        )
+        self._recipe_scanner_getter: Callable[[], Awaitable[Any]] = (
+            recipe_scanner_getter or self._resolve_recipe_scanner
+        )
+
+    @staticmethod
+    async def _resolve_scanner(model_type: str) -> Any:
+        """Resolve the per-type scanner for a manifest ``model_type``.
+
+        The getter is looked up on the ServiceRegistry module namespace at call
+        time so tests (and the registry stubs) can patch it.
+        """
+        from ...services import service_registry
+
+        getter_name = _MODEL_TYPE_GETTER_NAMES.get(model_type)
+        if getter_name is None:
+            raise ValueError(f"Unknown model type: {model_type}")
+        getter = getattr(service_registry.ServiceRegistry, getter_name, None)
+        if not callable(getter):
+            raise ValueError(f"No scanner getter for model type: {model_type}")
+        scanner = await cast(Callable[[], Awaitable[Any]], getter)()
+        if scanner is None:
+            raise ValueError(f"No scanner registered for model type: {model_type}")
+        return scanner
+
+    @staticmethod
+    async def _resolve_recipe_scanner() -> Any:
+        """Resolve the recipe scanner via the ServiceRegistry module namespace."""
+        from ...services import service_registry
+
+        getter = getattr(service_registry.ServiceRegistry, "get_recipe_scanner", None)
+        if not callable(getter):
+            raise ValueError("Recipe scanner getter unavailable")
+        scanner = await cast(Callable[[], Awaitable[Any]], getter)()
+        if scanner is None:
+            raise ValueError("No recipe scanner registered")
+        return scanner
+
+    async def undo_delete(self, request: web.Request) -> web.Response:
+        """Restore a staged batch and its library cache entry.
+
+        Body: ``{"batch_id": str}``. On success returns
+        ``{"success": True, "restored": [<original paths>], "kind": kind}``.
+        Expired/unknown batches and occupied target paths -> 404.
+        """
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response(
+                {"success": False, "error": "Invalid JSON body"}, status=400
+            )
+        if not isinstance(data, dict):
+            return web.json_response(
+                {"success": False, "error": "Invalid JSON body"}, status=400
+            )
+        batch_id = data.get("batch_id")
+        if not batch_id or not isinstance(batch_id, str):
+            return web.json_response(
+                {"success": False, "error": "batch_id is required"}, status=400
+            )
+        if not _BATCH_ID_RE.fullmatch(batch_id):
+            # batch_id is joined into a path by _find_batch_dir - restrict to
+            # the exact staged-id shape so traversal payloads get 400.
+            return web.json_response(
+                {"success": False, "error": "Invalid batch_id"}, status=400
+            )
+
+        service = await self._service_factory()
+        try:
+            # Read the manifest BEFORE undo: undo() removes the batch dir.
+            manifest = await self._read_staged_manifest(service, batch_id)
+            result = await service.undo(batch_id)
+        except ValueError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            logger.error("Unexpected error undoing batch %s: %s", batch_id, exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+        kind = result.get("kind")
+        try:
+            if kind == "model":
+                if manifest is not None:
+                    await self._restore_model_cache(manifest)
+                else:
+                    # undo() raises when the manifest is missing, so this only
+                    # happens defensively - files are restored regardless.
+                    logger.warning(
+                        "Manifest missing after undo of %s; skipping cache restore",
+                        batch_id,
+                    )
+                _broadcast_models_changed()
+            elif kind == "recipe":
+                # Recipe undo is client-refresh only: re-add to the scanner
+                # cache, no models_changed broadcast.
+                if manifest is not None:
+                    await self._restore_recipe_cache(result, manifest)
+                else:
+                    logger.warning(
+                        "Manifest missing after undo of %s; skipping cache restore",
+                        batch_id,
+                    )
+        except Exception as exc:
+            # Files are already restored; only the cache restoration failed.
+            logger.error(
+                "Cache restoration failed after undo of %s: %s",
+                batch_id,
+                exc,
+                exc_info=True,
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+        return web.json_response(
+            {
+                "success": True,
+                "restored": result.get("restored", []),
+                "kind": kind,
+            }
+        )
+
+    @staticmethod
+    async def _read_staged_manifest(
+        service: Any, batch_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """Locate and read the batch manifest while it still exists on disk."""
+        batch_dir = await service._find_batch_dir(batch_id)
+        if not batch_dir:
+            return None
+        manifest_path = os.path.join(batch_dir, "manifest.json")
+        try:
+            with open(manifest_path, "r", encoding="utf-8") as handle:
+                payload = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            logger.debug("Failed to read manifest for batch %s: %s", batch_id, exc)
+            return None
+        return payload if isinstance(payload, dict) else None
+
+    async def _restore_model_cache(self, manifest: Dict[str, Any]) -> None:
+        """Re-add every deleted model's cache entry from the manifest.
+
+        Each main-file entry carries the deleted model's ``snapshot`` (added at
+        stage time), so a merged bulk manifest holds ALL snapshots - undo must
+        restore every one, not just the top-level winner's. Old-format
+        manifests without entry snapshots fall back to the top-level
+        ``model_snapshot`` (backward compat / single-delete path).
+        """
+        model_type = manifest.get("model_type")
+        if not model_type or not isinstance(model_type, str):
+            raise ValueError(f"Manifest carries no model_type: {manifest.get('batch_id')}")
+        scanner = await self._scanner_getter(model_type)
+
+        # Collect one snapshot per distinct file_path from the entry snapshots.
+        snapshots: List[Dict[str, Any]] = []
+        seen: Set[str] = set()
+        for entry in manifest.get("entries") or []:
+            snapshot = entry.get("snapshot")
+            if not isinstance(snapshot, dict):
+                continue
+            file_path = snapshot.get("file_path")
+            if not file_path or not isinstance(file_path, str):
+                continue
+            if file_path in seen:
+                continue
+            seen.add(file_path)
+            snapshots.append(snapshot)
+
+        if not snapshots:
+            # Backward compat: pre-F3 manifests carry only the top-level
+            # model_snapshot (single-delete path, unchanged behavior).
+            top = manifest.get("model_snapshot")
+            if isinstance(top, dict) and top.get("file_path"):
+                snapshots = [top]
+            else:
+                logger.warning(
+                    "Manifest %s has no restorable model snapshot; skipping cache restore",
+                    manifest.get("batch_id"),
+                )
+                return
+
+        cache = await scanner.get_cached_data()
+        if cache is None:
+            logger.warning(
+                "Scanner cache unavailable for %s; skipping cache restore", model_type
+            )
+            return
+
+        for snapshot in snapshots:
+            file_path = str(snapshot["file_path"])
+            # A rescan between delete and undo may have re-added a stale entry
+            # for this path - drop it so exactly one (the snapshot) remains.
+            cache.raw_data = [
+                item for item in cache.raw_data if item.get("file_path") != file_path
+            ]
+
+            # Restore tag counts (mirror of the bulk-delete decrement in
+            # _batch_update_cache_for_deleted_models: undo re-increments).
+            tags = snapshot.get("tags")
+            if isinstance(tags, list):
+                for tag in tags:
+                    if not isinstance(tag, str) or not tag:
+                        continue
+                    scanner._tags_count[tag] = scanner._tags_count.get(tag, 0) + 1
+
+            cache.raw_data.append(dict(snapshot))
+
+            # Re-register the path in the hash index (add_entry guards a
+            # missing sha256 internally; still guard defensively here).
+            sha256 = snapshot.get("sha256") or ""
+            autov3 = snapshot.get("autov3")
+            hash_index = getattr(scanner, "_hash_index", None)
+            if hash_index is not None and sha256 and file_path:
+                hash_index.add_entry(sha256, file_path, autov3)
+
+        # Follow the bulk-delete cache-update pattern ONCE after all entries,
+        # including the explicit version-index rebuild so the version index
+        # does not go stale.
+        cache.rebuild_version_index()
+        await cache.resort()
+
+        scanner.bump_cache_version()
+
+        persist = getattr(scanner, "_persist_current_cache", None)
+        if callable(persist):
+            result = persist()
+            if inspect.isawaitable(result):
+                await result
+
+    async def _restore_recipe_cache(
+        self, result: Dict[str, Any], manifest: Dict[str, Any]
+    ) -> None:
+        """Re-add a restored recipe via ``RecipeScanner.add_recipe``.
+
+        The recipe JSON embeds the full recipe_data (incl. id/file_path);
+        ``add_recipe`` only READS the ``_json_path_map`` so the forced frontend
+        refresh self-heals any transient path-map gap.
+        """
+        restored = result.get("restored") or []
+        json_path = next(
+            (p for p in restored if isinstance(p, str) and p.endswith(".json")),
+            None,
+        )
+        if not json_path or not os.path.exists(json_path):
+            # Defensive fallback to the manifest's recipe_snapshot file_path.
+            snapshot = manifest.get("recipe_snapshot") or {}
+            fallback = snapshot.get("file_path")
+            if fallback and os.path.exists(fallback):
+                json_path = fallback
+            else:
+                logger.warning(
+                    "Restored recipe JSON not found in %s; skipping cache restore",
+                    restored,
+                )
+                return
+        try:
+            with open(json_path, "r", encoding="utf-8") as handle:
+                recipe_data = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            logger.warning("Failed to load restored recipe JSON %s: %s", json_path, exc)
+            return
+        if not isinstance(recipe_data, dict):
+            return
+        recipe_scanner = await self._recipe_scanner_getter()
+        await recipe_scanner.add_recipe(recipe_data)
+
+
+__all__ = ["PendingDeleteHandler"]
@@ -34,6 +34,7 @@ from ...utils.civitai_utils import (
 )
 from ...utils.constants import NSFW_LEVELS
 from ...utils.exif_utils import ExifUtils
+from ...utils.recipe_open_stats import RecipeOpenStats
 from ...recipes.merger import GenParamsMerger
 from ...recipes.enrichment import RecipeEnricher
 from ...services.websocket_manager import ws_manager as default_ws_manager
@@ -98,6 +99,7 @@ class RecipeHandlerSet:
            "download_shared_recipe": self.sharing.download_shared_recipe,
            "get_recipe_syntax": self.query.get_recipe_syntax,
            "update_recipe": self.management.update_recipe,
+            "record_recipe_open": self.management.record_recipe_open,
            "reconnect_lora": self.management.reconnect_lora,
            "find_duplicates": self.query.find_duplicates,
            "move_recipes_bulk": self.management.move_recipes_bulk,
@@ -112,6 +114,11 @@ class RecipeHandlerSet:
            "repair_recipe": self.management.repair_recipe,
            "repair_recipes_bulk": self.management.repair_recipes_bulk,
            "get_repair_progress": self.management.get_repair_progress,
+            "rematch_recipes": self.management.rematch_recipes,
+            "cancel_rematch": self.management.cancel_rematch,
+            "rematch_recipe": self.management.rematch_recipe,
+            "rematch_recipes_bulk": self.management.rematch_recipes_bulk,
+            "get_rematch_progress": self.management.get_rematch_progress,
            "start_batch_import": self.batch_import.start_batch_import,
            "get_batch_import_progress": self.batch_import.get_batch_import_progress,
            "cancel_batch_import": self.batch_import.cancel_batch_import,
@@ -575,7 +582,12 @@ class RecipeQueryHandler:
            if recipe_scanner is None:
                raise RuntimeError("Recipe scanner unavailable")

-            fingerprint_groups = await recipe_scanner.find_all_duplicate_recipes()
+            include_prompt = (
+                request.query.get("include_prompt", "false").lower() in ("1", "true")
+            )
+            fingerprint_groups = await recipe_scanner.find_all_duplicate_recipes(
+                include_prompt=include_prompt
+            )
            url_groups = await recipe_scanner.find_duplicate_recipes_by_source()
            response_data = []

@@ -608,6 +620,7 @@ class RecipeQueryHandler:
                    response_data.append(
                        {
                            "type": "fingerprint",
+                            "key": f"g-{len(response_data) + 1}",
                            "fingerprint": fingerprint,
                            "count": len(recipes),
                            "recipes": recipes,
@@ -643,6 +656,7 @@ class RecipeQueryHandler:
                    response_data.append(
                        {
                            "type": "source_path",
+                            "key": f"g-{len(response_data) + 1}",
                            "fingerprint": url,
                            "count": len(recipes),
                            "recipes": recipes,
@@ -887,6 +901,159 @@ class RecipeManagementHandler:
            self._logger.error("Error repairing single recipe: %s", exc, exc_info=True)
            return web.json_response({"success": False, "error": str(exc)}, status=500)

+    async def rematch_recipes(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response(
+                    {"success": False, "error": "Recipe scanner unavailable"},
+                    status=503,
+                )
+
+            # Mutual exclusion: a global rematch cannot start while a rematch
+            # OR a repair is already running — both mutate recipes under the
+            # same mutation lock.
+            if (
+                self._ws_manager.is_recipe_rematch_running()
+                or self._ws_manager.is_recipe_repair_running()
+            ):
+                return web.json_response(
+                    {"success": False, "error": "Recipe rematch already in progress"},
+                    status=409,
+                )
+
+            recipe_scanner.reset_cancellation()
+
+            async def progress_callback(data):
+                await self._ws_manager.broadcast_recipe_rematch_progress(data)
+
+            # Run in background to avoid timeout
+            async def run_rematch():
+                try:
+                    await recipe_scanner.rematch_all_recipes(
+                        progress_callback=progress_callback
+                    )
+                except Exception as e:
+                    self._logger.error(
+                        f"Error in recipe rematch task: {e}", exc_info=True
+                    )
+                    await self._ws_manager.broadcast_recipe_rematch_progress(
+                        {"status": "error", "error": str(e)}
+                    )
+                finally:
+                    # Keep the final status for a while so the UI can see it
+                    await asyncio.sleep(5)
+                    self._ws_manager.cleanup_recipe_rematch_progress()
+
+            asyncio.create_task(run_rematch())
+
+            return web.json_response(
+                {"success": True, "message": "Recipe rematch started"}
+            )
+        except Exception as exc:
+            self._logger.error("Error starting recipe rematch: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def cancel_rematch(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response(
+                    {"success": False, "error": "Recipe scanner unavailable"},
+                    status=503,
+                )
+
+            recipe_scanner.cancel_task()
+            return web.json_response(
+                {"success": True, "message": "Cancellation requested"}
+            )
+        except Exception as exc:
+            self._logger.error("Error cancelling recipe rematch: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def rematch_recipes_bulk(self, request: web.Request) -> web.Response:
+        """Rematch deleted resources for multiple recipes by their IDs.
+
+        Accepts a JSON body with a "recipe_ids" array. The per-recipe loop is
+        delegated to the scanner's rematch_recipes_bulk; this handler only
+        parses the request and returns the scanner's summary.
+        """
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response(
+                    {"success": False, "error": "Recipe scanner unavailable"},
+                    status=503,
+                )
+
+            # A bulk rematch must not queue behind a running global rematch's
+            # mutation lock.
+            if self._ws_manager.is_recipe_rematch_running():
+                return web.json_response(
+                    {"success": False, "error": "Recipe rematch already in progress"},
+                    status=409,
+                )
+
+            data = await request.json()
+            recipe_ids = data.get("recipe_ids", [])
+            if not recipe_ids:
+                return web.json_response(
+                    {"success": False, "error": "recipe_ids are required"},
+                    status=400,
+                )
+
+            result = await recipe_scanner.rematch_recipes_bulk(recipe_ids)
+            return web.json_response(result)
+        except Exception as exc:
+            self._logger.error(
+                "Error performing bulk rematch: %s", exc, exc_info=True
+            )
+            return web.json_response(
+                {"success": False, "error": str(exc)}, status=500
+            )
+
+    async def rematch_recipe(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                return web.json_response(
+                    {"success": False, "error": "Recipe scanner unavailable"},
+                    status=503,
+                )
+
+            # Reject per-recipe rematches while a global run is in progress so
+            # they do not queue behind the mutation lock.
+            if self._ws_manager.is_recipe_rematch_running():
+                return web.json_response(
+                    {"success": False, "error": "Recipe rematch already in progress"},
+                    status=409,
+                )
+
+            recipe_id = request.match_info["recipe_id"]
+            result = await recipe_scanner.rematch_recipe_by_id(recipe_id)
+            return web.json_response(result)
+        except RecipeNotFoundError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            self._logger.error("Error rematching single recipe: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def get_rematch_progress(self, request: web.Request) -> web.Response:
+        try:
+            progress = self._ws_manager.get_recipe_rematch_progress()
+            if progress:
+                return web.json_response({"success": True, "progress": progress})
+            return web.json_response(
+                {"success": False, "message": "No rematch in progress"}, status=404
+            )
+        except Exception as exc:
+            self._logger.error("Error getting rematch progress: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
    async def reimport_recipe(self, request: web.Request) -> web.Response:
        """Delete a recipe and re-import it from its source URL.

@@ -1293,6 +1460,33 @@ class RecipeManagementHandler:
            self._logger.error("Error updating recipe: %s", exc, exc_info=True)
            return web.json_response({"error": str(exc)}, status=500)

+    async def record_recipe_open(self, request: web.Request) -> web.Response:
+        """Record that a recipe's detail modal was opened.
+
+        Lightweight fire-and-forget endpoint backing the "Recently Opened"
+        sort. It only writes the timestamp into the separate open-stats file
+        — recipe JSON and EXIF are never touched.
+        """
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            recipe_id = request.match_info["recipe_id"]
+            # Skip recording opens for recipes the scanner no longer knows.
+            recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+            if not recipe_json_path:
+                return web.json_response(
+                    {"success": False, "error": "Recipe not found"}, status=404
+                )
+
+            RecipeOpenStats().record_open(recipe_id)
+            return web.json_response({"success": True})
+        except Exception as exc:
+            self._logger.error("Error recording recipe open: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
    async def move_recipe(self, request: web.Request) -> web.Response:
        try:
            await self._ensure_dependencies_ready()
@@ -0,0 +1,25 @@
+"""Route controller for the pending-delete undo endpoint."""
+
+from __future__ import annotations
+
+from aiohttp import web
+
+from .handlers.pending_delete_handler import PendingDeleteHandler
+
+
+class PendingDeleteRoutes:
+    """Shared route controller mirroring MiscRoutes/UpdateRoutes.
+
+    Registered ONCE per mode (py/lora_manager.py, standalone.py); NEVER through
+    the per-model-type ModelRouteRegistrar, which is instantiated per model
+    type and would register this non-prefixed route three times.
+    """
+
+    @staticmethod
+    def setup_routes(app: web.Application) -> None:
+        """Register the shared undo-delete endpoint."""
+        handler = PendingDeleteHandler()
+        _ = app.router.add_post("/api/lm/undo-delete", handler.undo_delete)
+
+
+__all__ = ["PendingDeleteRoutes"]
@@ -43,6 +43,9 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    ),
    RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/syntax", "get_recipe_syntax"),
    RouteDefinition("PUT", "/api/lm/recipe/{recipe_id}/update", "update_recipe"),
+    RouteDefinition(
+        "POST", "/api/lm/recipe/{recipe_id}/opened", "record_recipe_open"
+    ),
    RouteDefinition("POST", "/api/lm/recipe/move", "move_recipe"),
    RouteDefinition("POST", "/api/lm/recipes/move-bulk", "move_recipes_bulk"),
    RouteDefinition("POST", "/api/lm/recipe/lora/reconnect", "reconnect_lora"),
@@ -61,6 +64,11 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
    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/rematch", "rematch_recipes"),
+    RouteDefinition("POST", "/api/lm/recipes/rematch-bulk", "rematch_recipes_bulk"),
+    RouteDefinition("POST", "/api/lm/recipe/{recipe_id}/rematch", "rematch_recipe"),
+    RouteDefinition("POST", "/api/lm/recipes/cancel-rematch", "cancel_rematch"),
+    RouteDefinition("GET", "/api/lm/recipes/rematch-progress", "get_rematch_progress"),
    RouteDefinition("POST", "/api/lm/recipes/batch-import/start", "start_batch_import"),
    RouteDefinition(
        "GET", "/api/lm/recipes/batch-import/progress", "get_batch_import_progress"
@@ -11,6 +11,7 @@ import os
 import secrets
 import shutil
 import socket
+import time
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -24,6 +25,39 @@ from .settings_manager import get_settings_manager

 logger = logging.getLogger(__name__)

+# Maximum times the download poll loop will re-schedule a transfer after it
+# is lost (daemon restart / RPC outage) before failing the download.
+MAX_TRANSFER_RECOVERY_ATTEMPTS = 2
+
+# stderr lines matching these markers indicate a disk write failure inside
+# aria2 (piece cache flush or raw file write).  They are promoted to INFO so
+# the root cause (disk full, permission denied, file locked by another
+# process, ...) is visible in the default logs; all other stderr output stays
+# at DEBUG to avoid noise.
+_DISK_WRITE_ERROR_MARKERS = (
+    # aria2 wrapper messages (write disk cache flush path)
+    "write disk cache flush failure",
+    "error when trying to flush write cache",
+    "failed to write into the file",
+    "failed to open the file",
+    "failed to seek the file",
+    # underlying root-cause phrases reported via "cause: ..." (POSIX + Windows)
+    "no space left on device",
+    "not enough space on the disk",
+    "input/output error",
+    "permission denied",
+    "access is denied",
+    "disk quota exceeded",
+    "used by another process",
+    "sharing violation",
+)
+
+# Minimum interval between INFO-level reports of the same stderr line so a
+# repeated failure (e.g. aria2 retrying against a full disk) does not spam
+# the log.
+STDERR_ERROR_REPORT_INTERVAL = 60.0
+
+
 def _try_certifi_ca_path() -> str | None:
    """Return the certifi CA bundle path if available, else None."""
    try:
@@ -85,10 +119,12 @@ class Aria2Downloader:
        self._rpc_session: Optional[aiohttp.ClientSession] = None
        self._rpc_session_lock = asyncio.Lock()
        self._process_lock = asyncio.Lock()
+        self._register_lock = asyncio.Lock()
        self._transfers: Dict[str, Aria2Transfer] = {}
        self._poll_interval = 0.5
        self._state_store = Aria2TransferStateStore()
        self._stderr_reader_task: Optional[asyncio.Task[Any]] = None
+        self._stderr_error_report: Dict[str, float] = {}

    @property
    def is_running(self) -> bool:
@@ -103,26 +139,58 @@ class Aria2Downloader:
        progress_callback=None,
        headers: Optional[Dict[str, str]] = None,
    ) -> Tuple[bool, str]:
-        """Download a file using aria2 RPC and wait for completion."""
+        """Download a file using aria2 RPC and wait for completion.
+
+        The poll loop is self-healing: when the in-memory transfer entry
+        disappears (e.g. another download restarted the daemon and
+        ``close()`` cleared ``_transfers``) or the RPC becomes unreachable,
+        the transfer is re-scheduled with ``continue=true`` so the download
+        resumes from the on-disk ``.aria2`` control file. Recovery is bounded
+        by ``MAX_TRANSFER_RECOVERY_ATTEMPTS``.
+        """

        await self._ensure_process()
        save_path = os.path.abspath(save_path)
-        transfer = self._transfers.get(download_id)
-        if transfer is None or os.path.abspath(transfer.save_path) != save_path:
-            gid = await self._schedule_download(
-                url,
-                save_path,
-                download_id=download_id,
-                headers=headers,
-            )
-            transfer = Aria2Transfer(gid=gid, save_path=save_path)
-            self._transfers[download_id] = transfer

+        async with self._register_lock:
+            transfer = self._transfers.get(download_id)
+            if transfer is None or os.path.abspath(transfer.save_path) != save_path:
+                transfer = await self._register_transfer(
+                    url,
+                    save_path,
+                    download_id=download_id,
+                    headers=headers,
+                )
+
+        recovery_attempts = 0
        try:
            while True:
-                status = await self._get_status_with_retry(download_id)
+                try:
+                    status = await self._get_status_with_retry(download_id)
+                except Aria2Error:
+                    status = None
+
                if status is None:
-                    return False, "aria2 download not found"
+                    if recovery_attempts >= MAX_TRANSFER_RECOVERY_ATTEMPTS:
+                        return False, "aria2 download not found"
+                    recovery_attempts += 1
+                    logger.warning(
+                        "aria2 transfer %s lost; re-scheduling with resume "
+                        "(attempt %d/%d)",
+                        download_id,
+                        recovery_attempts,
+                        MAX_TRANSFER_RECOVERY_ATTEMPTS,
+                    )
+                    await asyncio.sleep(1.0)
+                    await self._ensure_process()
+                    async with self._register_lock:
+                        transfer = await self._register_transfer(
+                            url,
+                            save_path,
+                            download_id=download_id,
+                            headers=headers,
+                        )
+                    continue

                snapshot = self._build_progress_snapshot(status)
                if progress_callback is not None:
@@ -139,7 +207,9 @@ class Aria2Downloader:

                await asyncio.sleep(self._poll_interval)
        finally:
-            self._transfers.pop(download_id, None)
+            current = self._transfers.get(download_id)
+            if current is not None and current.gid == transfer.gid:
+                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
@@ -242,6 +312,25 @@ class Aria2Downloader:
        )
        return gid

+    async def _register_transfer(
+        self,
+        url: str,
+        save_path: str,
+        *,
+        download_id: str,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Aria2Transfer:
+        """Schedule a download and track it in the in-memory transfer registry."""
+        gid = await self._schedule_download(
+            url,
+            save_path,
+            download_id=download_id,
+            headers=headers,
+        )
+        transfer = Aria2Transfer(gid=gid, save_path=os.path.abspath(save_path))
+        self._transfers[download_id] = transfer
+        return transfer
+
    async def get_status(self, download_id: str) -> Optional[Dict[str, Any]]:
        """Return the raw aria2 status payload for a known download."""

@@ -389,16 +478,51 @@ class Aria2Downloader:
        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.
+
+        Lines that indicate a disk write failure (e.g. the "cause: No space
+        left on device" line that follows "Write disk cache flush failure")
+        are promoted to INFO so the root cause is visible without enabling
+        debug logging; every other line stays at DEBUG to avoid noise.
        """
        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)
+                    if self._is_disk_write_error(text):
+                        self._report_stderr_error(text)
+                    else:
+                        logger.debug("aria2 stderr: %s", text)
        except Exception:
            pass

+    @staticmethod
+    def _is_disk_write_error(text: str) -> bool:
+        lowered = text.lower()
+        return any(marker in lowered for marker in _DISK_WRITE_ERROR_MARKERS)
+
+    def _report_stderr_error(self, text: str) -> None:
+        """INFO-log a disk write failure line, rate-limited per line text.
+
+        aria2 re-emits the same error chain on every poll/retry while the
+        underlying condition persists; only the first occurrence within
+        ``STDERR_ERROR_REPORT_INTERVAL`` seconds is promoted to INFO.
+        """
+        now = time.monotonic()
+        last = self._stderr_error_report.get(text)
+        if last is not None and now - last < STDERR_ERROR_REPORT_INTERVAL:
+            logger.debug("aria2 stderr (repeated disk write error): %s", text)
+            return
+        # Drop entries older than the window so the map stays bounded even
+        # during a long disk-full episode (piece indexes change per line).
+        self._stderr_error_report = {
+            line: timestamp
+            for line, timestamp in self._stderr_error_report.items()
+            if now - timestamp < STDERR_ERROR_REPORT_INTERVAL
+        }
+        self._stderr_error_report[text] = now
+        logger.info("aria2 disk write failure: %s", text)
+
    async def _dispatch_progress(self, callback, snapshot: DownloadProgress) -> None:
        try:
            result = callback(snapshot, snapshot)
@@ -633,6 +633,13 @@ class BaseModelService(ABC):
        except Exception:
            hide_early_access = False

+        # Check user setting for hiding permanent paid updates
+        hide_paid = False
+        try:
+            hide_paid = bool(self.settings.get("hide_paid_updates", False))
+        except Exception:
+            hide_paid = False
+
        records = None
        resolved: Optional[Dict[int, bool]] = None
        if same_base_mode:
@@ -641,7 +648,10 @@ class BaseModelService(ABC):
                try:
                    records = await cast(Awaitable[Any], record_method(self.model_type, ordered_ids))
                    resolved = {
-                        model_id: record.has_update(hide_early_access=hide_early_access)
+                        model_id: record.has_update(
+                            hide_early_access=hide_early_access,
+                            hide_paid=hide_paid,
+                        )
                        for model_id, record in records.items()
                    }
                except Exception as exc:
@@ -663,6 +673,7 @@ class BaseModelService(ABC):
                        self.model_type,
                        ordered_ids,
                        hide_early_access=hide_early_access,
+                        hide_paid=hide_paid,
                    ))
                except Exception as exc:
                    logger.error(
@@ -677,7 +688,10 @@ class BaseModelService(ABC):
        if resolved is None:
            tasks = [
                self.update_service.has_update(
-                    self.model_type, model_id, hide_early_access=hide_early_access
+                    self.model_type,
+                    model_id,
+                    hide_early_access=hide_early_access,
+                    hide_paid=hide_paid,
                )
                for model_id in ordered_ids
            ]
@@ -717,6 +731,7 @@ class BaseModelService(ABC):
                        threshold_version,
                        base_model,
                        hide_early_access=hide_early_access,
+                        hide_paid=hide_paid,
                    )
                else:
                    flag = default_flag
@@ -13,7 +13,7 @@ from ..utils.models import CheckpointMetadata
 from ..utils.file_utils import find_preview_file, normalize_path, calculate_autov3
 from ..utils.metadata_manager import MetadataManager
 from ..config import config
-from .model_scanner import ModelScanner
+from .model_scanner import ModelScanner, _is_excluded_dir
 from .model_hash_index import ModelHashIndex

 logger = logging.getLogger(__name__)
@@ -328,7 +328,8 @@ class CheckpointScanner(ModelScanner):
            if not os.path.exists(root_path):
                continue

-            for dirpath, _dirnames, filenames in os.walk(root_path):
+            for dirpath, dirnames, filenames in os.walk(root_path):
+                dirnames[:] = [d for d in dirnames if not _is_excluded_dir(d)]
                for filename in filenames:
                    if not filename.endswith(".metadata.json"):
                        continue
@@ -21,6 +21,7 @@ from .model_metadata_provider import (
 from .downloader import get_downloader
 from .errors import RateLimitError, ResourceNotFoundError
 from ..utils.civitai_utils import resolve_license_payload
+from ..utils.constants import MODEL_WEIGHT_FILE_TYPES

 logger = logging.getLogger(__name__)

@@ -538,10 +539,16 @@ class CivitaiClient:
        return model_versions[0]

    def _extract_primary_model_hash(self, version_entry: Dict[str, Any]) -> Optional[str]:
+        # Prefer the generic "Model" file (most reliable version identity);
+        # fall back to any other weights-type primary.
        for file_info in version_entry.get("files", []):
            if file_info.get("type") == "Model" and file_info.get("primary"):
-                hashes = file_info.get("hashes", {})
-                model_hash = hashes.get("SHA256")
+                model_hash = (file_info.get("hashes", {}) or {}).get("SHA256")
+                if model_hash:
+                    return model_hash
+        for file_info in version_entry.get("files", []):
+            if file_info.get("type") in MODEL_WEIGHT_FILE_TYPES and file_info.get("primary"):
+                model_hash = (file_info.get("hashes", {}) or {}).get("SHA256")
                if model_hash:
                    return model_hash
        return None
@@ -83,6 +83,7 @@ class DownloadCoordinator:
            save_dir=payload.get("model_root"),
            relative_path=payload.get("relative_path", ""),
            use_default_paths=payload.get("use_default_paths", False),
+            use_save_dir_as_root=payload.get("use_save_dir_as_root", False),
            progress_callback=progress_callback,
            download_id=download_id,
            source=payload.get("source"),
@@ -3,6 +3,7 @@
 # reportImportCycles, so the ServiceRegistry singleton pattern necessarily forms
 # import cycles. Breaking them would require an architectural refactor.
 import copy
+import json
 import logging
 import os
 import asyncio
@@ -18,6 +19,7 @@ from ..utils.models import LoraMetadata, CheckpointMetadata, EmbeddingMetadata
 from ..utils.constants import (
    CARD_PREVIEW_WIDTH,
    DIFFUSION_MODEL_BASE_MODELS,
+    MODEL_WEIGHT_FILE_TYPES,
    SUPPORTED_DOWNLOAD_SKIP_BASE_MODELS,
    VALID_LORA_TYPES,
 )
@@ -46,6 +48,11 @@ CIVITAI_DOWNLOAD_URL_PREFIXES = (
 )


+# File types that are never the intended download target even when CivitAI
+# marks them primary — configs/archives/workflows are auxiliary artifacts.
+NON_DOWNLOADABLE_PRIMARY_TYPES = ("Config", "Archive", "Workflow", "Training Data")
+
+
 class DownloadManager:
    _instance = None
    _lock = asyncio.Lock()
@@ -217,6 +224,7 @@ class DownloadManager:
        download_id: str | None = None,
        source: str | None = None,
        file_params: Dict[str, Any] | None = None,
+        use_save_dir_as_root: bool = False,
    ) -> Dict[str, Any]:
        """Download model from Civitai with task tracking and concurrency control

@@ -257,6 +265,7 @@ class DownloadManager:
            "save_dir": save_dir,
            "relative_path": relative_path,
            "use_default_paths": bool(use_default_paths),
+            "use_save_dir_as_root": bool(use_save_dir_as_root),
            "source": source,
            "file_params": copy.deepcopy(file_params) if file_params is not None else None,
            "progress": 0,
@@ -287,6 +296,7 @@ class DownloadManager:
                use_default_paths,
                source,
                file_params,
+                use_save_dir_as_root,
            )
        )

@@ -321,6 +331,7 @@ class DownloadManager:
        use_default_paths: bool = False,
        source: str | None = None,
        file_params: Dict[str, Any] | None = None,
+        use_save_dir_as_root: bool = False,
    ):
        """Execute download with semaphore to limit concurrency"""
        # Update status to waiting
@@ -401,6 +412,7 @@ class DownloadManager:
                        ),
                        source,
                        file_params,
+                        use_save_dir_as_root=use_save_dir_as_root,
                    )

                    # Update status based on result
@@ -621,6 +633,7 @@ class DownloadManager:
            "save_dir": info.get("save_dir"),
            "relative_path": info.get("relative_path", ""),
            "use_default_paths": bool(info.get("use_default_paths", False)),
+            "use_save_dir_as_root": bool(info.get("use_save_dir_as_root", False)),
            "source": info.get("source"),
            "file_params": copy.deepcopy(info.get("file_params")),
            "transfer_backend": info.get("transfer_backend", "aria2"),
@@ -643,6 +656,7 @@ class DownloadManager:
            "save_dir": record.get("save_dir"),
            "relative_path": record.get("relative_path", ""),
            "use_default_paths": bool(record.get("use_default_paths", False)),
+            "use_save_dir_as_root": bool(record.get("use_save_dir_as_root", False)),
            "source": record.get("source"),
            "file_params": copy.deepcopy(record.get("file_params")),
            "progress": record.get("progress", 0),
@@ -1001,6 +1015,7 @@ class DownloadManager:
                                        bool(restored.get("use_default_paths", False)),
                                        restored.get("source"),
                                        restored.get("file_params"),
+                                        bool(restored.get("use_save_dir_as_root", False)),
                                    )
                                )
                        continue
@@ -1134,6 +1149,7 @@ class DownloadManager:
        transfer_backend: str = "python",
        source: str | None = None,
        file_params: Dict[str, Any] | None = None,
+        use_save_dir_as_root: bool = False,
    ) -> Dict[str, Any]:
        """Wrapper for original download_from_civitai implementation"""
        try:
@@ -1362,36 +1378,41 @@ class DownloadManager:
            # Handle use_default_paths
            if use_default_paths:
                settings_manager = get_settings_manager()
-                # Set save_dir based on model type
-                if model_type == "checkpoint":
-                    if is_diffusion_model:
-                        default_path = settings_manager.get("default_unet_root")
-                        error_msg = "Default unet root path not set in settings"
-                    else:
-                        default_path = settings_manager.get("default_checkpoint_root")
-                        error_msg = "Default checkpoint root path not set in settings"
-                    if not default_path:
-                        return {
-                            "success": False,
-                            "error": error_msg,
-                        }
-                    save_dir = default_path
-                elif model_type == "lora":
-                    default_path = settings_manager.get("default_lora_root")
-                    if not default_path:
-                        return {
-                            "success": False,
-                            "error": "Default lora root path not set in settings",
-                        }
-                    save_dir = default_path
-                elif model_type == "embedding":
-                    default_path = settings_manager.get("default_embedding_root")
-                    if not default_path:
-                        return {
-                            "success": False,
-                            "error": "Default embedding root path not set in settings",
-                        }
-                    save_dir = default_path
+                # With use_save_dir_as_root, an explicitly provided save_dir is kept
+                # as the base root and the path template is resolved underneath it.
+                # Otherwise fall back to the configured default root, which keeps the
+                # classic "download to default root" behavior for regular downloads.
+                if not save_dir or not use_save_dir_as_root:
+                    # Set save_dir based on model type
+                    if model_type == "checkpoint":
+                        if is_diffusion_model:
+                            default_path = settings_manager.get("default_unet_root")
+                            error_msg = "Default unet root path not set in settings"
+                        else:
+                            default_path = settings_manager.get("default_checkpoint_root")
+                            error_msg = "Default checkpoint root path not set in settings"
+                        if not default_path:
+                            return {
+                                "success": False,
+                                "error": error_msg,
+                            }
+                        save_dir = default_path
+                    elif model_type == "lora":
+                        default_path = settings_manager.get("default_lora_root")
+                        if not default_path:
+                            return {
+                                "success": False,
+                                "error": "Default lora root path not set in settings",
+                            }
+                        save_dir = default_path
+                    elif model_type == "embedding":
+                        default_path = settings_manager.get("default_embedding_root")
+                        if not default_path:
+                            return {
+                                "success": False,
+                                "error": "Default embedding root path not set in settings",
+                            }
+                        save_dir = default_path

                # Calculate relative path using template
                relative_path = self._calculate_relative_path(version_info, model_type)
@@ -1414,24 +1435,48 @@ class DownloadManager:
                # Create directory if it doesn't exist
                os.makedirs(save_dir, exist_ok=True)

-            # Check if this is an early access model
-            if version_info.get("earlyAccessEndsAt"):
-                early_access_date = version_info.get("earlyAccessEndsAt", "")
-                # Convert to a readable date if possible
+            # Check if this is a paid or early access model
+            paid_access = version_info.get("paidAccess")
+            if isinstance(paid_access, str):
+                # Some providers (e.g. CivArchive fallback) carry the DTO as JSON text
                try:
-                    from datetime import datetime
-
-                    date_obj = datetime.fromisoformat(
-                        early_access_date.replace("Z", "+00:00")
-                    )
-                    formatted_date = date_obj.strftime("%Y-%m-%d")
+                    parsed = json.loads(paid_access)
+                    paid_access = parsed if isinstance(parsed, dict) else None
+                except (TypeError, ValueError):
+                    paid_access = None
+            if not isinstance(paid_access, dict):
+                paid_access = None
+            # An empty DTO ({"permanent": false, "endsAt": null}) is not a gate
+            if paid_access and not paid_access.get("permanent") and not paid_access.get("endsAt"):
+                paid_access = None
+            if version_info.get("earlyAccessEndsAt") or paid_access:
+                permanent_paid = bool(paid_access.get("permanent")) if paid_access else False
+                if permanent_paid:
                    early_access_msg = (
-                        f"This model requires payment (until {formatted_date}). "
+                        "This model requires payment. Please ensure you have "
+                        "purchased access and are logged in to Civitai."
                    )
-                except:
-                    early_access_msg = "This model requires payment. "
+                else:
+                    early_access_date = version_info.get("earlyAccessEndsAt")
+                    if not early_access_date and paid_access:
+                        early_access_date = paid_access.get("endsAt")
+                    if not early_access_date:
+                        early_access_date = ""
+                    # Convert to a readable date if possible
+                    try:
+                        from datetime import datetime

-                early_access_msg += "Please ensure you have purchased early access and are logged in to Civitai."
+                        date_obj = datetime.fromisoformat(
+                            early_access_date.replace("Z", "+00:00")
+                        )
+                        formatted_date = date_obj.strftime("%Y-%m-%d")
+                        early_access_msg = (
+                            f"This model requires payment (until {formatted_date}). "
+                        )
+                    except Exception:
+                        early_access_msg = "This model requires payment. "
+
+                    early_access_msg += "Please ensure you have purchased early access and are logged in to Civitai."
                logger.warning(
                    f"Early access model detected: {version_info.get('name', 'Unknown')}"
                )
@@ -1486,7 +1531,7 @@ class DownloadManager:
                            f
                            for f in files
                            if f.get("primary")
-                            and f.get("type") in ("Model", "Negative", "Diffusion Model", "UNet")
+                            and f.get("type") in MODEL_WEIGHT_FILE_TYPES
                        ),
                        None,
                    )
@@ -1526,21 +1571,52 @@ class DownloadManager:
            # Fallback to primary file if no match found
            if not file_info:
                logger.debug("[download] Looking for primary file as fallback")
+                # Prefer a weights-type file CivitAI marked primary; then any
+                # weights-type file (providers without primary flags, e.g.
+                # civarchive); then trust CivitAI's primary flag regardless of
+                # type — newer types like 'Enhancement LoRA' are valid primary
+                # files. Weights files are preferred over non-weights primary
+                # files so a Config/Archive primary never replaces a Model.
                file_info = next(
                    (
                        f
                        for f in files
-                        if f.get("primary") and f.get("type") in ("Model", "Negative", "Diffusion Model", "UNet")
+                        if f.get("primary") and f.get("type") in MODEL_WEIGHT_FILE_TYPES
                    ),
                    None,
                )
                if file_info:
                    logger.debug(
-                        "[download] Fallback primary file selected: id=%s, name=%s",
+                        "[download] Fallback primary file selected (primary + weights): id=%s, name=%s",
                        file_info.get("id"), file_info.get("name"),
                    )
                else:
-                    logger.debug("[download] No primary file found in fallback lookup")
+                    file_info = next(
+                        (f for f in files if f.get("type") in MODEL_WEIGHT_FILE_TYPES),
+                        None,
+                    )
+                    if file_info:
+                        logger.debug(
+                            "[download] Fallback primary file selected (weights type, no primary flag): id=%s, name=%s",
+                            file_info.get("id"), file_info.get("name"),
+                        )
+                    else:
+                        file_info = next(
+                            (
+                                f
+                                for f in files
+                                if f.get("primary")
+                                and f.get("type") not in NON_DOWNLOADABLE_PRIMARY_TYPES
+                            ),
+                            None,
+                        )
+                        if file_info:
+                            logger.debug(
+                                "[download] Fallback primary file selected (trusting CivitAI primary flag): id=%s, name=%s, type=%s",
+                                file_info.get("id"), file_info.get("name"), file_info.get("type"),
+                            )
+                        else:
+                            logger.debug("[download] No primary file found in fallback lookup")

            if not file_info:
                return {"success": False, "error": "No suitable file found in metadata"}
@@ -2761,6 +2837,7 @@ class DownloadManager:
                                bool(persisted.get("use_default_paths", False)),
                                persisted.get("source"),
                                persisted.get("file_params"),
+                                bool(persisted.get("use_save_dir_as_root", False)),
                            ),
                        )
            except Exception as exc:
@@ -7,6 +7,7 @@ import os
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Mapping, Optional, TYPE_CHECKING, cast

 from ..services.service_registry import ServiceRegistry
+from ..services.pending_delete_service import get_pending_delete_service
 from ..utils.constants import PREVIEW_EXTENSIONS
 from ..utils.metadata_manager import MetadataManager

@@ -129,9 +130,24 @@ class ModelLifecycleService:
        target_dir = os.path.dirname(file_path)
        base_name = os.path.basename(file_path)
        file_name, main_extension = os.path.splitext(base_name)
-        deleted_files = await delete_model_artifacts(
-            target_dir, file_name, main_extension=main_extension
+
+        # Stage the delete into the pending-delete service when undo is
+        # enabled; a successful stage renames the artifacts away, otherwise
+        # fall back to the direct hard delete.
+        pending_delete_service = await get_pending_delete_service()
+        batch_id = await pending_delete_service.stage_model_delete(
+            scanner=self._scanner,
+            target_dir=target_dir,
+            file_name=file_name,
+            main_extension=main_extension,
+            original_file_path=file_path,
+            cached_entry=cached_entry,
        )
+        deleted_files: List[str] = []
+        if batch_id is None:
+            deleted_files = await delete_model_artifacts(
+                target_dir, file_name, main_extension=main_extension
+            )

        if cache:
            cache.raw_data = [
@@ -151,7 +167,11 @@ class ModelLifecycleService:
        if callable(persist_current_cache):
            await cast(Awaitable[Any], persist_current_cache())

-        return {"success": True, "deleted_files": deleted_files}
+        return {
+            "success": True,
+            "deleted_files": deleted_files,
+            "batch_id": batch_id,
+        }

    @staticmethod
    def _extract_model_id_from_payload(payload: Any) -> Optional[int]:
@@ -19,12 +19,28 @@ from .service_registry import ServiceRegistry
 from .websocket_manager import ws_manager
 from .persistent_model_cache import get_persistent_cache
 from .settings_manager import get_settings_manager
+from .pending_delete_service import PENDING_DELETE_DIR_NAME, get_pending_delete_service
 from .cache_entry_validator import CacheEntryValidator
 from .cache_health_monitor import CacheHealthMonitor, CacheHealthStatus

 logger = logging.getLogger(__name__)


+def _is_excluded_dir(name: str) -> bool:
+    """Return True when a directory entry must be skipped during model walks.
+
+    The pending-delete staging directory is excluded so staged files never
+    appear in the library as ghost model entries.
+    """
+    return name == PENDING_DELETE_DIR_NAME
+
+
+def _is_pending_delete_path(path: str) -> bool:
+    """Return True when any path component is the pending-delete staging dir."""
+    normalized = str(path).replace(os.sep, "/")
+    return any(part == PENDING_DELETE_DIR_NAME for part in normalized.split("/"))
+
+
@dataclass
 class CacheBuildResult:
    """Represents the outcome of scanning model files for cache building."""
@@ -711,6 +727,8 @@ class ModelScanner:
                                    if ext in self.file_extensions:
                                        total_files += 1
                                elif entry.is_dir(follow_symlinks=True):
+                                    if _is_excluded_dir(entry.name):
+                                        continue
                                    count_recursive(entry.path)
                            except Exception as e:
                                logger.error(f"Error counting files in entry {entry.path}: {e}")
@@ -864,7 +882,8 @@ class ModelScanner:
                    continue
                
                # Recursively scan directory
-                for root, _, files in os.walk(root_path, followlinks=True):
+                for root, dirnames, files in os.walk(root_path, followlinks=True):
+                    dirnames[:] = [d for d in dirnames if not _is_excluded_dir(d)]
                    real_root = os.path.realpath(root)
                    if real_root in visited_real_paths:
                        continue
@@ -1137,6 +1156,11 @@ class ModelScanner:
        hash_index = hash_index or self._hash_index
        excluded_models = excluded_models if excluded_models is not None else self._excluded_models

+        # Belt-and-braces: staged files must never become library entries even
+        # if a caller invokes this method directly with a staging path.
+        if _is_pending_delete_path(file_path):
+            return None
+
        metadata, should_skip = await MetadataManager.load_metadata(file_path, self.model_class)
    
        if should_skip:
@@ -1456,6 +1480,8 @@ class ModelScanner:
                            if self.is_cancelled():
                                return
                        elif entry.is_dir(follow_symlinks=True):
+                            if _is_excluded_dir(entry.name):
+                                continue
                            await scan_recursive(entry.path, root_path, visited_paths)
                    except Exception as entry_error:
                        logger.error(f"Error processing entry {entry.path}: {entry_error}")
@@ -2206,6 +2232,11 @@ class ModelScanner:
            # Track deleted models to update cache once
            deleted_models = []
            
+            # Stage each file into the pending-delete staging area and merge
+            # all per-file batches into ONE batch for the whole bulk action.
+            pending_delete_service = await get_pending_delete_service()
+            batch_ids: List[str] = []
+            
            for file_path in file_paths:
                if self.is_cancelled():
                    logger.info(f"{self.model_type.capitalize()} Scanner: Bulk delete cancelled by user")
@@ -2218,11 +2249,35 @@ class ModelScanner:
                    base_name = os.path.basename(file_path)
                    file_name, main_extension = os.path.splitext(base_name)

-                    deleted_files = await delete_model_artifacts(
-                        target_dir,
-                        file_name,
+                    # Snapshot the cache entry BEFORE the cache mutation that
+                    # runs after the loop - the manifest needs it for undo.
+                    cached_entry = None
+                    if cache is not None:
+                        cached_entry = next(
+                            (item for item in cache.raw_data if item.get('file_path') == file_path),
+                            None,
+                        )
+
+                    batch_id = await pending_delete_service.stage_model_delete(
+                        scanner=self,
+                        target_dir=target_dir,
+                        file_name=file_name,
                        main_extension=main_extension,
+                        original_file_path=file_path,
+                        cached_entry=cached_entry,
                    )
+
+                    if batch_id is not None:
+                        # Artifacts were renamed into staging: the main file is
+                        # gone from its original location.
+                        batch_ids.append(batch_id)
+                        deleted_files = [file_path]
+                    else:
+                        deleted_files = await delete_model_artifacts(
+                            target_dir,
+                            file_name,
+                            main_extension=main_extension,
+                        )
                    
                    if deleted_files:
                        deleted_models.append(file_path)
@@ -2246,6 +2301,18 @@ class ModelScanner:
                        'error': str(e)
                    })
            
+            # Merge every staged per-file batch into ONE undoable batch. On a
+            # merge failure (cross-volume EXDEV etc.) the response falls back
+            # to the constituent batch_ids array so the frontend can undo them
+            # sequentially.
+            batch_field: Dict[str, Any] = {}
+            if batch_ids:
+                merged_id = await pending_delete_service.merge_batches(batch_ids)
+                if merged_id is not None:
+                    batch_field['batch_id'] = merged_id
+                else:
+                    batch_field['batch_ids'] = list(batch_ids)
+            
            # Batch update cache if any models were deleted
            if deleted_models:
                # Update the cache in a batch operation
@@ -2257,7 +2324,8 @@ class ModelScanner:
                'total_deleted': total_deleted,
                'total_attempted': len(file_paths),
                'cache_updated': cache_updated,
-                'results': results
+                'results': results,
+                **batch_field
            }
            
        except Exception as e:
@@ -6,6 +6,7 @@
 from __future__ import annotations

 import asyncio
+import json
 import logging
 import os
 import sqlite3
@@ -74,6 +75,8 @@ class ModelVersionRecord:
    sort_index: int = 0
    is_early_access: bool = False
    usage_control: Optional[str] = None  # "Download", "Generation", "InternalGeneration"
+    paid_access: Optional[str] = None  # JSON string of the CivitAI paidAccess DTO
+    is_paid: bool = False  # True when paidAccess.permanent is True (permanent paid gate)


@dataclass
@@ -107,13 +110,17 @@ class ModelUpdateRecord:
        return [version.version_id for version in self.versions if version.is_in_library]

    def has_update(
-        self, hide_early_access: bool = False, hide_non_downloadable: bool = True
+        self,
+        hide_early_access: bool = False,
+        hide_non_downloadable: bool = True,
+        hide_paid: bool = False,
    ) -> bool:
        """Return True when a non-ignored remote version newer than the newest local copy is available.

        Args:
            hide_early_access: If True, exclude early access versions from update check.
            hide_non_downloadable: If True, exclude versions that don't allow downloads.
+            hide_paid: If True, exclude permanent paid versions from update check.
        """

        if self.should_ignore_model:
@@ -129,6 +136,7 @@ class ModelUpdateRecord:
                not version.is_in_library
                and not version.should_ignore
                and not (hide_early_access and ModelUpdateRecord._is_early_access_active(version))
+                and not (hide_paid and version.is_paid)
                and not (hide_non_downloadable and not ModelUpdateRecord._is_downloadable(version))
                for version in self.versions
            )
@@ -138,6 +146,8 @@ class ModelUpdateRecord:
                continue
            if hide_early_access and ModelUpdateRecord._is_early_access_active(version):
                continue
+            if hide_paid and version.is_paid:
+                continue
            if hide_non_downloadable and not ModelUpdateRecord._is_downloadable(version):
                continue
            if version.version_id > max_in_library:
@@ -152,6 +162,11 @@ class ModelUpdateRecord:
        1. If exact EA end time available (from single version API), use it for precise check
        2. Otherwise fallback to basic EA flag (from bulk API)
        """
+        # Permanent paid versions are not early access; they are filtered by
+        # hide_paid instead. Only timed gates count as early access.
+        if version.is_paid and not version.early_access_ends_at:
+            return False
+
        # Phase 2: Precise check with exact end time
        if version.early_access_ends_at:
            try:
@@ -178,6 +193,7 @@ class ModelUpdateRecord:
        local_base_model: Optional[str],
        hide_early_access: bool = False,
        hide_non_downloadable: bool = True,
+        hide_paid: bool = False,
    ) -> bool:
        """Return True when a newer remote version with the same base model exists.

@@ -186,6 +202,7 @@ class ModelUpdateRecord:
            local_base_model: The base model to filter by.
            hide_early_access: If True, exclude early access versions from update check.
            hide_non_downloadable: If True, exclude versions that don't allow downloads.
+            hide_paid: If True, exclude permanent paid versions from update check.
        """

        if self.should_ignore_model:
@@ -216,6 +233,8 @@ class ModelUpdateRecord:
                continue
            if hide_early_access and ModelUpdateRecord._is_early_access_active(version):
                continue
+            if hide_paid and version.is_paid:
+                continue
            if hide_non_downloadable and not ModelUpdateRecord._is_downloadable(version):
                continue
            version_base = _normalize_base_model(version.base_model)
@@ -252,6 +271,8 @@ class ModelUpdateService:
            is_in_library INTEGER NOT NULL DEFAULT 0,
            should_ignore INTEGER NOT NULL DEFAULT 0,
            usage_control TEXT,
+            paid_access TEXT,
+            is_paid INTEGER NOT NULL DEFAULT 0,
            PRIMARY KEY (model_id, version_id),
            FOREIGN KEY(model_id) REFERENCES model_update_status(model_id) ON DELETE CASCADE
        );
@@ -491,6 +512,14 @@ class ModelUpdateService:
                "ALTER TABLE model_update_versions "
                "ADD COLUMN usage_control TEXT"
            ),
+            "paid_access": (
+                "ALTER TABLE model_update_versions "
+                "ADD COLUMN paid_access TEXT"
+            ),
+            "is_paid": (
+                "ALTER TABLE model_update_versions "
+                "ADD COLUMN is_paid INTEGER NOT NULL DEFAULT 0"
+            ),
        }

        for column, statement in migrations.items():
@@ -592,6 +621,8 @@ class ModelUpdateService:
                should_ignore INTEGER NOT NULL DEFAULT 0,
                early_access_ends_at TEXT,
                is_early_access INTEGER NOT NULL DEFAULT 0,
+                paid_access TEXT,
+                is_paid INTEGER NOT NULL DEFAULT 0,
                PRIMARY KEY (model_id, version_id),
                FOREIGN KEY(model_id) REFERENCES model_update_status(model_id) ON DELETE CASCADE
            )
@@ -611,6 +642,8 @@ class ModelUpdateService:
            "should_ignore",
            "early_access_ends_at",
            "is_early_access",
+            "paid_access",
+            "is_paid",
        ]
        defaults = {
            "sort_index": "0",
@@ -623,6 +656,8 @@ class ModelUpdateService:
            "should_ignore": "0",
            "early_access_ends_at": "NULL",
            "is_early_access": "0",
+            "paid_access": "NULL",
+            "is_paid": "0",
        }

        select_parts = []
@@ -936,17 +971,30 @@ class ModelUpdateService:
        async with self._lock:
            return self._get_record(model_type, model_id)

-    async def has_update(self, model_type: str, model_id: int, hide_early_access: bool = False) -> bool:
+    async def has_update(
+        self,
+        model_type: str,
+        model_id: int,
+        hide_early_access: bool = False,
+        hide_paid: bool = False,
+    ) -> bool:
        """Determine if a model has updates pending."""

        record = await self.get_record(model_type, model_id)
-        return record.has_update(hide_early_access=hide_early_access) if record else False
+        return (
+            record.has_update(
+                hide_early_access=hide_early_access, hide_paid=hide_paid
+            )
+            if record
+            else False
+        )

    async def has_updates_bulk(
        self,
        model_type: str,
        model_ids: Sequence[int],
        hide_early_access: bool = False,
+        hide_paid: bool = False,
    ) -> Dict[int, bool]:
        """Return update availability for each model id in a single database pass."""

@@ -959,7 +1007,9 @@ class ModelUpdateService:

        return {
            model_id: (
-                records[model_id].has_update(hide_early_access=hide_early_access)
+                records[model_id].has_update(
+                    hide_early_access=hide_early_access, hide_paid=hide_paid
+                )
                if model_id in records
                else False
            )
@@ -1190,6 +1240,7 @@ class ModelUpdateService:
                        "earlyAccessEndsAt": _normalize_string(
                            entry.get("earlyAccessEndsAt")
                        ),
+                        "paidAccess": entry.get("paidAccess"),
                    }
        except RateLimitError:
            raise
@@ -1214,6 +1265,17 @@ class ModelUpdateService:
                    "earlyAccessEndsAt"
                ):
                    version["earlyAccessEndsAt"] = extra["earlyAccessEndsAt"]
+                # Only backfill when the model-level response carries no *active*
+                # paidAccess signal: a present-but-empty DTO (e.g.
+                # {"permanent": false, "endsAt": null}) would otherwise block
+                # the authoritative by-hash data.
+                extra_paid = ModelUpdateService._normalize_paid_access(
+                    extra.get("paidAccess")
+                )
+                if extra_paid and not ModelUpdateService._normalize_paid_access(
+                    version.get("paidAccess")
+                ):
+                    version["paidAccess"] = extra["paidAccess"]

    @staticmethod
    def _collect_hashes_from_response(response: Mapping[str, Any]) -> Dict[int, str]:
@@ -1464,6 +1526,8 @@ class ModelUpdateService:
                    early_access_ends_at=remote_version.early_access_ends_at,
                    is_early_access=remote_version.is_early_access,
                    usage_control=remote_version.usage_control,
+                    paid_access=remote_version.paid_access,
+                    is_paid=remote_version.is_paid,
                )
            )

@@ -1564,6 +1628,18 @@ class ModelUpdateService:
        is_early_access = availability == "EarlyAccess"
        usage_control = _normalize_string(entry.get("usageControl"))

+        # CivitAI's paidAccess DTO ({"permanent": bool, "endsAt": ISO|null})
+        # gates versions behind a paid tier while availability stays "Public".
+        paid_access = self._normalize_paid_access(entry.get("paidAccess"))
+        paid_access_json = json.dumps(paid_access) if paid_access else None
+        is_paid = bool(paid_access.get("permanent")) if paid_access else False
+        if early_access_ends_at is None and paid_access and paid_access.get("endsAt"):
+            early_access_ends_at = _normalize_string(paid_access.get("endsAt"))
+        # Only timed gates are early access; permanent paid versions are not
+        # (consumers filter them via is_paid), so the stored flag stays accurate.
+        if not is_early_access and paid_access and paid_access.get("endsAt"):
+            is_early_access = True
+
        return ModelVersionRecord(
            version_id=version_id,
            name=name,
@@ -1577,8 +1653,36 @@ class ModelUpdateService:
            sort_index=index,
            is_early_access=is_early_access,
            usage_control=usage_control,
+            paid_access=paid_access_json,
+            is_paid=is_paid,
        )

+    @staticmethod
+    def _normalize_paid_access(value) -> Optional[Dict[str, Any]]:
+        """Normalize a CivitAI ``paidAccess`` DTO into a mapping.
+
+        Accepts a dict, None, or a JSON string (as carried by the by-hash
+        enrichment path) and returns ``{"permanent": bool, "endsAt": str|None}``
+        or None when the input carries no paid-access signal.
+        """
+        if value is None:
+            return None
+        if isinstance(value, str):
+            try:
+                parsed = json.loads(value)
+            except (TypeError, ValueError):
+                return None
+            if not isinstance(parsed, dict):
+                return None
+            value = parsed
+        if not isinstance(value, Mapping):
+            return None
+        permanent = bool(value.get("permanent"))
+        ends_at = _normalize_string(value.get("endsAt"))
+        if not permanent and ends_at is None:
+            return None
+        return {"permanent": permanent, "endsAt": ends_at}
+
    def _extract_size_bytes(self, files) -> Optional[int]:
        if not isinstance(files, Iterable):
            return None
@@ -1691,7 +1795,7 @@ class ModelUpdateService:
                    f"""
                    SELECT model_id, version_id, sort_index, name, base_model, released_at,
                           size_bytes, preview_url, is_in_library, should_ignore, early_access_ends_at,
-                           is_early_access, usage_control
+                           is_early_access, usage_control, paid_access, is_paid
                    FROM model_update_versions
                    WHERE model_id IN ({placeholders})
                    ORDER BY model_id ASC, sort_index ASC, version_id ASC
@@ -1720,6 +1824,8 @@ class ModelUpdateService:
                    sort_index=_normalize_int(row["sort_index"]) or 0,
                    is_early_access=bool(row["is_early_access"]),
                    usage_control=row["usage_control"],
+                    paid_access=row["paid_access"],
+                    is_paid=bool(row["is_paid"]),
                )
            )

@@ -1771,13 +1877,19 @@ class ModelUpdateService:
                (record.model_id,),
            )
            for version in record.versions:
+                paid_access_value = (
+                    version.paid_access
+                    if version.paid_access is None
+                    or isinstance(version.paid_access, str)
+                    else json.dumps(version.paid_access)
+                )
                conn.execute(
                    """
                    INSERT INTO model_update_versions (
                        version_id, model_id, sort_index, name, base_model, released_at,
                        size_bytes, preview_url, is_in_library, should_ignore, early_access_ends_at,
-                        is_early_access, usage_control
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        is_early_access, usage_control, paid_access, is_paid
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                    """,
                    (
                        version.version_id,
@@ -1793,6 +1905,8 @@ class ModelUpdateService:
                        version.early_access_ends_at,
                        1 if version.is_early_access else 0,
                        version.usage_control,
+                        paid_access_value,
+                        1 if version.is_paid else 0,
                    ),
                )
            conn.commit()
@@ -20,3 +20,12 @@ class RecipeDownloadError(RecipeServiceError):

 class RecipeConflictError(RecipeServiceError):
    """Raised when a conflicting recipe state is detected."""
+
+
+class RecipePersistenceError(RecipeServiceError):
+    """Raised when a rematched recipe cannot be persisted to disk.
+
+    Raised by the recipe rematch path when ``_save_recipe_persistently``
+    returns False (JSON/EXIF/SQLite write failure). Callers translate it
+    into a ``success: False`` summary with an ``error`` message key.
+    """
@@ -14,6 +14,7 @@ from typing import Any, Awaitable, Dict, Iterable, Optional, cast
 from ...config import config
 from ...recipes.constants import GEN_PARAM_KEYS
 from ...utils.utils import calculate_recipe_fingerprint
+from ..pending_delete_service import get_pending_delete_service
 from .errors import RecipeNotFoundError, RecipeValidationError


@@ -201,12 +202,31 @@ class RecipePersistenceService:
            recipe_data = json.load(file_obj)

        image_path = recipe_data.get("file_path")
+
+        # Stage the delete so the recipe can be undone within the undo window.
+        # The staging service COPIES the JSON (and existing image) into the
+        # global staging dir and stores recipe_data as the manifest snapshot;
+        # the originals are removed below as before. When staging is skipped
+        # (undo disabled / staging failure) the existing hard delete runs.
+        pending_delete_service = await get_pending_delete_service()
+        batch_id = await pending_delete_service.stage_recipe_delete(
+            recipe_json_path=recipe_json_path,
+            image_path=image_path,
+            recipe_data=recipe_data,
+        )
+
        os.remove(recipe_json_path)
        if image_path and os.path.exists(image_path):
            os.remove(image_path)

        await recipe_scanner.remove_recipe(recipe_id)
-        return PersistenceResult({"success": True, "message": "Recipe deleted successfully"})
+        return PersistenceResult(
+            {
+                "success": True,
+                "message": "Recipe deleted successfully",
+                "batch_id": batch_id,
+            }
+        )

    async def update_recipe(self, *, recipe_scanner, recipe_id: str, updates: dict[str, Any]) -> PersistenceResult:
        """Update persisted metadata for a recipe."""
@@ -450,6 +470,9 @@ class RecipePersistenceService:

        deleted_recipes: list[str] = []
        failed_recipes: list[dict[str, Any]] = []
+        batch_ids: list[str] = []
+
+        pending_delete_service = await get_pending_delete_service()

        for recipe_id in recipe_ids:
            recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
@@ -461,6 +484,17 @@ class RecipePersistenceService:
                with open(recipe_json_path, "r", encoding="utf-8") as file_obj:
                    recipe_data = json.load(file_obj)
                image_path = recipe_data.get("file_path")
+
+                # Stage each recipe into its own batch; collect the ids so the
+                # whole bulk action can be merged into ONE undoable batch.
+                batch_id = await pending_delete_service.stage_recipe_delete(
+                    recipe_json_path=recipe_json_path,
+                    image_path=image_path,
+                    recipe_data=recipe_data,
+                )
+                if batch_id:
+                    batch_ids.append(batch_id)
+
                os.remove(recipe_json_path)
                if image_path and os.path.exists(image_path):
                    os.remove(image_path)
@@ -471,15 +505,27 @@ class RecipePersistenceService:
        if deleted_recipes:
            await recipe_scanner.bulk_remove(deleted_recipes)

-        return PersistenceResult(
-            {
-                "success": True,
-                "deleted": deleted_recipes,
-                "failed": failed_recipes,
-                "total_deleted": len(deleted_recipes),
-                "total_failed": len(failed_recipes),
-            }
-        )
+        payload: dict[str, Any] = {
+            "success": True,
+            "deleted": deleted_recipes,
+            "failed": failed_recipes,
+            "total_deleted": len(deleted_recipes),
+            "total_failed": len(failed_recipes),
+        }
+
+        if batch_ids:
+            merged_batch_id = await pending_delete_service.merge_batches(batch_ids)
+            if merged_batch_id:
+                # Merge succeeded: one undo action covers the whole bulk.
+                payload["batch_id"] = merged_batch_id
+            else:
+                # Merge failure (e.g. cross-volume move): expose the constituent
+                # batches so the caller can undo them one at a time.
+                payload["batch_ids"] = batch_ids
+        else:
+            payload["batch_id"] = None
+
+        return PersistenceResult(payload)

    async def save_recipe_from_widget(
        self,
@@ -22,6 +22,8 @@ class WebSocketManager:
        self._auto_organize_progress: Optional[Dict[str, Any]] = None
        # Add recipe repair progress tracking
        self._recipe_repair_progress: Optional[Dict[str, Any]] = None
+        # Add recipe rematch progress tracking
+        self._recipe_rematch_progress: Optional[Dict[str, Any]] = None
        self._auto_organize_lock = asyncio.Lock()
        
    async def handle_connection(self, request: web.Request) -> web.WebSocketResponse:
@@ -223,6 +225,30 @@ class WebSocketManager:
        status = self._recipe_repair_progress.get('status')
        return status in ['started', 'processing']
    
+    async def broadcast_recipe_rematch_progress(self, data: Dict[str, Any]):
+        """Broadcast recipe rematch progress to connected clients"""
+        # Store progress data in memory
+        self._recipe_rematch_progress = data
+        
+        # Broadcast via WebSocket
+        await self.broadcast(data)
+    
+    def get_recipe_rematch_progress(self) -> Optional[Dict[str, Any]]:
+        """Get current recipe rematch progress"""
+        return self._recipe_rematch_progress
+    
+    def cleanup_recipe_rematch_progress(self):
+        """Clear recipe rematch progress data if it is in a finished state"""
+        if self._recipe_rematch_progress and self._recipe_rematch_progress.get('status') in ['completed', 'cancelled', 'error']:
+            self._recipe_rematch_progress = None
+    
+    def is_recipe_rematch_running(self) -> bool:
+        """Check if recipe rematch is currently running"""
+        if not self._recipe_rematch_progress:
+            return False
+        status = self._recipe_rematch_progress.get('status')
+        return status in ['started', 'processing']
+    
    def is_auto_organize_running(self) -> bool:
        """Check if auto-organize is currently running"""
        if not self._auto_organize_progress:
@@ -62,6 +62,20 @@ MODEL_FILE_EXTENSIONS = {
    ".gguf",
 }

+# CivitAI ModelFile.type values eligible as the main download file.
+# Mirrors CivitAI's getPrimaryFile() (model-helpers.ts): weight types are
+# preferred, but any file CivitAI marks `primary` is accepted — newer types
+# like 'Enhancement LoRA' (Anima/AIR image-editing LoRAs) are valid primary
+# files despite not being in the traditional weights allowlist.
+MODEL_WEIGHT_FILE_TYPES = (
+    "Model",
+    "Pruned Model",
+    "Negative",
+    "UNet",
+    "Diffusion Model",
+    "Enhancement LoRA",
+)
+
 # Valid sub-types for each scanner type
 VALID_LORA_SUB_TYPES = ["lora", "locon", "dora"]
 VALID_CHECKPOINT_SUB_TYPES = ["checkpoint", "diffusion_model"]
@@ -55,6 +55,32 @@ class MetadataManager:
            logger.error(f"{error_type} in metadata file: {metadata_path}. Error: {str(e)}. Skipping model to preserve existing data.")
            return None, True  # should_skip = True

+    @staticmethod
+    def _fill_local_file_facts(payload: Dict[str, Any], file_path: str) -> None:
+        """Fill missing local file facts (``file_name``/``size``/``modified``) from disk.
+
+        These three fields are part of the required metadata schema but describe
+        the local file, not remote metadata. Payloads rebuilt by the self-heal
+        refresh flow (sidecar deleted, then recreated from remote data) lack
+        them, which makes the recreated sidecar unparseable by
+        ``BaseModelMetadata.from_dict`` and causes the scanner to skip the model.
+        Fill them from the actual file whenever absent.
+        """
+        if not file_path:
+            return
+        if payload.get("file_name") and "size" in payload and "modified" in payload:
+            return
+        try:
+            stat_result = os.stat(file_path)
+        except OSError:
+            return
+        if not payload.get("file_name"):
+            payload["file_name"] = os.path.splitext(os.path.basename(file_path))[0]
+        if "size" not in payload:
+            payload["size"] = stat_result.st_size
+        if "modified" not in payload:
+            payload["modified"] = stat_result.st_mtime
+
    @staticmethod
    async def load_metadata_payload(file_path: str) -> Dict[str, Any]:
        """
@@ -96,6 +122,11 @@ class MetadataManager:

        if file_path:
            payload.setdefault("file_path", normalize_path(file_path))
+            # Required schema fields that are local filesystem facts. When the
+            # sidecar is missing (e.g. deleted and being recreated by the
+            # self-heal refresh flow), restore them so the recreated sidecar
+            # and cache entries stay parseable.
+            MetadataManager._fill_local_file_facts(payload, file_path)

        return payload

@@ -104,6 +135,14 @@ class MetadataManager:
        """
        Replace the provided model data with the authoritative payload from disk.
        Preserves the cached folder entry if present.
+
+        When the sidecar is missing entirely (self-heal after manual deletion),
+        the disk payload is nearly empty and the cache snapshot is the only
+        source for the schema fields required by ``BaseModelMetadata.from_dict``
+        (file_name/model_name/size/modified/sha256/base_model/preview_url), so
+        every missing key is restored from it to keep any recreated sidecar
+        parseable and avoid data loss on failed refreshes. When the sidecar
+        exists, disk data stays authoritative and no cache key is resurrected.
        """

        file_path = model_data.get("file_path")
@@ -111,12 +150,29 @@ class MetadataManager:
            return model_data

        folder = model_data.get("folder")
+        metadata_path = f"{os.path.splitext(file_path)[0]}.metadata.json"
+        sidecar_exists = os.path.exists(metadata_path)
+        cached = model_data.copy()
        payload = await MetadataManager.load_metadata_payload(file_path)
        if folder is not None:
            payload["folder"] = folder

        model_data.clear()
        model_data.update(payload)
+
+        if not sidecar_exists:
+            for key, value in cached.items():
+                if key not in model_data and key != "folder":
+                    model_data[key] = value
+            # The schema defines `modified` as the import timestamp; keep the
+            # cache's value over the stat-derived fallback from
+            # load_metadata_payload.
+            if "modified" in cached:
+                model_data["modified"] = cached["modified"]
+
+        # file_name/size are local file facts; prefer fresh stat values over
+        # the possibly stale cache snapshot.
+        MetadataManager._fill_local_file_facts(model_data, file_path)
        return model_data
    
    @staticmethod
@@ -155,7 +211,12 @@ class MetadataManager:
                metadata_dict['file_path'] = normalize_path(metadata_dict['file_path'])
            if 'preview_url' in metadata_dict:
                metadata_dict['preview_url'] = normalize_path(metadata_dict['preview_url'])
-            
+
+            # Local file facts are required schema fields; fill them when a
+            # payload rebuilt without them (e.g. self-heal) is being persisted.
+            if metadata_dict.get("file_path"):
+                MetadataManager._fill_local_file_facts(metadata_dict, metadata_dict["file_path"])
+
            # Write to temporary file first
            with open(temp_path, 'w', encoding='utf-8') as f:
                json.dump(metadata_dict, f, indent=2, ensure_ascii=False)
@@ -0,0 +1,161 @@
+"""Track recipe modal open timestamps for the "Recently Opened" sort.
+
+The data is deliberately kept OUTSIDE the recipe metadata files: recording an
+open must be cheap and must never rewrite recipe JSON or EXIF (which the
+generic metadata update path does). A tiny JSON map of
+``recipe_id -> unix timestamp`` lives under
+``{settings_dir}/stats/recipe_last_opened.json`` and is written atomically on
+a short debounce.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+
+from ..utils.settings_paths import get_settings_dir
+
+logger = logging.getLogger(__name__)
+
+
+class RecipeOpenStats:
+    """Persist the last time each recipe was opened in the recipe modal."""
+
+    STATS_FILENAME: str = "recipe_last_opened.json"
+    SAVE_DELAY: float = 1.0  # seconds of debounce between consecutive writes
+
+    _instance: "RecipeOpenStats | None" = None
+    _opened: dict[str, float]
+    _file_mtime: float | None
+    _dirty: bool
+    _lock: asyncio.Lock
+    _save_task: "asyncio.Task[None] | None"
+    _stats_file_path: str
+    _initialized: bool
+
+    def __new__(cls) -> "RecipeOpenStats":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self) -> None:
+        if getattr(self, "_initialized", False):
+            return
+        self._opened = {}
+        self._file_mtime = None
+        self._dirty = False
+        self._lock = asyncio.Lock()
+        self._save_task = None
+        self._stats_file_path = self._get_stats_file_path()
+        self._load_stats()
+        self._initialized = True
+
+    def _get_stats_file_path(self) -> str:
+        settings_dir = get_settings_dir(create=True)
+        return os.path.join(settings_dir, "stats", self.STATS_FILENAME)
+
+    def _load_stats(self) -> None:
+        """Load the opened map from disk, tolerating corrupt/absent files.
+
+        The mtime is recorded even when parsing fails so a corrupt file is
+        not re-read (and re-logged) on every lookup.
+        """
+        if not os.path.exists(self._stats_file_path):
+            return
+        try:
+            mtime = os.path.getmtime(self._stats_file_path)
+        except OSError:
+            return
+        try:
+            with open(self._stats_file_path, "r", encoding="utf-8") as file_obj:
+                raw = json.load(file_obj)
+            if isinstance(raw, dict):
+                self._opened = {
+                    str(key): float(value)
+                    for key, value in raw.items()
+                    if isinstance(value, (int, float))
+                }
+        except Exception as exc:  # pragma: no cover - defensive logging path
+            logger.error("Error loading recipe open stats: %s", exc)
+            self._opened = {}
+        self._file_mtime = mtime
+
+    def get_opened_map(self) -> dict[str, float]:
+        """Return a copy of ``recipe_id -> last opened timestamp``.
+
+        Refreshes from disk when the file changed since the last load so a
+        second server process (or manual edit) is picked up without restart.
+        """
+        try:
+            if os.path.exists(self._stats_file_path):
+                mtime = os.path.getmtime(self._stats_file_path)
+                if self._file_mtime is None or mtime != self._file_mtime:
+                    self._load_stats()
+        except OSError:
+            pass
+        return dict(self._opened)
+
+    def record_open(self, recipe_id: str) -> None:
+        """Mark a recipe as opened now; persists shortly in the background."""
+        if not recipe_id:
+            return
+        self._opened[str(recipe_id)] = time.time()
+        self._dirty = True
+        if self._save_task is None or self._save_task.done():
+            self._save_task = asyncio.create_task(self._delayed_save())
+
+    async def _delayed_save(self) -> None:
+        """Debounced writer: batches rapid consecutive opens into one write."""
+        await asyncio.sleep(self.SAVE_DELAY)
+        _ = await self.save_stats()
+
+    async def save_stats(self, force: bool = False) -> bool:
+        """Persist the opened map atomically if dirty (or when forced).
+
+        The on-disk map is merged in first so a second process sharing the
+        settings dir does not lose its entries; the larger timestamp wins
+        per recipe.
+        """
+        if not force and not self._dirty:
+            return False
+        async with self._lock:
+            if not force and not self._dirty:
+                return False
+            try:
+                merged = self._merge_with_disk()
+                os.makedirs(os.path.dirname(self._stats_file_path), exist_ok=True)
+                temp_path = f"{self._stats_file_path}.tmp"
+                with open(temp_path, "w", encoding="utf-8") as file_obj:
+                    json.dump(merged, file_obj, indent=2)
+                os.replace(temp_path, self._stats_file_path)
+                self._opened = merged
+                self._file_mtime = os.path.getmtime(self._stats_file_path)
+                self._dirty = False
+                return True
+            except Exception as exc:  # pragma: no cover - defensive logging path
+                logger.error("Error saving recipe open stats: %s", exc, exc_info=True)
+                return False
+
+    def _merge_with_disk(self) -> dict[str, float]:
+        """Merge the in-memory map with the current on-disk map."""
+        disk: dict[str, float] = {}
+        try:
+            if os.path.exists(self._stats_file_path):
+                with open(self._stats_file_path, "r", encoding="utf-8") as file_obj:
+                    raw = json.load(file_obj)
+                if isinstance(raw, dict):
+                    disk = {
+                        str(key): float(value)
+                        for key, value in raw.items()
+                        if isinstance(value, (int, float))
+                    }
+        except Exception as exc:  # pragma: no cover - defensive logging path
+            logger.error("Error reading recipe open stats for merge: %s", exc)
+        merged = dict(disk)
+        for key, value in self._opened.items():
+            merged[key] = max(value, disk.get(key, 0.0))
+        return merged
@@ -10,6 +10,7 @@ from typing import Any, Awaitable, Dict, Set, cast

 from ..config import config
 from ..services.service_registry import ServiceRegistry
+from ..services.model_scanner import _is_excluded_dir
 from ..utils.settings_paths import get_settings_dir

 # Check if running in standalone mode
@@ -421,7 +422,8 @@ class UsageStats:
            if not os.path.exists(root_path):
                continue

-            for dirpath, _dirnames, filenames in os.walk(root_path):
+            for dirpath, dirnames, filenames in os.walk(root_path):
+                dirnames[:] = [d for d in dirnames if not _is_excluded_dir(d)]
                for filename in filenames:
                    extension = os.path.splitext(filename)[1].lower()
                    if extension not in supported_extensions:
@@ -323,6 +323,42 @@ def model_patcher_to_name(model_patcher: Any) -> Optional[str]:
    return _abs_model_path_to_name(abs_path)


+def sampler_object_to_name(sampler: Any) -> Optional[str]:
+    """Extract a ComfyUI-style sampler name from a SAMPLER (KSAMPLER) object.
+
+    Standard outputs (KSamplerSelect, most built-in sampler nodes) round-trip
+    losslessly via the underlying sampler function's ``__name__``
+    (``sample_euler`` -> ``euler``). A few edge cases need special-casing
+    because the function name diverges from the ``SAMPLER_NAMES`` entry:
+
+      - ``dpm_fast`` / ``dpm_adaptive`` are local closures inside
+        ``comfy.samplers.ksampler`` (``dpm_fast_function`` / ``dpm_adaptive_function``)
+      - ``uni_pc`` / ``uni_pc_bh2`` use ``sample_unipc`` / ``sample_unipc_bh2``
+
+    ``ddim`` is constructed by ComfyUI as ``euler`` with random inpaint, so
+    the original ``ddim`` name is unrecoverable (extracts as ``euler``).
+    Custom sampler nodes that pass non-``sample_*`` functions return None.
+
+    Returns None when the name cannot be recovered.
+    """
+    sampler_function = getattr(sampler, "sampler_function", None)
+    func_name = getattr(sampler_function, "__name__", None)
+    if not isinstance(func_name, str) or not func_name:
+        return None
+    if func_name == "dpm_fast_function":
+        return "dpm_fast"
+    if func_name == "dpm_adaptive_function":
+        return "dpm_adaptive"
+    if func_name.startswith("sample_"):
+        name = func_name[len("sample_"):]
+        if name == "unipc":
+            return "uni_pc"
+        if name == "unipc_bh2":
+            return "uni_pc_bh2"
+        return name or None
+    return None
+
+
 def _abs_model_path_to_name(abs_path: str) -> str:
    """Convert an absolute model path to a ComfyUI-style relative name.

@@ -469,6 +505,24 @@ def calculate_recipe_fingerprint(loras):
    return fingerprint


+def normalize_prompt_for_dedup(prompt) -> str:
+    """Normalize a positive prompt for duplicate recipe matching.
+
+    Applies casefolding, collapses whitespace runs into single spaces, and
+    trims leading/trailing whitespace. Missing or non-string prompts
+    normalize to an empty string.
+
+    Args:
+        prompt: The positive prompt text (or None)
+
+    Returns:
+        str: The normalized prompt
+    """
+    if not prompt or not isinstance(prompt, str):
+        return ""
+    return re.sub(r"\s+", " ", prompt).strip().casefold()
+
+
 def calculate_relative_path_for_model(
    model_data: Dict[str, Any], model_type: str = "lora"
 ) -> str:
@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "Revolutionize your workflow with the ultimate LoRA companion for ComfyUI!"
-version = "1.2.0"
+version = "1.2.1"
 license = {file = "LICENSE"}
 dependencies = [
    "aiohttp",
@@ -339,6 +339,7 @@ class StandaloneLoraManager(LoraManager):
        from py.routes.recipe_routes import RecipeRoutes
        from py.routes.update_routes import UpdateRoutes
        from py.routes.misc_routes import MiscRoutes
+        from py.routes.pending_delete_routes import PendingDeleteRoutes
        from py.routes.example_images_routes import ExampleImagesRoutes
        from py.routes.preview_routes import PreviewRoutes
        from py.routes.stats_routes import StatsRoutes
@@ -356,6 +357,7 @@ class StandaloneLoraManager(LoraManager):
        RecipeRoutes.setup_routes(app)
        UpdateRoutes.setup_routes(app)
        MiscRoutes.setup_routes(app)
+        PendingDeleteRoutes.setup_routes(app)
        ExampleImagesRoutes.setup_routes(app, ws_manager=ws_manager)
        PreviewRoutes.setup_routes(app)

@@ -41,6 +41,11 @@
    border-color: var(--lora-accent);
 }

+.model-card.drag-over {
+    outline: 2px dashed var(--lora-accent);
+    outline-offset: -2px;
+}
+
 .model-card:focus-visible {
    outline: 2px solid var(--lora-accent);
    outline-offset: 2px;
@@ -486,6 +486,26 @@
    }
 }

+/* Empty-state hint in the duplicates view */
+.duplicates-empty-state {
+    padding: 48px 16px;
+    text-align: center;
+    opacity: 0.7;
+    font-size: 0.95em;
+    width: 100%;
+}
+
+/* Matching basis text in the duplicates banner */
+.duplicates-basis {
+    font-size: 0.85em;
+    opacity: 0.8;
+    padding: 3px 10px;
+    border-radius: var(--border-radius-xs);
+    background: oklch(var(--color-accent-l) var(--color-accent-c) var(--color-accent-h) / 0.12);
+    border: 1px solid oklch(var(--color-accent-l) var(--color-accent-c) var(--color-accent-h) / 0.25);
+    white-space: nowrap;
+}
+
 /* Help icon styling */
 .help-icon {
    color: var(--text-color);
@@ -447,6 +447,19 @@
    border-color: color-mix(in oklch, #F59F00 45%, transparent);
 }

+/* Paid badge - violet tone (#845EF7) to distinguish from early-access amber */
+.version-badge-paid {
+    background: color-mix(in oklch, #845EF7 25%, transparent);
+    color: #7048E8;
+    border-color: color-mix(in oklch, #845EF7 55%, transparent);
+}
+
+[data-theme="dark"] .version-badge-paid {
+    background: color-mix(in oklch, #845EF7 20%, transparent);
+    color: #9775FA;
+    border-color: color-mix(in oklch, #845EF7 45%, transparent);
+}
+
 .version-meta-ea {
    color: #E67700;
    font-weight: 600;
@@ -911,6 +911,93 @@
    outline: none;
 }

+/* Recipes layout segmented control with visual previews */
+.layout-options-control {
+    width: 100%;
+    display: flex;
+    justify-content: flex-end;
+}
+
+.layout-options {
+    display: flex;
+    gap: 6px;
+    width: 100%;
+}
+
+.layout-option {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 6px;
+    padding: 8px;
+    border-radius: var(--border-radius-sm);
+    border: 1px solid var(--border-color);
+    background-color: var(--lora-surface);
+    color: var(--text-color);
+    cursor: pointer;
+    transition: border-color 0.2s ease, background-color 0.2s ease;
+}
+
+.layout-option:hover,
+.layout-option:focus-visible {
+    border-color: var(--lora-accent);
+    outline: none;
+}
+
+.layout-option.active {
+    border-color: var(--lora-accent);
+    background-color: rgba(from var(--lora-accent) r g b / 0.12);
+    color: var(--lora-accent);
+}
+
+.layout-option-label {
+    font-size: 0.85em;
+    white-space: nowrap;
+}
+
+.layout-option-preview {
+    width: 72px;
+    height: 44px;
+    padding: 4px;
+    border-radius: var(--border-radius-xs);
+    background-color: var(--card-bg);
+    border: 1px solid var(--border-color);
+    box-sizing: border-box;
+}
+
+.layout-option-preview span {
+    background: currentColor;
+    opacity: 0.4;
+    border-radius: 1px;
+}
+
+.layout-preview-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    grid-template-rows: 1fr 1fr;
+    gap: 3px;
+}
+
+.layout-preview-masonry {
+    display: flex;
+    gap: 3px;
+    align-items: flex-start;
+}
+
+.layout-preview-masonry span {
+    flex: 1;
+    height: 100%;
+}
+
+.layout-preview-masonry span:nth-child(2) {
+    height: 60%;
+}
+
+.layout-preview-masonry span:nth-child(3) {
+    height: 80%;
+}
+
 /* Range Slider Control */
 .range-control {
    width: 100%;
@@ -80,6 +80,51 @@
    margin-top: 10px;
 }

+/* Action toast: ghost action button + countdown (e.g. Undo delete) */
+.toast-action-btn {
+    margin-left: auto;
+    flex-shrink: 0;
+    padding: 4px 12px;
+    background: transparent;
+    color: var(--lora-accent);
+    border: 1px solid var(--lora-accent);
+    border-radius: var(--border-radius-sm);
+    font-size: 0.85em;
+    font-weight: 600;
+    cursor: pointer;
+    transition: background 0.2s ease, color 0.2s ease;
+}
+
+.toast-action-btn:hover {
+    background: var(--lora-accent);
+    color: #fff;
+}
+
+.toast-countdown {
+    flex-shrink: 0;
+    font-size: 0.75em;
+    opacity: 0.65;
+    white-space: nowrap;
+}
+
+.toast-close-btn {
+    flex-shrink: 0;
+    padding: 0 4px;
+    background: transparent;
+    color: var(--text-color);
+    border: none;
+    border-radius: 4px;
+    font-size: 1.1em;
+    line-height: 1;
+    opacity: 0.5;
+    cursor: pointer;
+    transition: opacity 0.2s ease;
+}
+
+.toast-close-btn:hover {
+    opacity: 1;
+}
+
 /* Responsive adjustments */
@media (max-width: 768px) {
    .toast {
@@ -168,6 +168,34 @@
    border-color: var(--lora-accent);
 }

+/* Recipes layout toggle (grid / masonry) — segmented control in the toolbar */
+.layout-toggle-group {
+    display: flex;
+    gap: 0;
+}
+
+.layout-toggle-group .layout-toggle-btn {
+    min-width: 36px;
+    width: 36px;
+    padding: 4px 0;
+    border-radius: 0;
+}
+
+.layout-toggle-group .layout-toggle-btn:first-child {
+    border-radius: var(--border-radius-xs) 0 0 var(--border-radius-xs);
+    border-right: none;
+}
+
+.layout-toggle-group .layout-toggle-btn:last-child {
+    border-radius: 0 var(--border-radius-xs) var(--border-radius-xs) 0;
+}
+
+.layout-toggle-group .layout-toggle-btn:hover,
+.layout-toggle-group .layout-toggle-btn:focus-visible {
+    transform: none;
+    box-shadow: var(--shadow-xs);
+}
+
 /* Keyboard shortcut indicator styling */
 .shortcut-key {
    display: inline-flex;
@@ -201,8 +201,13 @@ export class BaseModelApiClient {
                if (state.virtualScroller) {
                    state.virtualScroller.removeItemByFilePath(filePath);
                }
-                showToast('toast.api.deleteSuccess', { type: this.apiConfig.config.displayName }, 'success');
-                return true;
+                const batchId = data.batch_id || null;
+                if (!batchId) {
+                    // Not staged (staging failed): keep the legacy toast.
+                    // When staged, the caller shows the undo action toast instead.
+                    showToast('toast.api.deleteSuccess', { type: this.apiConfig.config.displayName }, 'success');
+                }
+                return { success: true, batch_id: batchId };
            } else {
                throw new Error(data.error || `Failed to delete ${this.apiConfig.config.singularName}`);
            }
@@ -1228,7 +1233,7 @@ export class BaseModelApiClient {
        }
    }

-    async downloadModel(modelId, versionId, modelRoot, relativePath, useDefaultPaths = false, downloadId, source = null, fileParams = null) {
+    async downloadModel(modelId, versionId, modelRoot, relativePath, useDefaultPaths = false, downloadId, source = null, fileParams = null, useSaveDirAsRoot = false) {
        try {
            const response = await fetch(DOWNLOAD_ENDPOINTS.download, {
                method: 'POST',
@@ -1239,6 +1244,7 @@ export class BaseModelApiClient {
                    model_root: modelRoot,
                    relative_path: relativePath,
                    use_default_paths: useDefaultPaths,
+                    use_save_dir_as_root: useSaveDirAsRoot,
                    download_id: downloadId,
                    ...(source ? { source } : {}),
                    ...(fileParams ? { file_params: fileParams } : {})
@@ -1622,9 +1628,14 @@ export class BaseModelApiClient {
            if (result.success) {
                return {
                    success: true,
-                    deleted_count: result.deleted_count,
+                    deleted_count: result.deleted_count ?? result.total_deleted,
                    failed_count: result.failed_count || 0,
-                    errors: result.errors || []
+                    errors: result.errors || [],
+                    // Undo batch fields — batch_id on merge success, batch_ids
+                    // array on merge failure (same success dict for the
+                    // status='cancelled' staged-subset path)
+                    batch_id: result.batch_id || null,
+                    batch_ids: result.batch_ids || null
                };
            } else {
                throw new Error(result.error || `Failed to delete ${this.apiConfig.config.displayName.toLowerCase()}s`);
@@ -16,6 +16,8 @@ const RECIPE_ENDPOINTS = {
    moveBulk: '/api/lm/recipes/move-bulk',
    bulkDelete: '/api/lm/recipes/bulk-delete',
    repairBulk: '/api/lm/recipes/repair-bulk',
+    rematchBulk: '/api/lm/recipes/rematch-bulk',
+    rematchSingle: '/api/lm/recipe/{recipe_id}/rematch',
 };

 const RECIPE_SIDEBAR_CONFIG = {
@@ -586,6 +588,38 @@ export class RecipeSidebarApiClient {
        return result;
    }

+    async rematchBulkModels(filePaths) {
+        if (!filePaths || filePaths.length === 0) {
+            throw new Error('No file paths provided');
+        }
+
+        const recipeIds = filePaths
+            .map((path) => extractRecipeId(path))
+            .filter((id) => !!id);
+
+        if (recipeIds.length === 0) {
+            throw new Error('No recipe IDs could be derived from file paths');
+        }
+
+        const response = await fetch(this.apiConfig.endpoints.rematchBulk, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                recipe_ids: recipeIds,
+            }),
+        });
+
+        const result = await response.json();
+
+        if (!response.ok || !result.success) {
+            throw new Error(result.error || 'Failed to rematch recipes');
+        }
+
+        return result;
+    }
+
    async bulkDeleteModels(filePaths) {
        if (!filePaths || filePaths.length === 0) {
            throw new Error('No file paths provided');
@@ -623,6 +657,10 @@ export class RecipeSidebarApiClient {
                deleted_count: result.total_deleted,
                failed_count: result.total_failed || 0,
                errors: result.failed || [],
+                // Undo batch fields — batch_id on merge success, batch_ids
+                // array on merge failure
+                batch_id: result.batch_id || null,
+                batch_ids: result.batch_ids || null,
            };
        } finally {
            state.loadingManager?.hide();
@@ -43,6 +43,7 @@ export class BulkContextMenu extends BaseContextMenu {
        const downloadMissingLorasItem = this.menu.querySelector('[data-action="download-missing-loras"]');
        const repairMetadataItem = this.menu.querySelector('[data-action="repair-metadata"]');
        const reimportMetadataItem = this.menu.querySelector('[data-action="reimport-metadata"]');
+        const rematchMetadataItem = this.menu.querySelector('[data-action="rematch-metadata"]');

        if (repairMetadataItem) {
            repairMetadataItem.style.display = config.repairMetadata ? 'flex' : 'none';
@@ -50,6 +51,9 @@ export class BulkContextMenu extends BaseContextMenu {
        if (reimportMetadataItem) {
            reimportMetadataItem.style.display = config.reimportMetadata ? 'flex' : 'none';
        }
+        if (rematchMetadataItem) {
+            rematchMetadataItem.style.display = config.rematchMetadata ? 'flex' : 'none';
+        }

        const isEmbeddings = currentModelType === 'embeddings';
        if (sendToWorkflowAppendItem) {
@@ -282,6 +286,9 @@ export class BulkContextMenu extends BaseContextMenu {
            case 'repair-metadata':
                bulkManager.repairSelectedRecipes();
                break;
+            case 'rematch-metadata':
+                bulkManager.rematchSelectedRecipes();
+                break;
            case 'reimport-metadata':
                bulkManager.reimportSelectedRecipes();
                break;
@@ -24,6 +24,7 @@ export class GlobalContextMenu extends BaseContextMenu {
        const cleanupExamplesItem = this.menu.querySelector('[data-action="cleanup-example-images-folders"]');
        const excludedModelsItem = this.menu.querySelector('[data-action="manage-excluded-models"]');
        const repairRecipesItem = this.menu.querySelector('[data-action="repair-recipes"]');
+        const rematchRecipesItem = this.menu.querySelector('[data-action="rematch-recipes"]');
        const groupByModelItem = this.menu.querySelector('[data-action="toggle-group-by-model"]');
        const groupByModelCheck = groupByModelItem?.querySelector('.check-indicator');

@@ -41,6 +42,7 @@ export class GlobalContextMenu extends BaseContextMenu {
            excludedModelsItem?.classList.add('hidden');
            groupByModelItem?.classList.add('hidden');
            repairRecipesItem?.classList.remove('hidden');
+            rematchRecipesItem?.classList.remove('hidden');
        } else {
            modelUpdateItem?.classList.remove('hidden');
            licenseRefreshItem?.classList.remove('hidden');
@@ -49,11 +51,28 @@ export class GlobalContextMenu extends BaseContextMenu {
            excludedModelsItem?.classList.remove('hidden');
            groupByModelItem?.classList.remove('hidden');
            repairRecipesItem?.classList.add('hidden');
+            rematchRecipesItem?.classList.add('hidden');
        }

+        this._updateSeparatorVisibility();
+
        super.showMenu(x, y, contextOrigin);
    }

+    _updateSeparatorVisibility() {
+        const children = Array.from(this.menu.children);
+        const isVisible = (el) => el.classList.contains('context-menu-item') && !el.classList.contains('hidden');
+
+        children.forEach((el, index) => {
+            if (!el.classList.contains('context-menu-separator')) {
+                return;
+            }
+            const hasVisibleBefore = children.slice(0, index).some(isVisible);
+            const hasVisibleAfter = children.slice(index + 1).some(isVisible);
+            el.classList.toggle('hidden', !(hasVisibleBefore && hasVisibleAfter));
+        });
+    }
+
    handleMenuAction(action, menuItem) {
        switch (action) {
            case 'cleanup-example-images-folders':
@@ -81,6 +100,11 @@ export class GlobalContextMenu extends BaseContextMenu {
                    console.error('Failed to repair recipes:', error);
                });
                break;
+            case 'rematch-recipes':
+                this.rematchRecipes(menuItem).catch((error) => {
+                    console.error('Failed to rematch recipes:', error);
+                });
+                break;
            case 'manage-excluded-models':
                this.manageExcludedModels();
                break;
@@ -439,4 +463,143 @@ export class GlobalContextMenu extends BaseContextMenu {
            console.error('Failed to cancel recipe repair:', error);
        }
    }
+
+    async rematchRecipes(menuItem) {
+        if (this._rematchInProgress) {
+            return;
+        }
+
+        this._rematchInProgress = true;
+        menuItem?.classList.add('disabled');
+
+        const loadingMessage = translate(
+            'globalContextMenu.rematchRecipes.loading',
+            {},
+            'Rematching recipes to local models...'
+        );
+
+        const progressUI = state.loadingManager?.showEnhancedProgress(loadingMessage);
+        progressUI?.showCancelButton(() => this.cancelRematch());
+
+        try {
+            const response = await fetch('/api/lm/recipes/rematch', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+            });
+
+            const result = await response.json();
+            if (!response.ok || !result.success) {
+                throw new Error(result.error || 'Failed to start rematch');
+            }
+
+            // Poll for progress (mirrors the repair flow; the backend reports `rematched` counts)
+            let isComplete = false;
+            while (!isComplete && this._rematchInProgress) {
+                const progressResponse = await fetch('/api/lm/recipes/rematch-progress');
+                if (progressResponse.ok) {
+                    const progressResult = await progressResponse.json();
+                    if (progressResult.success && progressResult.progress) {
+                        const p = progressResult.progress;
+                        if (p.status === 'processing') {
+                            const percent = (p.current / p.total) * 100;
+                            progressUI?.updateProgress(percent, p.recipe_name, `${loadingMessage} (${p.current}/${p.total})`);
+                        } else if (p.status === 'completed') {
+                            isComplete = true;
+                            // Newer backends report unified matched_entries /
+                            // matched_recipes; fall back to legacy `rematched`
+                            // (recipe count) for older ones.
+                            const entries = p.matched_entries ?? p.rematched ?? 0;
+                            const recipes = p.matched_recipes ?? p.rematched ?? 0;
+                            const failures = p.errors || 0;
+                            const unresolved = p.unresolved_entries ?? 0;
+                            if (entries > 0) {
+                                const successKey = failures > 0
+                                    ? 'globalContextMenu.rematchRecipes.successErrors'
+                                    : 'globalContextMenu.rematchRecipes.success';
+                                const successText = failures > 0
+                                    ? `Matched ${entries} entries across ${recipes} recipes, ${failures} failed.`
+                                    : `Matched ${entries} entries across ${recipes} recipes.`;
+                                progressUI?.complete(translate(
+                                    successKey,
+                                    { count: recipes, recipes, entries, failures },
+                                    successText
+                                ));
+                                showToast(successKey, { count: recipes, recipes, entries, failures }, failures > 0 ? 'warning' : 'success');
+                            } else if (failures > 0) {
+                                // Nothing matched and at least one recipe
+                                // errored — "no rematch needed" would be
+                                // actively misleading here.
+                                progressUI?.complete(translate(
+                                    'globalContextMenu.rematchRecipes.allFailed',
+                                    { total: p.total, recipes, entries, failures },
+                                    `Rematch failed for ${failures} of ${p.total} recipes.`
+                                ));
+                                showToast('globalContextMenu.rematchRecipes.allFailed', { total: p.total, recipes, entries, failures }, 'error');
+                            } else if (unresolved > 0) {
+                                // Entries existed but have no local model —
+                                // expected for models deleted from Civitai;
+                                // informational, not an error.
+                                const unresolvedRecipes = p.unresolved_recipes ?? 0;
+                                progressUI?.complete(translate(
+                                    'globalContextMenu.rematchRecipes.noMatch',
+                                    { entries: unresolved, recipes: unresolvedRecipes, total: p.total, failures },
+                                    `No local match found for ${unresolved} entries in ${unresolvedRecipes} recipes.`
+                                ));
+                                showToast('globalContextMenu.rematchRecipes.noMatch', { entries: unresolved, recipes: unresolvedRecipes, total: p.total, failures }, 'info');
+                            } else {
+                                // Everything was skipped (nothing to do).
+                                progressUI?.complete(translate(
+                                    'globalContextMenu.rematchRecipes.success',
+                                    { count: recipes, recipes, entries, failures },
+                                    `Matched ${entries} entries across ${recipes} recipes.`
+                                ));
+                                showToast('globalContextMenu.rematchRecipes.success', { count: recipes, recipes, entries, failures }, 'success');
+                            }
+                            // Refresh recipes page if active
+                            if (window.recipesPage) {
+                                window.recipesPage.refresh();
+                            }
+                        } else if (p.status === 'error') {
+                            throw new Error(p.error || 'Rematch failed');
+                        } else if (p.status === 'cancelled') {
+                            isComplete = true;
+                            const cancelledEntries = p.matched_entries ?? p.rematched ?? 0;
+                            const cancelledRecipes = p.matched_recipes ?? p.rematched ?? 0;
+                            progressUI?.complete(translate(
+                                'globalContextMenu.rematchRecipes.cancelled',
+                                { count: cancelledRecipes, recipes: cancelledRecipes, entries: cancelledEntries },
+                                `Rematch cancelled. ${cancelledRecipes} recipes updated (${cancelledEntries} entries).`
+                            ));
+                            showToast('globalContextMenu.rematchRecipes.cancelled', { count: cancelledRecipes, recipes: cancelledRecipes, entries: cancelledEntries }, 'info');
+                        }
+                    } else if (progressResponse.status === 404) {
+                        // Progress might have finished quickly and been cleaned up
+                        isComplete = true;
+                        progressUI?.complete();
+                    }
+                }
+
+                if (!isComplete) {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                }
+            }
+        } catch (error) {
+            console.error('Recipe rematch failed:', error);
+            progressUI?.complete(translate('globalContextMenu.rematchRecipes.error', { message: error.message }, 'Rematch failed: {message}'));
+            showToast('globalContextMenu.rematchRecipes.error', { message: error.message }, 'error');
+        } finally {
+            this._rematchInProgress = false;
+            menuItem?.classList.remove('disabled');
+        }
+    }
+
+    async cancelRematch() {
+        try {
+            await fetch('/api/lm/recipes/cancel-rematch', {
+                method: 'POST',
+            });
+        } catch (error) {
+            console.error('Failed to cancel recipe rematch:', error);
+        }
+    }
 }
@@ -1,6 +1,7 @@
 import { BaseContextMenu } from './BaseContextMenu.js';
 import { ModelContextMenuMixin } from './ModelContextMenuMixin.js';
 import { showToast, copyToClipboard, sendLoraToWorkflow } from '../../utils/uiHelpers.js';
+import { isModelWeightFile } from '../../utils/modelFileTypes.js';
 import { setSessionItem, removeSessionItem } from '../../utils/storageHelpers.js';
 import { updateRecipeMetadata } from '../../api/recipeApi.js';
 import { state } from '../../state/index.js';
@@ -97,6 +98,10 @@ export class RecipeContextMenu extends BaseContextMenu {
                // Repair recipe metadata
                this.repairRecipe(recipeId);
                break;
+            case 'rematch':
+                // Rematch recipe resources to local models
+                this.rematchRecipe(recipeId);
+                break;
            case 'reimport':
                this.reimportRecipe(recipeId);
                break;
@@ -251,7 +256,7 @@ export class RecipeContextMenu extends BaseContextMenu {
                loras: validLoras.map(lora => {
                    const civitaiInfo = lora.civitaiInfo;
                    const modelFile = civitaiInfo.files ?
-                        civitaiInfo.files.find(file => file.type === 'Model') : null;
+                        civitaiInfo.files.find(file => isModelWeightFile(file.type)) : null;

                    return {
                        // Basic lora info
@@ -330,6 +335,62 @@ export class RecipeContextMenu extends BaseContextMenu {
        }
    }

+    async rematchRecipe(recipeId) {
+        if (!recipeId) {
+            showToast('toast.recipes.rematchFailed', { message: 'Missing recipe ID' }, 'error');
+            return;
+        }
+
+        // Capture before any await: the menu's click handler nulls currentCard
+        const filePath = this.currentCard?.dataset?.filepath;
+
+        try {
+            showToast('Rematching recipe to local models...', {}, 'info');
+
+            const response = await fetch(`/api/lm/recipe/${recipeId}/rematch`, {
+                method: 'POST'
+            });
+            const result = await response.json();
+
+            if (result.success) {
+                const matchedEntries = result.matched_entries || result.rematched || 0;
+                const failures = result.errors || 0;
+                if (matchedEntries > 0) {
+                    const toastKey = failures > 0
+                        ? 'toast.recipes.rematchCompleteErrors'
+                        : 'toast.recipes.rematchComplete';
+                    showToast(
+                        toastKey,
+                        { rematched: matchedEntries, skipped: result.skipped || 0, total: 1, entries: matchedEntries, recipes: 1, failures },
+                        failures > 0 ? 'warning' : 'success'
+                    );
+                    const detailResponse = await fetch(`/api/lm/recipe/${recipeId}`);
+                    if (detailResponse.ok) {
+                        const updatedRecipe = await detailResponse.json();
+                        if (filePath && state.virtualScroller) {
+                            state.virtualScroller.updateSingleItem(filePath, updatedRecipe);
+                        }
+                    }
+                } else if (result.unresolved_entries > 0) {
+                    // Entries existed but have no local model — expected for
+                    // models deleted from Civitai; informational, not an error.
+                    showToast(
+                        'toast.recipes.rematchUnmatched',
+                        { entries: result.unresolved_entries, recipes: 1, total: 1 },
+                        'info'
+                    );
+                } else {
+                    showToast('toast.recipes.rematchSkipped', { total: 1 }, 'info');
+                }
+            } else {
+                throw new Error(result.error || 'Rematch failed');
+            }
+        } catch (error) {
+            console.error('Error rematching recipe:', error);
+            showToast('toast.recipes.rematchFailed', { message: error.message }, 'error');
+        }
+    }
+
    async reimportRecipe(recipeId) {
        if (!recipeId) {
            showToast('recipes.contextMenu.reimport.missingId', {}, 'error');
@@ -1,5 +1,7 @@
 // Duplicates Manager Component
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, showActionToast } from '../utils/uiHelpers.js';
+import { handleUndoDelete } from '../utils/undoHelpers.js';
+import { translate } from '../utils/i18nHelpers.js';
 import { RecipeCard } from './RecipeCard.js';
 import { state, getCurrentPageState } from '../state/index.js';
 import { recreateVirtualScroll } from '../utils/infiniteScroll.js';
@@ -10,11 +12,87 @@ export class DuplicatesManager {
        this.duplicateGroups = [];
        this.inDuplicateMode = false;
        this.selectedForDeletion = new Set();
+        this._initPromptMatchToggle();
+        this._initHelpTooltip();
    }
-    
+
+    _getPromptMatchPreference() {
+        return localStorage.getItem('recipes_duplicates_include_prompt') === '1';
+    }
+
+    _setPromptMatchPreference(enabled) {
+        localStorage.setItem('recipes_duplicates_include_prompt', enabled ? '1' : '0');
+    }
+
+    updateBasisDisplay() {
+        const basisEl = document.getElementById('duplicatesBasis');
+        const helpTextEl = document.getElementById('duplicatesHelpText');
+        const checkbox = document.getElementById('promptMatchInput');
+        const includePrompt = this._getPromptMatchPreference();
+        if (checkbox) {
+            checkbox.checked = includePrompt;
+        }
+        if (basisEl) {
+            basisEl.textContent = translate(
+                includePrompt
+                    ? 'recipes.duplicates.basis.loraComboAndPrompt'
+                    : 'recipes.duplicates.basis.loraCombo'
+            );
+        }
+        if (helpTextEl) {
+            helpTextEl.textContent = translate(
+                includePrompt
+                    ? 'recipes.duplicates.basis.hintPromptIncluded'
+                    : 'recipes.duplicates.basis.hintLoraCombo'
+            );
+        }
+    }
+
+    _initPromptMatchToggle() {
+        const checkbox = document.getElementById('promptMatchInput');
+        if (!checkbox) return;
+        checkbox.addEventListener('change', async (e) => {
+            this._setPromptMatchPreference(e.target.checked);
+            this.updateBasisDisplay();
+            checkbox.disabled = true;
+            try {
+                await this.findDuplicates();
+            } finally {
+                checkbox.disabled = false;
+            }
+        });
+    }
+
+    _initHelpTooltip() {
+        const helpIcon = document.getElementById('duplicatesHelp');
+        const helpTooltip = document.getElementById('duplicatesHelpTooltip');
+        if (!helpIcon || !helpTooltip) return;
+
+        helpIcon.addEventListener('mouseenter', () => {
+            const bannerContent = helpIcon.closest('.banner-content');
+            if (!bannerContent) return;
+            const iconRect = helpIcon.getBoundingClientRect();
+            const bannerRect = bannerContent.getBoundingClientRect();
+            helpTooltip.style.display = 'block';
+            helpTooltip.style.top = `${iconRect.bottom - bannerRect.top + 10}px`;
+            helpTooltip.style.left = `${iconRect.left - bannerRect.left - 10}px`;
+            const tooltipRect = helpTooltip.getBoundingClientRect();
+            if (tooltipRect.right > window.innerWidth - 20) {
+                helpTooltip.style.left = `${bannerContent.offsetWidth - tooltipRect.width - 20}px`;
+            }
+        });
+        helpIcon.addEventListener('mouseleave', () => {
+            helpTooltip.style.display = 'none';
+        });
+    }
+
    async findDuplicates() {
        try {
-            const response = await fetch('/api/lm/recipes/find-duplicates');
+            const includePrompt = this._getPromptMatchPreference();
+            const endpoint = includePrompt
+                ? '/api/lm/recipes/find-duplicates?include_prompt=1'
+                : '/api/lm/recipes/find-duplicates';
+            const response = await fetch(endpoint);
            if (!response.ok) {
                throw new Error('Failed to find duplicates');
            }
@@ -28,7 +106,14 @@ export class DuplicatesManager {
            
            if (this.duplicateGroups.length === 0) {
                showToast('toast.duplicates.noDuplicatesFound', { type: 'recipes' }, 'info');
-                return false;
+                // Keep (or enter) the duplicates view when the user is tuning
+                // the matching basis, so the prompt-matching toggle stays
+                // reachable; otherwise just toast and stay on the library grid.
+                if (!this.inDuplicateMode && !includePrompt) {
+                    return false;
+                }
+                this.enterDuplicateMode();
+                return true;
            }
            
            this.enterDuplicateMode();
@@ -53,9 +138,14 @@ export class DuplicatesManager {
        const countSpan = document.getElementById('duplicatesCount');
        
        if (banner && countSpan) {
-            countSpan.textContent = `Found ${this.duplicateGroups.length} duplicate group${this.duplicateGroups.length !== 1 ? 's' : ''}`;
+            countSpan.textContent = this.duplicateGroups.length === 0
+                ? translate('recipes.duplicates.noGroups')
+                : translate('recipes.duplicates.found', { count: this.duplicateGroups.length });
            banner.style.display = 'block';
        }
+
+        // Restore the prompt-matching preference and show the matching basis
+        this.updateBasisDisplay();
        
        // Disable virtual scrolling if active
        if (state.virtualScroller) {
@@ -113,12 +203,23 @@ export class DuplicatesManager {
        
        // Clear existing content
        recipeGrid.innerHTML = '';
+
+        // Empty-state view: keep the banner (and the matching-basis toggle)
+        // reachable when no groups match the current basis
+        if (this.duplicateGroups.length === 0) {
+            const emptyState = document.createElement('div');
+            emptyState.className = 'duplicates-empty-state';
+            emptyState.textContent = translate('recipes.duplicates.noGroups');
+            recipeGrid.appendChild(emptyState);
+            return;
+        }
        
        // Render each duplicate group
        this.duplicateGroups.forEach((group, groupIndex) => {
+            const groupKey = group.key;
            const groupDiv = document.createElement('div');
            groupDiv.className = 'duplicate-group';
-            groupDiv.dataset.fingerprint = group.fingerprint;
+            groupDiv.dataset.groupKey = groupKey;
            
            // Create group header
            const header = document.createElement('div');
@@ -126,10 +227,10 @@ export class DuplicatesManager {
            header.innerHTML = `
                <span>Duplicate Group #${groupIndex + 1} (${group.recipes.length} recipes)</span>
                <span>
-                    <button class="btn-select-all" onclick="recipeManager.duplicatesManager.toggleSelectAllInGroup('${group.fingerprint}')">
+                    <button class="btn-select-all" onclick="recipeManager.duplicatesManager.toggleSelectAllInGroup('${groupKey}')">
                        Select All
                    </button>
-                    <button class="btn-select-latest" onclick="recipeManager.duplicatesManager.selectLatestInGroup('${group.fingerprint}')">
+                    <button class="btn-select-latest" onclick="recipeManager.duplicatesManager.selectLatestInGroup('${groupKey}')">
                        Keep Latest
                    </button>
                </span>
@@ -182,7 +283,7 @@ export class DuplicatesManager {
                checkbox.type = 'checkbox';
                checkbox.className = 'selector-checkbox';
                checkbox.dataset.recipeId = recipe.id;
-                checkbox.dataset.groupFingerprint = group.fingerprint;
+                checkbox.dataset.groupKey = groupKey;
                
                // Check if already selected
                if (this.selectedForDeletion.has(recipe.id)) {
@@ -244,8 +345,8 @@ export class DuplicatesManager {
        }
    }
    
-    toggleSelectAllInGroup(fingerprint) {
-        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+    toggleSelectAllInGroup(groupKey) {
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-key="${groupKey}"]`);
        const allSelected = Array.from(checkboxes).every(checkbox => checkbox.checked);
        
        // If all are selected, deselect all; otherwise select all
@@ -264,7 +365,7 @@ export class DuplicatesManager {
        });
        
        // Update the button text
-        const button = document.querySelector(`.duplicate-group[data-fingerprint="${fingerprint}"] .btn-select-all`);
+        const button = document.querySelector(`.duplicate-group[data-group-key="${groupKey}"] .btn-select-all`);
        if (button) {
            button.textContent = !allSelected ? "Deselect All" : "Select All";
        }
@@ -272,8 +373,8 @@ export class DuplicatesManager {
        this.updateSelectedCount();
    }
    
-    selectAllInGroup(fingerprint) {
-        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+    selectAllInGroup(groupKey) {
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-key="${groupKey}"]`);
        checkboxes.forEach(checkbox => {
            checkbox.checked = true;
            this.selectedForDeletion.add(checkbox.dataset.recipeId);
@@ -281,7 +382,7 @@ export class DuplicatesManager {
        });
        
        // Update the button text
-        const button = document.querySelector(`.duplicate-group[data-fingerprint="${fingerprint}"] .btn-select-all`);
+        const button = document.querySelector(`.duplicate-group[data-group-key="${groupKey}"] .btn-select-all`);
        if (button) {
            button.textContent = "Deselect All";
        }
@@ -289,12 +390,12 @@ export class DuplicatesManager {
        this.updateSelectedCount();
    }
    
-    selectLatestInGroup(fingerprint) {
+    selectLatestInGroup(groupKey) {
        // Find all checkboxes in this group
-        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-fingerprint="${fingerprint}"]`);
+        const checkboxes = document.querySelectorAll(`.selector-checkbox[data-group-key="${groupKey}"]`);
        
        // Get all the recipes in this group
-        const group = this.duplicateGroups.find(g => g.fingerprint === fingerprint);
+        const group = this.duplicateGroups.find(g => g.key === groupKey);
        if (!group) return;
        
        // Sort recipes by date (newest first)
@@ -328,7 +429,7 @@ export class DuplicatesManager {
    selectLatestDuplicates() {
        // For each duplicate group, select all but the latest recipe
        this.duplicateGroups.forEach(group => {
-            this.selectLatestInGroup(group.fingerprint);
+            this.selectLatestInGroup(group.key);
        });
    }
    
@@ -379,8 +480,34 @@ export class DuplicatesManager {
            if (!data.success) {
                throw new Error(data.error || 'Unknown error deleting recipes');
            }
-            
-            showToast('toast.duplicates.deleteSuccess', { count: data.total_deleted, type: 'recipes' }, 'success');
+
+            const batchIds = !data.batch_id && Array.isArray(data.batch_ids) && data.batch_ids.length
+                ? data.batch_ids
+                : null;
+
+            if (data.batch_id || batchIds) {
+                // One undo action restores the whole selected group
+                const refreshFn = () => window.recipeManager.loadRecipes(true);
+                const onAction = data.batch_id
+                    ? () => handleUndoDelete(data.batch_id, refreshFn)
+                    : async () => {
+                        for (const id of batchIds) {
+                            const succeeded = await handleUndoDelete(id, null, { showToast: false, refresh: false });
+                            if (!succeeded) {
+                                showToast('toast.undo.failed', { error: '' }, 'error');
+                                return;
+                            }
+                        }
+                        refreshFn();
+                        showToast('toast.undo.restored', {}, 'success');
+                    };
+                showActionToast('toast.undo.deletedBulk', { count: data.total_deleted }, 'success', {
+                    actionText: translate('toast.undo.action'),
+                    onAction,
+                });
+            } else {
+                showToast('toast.duplicates.deleteSuccess', { count: data.total_deleted, type: 'recipes' }, 'success');
+            }
            
            // Exit duplicate mode if deletions were successful
            if (data.total_deleted > 0) {
@@ -1,5 +1,7 @@
 // Model Duplicates Manager Component for LoRAs and Checkpoints
-import { showToast } from '../utils/uiHelpers.js';
+import { showToast, showActionToast } from '../utils/uiHelpers.js';
+import { handleUndoDelete } from '../utils/undoHelpers.js';
+import { translate } from '../utils/i18nHelpers.js';
 import { state, getCurrentPageState } from '../state/index.js';
 import { formatDate } from '../utils/formatters.js';
 import { resetAndReload} from '../api/modelApiFactory.js';
@@ -732,8 +734,34 @@ export class ModelDuplicatesManager {
            if (!data.success) {
                throw new Error(data.error || 'Unknown error deleting models');
            }
-            
-            showToast('toast.duplicates.deleteSuccess', { count: data.total_deleted, type: this.modelType }, 'success');
+
+            const batchIds = !data.batch_id && Array.isArray(data.batch_ids) && data.batch_ids.length
+                ? data.batch_ids
+                : null;
+
+            if (data.batch_id || batchIds) {
+                // One undo action restores the whole selected group
+                const refreshFn = () => resetAndReload(true);
+                const onAction = data.batch_id
+                    ? () => handleUndoDelete(data.batch_id, refreshFn)
+                    : async () => {
+                        for (const id of batchIds) {
+                            const succeeded = await handleUndoDelete(id, null, { showToast: false, refresh: false });
+                            if (!succeeded) {
+                                showToast('toast.undo.failed', { error: '' }, 'error');
+                                return;
+                            }
+                        }
+                        refreshFn();
+                        showToast('toast.undo.restored', {}, 'success');
+                    };
+                showActionToast('toast.undo.deletedBulk', { count: data.total_deleted }, 'success', {
+                    actionText: translate('toast.undo.action'),
+                    onAction,
+                });
+            } else {
+                showToast('toast.duplicates.deleteSuccess', { count: data.total_deleted, type: this.modelType }, 'success');
+            }
            
            // If models were successfully deleted
            if (data.total_deleted > 0) {
@@ -1,5 +1,5 @@
 // Recipe Card Component
-import { showToast, copyToClipboard, sendLoraToWorkflow } from '../utils/uiHelpers.js';
+import { showToast, showActionToast, copyToClipboard, sendLoraToWorkflow } from '../utils/uiHelpers.js';
 import { updateRecipeMetadata } from '../api/recipeApi.js';
 import { configureModelCardVideo } from './shared/ModelCard.js';
 import { modalManager } from '../managers/ModalManager.js';
@@ -7,6 +7,8 @@ import { getCurrentPageState } from '../state/index.js';
 import { state } from '../state/index.js';
 import { bulkManager } from '../managers/BulkManager.js';
 import { NSFW_LEVELS, getBaseModelAbbreviation, getMatureBlurThreshold } from '../utils/constants.js';
+import { translate } from '../utils/i18nHelpers.js';
+import { handleUndoDelete } from '../utils/undoHelpers.js';

 class RecipeCard {
    constructor(recipe, clickHandler) {
@@ -363,7 +365,7 @@ class RecipeCard {
                        </div>
                        <div class="delete-info">
                            <h3>${this.recipe.title}</h3>
-                            <p>This action cannot be undone.</p>
+                            <p>${translate('modals.deleteRecipe.recoverableWarning')}</p>
                        </div>
                    </div>
                    <p class="delete-note">Note: Deleting this recipe will not affect the LoRA files used in it.</p>
@@ -432,7 +434,16 @@ class RecipeCard {
                return response.json();
            })
            .then(data => {
-                showToast('toast.recipes.deletedSuccessfully', {}, 'success');
+                if (data.batch_id) {
+                    // Staged delete: offer undo instead of the plain success toast
+                    const batchId = data.batch_id;
+                    showActionToast('toast.undo.deleted', { name: this.recipe.title }, 'success', {
+                        actionText: translate('toast.undo.action'),
+                        onAction: () => handleUndoDelete(batchId, () => window.recipeManager.loadRecipes(true)),
+                    });
+                } else {
+                    showToast('toast.recipes.deletedSuccessfully', {}, 'success');
+                }

                state.virtualScroller.removeItemByFilePath(deleteModal.dataset.filePath);

@@ -1,5 +1,6 @@
 // Recipe Modal Component
 import { showToast, copyToClipboard, sendLoraToWorkflow, sendModelPathToWorkflow, openCivitaiByMetadata, stripLoraTags, sendPromptToWorkflow, sendGenParamsToWorkflow } from '../utils/uiHelpers.js';
+import { isModelWeightFile } from '../utils/modelFileTypes.js';
 import { translate } from '../utils/i18nHelpers.js';
 import { state } from '../state/index.js';
 import { setSessionItem, removeSessionItem, getStorageItem, setStorageItem } from '../utils/storageHelpers.js';
@@ -305,6 +306,14 @@ class RecipeModal {
        modalManager.showModal('recipeModal');

        if (this.recipeId) {
+            // Fire-and-forget: record this open for the "Recently Opened"
+            // sort. Tracking must never disturb the modal, so failures are
+            // swallowed.
+            fetch(`/api/lm/recipe/${encodeURIComponent(this.recipeId)}/opened`, {
+                method: 'POST',
+                keepalive: true,
+            }).catch(() => {});
+
            const hydrationRequestId = ++this.recipeHydrationRequestId;
            const requestEditVersions = this.captureLocalEditVersions();
            this.hydrateRecipeDetails(
@@ -1412,7 +1421,7 @@ class RecipeModal {
                loras: validLoras.map(lora => {
                    const civitaiInfo = lora.civitaiInfo;
                    const modelFile = civitaiInfo.files ?
-                        civitaiInfo.files.find(file => file.type === 'Model') : null;
+                        civitaiInfo.files.find(file => isModelWeightFile(file.type)) : null;

                    return {
                        // Basic lora info
@@ -4,7 +4,7 @@ import { getStorageItem, setStorageItem, removeStorageItem, getSessionItem, setS
 import { showToast, openCivitaiByMetadata } from '../../utils/uiHelpers.js';
 import { performModelUpdateCheck } from '../../utils/updateCheckHelpers.js';
 import { sidebarManager } from '../SidebarManager.js';
-import { initSortDropdown } from './SortDropdown.js';
+import { initSortDropdown, applySortToSelect, randomizeSortValue } from './SortDropdown.js';

 /**
 * PageControls class - Unified control management for model pages
@@ -108,20 +108,20 @@ export class PageControls {
        const sortSelect = document.getElementById('sortSelect');
        if (sortSelect) {
            initSortDropdown(sortSelect);
-            this.applySortToSelect(this.pageState.sortBy);
+            applySortToSelect(this.pageState.sortBy);
            sortSelect.addEventListener('change', async (e) => {
                let value = e.target.value;
                if (value.startsWith('random')) {
                    // Every pick of Random reshuffles the list: generate a
                    // fresh seed so the backend keeps a stable order across
                    // paginated requests.
-                    value = this._randomizeSortValue();
+                    value = randomizeSortValue();
                }
                this.pageState.sortBy = value;
                this.saveSortPreference(value);
                // Reset the seeded Random option when switching away from
                // Random, or re-apply the fresh seed when picking it again.
-                this.applySortToSelect(value);
+                applySortToSelect(value);
                await this.resetAndReload();
            });
        }
@@ -322,44 +322,6 @@ export class PageControls {
        }
    }
    
-    /**
-     * Apply a sort value to the native sort <select>, keeping the Random
-     * option's value in sync when the persisted value carries a seed
-     * (e.g. "random:abc123"). Must be used instead of assigning
-     * sortSelect.value directly whenever the value may be a seeded random
-     * sort, otherwise the native select has no matching option.
-     * @param {string} sortValue - Sort value like "name:asc" or "random:<seed>"
-     */
-    applySortToSelect(sortValue) {
-        const sortSelect = document.getElementById('sortSelect');
-        if (!sortSelect) return;
-        const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
-        if (randomOpt) {
-            randomOpt.value = String(sortValue).startsWith('random') ? sortValue : 'random';
-        }
-        sortSelect.value = sortValue;
-    }
-
-    /**
-     * Generate a fresh seeded random sort value ("random:<seed>") and keep
-     * the native <select> in sync so its value matches the persisted sort
-     * string and the dropdown shows the selected label.
-     * @returns {string} The new sort value, e.g. "random:abc123xyz"
-     */
-    _randomizeSortValue() {
-        const seed = Math.random().toString(36).slice(2, 12);
-        const value = `random:${seed}`;
-        const sortSelect = document.getElementById('sortSelect');
-        if (sortSelect) {
-            const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
-            if (randomOpt) {
-                randomOpt.value = value;
-            }
-            sortSelect.value = value;
-        }
-        return value;
-    }
-
    /**
     * Load sort preference from storage
     */
@@ -374,7 +336,7 @@ export class PageControls {
            // Handle legacy format conversion
            const convertedSort = this.convertLegacySortFormat(savedSort);
            this.pageState.sortBy = convertedSort;
-            this.applySortToSelect(convertedSort);
+            applySortToSelect(convertedSort);
        }
    }
    
@@ -568,7 +530,7 @@ export class PageControls {
        this.pageState.sortBy = restoredSort;
        this.saveSortPreference(restoredSort);
        this._removeVlmSortOption();
-        this.applySortToSelect(restoredSort);
+        applySortToSelect(restoredSort);
        const sortSelect = document.getElementById('sortSelect');
        if (sortSelect) {
            sortSelect.disabled = false;
@@ -620,7 +582,7 @@ export class PageControls {
            const savedGroupedSort = getStorageItem(groupedKey);
            if (savedGroupedSort) {
                this.pageState.sortBy = savedGroupedSort;
-                this.applySortToSelect(savedGroupedSort);
+                applySortToSelect(savedGroupedSort);
            }
        } else {
            // Leaving group mode: persist current sort for next time, restore non-group sort
@@ -628,7 +590,7 @@ export class PageControls {
            const savedNormalSort = getStorageItem(`${this.pageType}_sort`);
            if (savedNormalSort) {
                this.pageState.sortBy = savedNormalSort;
-                this.applySortToSelect(savedNormalSort);
+                applySortToSelect(savedNormalSort);
            }
        }
    }
@@ -913,7 +875,7 @@ export class PageControls {
        }

        if (sortSelect) {
-            this.applySortToSelect(this.pageState.sortBy);
+            applySortToSelect(this.pageState.sortBy);
        }
        if (searchInput) {
            searchInput.value = this.pageState.filters?.search || '';
@@ -18,6 +18,44 @@
 const SORT_GROUP_SELECTOR = '.sort-dropdown-group';
 const ACTIVE_GROUP_SELECTOR = '.sort-dropdown-group.active, .dropdown-group.active';

+/**
+ * Apply a sort value to the page's native sort <select>, keeping the Random
+ * option's value in sync when the persisted value carries a seed
+ * (e.g. "random:abc123"). Must be used instead of assigning
+ * sortSelect.value directly whenever the value may be a seeded random
+ * sort, otherwise the native select has no matching option.
+ * @param {string} sortValue - Sort value like "name:asc" or "random:<seed>"
+ */
+export function applySortToSelect(sortValue) {
+    const sortSelect = document.getElementById('sortSelect');
+    if (!sortSelect) return;
+    const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
+    if (randomOpt) {
+        randomOpt.value = String(sortValue).startsWith('random') ? sortValue : 'random';
+    }
+    sortSelect.value = sortValue;
+}
+
+/**
+ * Generate a fresh seeded random sort value ("random:<seed>") and keep the
+ * native <select> in sync so its value matches the persisted sort string and
+ * the dropdown shows the selected label.
+ * @returns {string} The new sort value, e.g. "random:abc123xyz"
+ */
+export function randomizeSortValue() {
+    const seed = Math.random().toString(36).slice(2, 12);
+    const value = `random:${seed}`;
+    const sortSelect = document.getElementById('sortSelect');
+    if (sortSelect) {
+        const randomOpt = sortSelect.querySelector('option[value="random"], option[value^="random:"]');
+        if (randomOpt) {
+            randomOpt.value = value;
+        }
+        sortSelect.value = value;
+    }
+    return value;
+}
+
 /**
 * Initialize a decoupled sort dropdown around a native <select>.
 * Idempotent: safe to call more than once on the same element.
@@ -741,6 +741,46 @@ export function createModelCard(model, modelType) {
        configureModelCardVideo(videoElement, autoplayOnHover);
    }

+    // Dropping an image/video onto the card replaces the model preview via the
+    // existing replace-preview endpoint (overwrites file on disk, refreshes card).
+    const preventDragDefaults = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+    };
+
+    ['dragenter', 'dragover'].forEach((eventName) => {
+        card.addEventListener(eventName, (event) => {
+            preventDragDefaults(event);
+            card.classList.add('drag-over');
+        });
+    });
+
+    card.addEventListener('dragleave', (event) => {
+        preventDragDefaults(event);
+        card.classList.remove('drag-over');
+    });
+
+    card.addEventListener('drop', (event) => {
+        preventDragDefaults(event);
+        card.classList.remove('drag-over');
+
+        const files = event.dataTransfer?.files;
+        if (!files || files.length === 0) return;
+
+        const file = files[0];
+        // Keep in sync with the accept list of the preview file picker (image/* + video/mp4).
+        if (!file.type.startsWith('image/') && file.type !== 'video/mp4') {
+            showToast('toast.api.previewDropInvalid', { name: file.name || '' }, 'error');
+            return;
+        }
+
+        const filePath = card.dataset.filepath;
+        if (!filePath) return;
+
+        // uploadPreview handles loading state, card refresh and error toasts internally.
+        getModelApiClient().uploadPreview(filePath, file);
+    });
+
    return card;
 }

@@ -182,6 +182,10 @@ function isEarlyAccessActive(version) {
    }
 }

+function isPaidPermanent(version) {
+    return version && version.isPaid === true;
+}
+
 function isDownloadAllowed(version) {
    if (!version.usageControl) {
        return true;
@@ -342,6 +346,7 @@ function resolveUpdateAvailability(record, baseModel, currentVersionId) {
    const strategy = state?.global?.settings?.version_grouping;
    const sameBaseMode = strategy === DISPLAY_FILTER_MODES.SAME_BASE;
    const hideEarlyAccess = state?.global?.settings?.hide_early_access_updates;
+    const hidePaid = state?.global?.settings?.hide_paid_updates;

    if (!sameBaseMode) {
        return Boolean(record?.hasUpdate);
@@ -388,6 +393,9 @@ function resolveUpdateAvailability(record, baseModel, currentVersionId) {
        if (hideEarlyAccess && isEarlyAccessActive(version)) {
            return false;
        }
+        if (hidePaid && isPaidPermanent(version)) {
+            return false;
+        }
        if (!isDownloadAllowed(version)) {
            return false;
        }
@@ -469,6 +477,7 @@ function renderRow(version, options) {
    const downloadedBadgeLabel = translate('modals.model.versions.badges.downloaded', {}, 'Downloaded');
    const newerBadgeLabel = translate('modals.model.versions.badges.newer', {}, 'Newer Version');
    const earlyAccessBadgeLabel = translate('modals.model.versions.badges.earlyAccess', {}, 'Early Access');
+    const paidBadgeLabel = translate('modals.model.versions.badges.paid', {}, 'Paid');
    const ignoredBadgeLabel = translate('modals.model.versions.badges.ignored', {}, 'Ignored');
    const versionName = version.name || translate('modals.model.versions.labels.unnamed', {}, 'Untitled Version');

@@ -522,6 +531,16 @@ function renderRow(version, options) {
        }));
    }

+    if (isPaidPermanent(version)) {
+        badges.push(buildBadge(paidBadgeLabel, 'paid', {
+            title: translate(
+                'modals.model.versions.badges.paidTooltip',
+                {},
+                'This version requires payment to download'
+            ),
+        }));
+    }
+
    if (!isDownloadAllowed(version)) {
        const onSiteOnlyBadgeLabel = translate('modals.model.versions.badges.onSiteOnly', {}, 'On-Site Only');
        badges.push(buildBadge(onSiteOnlyBadgeLabel, 'info', {
@@ -564,6 +583,12 @@ function renderRow(version, options) {
                {},
                'This version is only available for on-site generation on Civitai'
            );
+        } else if (isPaidPermanent(version)) {
+            downloadTitle = translate(
+                'modals.model.versions.actions.downloadPaidTooltip',
+                {},
+                'Download this paid version from Civitai'
+            );
        } else if (isEarlyAccess) {
            downloadTitle = translate(
                'modals.model.versions.actions.downloadEarlyAccessTooltip',
@@ -1307,15 +1332,41 @@ export function initVersionsTab({
        });
    }

-    async function resolveDownloadPathFromCurrentVersion() {
+    function getCurrentInLibraryVersion() {
        if (!normalizedCurrentVersionId || !controller.record?.versions) {
            return null;
        }
-
-        const currentVersion = controller.record.versions.find(
+        return controller.record.versions.find(
            v => v.versionId === normalizedCurrentVersionId && v.isInLibrary && v.filePath
-        );
-        if (!currentVersion?.filePath) {
+        ) || null;
+    }
+
+    function getDownloadPathTemplate() {
+        try {
+            const singularType = modelType.replace(/s$/, '');
+            const templates = state.global?.settings?.download_path_templates;
+            return (templates && templates[singularType]) || '';
+        } catch (error) {
+            return '';
+        }
+    }
+
+    function shouldResolveTemplatePath(targetVersion, pathInfo) {
+        if (!getDownloadPathTemplate() || !pathInfo?.modelRoot) {
+            return false;
+        }
+        const currentVersion = getCurrentInLibraryVersion();
+        const currentBase = normalizeBaseModelName(currentVersion?.baseModel);
+        const targetBase = normalizeBaseModelName(targetVersion?.baseModel);
+        if (!currentBase || !targetBase || currentBase === targetBase) {
+            return false;
+        }
+        return true;
+    }
+
+    async function resolveDownloadPathFromCurrentVersion() {
+        const currentVersion = getCurrentInLibraryVersion();
+        if (!currentVersion) {
            return null;
        }

@@ -1372,10 +1423,13 @@ export function initVersionsTab({

        try {
            const pathInfo = await resolveDownloadPathFromCurrentVersion();
+            const resolveTemplatePath = shouldResolveTemplatePath(version, pathInfo);
            const success = await downloadManager.downloadVersionWithDefaults(modelType, modelId, versionId, {
                versionName: version.name || `#${version.versionId}`,
                modelRoot: pathInfo?.modelRoot || '',
-                targetFolder: pathInfo?.targetFolder || '',
+                targetFolder: resolveTemplatePath ? '' : (pathInfo?.targetFolder || ''),
+                useDefaultPaths: resolveTemplatePath ? true : null,
+                useSaveDirAsRoot: resolveTemplatePath,
            });

            if (success) {
@@ -1,5 +1,6 @@
 import { state, getCurrentPageState } from '../state/index.js';
-import { showToast, copyToClipboard, sendLoraToWorkflow, sendEmbeddingToWorkflow, buildLoraSyntax, getNSFWLevelName } from '../utils/uiHelpers.js';
+import { showToast, showActionToast, copyToClipboard, sendLoraToWorkflow, sendEmbeddingToWorkflow, buildLoraSyntax, getNSFWLevelName } from '../utils/uiHelpers.js';
+import { handleUndoDelete } from '../utils/undoHelpers.js';
 import { updateCardsForBulkMode } from '../components/shared/ModelCard.js';
 import { modalManager } from './ModalManager.js';
 import { getModelApiClient, resetAndReload } from '../api/modelApiFactory.js';
@@ -95,7 +96,8 @@ export class BulkManager {
                setFavorite: true,
                unfavorite: true,
                repairMetadata: true,
-                reimportMetadata: true
+                reimportMetadata: true,
+                rematchMetadata: true
            }
        };

@@ -648,10 +650,38 @@ export class BulkManager {
                showToast('toast.api.operationCancelled', {}, 'info');
            } else if (result.success) {
                const currentConfig = this.getCurrentDisplayConfig();
-                showToast('toast.models.deletedSuccessfully', {
-                    count: result.deleted_count,
-                    type: currentConfig.displayName.toLowerCase()
-                }, 'success');
+                const isRecipes = state.currentPageType === 'recipes';
+                const refreshFn = isRecipes
+                    ? () => window.recipeManager.loadRecipes(true)
+                    : () => resetAndReload(true);
+
+                if (result.batch_id || (result.batch_ids && result.batch_ids.length)) {
+                    // One undo action for the whole bulk action — the backend
+                    // merges staged per-file batches into a single batch, with
+                    // a batch_ids fallback array when the merge failed
+                    const onAction = result.batch_id
+                        ? () => handleUndoDelete(result.batch_id, refreshFn)
+                        : async () => {
+                            for (const id of result.batch_ids) {
+                                const succeeded = await handleUndoDelete(id, null, { showToast: false, refresh: false });
+                                if (!succeeded) {
+                                    showToast('toast.undo.failed', { error: '' }, 'error');
+                                    return;
+                                }
+                            }
+                            refreshFn();
+                            showToast('toast.undo.restored', {}, 'success');
+                        };
+                    showActionToast('toast.undo.deletedBulk', { count: result.deleted_count }, 'success', {
+                        actionText: translate('toast.undo.action'),
+                        onAction,
+                    });
+                } else {
+                    showToast('toast.models.deletedSuccessfully', {
+                        count: result.deleted_count,
+                        type: currentConfig.displayName.toLowerCase()
+                    }, 'success');
+                }

                filePaths.forEach(path => {
                    state.virtualScroller.removeItemByFilePath(path);
@@ -871,6 +901,105 @@ export class BulkManager {
        }
    }

+    async rematchSelectedRecipes() {
+        if (state.selectedModels.size === 0) {
+            showToast('toast.recipes.noRecipesSelected', {}, 'warning');
+            return;
+        }
+
+        if (state.currentPageType !== 'recipes') {
+            showToast('This operation is only available for recipes', {}, 'warning');
+            return;
+        }
+
+        try {
+            const apiClient = this.getActiveApiClient();
+            const filePaths = Array.from(state.selectedModels);
+
+            if (typeof apiClient.rematchBulkModels !== 'function') {
+                showToast('Bulk rematch is not supported for this model type', {}, 'error');
+                return;
+            }
+
+            state.loadingManager.showSimpleLoading('Rematching recipes to local models...');
+
+            const result = await apiClient.rematchBulkModels(filePaths);
+
+            if (result.success) {
+                const total = result.total || filePaths.length;
+                // Unified counters from the backend; legacy fields fall back
+                // for older backends: `rematched` (entry count) for
+                // matched_entries, `total` (selection size) for
+                // matched_recipes.
+                const rematched = result.rematched || 0;
+                const skipped = result.skipped || 0;
+                const matchedRecipes = result.matched_recipes || result.total || 0;
+                const matchedEntries = result.matched_entries || rematched;
+                const failures = result.errors || 0;
+                const unresolvedEntries = result.unresolved_entries || 0;
+                const unresolvedRecipes = result.unresolved_recipes || 0;
+
+                const recipes = result.recipes || [];
+                for (const recipe of recipes) {
+                    if (recipe.file_path) {
+                        state.virtualScroller.updateSingleItem(
+                            recipe.file_path,
+                            recipe
+                        );
+                    }
+                }
+
+                if (matchedEntries > 0) {
+                    const hasFailures = failures > 0;
+                    const toastKey = hasFailures
+                        ? 'toast.recipes.rematchCompleteErrors'
+                        : 'toast.recipes.rematchComplete';
+                    showToast(
+                        toastKey,
+                        { rematched, skipped, total, entries: matchedEntries, recipes: matchedRecipes, failures },
+                        hasFailures ? 'warning' : 'success'
+                    );
+                } else if (failures > 0) {
+                    // Nothing matched and at least one recipe errored —
+                    // "no rematch needed" would be actively misleading here.
+                    showToast(
+                        'toast.recipes.rematchAllFailed',
+                        { total, failures },
+                        'error'
+                    );
+                } else if (unresolvedEntries > 0) {
+                    // Entries existed but have no local model — expected for
+                    // models deleted from Civitai; informational, not an error.
+                    showToast(
+                        'toast.recipes.rematchUnmatched',
+                        { entries: unresolvedEntries, recipes: unresolvedRecipes, total },
+                        'info'
+                    );
+                } else {
+                    showToast(
+                        'toast.recipes.rematchSkipped',
+                        { total },
+                        'info'
+                    );
+                }
+
+                if (state.bulkMode) this.toggleBulkMode();
+            } else {
+                throw new Error(result.error || 'Bulk rematch failed');
+            }
+        } catch (error) {
+            console.error('Error during bulk recipe rematch:', error);
+            showToast('toast.recipes.rematchFailed', { message: error.message }, 'error');
+        } finally {
+            if (state.loadingManager?.hide) {
+                state.loadingManager.hide();
+            }
+            if (typeof state.loadingManager?.restoreProgressBar === 'function') {
+                state.loadingManager.restoreProgressBar();
+            }
+        }
+    }
+
    async refreshAllMetadata() {
        if (state.selectedModels.size === 0) {
            showToast('toast.models.noModelsSelected', {}, 'warning');
@@ -3,6 +3,7 @@ import { showToast, setupAutoNewlineOnPaste } from '../utils/uiHelpers.js';
 import { state } from '../state/index.js';
 import { LoadingManager } from './LoadingManager.js';
 import { getModelApiClient, resetAndReload } from '../api/modelApiFactory.js';
+import { isModelWeightFile } from '../utils/modelFileTypes.js';
 import { getStorageItem, setStorageItem } from '../utils/storageHelpers.js';
 import { FolderTreeManager } from '../components/FolderTreeManager.js';
 import { translate } from '../utils/i18nHelpers.js';
@@ -557,8 +558,7 @@ export class DownloadManager {
            const firstImage = version.images?.find(img => !img.url.endsWith('.mp4'));
            const thumbnailUrl = firstImage ? firstImage.url : '/loras_static/images/no-preview.png';

-            // Count model-type files per version
-            const modelFiles = (version.files || []).filter(f => f.type === 'Model' || f.type === 'UNet' || f.type === 'Diffusion Model');
+            const modelFiles = (version.files || []).filter(f => isModelWeightFile(f.type));
            const primaryFile = modelFiles.find(f => f.primary) || modelFiles[0] || {};
            const fileSize = version.modelSizeKB ?
                (version.modelSizeKB / 1024).toFixed(2) :
@@ -685,7 +685,7 @@ export class DownloadManager {
        if (!version) return;

        this.currentVersion = version;
-        const modelFiles = (version.files || []).filter(f => f.type === 'Model' || f.type === 'UNet' || f.type === 'Diffusion Model');
+        const modelFiles = (version.files || []).filter(f => isModelWeightFile(f.type));

        document.getElementById('versionStep').style.display = 'none';
        document.getElementById('fileSelectionStep').style.display = 'block';
@@ -747,7 +747,7 @@ export class DownloadManager {
            return;
        }

-        const modelFiles = (version.files || []).filter(f => f.type === 'Model' || f.type === 'UNet' || f.type === 'Diffusion Model');
+        const modelFiles = (version.files || []).filter(f => isModelWeightFile(f.type));
        this.selectedFile = modelFiles.find(f => f.id.toString() === selectedRadio.value);

        console.log('[download] confirmFileSelection: selected file id=%s, name="%s", type="%s", metadata=%o',
@@ -912,6 +912,7 @@ export class DownloadManager {
        modelRoot = '',
        targetFolder = '',
        useDefaultPaths = false,
+        useSaveDirAsRoot = false,
        source = null,
        fileParams = null,
        closeModal = false,
@@ -923,7 +924,7 @@ export class DownloadManager {
        }

        const displayName = versionName || `#${versionId}`;
-        const retryParams = { modelId, versionId, versionName, modelRoot, targetFolder, useDefaultPaths, source, fileParams, closeModal: false };
+        const retryParams = { modelId, versionId, versionName, modelRoot, targetFolder, useDefaultPaths, useSaveDirAsRoot, source, fileParams, closeModal: false };
        let ws = null;
        let updateProgress = () => { };
        let cancelled = false;
@@ -995,7 +996,8 @@ export class DownloadManager {
                useDefaultPaths,
                downloadId,
                source,
-                fileParams
+                fileParams,
+                useSaveDirAsRoot
            );

            if (cancelled) {
@@ -1809,7 +1811,9 @@ export class DownloadManager {
        versionName = '', 
        source = null,
        modelRoot = '',
-        targetFolder = ''
+        targetFolder = '',
+        useDefaultPaths = null,
+        useSaveDirAsRoot = false
    } = {}) {
        console.warn('[download] downloadVersionWithDefaults: NO fileParams will be sent — backend will always use primary file. '
            + 'modelType=%s, modelId=%s, versionId=%s, versionName="%s"',
@@ -1824,14 +1828,14 @@ export class DownloadManager {
        this.modelId = modelId ? modelId.toString() : null;
        this.source = source;

-        const useDefaultPaths = !modelRoot;
        return this.executeDownloadWithProgress({
            modelId,
            versionId,
            versionName,
            modelRoot: modelRoot || '',
            targetFolder: targetFolder || '',
-            useDefaultPaths,
+            useDefaultPaths: useDefaultPaths ?? !modelRoot,
+            useSaveDirAsRoot,
            source,
            closeModal: false,
        });
@@ -434,6 +434,22 @@ export class ModalManager {
        this.currentOpenModal = id; // Update currently open modal
        document.body.style.top = `-${this.scrollPosition}px`;
        document.body.classList.add('modal-open');
+
+        modal.restoreFocusTo = null;
+        if (this._isDeleteConfirmModal(modal.element)) {
+            const activeElement = document.activeElement;
+            modal.restoreFocusTo = activeElement && activeElement !== document.body
+                ? activeElement
+                : null;
+            modal.element.querySelector('.cancel-btn')?.focus();
+        }
+    }
+
+    // Several non-delete modals share the delete-modal styling class, so an
+    // actual .delete-btn is required before focus is moved to Cancel.
+    _isDeleteConfirmModal(element) {
+        return element.classList.contains('delete-modal') &&
+            Boolean(element.querySelector('.delete-btn'));
    }

    closeModal(id) {
@@ -463,6 +479,13 @@ export class ModalManager {
            modal.cleanupCallback();
            modal.cleanupCallback = null;
        }
+
+        if (modal.restoreFocusTo) {
+            if (modal.restoreFocusTo.isConnected) {
+                modal.restoreFocusTo.focus();
+            }
+            modal.restoreFocusTo = null;
+        }
    }

    handleEscape(e) {
@@ -1017,11 +1017,8 @@ export class SettingsManager {
            displayDensitySelect.value = state.global.settings.display_density || 'default';
        }

-        // Set recipes layout setting
-        const recipesLayoutSelect = document.getElementById('recipesLayout');
-        if (recipesLayoutSelect) {
-            recipesLayoutSelect.value = state.global.settings.recipes_layout || 'grid';
-        }
+        // Set recipes layout setting (segmented control active state)
+        this.updateRecipesLayoutControls(state.global.settings.recipes_layout || 'grid');

        // Set card info display setting
        const cardInfoDisplaySelect = document.getElementById('cardInfoDisplay');
@@ -1064,6 +1061,12 @@ export class SettingsManager {
            hideEarlyAccessUpdatesCheckbox.checked = state.global.settings.hide_early_access_updates || false;
        }

+        // Set hide paid updates setting
+        const hidePaidUpdatesCheckbox = document.getElementById('hidePaidUpdates');
+        if (hidePaidUpdatesCheckbox) {
+            hidePaidUpdatesCheckbox.checked = state.global.settings.hide_paid_updates || false;
+        }
+
        const skipPreviouslyDownloadedModelVersionsCheckbox = document.getElementById('skipPreviouslyDownloadedModelVersions');
        if (skipPreviouslyDownloadedModelVersionsCheckbox) {
            skipPreviouslyDownloadedModelVersionsCheckbox.checked =
@@ -2288,19 +2291,18 @@ export class SettingsManager {
            : element.value;

        try {
+            // Recipes layout has its own shared entry point used by both the
+            // settings modal segmented control and the recipes page toolbar toggle
+            if (settingKey === 'recipes_layout') {
+                return this.saveRecipesLayout(element.value);
+            }
+
            // Update frontend state with mapped keys
            await this.saveSetting(settingKey, value);

            // Apply frontend settings immediately
            this.applyFrontendSettings();

-            // Dispatch layout change event; the scroller instance is about to be rebuilt,
-            // so calculateLayout() must NOT run on the old instance here
-            if (settingKey === 'recipes_layout') {
-                window.dispatchEvent(new CustomEvent('lm:recipes-layout-changed'));
-                return;
-            }
-
            // Recalculate layout when display density changes
            if (settingKey === 'display_density' && state.virtualScroller) {
                state.virtualScroller.calculateLayout();
@@ -2328,6 +2330,47 @@ export class SettingsManager {
        }
    }

+    /**
+     * Save the recipes page layout (grid | masonry) and rebuild the scroller.
+     * Shared entry point for the settings modal segmented control and the
+     * recipes page toolbar toggle; both stay in sync via
+     * updateRecipesLayoutControls().
+     */
+    async saveRecipesLayout(value) {
+        if (value !== 'grid' && value !== 'masonry') {
+            return;
+        }
+
+        // Update frontend state with mapped keys
+        await this.saveSetting('recipes_layout', value);
+
+        // Apply frontend settings immediately
+        this.applyFrontendSettings();
+
+        // Dispatch layout change event; the scroller instance is about to be rebuilt,
+        // so calculateLayout() must NOT run on the old instance here
+        window.dispatchEvent(new CustomEvent('lm:recipes-layout-changed'));
+
+        this.updateRecipesLayoutControls(value);
+    }
+
+    /**
+     * Sync the active state of every recipes layout control
+     * (settings modal segmented control and recipes page toolbar toggle).
+     */
+    updateRecipesLayoutControls(value) {
+        document.querySelectorAll('[data-recipes-layout]').forEach((control) => {
+            const active = control.dataset.recipesLayout === value;
+            control.classList.toggle('active', active);
+            if (control.hasAttribute('aria-pressed')) {
+                control.setAttribute('aria-pressed', String(active));
+            }
+            if (control.hasAttribute('aria-checked')) {
+                control.setAttribute('aria-checked', String(active));
+            }
+        });
+    }
+
    async saveRangeSetting(elementId, displayId, settingKey) {
        const element = document.getElementById(elementId);
        if (!element) return;
@@ -10,7 +10,7 @@ import { DuplicatesManager } from './components/DuplicatesManager.js';
 import { refreshVirtualScroll, recreateVirtualScroll } from './utils/infiniteScroll.js';
 import { refreshRecipes, RecipeSidebarApiClient } from './api/recipeApi.js';
 import { sidebarManager } from './components/SidebarManager.js';
-import { initSortDropdown } from './components/controls/SortDropdown.js';
+import { initSortDropdown, applySortToSelect, randomizeSortValue } from './components/controls/SortDropdown.js';

 class RecipePageControls {
    constructor() {
@@ -245,10 +245,20 @@ class RecipeManager {
                this.pageState.sortBy = savedSort;
            }
            initSortDropdown(sortSelect);
-            sortSelect.value = this.pageState.sortBy || 'date:desc';
+            applySortToSelect(this.pageState.sortBy || 'date:desc');
            sortSelect.addEventListener('change', () => {
-                this.pageState.sortBy = sortSelect.value;
-                setStorageItem('recipes_sort', sortSelect.value);
+                let value = sortSelect.value;
+                if (value.startsWith('random')) {
+                    // Every pick of Random reshuffles the list: generate a
+                    // fresh seed so the backend keeps a stable order across
+                    // paginated requests.
+                    value = randomizeSortValue();
+                }
+                this.pageState.sortBy = value;
+                setStorageItem('recipes_sort', value);
+                // Reset the seeded Random option when switching away from
+                // Random, or re-apply the fresh seed when picking it again.
+                applySortToSelect(value);
                refreshVirtualScroll();
            });
        }
@@ -272,6 +282,30 @@ class RecipeManager {
            });
        }

+        // Layout toggle (grid / masonry) — shares the recipes_layout setting with
+        // the settings modal segmented control; active states stay in sync via
+        // settingsManager.updateRecipesLayoutControls() after each save
+        const layoutToggleBtns = document.querySelectorAll('.layout-toggle-btn');
+        if (layoutToggleBtns.length) {
+            const currentLayout = state.global.settings?.recipes_layout || 'grid';
+            layoutToggleBtns.forEach((btn) => {
+                const isActive = btn.dataset.recipesLayout === currentLayout;
+                btn.classList.toggle('active', isActive);
+                btn.setAttribute('aria-pressed', String(isActive));
+                btn.addEventListener('click', async () => {
+                    const layout = btn.dataset.recipesLayout;
+                    if ((state.global.settings?.recipes_layout || 'grid') === layout) {
+                        return;
+                    }
+                    try {
+                        await window.settingsManager?.saveRecipesLayout(layout);
+                    } catch (error) {
+                        console.error('Failed to switch recipes layout:', error);
+                    }
+                });
+            });
+        }
+
        // Rebuild the scroller on layout switch; in duplicates mode defer until
        // exitDuplicateMode re-enables the scroller (direct recreation would dispose
        // the old instance while initializeVirtualScroll skips duplicates mode)
@@ -49,6 +49,7 @@ const DEFAULT_SETTINGS_BASE = Object.freeze({
    priority_tags: { ...DEFAULT_PRIORITY_TAG_CONFIG },
    version_grouping: 'same_base',
    hide_early_access_updates: false,
+    hide_paid_updates: false,
    auto_organize_exclusions: [],
    metadata_refresh_skip_paths: [],
    skip_previously_downloaded_model_versions: false,
@@ -646,10 +646,17 @@ export class MasonryScroller {
            const pageType = state.currentPageType;

            if (pageType === 'recipes') {
-                placeholderText = `
-                    <p>No recipes found</p>
-                    <p>Add recipe images to your recipes folder to see them here.</p>
-                `;
+                if (String(getCurrentPageState().sortBy).startsWith('opened')) {
+                    placeholderText = `
+                        <p>No recently opened recipes</p>
+                        <p>Recipes you open will appear here.</p>
+                    `;
+                } else {
+                    placeholderText = `
+                        <p>No recipes found</p>
+                        <p>Add recipe images to your recipes folder to see them here.</p>
+                    `;
+                }
            } else if (pageType === 'loras') {
                placeholderText = `
                    <p>No LoRAs found</p>
@@ -699,10 +699,17 @@ export class VirtualScroller {
            const pageType = state.currentPageType;

            if (pageType === 'recipes') {
-                placeholderText = `
-                    <p>No recipes found</p>
-                    <p>Add recipe images to your recipes folder to see them here.</p>
-                `;
+                if (String(getCurrentPageState().sortBy).startsWith('opened')) {
+                    placeholderText = `
+                        <p>No recently opened recipes</p>
+                        <p>Recipes you open will appear here.</p>
+                    `;
+                } else {
+                    placeholderText = `
+                        <p>No recipes found</p>
+                        <p>Add recipe images to your recipes folder to see them here.</p>
+                    `;
+                }
            } else if (pageType === 'loras') {
                placeholderText = `
                    <p>No LoRAs found</p>
@@ -1,37 +1,59 @@
 import { modalManager } from '../managers/ModalManager.js';
-import { getModelApiClient } from '../api/modelApiFactory.js';
+import { getModelApiClient, resetAndReload } from '../api/modelApiFactory.js';
+import { showActionToast } from './uiHelpers.js';
+import { translate } from './i18nHelpers.js';
+import { handleUndoDelete } from './undoHelpers.js';
+import { formatFileSize } from '../components/shared/utils.js';

 let pendingDeletePath = null;
+let pendingDeleteName = null;
 let pendingExcludePath = null;

 export function showDeleteModal(filePath) {
    pendingDeletePath = filePath;
-    
+
    const escapedPath = window.CSS && typeof window.CSS.escape === 'function'
        ? window.CSS.escape(filePath)
        : filePath.replace(/["\\]/g, '\\$&');
    const card = document.querySelector(`.model-card[data-filepath="${escapedPath}"]`);
    const modelName = card ? card.dataset.name : filePath.split('/').pop();
+    pendingDeleteName = modelName;
    const modal = modalManager.getModal('deleteModal').element;
    const modelInfo = modal.querySelector('.delete-model-info');
-    
+
+    const fileSize = card?.dataset.file_size;
+    const sizeLine = fileSize
+        ? `<br>${translate('modals.deleteModel.freesSpace', { size: formatFileSize(parseInt(fileSize, 10)) })}`
+        : '';
+
    modelInfo.innerHTML = `
        <strong>Model:</strong> ${modelName}
        <br>
        <strong>File:</strong> ${filePath}
+        <br>
+        ${translate('modals.deleteModel.recoverableWarning')}${sizeLine}
    `;
-    
+
    modalManager.showModal('deleteModal');
 }

 export async function confirmDelete() {
    if (!pendingDeletePath) return;
-    
+
    try {
-        await getModelApiClient().deleteModel(pendingDeletePath);
-        
+        const modelName = pendingDeleteName;
+        const result = await getModelApiClient().deleteModel(pendingDeletePath);
+
        closeDeleteModal();

+        if (result?.batch_id) {
+            const batchId = result.batch_id;
+            showActionToast('toast.undo.deleted', { name: modelName }, 'success', {
+                actionText: translate('toast.undo.action'),
+                onAction: () => handleUndoDelete(batchId, () => resetAndReload(true)),
+            });
+        }
+
        if (window.modelDuplicatesManager) {
            window.modelDuplicatesManager.updateDuplicatesBadgeAfterRefresh();
        }
@@ -44,6 +66,7 @@ export async function confirmDelete() {
 export function closeDeleteModal() {
    modalManager.closeModal('deleteModal');
    pendingDeletePath = null;
+    pendingDeleteName = null;
 }

 // Functions for the exclude modal
@@ -0,0 +1,15 @@
+// CivitAI ModelFile.type values eligible as the main download file.
+// Mirrors the backend constant MODEL_WEIGHT_FILE_TYPES (py/utils/constants.py).
+// Keep both lists in sync when CivitAI introduces new file types.
+export const MODEL_WEIGHT_FILE_TYPES = [
+    'Model',
+    'Pruned Model',
+    'Negative',
+    'UNet',
+    'Diffusion Model',
+    'Enhancement LoRA',
+];
+
+export function isModelWeightFile(type) {
+    return MODEL_WEIGHT_FILE_TYPES.includes(type);
+}
@@ -133,15 +133,28 @@ export async function copyToClipboard(text, successMessage = null) {
  }
 }

-export function showToast(key, params = {}, type = 'info', fallback = null) {
-  // Plain messages (contain spaces) are not i18n dot-notation keys — use verbatim
-  // to avoid spurious "Translation key not found" warnings from i18next
-  const isPlainMessage = typeof key === 'string' && /\s/.test(key);
-  const message = isPlainMessage ? key : translate(key, params, fallback);
+/**
+ * Build a toast element (internal — not exported).
+ * @param {string} message - Already-resolved message text
+ * @param {string} type - Toast type (info/success/warning/error)
+ * @returns {HTMLElement} The toast element (not yet attached to the DOM)
+ */
+function createToastElement(message, type) {
  const toast = document.createElement('div');
  toast.className = `toast toast-${type}`;
  toast.textContent = message;
+  return toast;
+}

+/**
+ * Attach a toast to the shared container, position it, and schedule its
+ * dismissal (internal — not exported).
+ * @param {HTMLElement} toast - The toast element to display
+ * @param {number} durationMs - How long the toast stays visible
+ * @param {Function} [onDismiss] - Optional callback fired once when dismissal begins
+ * @returns {Function} Manual dismiss function (idempotent)
+ */
+function appendToast(toast, durationMs, onDismiss = null) {
  // Get or create toast container
  let toastContainer = document.querySelector('.toast-container');
  if (!toastContainer) {
@@ -161,35 +174,141 @@ export function showToast(key, params = {}, type = 'info', fallback = null) {
  // Set position based on existing toasts
  toast.style.top = `${topOffset + (toastIndex * (toast.offsetHeight || 60 + spacing))}px`;

-  requestAnimationFrame(() => {
-    toast.classList.add('show');
+  let dismissed = false;
+  const dismiss = () => {
+    if (dismissed) return;
+    dismissed = true;

-    // Set timeout based on type
-    let timeout = 2000; // Default (info)
-    if (type === 'warning' || type === 'error') {
-      timeout = 5000;
+    if (typeof onDismiss === 'function') {
+      onDismiss();
    }

-    setTimeout(() => {
-      toast.classList.remove('show');
-      toast.addEventListener('transitionend', () => {
-        toast.remove();
+    toast.classList.remove('show');
+    toast.addEventListener('transitionend', () => {
+      toast.remove();

-        // Reposition remaining toasts
-        if (toastContainer) {
-          const remainingToasts = Array.from(toastContainer.querySelectorAll('.toast'));
-          remainingToasts.forEach((t, index) => {
-            t.style.top = `${topOffset + (index * (t.offsetHeight || 60 + spacing))}px`;
-          });
+      // Reposition remaining toasts
+      if (toastContainer) {
+        const remainingToasts = Array.from(toastContainer.querySelectorAll('.toast'));
+        remainingToasts.forEach((t, index) => {
+          t.style.top = `${topOffset + (index * (t.offsetHeight || 60 + spacing))}px`;
+        });

-          // Remove container if empty
-          if (remainingToasts.length === 0) {
-            toastContainer.remove();
-          }
+        // Remove container if empty
+        if (remainingToasts.length === 0) {
+          toastContainer.remove();
        }
-      });
-    }, timeout);
+      }
+    });
+  };
+
+  requestAnimationFrame(() => {
+    toast.classList.add('show');
+    setTimeout(dismiss, durationMs);
  });
+
+  return dismiss;
+}
+
+export function showToast(key, params = {}, type = 'info', fallback = null) {
+  // Plain messages (contain spaces) are not i18n dot-notation keys — use verbatim
+  // to avoid spurious "Translation key not found" warnings from i18next
+  const isPlainMessage = typeof key === 'string' && /\s/.test(key);
+  const message = isPlainMessage ? key : translate(key, params, fallback);
+  const toast = createToastElement(message, type);
+
+  // Set timeout based on type
+  let duration = 2000; // Default (info)
+  if (type === 'warning' || type === 'error') {
+    duration = 5000;
+  }
+
+  appendToast(toast, duration);
+}
+
+/**
+ * Show a toast with an action button (e.g. Undo) and an optional countdown.
+ * The message accepts the same key/plain-string contract as showToast, so
+ * callers may pass either an i18n key or an already-translated string.
+ * @param {string} key - i18n key or plain message
+ * @param {Object} [params] - i18n interpolation params
+ * @param {string} [type] - Toast type (info/success/warning/error)
+ * @param {Object} [options]
+ * @param {string} [options.actionText] - Label for the action button (button omitted when empty)
+ * @param {Function} [options.onAction] - Callback invoked at most once on button click
+ * @param {number} [options.durationMs=20000] - How long the toast stays visible
+ * @param {boolean} [options.countdown=true] - Show a ticking `(N)s` countdown
+ */
+export function showActionToast(key, params = {}, type = 'info', options = {}) {
+  const { actionText, onAction, durationMs = 20000, countdown = true } = options;
+
+  const isPlainMessage = typeof key === 'string' && /\s/.test(key);
+  const message = isPlainMessage ? key : translate(key, params);
+  const toast = createToastElement(message, type);
+
+  let countdownInterval = null;
+  const clearCountdown = () => {
+    if (countdownInterval !== null) {
+      clearInterval(countdownInterval);
+      countdownInterval = null;
+    }
+  };
+
+  // The interval must be cleared on EVERY dismiss path (timeout, countdown end,
+  // manual button click) — the onDismiss hook covers the appendToast timeout path.
+  const dismiss = appendToast(toast, durationMs, clearCountdown);
+
+  let actionFired = false;
+  if (actionText) {
+    const button = document.createElement('button');
+    button.type = 'button';
+    button.className = 'toast-action-btn';
+    button.textContent = actionText;
+    button.addEventListener('click', (event) => {
+      event.preventDefault();
+      // Guard against double-click firing the action twice
+      if (actionFired) return;
+      actionFired = true;
+
+      clearCountdown();
+      if (typeof onAction === 'function') {
+        onAction();
+      }
+      dismiss();
+    });
+    toast.append(button);
+  }
+
+  if (countdown) {
+    const countdownEl = document.createElement('span');
+    countdownEl.className = 'toast-countdown';
+    let remainingSeconds = Math.max(0, Math.ceil(durationMs / 1000));
+    countdownEl.textContent = `(${remainingSeconds}s)`;
+    toast.append(countdownEl);
+
+    countdownInterval = setInterval(() => {
+      remainingSeconds -= 1;
+      countdownEl.textContent = `(${Math.max(remainingSeconds, 0)}s)`;
+      if (remainingSeconds <= 0) {
+        clearCountdown();
+        dismiss();
+      }
+    }, 1000);
+  }
+
+  // Manual close button: hides the toast early without firing onAction. The
+  // backend undo window keeps running and the batch is purged when it expires.
+  const closeBtn = document.createElement('button');
+  closeBtn.type = 'button';
+  closeBtn.className = 'toast-close-btn';
+  closeBtn.textContent = '×';
+  closeBtn.setAttribute('aria-label', translate('common.actions.close'));
+  closeBtn.addEventListener('click', (event) => {
+    event.preventDefault();
+    clearCountdown();
+    dismiss();
+  });
+  toast.append(closeBtn);
 }

 export function restoreFolderFilter() {
@@ -987,6 +1106,9 @@ export async function sendEmbeddingToWorkflow(embeddingCode, onComplete = null)
    if (!isNodeEnabled(node)) {
      return false;
    }
+    if (node.capabilities?.text_widget_connected === true) {
+      return false;
+    }
    return (
      node.capabilities?.has_text_widget === true ||
      node.marker_role === "send_prompt_target"
@@ -995,7 +1117,15 @@ export async function sendEmbeddingToWorkflow(embeddingCode, onComplete = null)

  const nodeKeys = Object.keys(textNodes);
  if (nodeKeys.length === 0) {
-    showToast('uiHelpers.workflow.noMatchingNodes', {}, 'warning');
+    showToast(
+      translate(
+        'uiHelpers.workflow.noPromptTargets',
+        {},
+        'No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target'
+      ),
+      {},
+      'warning'
+    );
    return false;
  }

@@ -1047,6 +1177,11 @@ export async function sendPromptToWorkflow(promptText, options = {}) {
    if (!isNodeEnabled(node)) {
      return false;
    }
+    // A node whose text widget is backed by a connected input cannot have its
+    // text changed via the widget — execution reads the linked input.
+    if (node.capabilities?.text_widget_connected === true) {
+      return false;
+    }
    return (
      node.capabilities?.has_text_widget === true ||
      node.marker_role === "send_prompt_target"
@@ -1055,7 +1190,12 @@ export async function sendPromptToWorkflow(promptText, options = {}) {

  const nodeKeys = Object.keys(textNodes);
  if (nodeKeys.length === 0) {
-    showToast(options.missingNodesMessage || 'uiHelpers.workflow.noMatchingNodes', {}, 'warning');
+    const defaultHint = translate(
+      'uiHelpers.workflow.noPromptTargets',
+      {},
+      'No compatible prompt targets in the workflow.\nRight-click a node in ComfyUI → Mark as → Send Prompt Target'
+    );
+    showToast(options.missingNodesMessage || defaultHint, {}, 'warning');
    return false;
  }

@@ -0,0 +1,55 @@
+import { showToast } from './uiHelpers.js';
+
+/**
+ * Undo a staged delete batch via the pending-delete endpoint.
+ * @param {string} batchId - The batch id returned by a staged delete response
+ * @param {Function|null} refreshFn - Called once after a successful restore (unless options.refresh is false)
+ * @param {Object} [options]
+ * @param {boolean} [options.showToast=true] - Suppress toasts (used by sequential multi-batch undo loops)
+ * @param {boolean} [options.refresh=true] - Suppress the refresh call (used by sequential multi-batch undo loops)
+ * @returns {Promise<boolean>} Whether the undo succeeded
+ */
+export async function handleUndoDelete(batchId, refreshFn, options = {}) {
+  const { showToast: showToastEnabled = true, refresh: refreshEnabled = true } = options;
+
+  try {
+    const response = await fetch('/api/lm/undo-delete', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ batch_id: batchId }),
+    });
+
+    if (response.ok) {
+      if (refreshEnabled && typeof refreshFn === 'function') {
+        refreshFn();
+      }
+      if (showToastEnabled) {
+        showToast('toast.undo.restored', {}, 'success');
+      }
+      return true;
+    }
+
+    // Read the error body to distinguish an expired batch from other failures
+    let errorMessage = '';
+    try {
+      const body = await response.json();
+      errorMessage = body?.error || '';
+    } catch {
+      errorMessage = '';
+    }
+
+    if (showToastEnabled) {
+      if (response.status === 404 && errorMessage.toLowerCase().includes('expired')) {
+        showToast('toast.undo.expired', {}, 'error');
+      } else {
+        showToast('toast.undo.failed', { error: errorMessage || response.statusText }, 'error');
+      }
+    }
+    return false;
+  } catch (error) {
+    if (showToastEnabled) {
+      showToast('toast.undo.failed', { error: error.message }, 'error');
+    }
+    return false;
+  }
+}
@@ -95,7 +95,10 @@
            <i class="fas fa-bell"></i> <span>{{ t('loras.bulkOperations.checkUpdates') }}</span>
        </div>
        <div class="context-menu-item" data-action="repair-metadata">
-            <i class="fas fa-tools"></i> <span>{{ t('loras.bulkOperations.repairMetadata') }}</span>
+            <i class="fas fa-tools"></i> <span>{{ t('loras.bulkOperations.repairMetadata') }}</span> (Deprecated)
+        </div>
+        <div class="context-menu-item" data-action="rematch-metadata">
+            <i class="fas fa-link"></i> <span>{{ t('loras.bulkOperations.rematchMetadata') }}</span>
        </div>
        <div class="context-menu-item" data-action="reimport-metadata">
            <i class="fas fa-undo-alt"></i> <span>{{ t('loras.bulkOperations.reimportMetadata') }}</span>
@@ -200,7 +203,10 @@
        <i class="fas fa-check check-indicator" style="margin-left:auto;display:none"></i>
    </div>
    <div class="context-menu-item" data-action="repair-recipes">
-        <i class="fas fa-tools"></i> <span>{{ t('globalContextMenu.repairRecipes.label') }}</span>
+        <i class="fas fa-tools"></i> <span>{{ t('globalContextMenu.repairRecipes.label') }}</span> (Deprecated)
+    </div>
+    <div class="context-menu-item" data-action="rematch-recipes">
+        <i class="fas fa-link"></i> <span>{{ t('globalContextMenu.rematchRecipes.label') }}</span>
    </div>
 </div>

@@ -48,17 +48,20 @@
                            <option value="versions_count:asc">{{ t('loras.controls.sort.versionsCountAsc', default='Fewest versions first') }}</option>
                        </optgroup>
                    {% endif %}
-                    {% if page_id != 'recipes' %}
-                        <optgroup label="{{ t('loras.controls.sort.random', default='Random') }}">
-                            <option value="random">{{ t('loras.controls.sort.randomAction', default='Randomize (shuffle)') }}</option>
-                        </optgroup>
-                    {% endif %}
                    {% if page_id == 'recipes' %}
                        <optgroup label="{{ t('recipes.controls.sort.lorasCount') }}">
                            <option value="loras_count:desc">{{ t('recipes.controls.sort.lorasCountDesc') }}</option>
                            <option value="loras_count:asc">{{ t('recipes.controls.sort.lorasCountAsc') }}</option>
                        </optgroup>
                    {% endif %}
+                    {% if page_id == 'recipes' %}
+                        <optgroup label="{{ t('recipes.controls.sort.opened', default='Recently Opened') }}">
+                            <option value="opened:desc">{{ t('recipes.controls.sort.openedDesc', default='Recently opened') }}</option>
+                        </optgroup>
+                    {% endif %}
+                    <optgroup label="{{ t('loras.controls.sort.random', default='Random') }}">
+                        <option value="random">{{ t('loras.controls.sort.randomAction', default='Randomize (shuffle)') }}</option>
+                    </optgroup>
                </select>
            </div>
            <div title="{% if page_id == 'recipes' %}{{ t('recipes.controls.refresh.title') }}{% else %}{{ t('loras.controls.refresh.title') }}{% endif %}" class="control-group dropdown-group">
@@ -131,6 +134,16 @@
        </div>
        
        <div class="controls-right">
+            {% if page_id == 'recipes' %}
+            <div class="control-group layout-toggle-group" role="group" aria-label="{{ t('recipes.controls.layout.title') }}" title="{{ t('recipes.controls.layout.title') }}">
+                <button type="button" class="layout-toggle-btn" data-recipes-layout="grid" aria-pressed="false" title="{{ t('recipes.controls.layout.grid') }}" aria-label="{{ t('recipes.controls.layout.grid') }}">
+                    <i class="fas fa-th-large" aria-hidden="true"></i>
+                </button>
+                <button type="button" class="layout-toggle-btn" data-recipes-layout="masonry" aria-pressed="false" title="{{ t('recipes.controls.layout.masonry') }}" aria-label="{{ t('recipes.controls.layout.masonry') }}">
+                    <i class="fas fa-columns" aria-hidden="true"></i>
+                </button>
+            </div>
+            {% endif %}
            <div class="control-group doctor-control-group">
                <button id="doctorTriggerBtn" class="doctor-trigger" title="{{ t('doctor.buttonTitle', default='Run diagnostics and common fixes') }}">
                    <i class="fas fa-stethoscope"></i>
@@ -629,16 +629,22 @@
                            <div class="setting-item">
                                <div class="setting-row">
                                    <div class="setting-info">
-                                        <label for="recipesLayout">
+                                        <label id="recipesLayoutLabel">
                                        {{ t('settings.layoutSettings.recipesLayout') }}
                                        <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.layoutSettings.recipesLayoutHelp') }}"></i>
                                    </label>
                                    </div>
-                                    <div class="setting-control select-control">
-                                        <select id="recipesLayout" onchange="settingsManager.saveSelectSetting('recipesLayout', 'recipes_layout')">
-                                            <option value="grid">{{ t('settings.layoutSettings.recipesLayoutOptions.grid') }}</option>
-                                            <option value="masonry">{{ t('settings.layoutSettings.recipesLayoutOptions.masonry') }}</option>
-                                        </select>
+                                    <div class="setting-control layout-options-control">
+                                        <div id="recipesLayoutOptions" class="layout-options" role="radiogroup" aria-label="{{ t('settings.layoutSettings.recipesLayout') }}" aria-labelledby="recipesLayoutLabel">
+                                            <button type="button" class="layout-option" data-recipes-layout="grid" onclick="settingsManager.saveRecipesLayout('grid')" role="radio" aria-checked="true">
+                                                <span class="layout-option-preview layout-preview-grid" aria-hidden="true"><span></span><span></span><span></span><span></span></span>
+                                                <span class="layout-option-label">{{ t('settings.layoutSettings.recipesLayoutOptions.grid') }}</span>
+                                            </button>
+                                            <button type="button" class="layout-option" data-recipes-layout="masonry" onclick="settingsManager.saveRecipesLayout('masonry')" role="radio" aria-checked="false">
+                                                <span class="layout-option-preview layout-preview-masonry" aria-hidden="true"><span></span><span></span><span></span></span>
+                                                <span class="layout-option-label">{{ t('settings.layoutSettings.recipesLayoutOptions.masonry') }}</span>
+                                            </button>
+                                        </div>
                                    </div>
                                </div>
                            </div>
@@ -1263,6 +1269,24 @@
                                    </div>
                                </div>
                            </div>
+
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label for="hidePaidUpdates">
+                                        {{ t('settings.hidePaidUpdates.label') }}
+                                        <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.hidePaidUpdates.help') }}"></i>
+                                    </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <label class="toggle-switch">
+                                            <input type="checkbox" id="hidePaidUpdates"
+                                                   onchange="settingsManager.saveToggleSetting('hidePaidUpdates', 'hide_paid_updates')">
+                                            <span class="toggle-slider"></span>
+                                        </label>
+                                    </div>
+                                </div>
+                            </div>
                        </div>
                        
                        <!-- Example Images -->
@@ -19,7 +19,10 @@
    <!-- <div class="context-menu-item" data-action="details"><i class="fas fa-info-circle"></i> View Details</div> -->
    <!-- Metadata -->
    <div class="context-menu-item" data-action="repair">
-        <i class="fas fa-tools"></i> {{ t('loras.contextMenu.repairMetadata') }}
+        <i class="fas fa-tools"></i> {{ t('loras.contextMenu.repairMetadata') }} (Deprecated)
+    </div>
+    <div class="context-menu-item" data-action="rematch">
+        <i class="fas fa-link"></i> {{ t('loras.contextMenu.rematchMetadata') }}
    </div>
    <div class="context-menu-item" data-action="reimport">
        <i class="fas fa-undo-alt"></i> {{ t('loras.contextMenu.reimportMetadata') }}
@@ -71,7 +74,16 @@
    <div class="banner-content">
        <i class="fas fa-exclamation-triangle"></i>
        <span id="duplicatesCount">{{ t('recipes.duplicates.found', count=0) }}</span>
+        <span id="duplicatesBasis" class="duplicates-basis"></span>
+        <i class="fas fa-question-circle help-icon" id="duplicatesHelp" aria-label="{{ t('common.actions.help') }}"></i>
        <div class="banner-actions">
+            <div class="setting-contro" id="promptMatchControl">
+                <span>{{ t('recipes.duplicates.includePromptLabel') }}:</span>
+                <label class="toggle-switch">
+                    <input type="checkbox" id="promptMatchInput">
+                    <span class="toggle-slider"></span>
+                </label>
+            </div>
            <button class="btn-select-latest" onclick="recipeManager.selectLatestDuplicates()">
                {{ t('recipes.duplicates.keepLatest') }}
            </button>
@@ -83,6 +95,9 @@
            </button>
        </div>
    </div>
+    <div class="help-tooltip" id="duplicatesHelpTooltip">
+        <p id="duplicatesHelpText"></p>
+    </div>
 </div>

 {% include 'components/folder_sidebar.html' %}
@@ -0,0 +1,201 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+
+const {
+  BASE_MODEL_API_MODULE,
+  STATE_MODULE,
+  UI_HELPERS_MODULE,
+  I18N_MODULE,
+  STORAGE_MODULE,
+  API_CONFIG_MODULE,
+  API_FACTORY_MODULE,
+  SIDEBAR_MANAGER_MODULE,
+} = vi.hoisted(() => ({
+  BASE_MODEL_API_MODULE: new URL('../../../static/js/api/baseModelApi.js', import.meta.url).pathname,
+  STATE_MODULE: new URL('../../../static/js/state/index.js', import.meta.url).pathname,
+  UI_HELPERS_MODULE: new URL('../../../static/js/utils/uiHelpers.js', import.meta.url).pathname,
+  I18N_MODULE: new URL('../../../static/js/utils/i18nHelpers.js', import.meta.url).pathname,
+  STORAGE_MODULE: new URL('../../../static/js/utils/storageHelpers.js', import.meta.url).pathname,
+  API_CONFIG_MODULE: new URL('../../../static/js/api/apiConfig.js', import.meta.url).pathname,
+  API_FACTORY_MODULE: new URL('../../../static/js/api/modelApiFactory.js', import.meta.url).pathname,
+  SIDEBAR_MANAGER_MODULE: new URL('../../../static/js/components/SidebarManager.js', import.meta.url).pathname,
+}));
+
+const showToastMock = vi.fn();
+const showSimpleLoadingMock = vi.fn();
+const showCancelButtonMock = vi.fn();
+const hideLoadingMock = vi.fn();
+
+vi.mock(STATE_MODULE, () => ({
+  state: {
+    loadingManager: {
+      showSimpleLoading: showSimpleLoadingMock,
+      showCancelButton: showCancelButtonMock,
+      hide: hideLoadingMock,
+    },
+    virtualScroller: {
+      removeItemByFilePath: vi.fn(),
+    },
+  },
+  getCurrentPageState: vi.fn(() => ({})),
+}));
+
+vi.mock(UI_HELPERS_MODULE, () => ({
+  showToast: showToastMock,
+}));
+
+vi.mock(I18N_MODULE, () => ({
+  translate: vi.fn((key) => key),
+}));
+
+vi.mock(STORAGE_MODULE, () => ({
+  getStorageItem: vi.fn(),
+  getSessionItem: vi.fn(),
+  removeSessionItem: vi.fn(),
+  saveMapToStorage: vi.fn(),
+}));
+
+vi.mock(API_CONFIG_MODULE, () => ({
+  getCompleteApiConfig: vi.fn(() => ({
+    endpoints: { bulkDelete: '/api/lm/loras/bulk-delete' },
+    config: { displayName: 'LoRA', singularName: 'LoRA' },
+  })),
+  getCurrentModelType: vi.fn(() => 'loras'),
+  isValidModelType: vi.fn(() => true),
+  DOWNLOAD_ENDPOINTS: {},
+  HF_ENDPOINTS: {},
+  WS_ENDPOINTS: {},
+}));
+
+vi.mock(API_FACTORY_MODULE, () => ({
+  resetAndReload: vi.fn(),
+}));
+
+vi.mock(SIDEBAR_MANAGER_MODULE, () => ({
+  sidebarManager: { refresh: vi.fn() },
+}));
+
+describe('BaseModelApiClient.bulkDeleteModels undo contract', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  async function createClient() {
+    const { BaseModelApiClient } = await import(BASE_MODEL_API_MODULE);
+    class TestClient extends BaseModelApiClient {}
+    return new TestClient('loras');
+  }
+
+  function mockBulkDeleteResponse(payload) {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => payload,
+    });
+  }
+
+  it('posts the file paths and defaults both batch fields to null', async () => {
+    mockBulkDeleteResponse({
+      success: true,
+      status: 'success',
+      total_deleted: 3,
+      total_attempted: 3,
+      cache_updated: true,
+      results: [],
+    });
+
+    const client = await createClient();
+    const result = await client.bulkDeleteModels(['/models/a.safetensors', '/models/b.safetensors']);
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      '/api/lm/loras/bulk-delete',
+      expect.objectContaining({ method: 'POST' })
+    );
+    expect(result).toEqual({
+      success: true,
+      deleted_count: 3,
+      failed_count: 0,
+      errors: [],
+      batch_id: null,
+      batch_ids: null,
+    });
+    expect(hideLoadingMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('passes through the merged batch_id when the backend staged the bulk delete', async () => {
+    mockBulkDeleteResponse({
+      success: true,
+      status: 'success',
+      total_deleted: 2,
+      total_attempted: 2,
+      cache_updated: true,
+      results: [],
+      batch_id: 'merged-batch-1',
+    });
+
+    const client = await createClient();
+    const result = await client.bulkDeleteModels(['/models/a.safetensors', '/models/b.safetensors']);
+
+    expect(result.batch_id).toBe('merged-batch-1');
+    expect(result.batch_ids).toBeNull();
+  });
+
+  it('passes through the batch_ids fallback array when the merge failed', async () => {
+    mockBulkDeleteResponse({
+      success: true,
+      status: 'success',
+      total_deleted: 2,
+      total_attempted: 2,
+      cache_updated: true,
+      results: [],
+      batch_ids: ['batch-1', 'batch-2'],
+    });
+
+    const client = await createClient();
+    const result = await client.bulkDeleteModels(['/models/a.safetensors', '/models/b.safetensors']);
+
+    expect(result.batch_id).toBeNull();
+    expect(result.batch_ids).toEqual(['batch-1', 'batch-2']);
+  });
+
+  it('keeps the batch field on the cancelled-status path (staged subset is undoable)', async () => {
+    mockBulkDeleteResponse({
+      success: true,
+      status: 'cancelled',
+      total_deleted: 1,
+      total_attempted: 2,
+      cache_updated: true,
+      results: [],
+      batch_id: 'partial-batch',
+    });
+
+    const client = await createClient();
+    const result = await client.bulkDeleteModels(['/models/a.safetensors', '/models/b.safetensors']);
+
+    expect(result.success).toBe(true);
+    expect(result.deleted_count).toBe(1);
+    expect(result.batch_id).toBe('partial-batch');
+    expect(result.batch_ids).toBeNull();
+  });
+
+  it('returns the cancelled marker when the user aborts the fetch', async () => {
+    const abortError = new Error('The user aborted a request.');
+    abortError.name = 'AbortError';
+    global.fetch = vi.fn().mockRejectedValue(abortError);
+
+    const client = await createClient();
+    const result = await client.bulkDeleteModels(['/models/a.safetensors']);
+
+    expect(result).toEqual({ success: false, cancelled: true });
+    expect(hideLoadingMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('throws the backend error message when the bulk delete fails', async () => {
+    mockBulkDeleteResponse({ success: false, error: 'disk full' });
+
+    const client = await createClient();
+    await expect(client.bulkDeleteModels(['/models/a.safetensors'])).rejects.toThrow('disk full');
+  });
+});
@@ -0,0 +1,161 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+
+const {
+  BASE_MODEL_API_MODULE,
+  STATE_MODULE,
+  UI_HELPERS_MODULE,
+  I18N_MODULE,
+  STORAGE_MODULE,
+  API_CONFIG_MODULE,
+  API_FACTORY_MODULE,
+  SIDEBAR_MANAGER_MODULE,
+} = vi.hoisted(() => ({
+  BASE_MODEL_API_MODULE: new URL('../../../static/js/api/baseModelApi.js', import.meta.url).pathname,
+  STATE_MODULE: new URL('../../../static/js/state/index.js', import.meta.url).pathname,
+  UI_HELPERS_MODULE: new URL('../../../static/js/utils/uiHelpers.js', import.meta.url).pathname,
+  I18N_MODULE: new URL('../../../static/js/utils/i18nHelpers.js', import.meta.url).pathname,
+  STORAGE_MODULE: new URL('../../../static/js/utils/storageHelpers.js', import.meta.url).pathname,
+  API_CONFIG_MODULE: new URL('../../../static/js/api/apiConfig.js', import.meta.url).pathname,
+  API_FACTORY_MODULE: new URL('../../../static/js/api/modelApiFactory.js', import.meta.url).pathname,
+  SIDEBAR_MANAGER_MODULE: new URL('../../../static/js/components/SidebarManager.js', import.meta.url).pathname,
+}));
+
+const showToastMock = vi.fn();
+const removeItemByFilePathMock = vi.fn();
+const showSimpleLoadingMock = vi.fn();
+const hideLoadingMock = vi.fn();
+
+vi.mock(STATE_MODULE, () => ({
+  state: {
+    loadingManager: {
+      showSimpleLoading: showSimpleLoadingMock,
+      hide: hideLoadingMock,
+    },
+    virtualScroller: {
+      removeItemByFilePath: removeItemByFilePathMock,
+    },
+  },
+  getCurrentPageState: vi.fn(() => ({})),
+}));
+
+vi.mock(UI_HELPERS_MODULE, () => ({
+  showToast: showToastMock,
+}));
+
+vi.mock(I18N_MODULE, () => ({
+  translate: vi.fn((key) => key),
+}));
+
+vi.mock(STORAGE_MODULE, () => ({
+  getStorageItem: vi.fn(),
+  getSessionItem: vi.fn(),
+  removeSessionItem: vi.fn(),
+  saveMapToStorage: vi.fn(),
+}));
+
+vi.mock(API_CONFIG_MODULE, () => ({
+  getCompleteApiConfig: vi.fn(() => ({
+    endpoints: { delete: '/api/lm/loras/delete' },
+    config: { displayName: 'LoRA', singularName: 'LoRA' },
+  })),
+  getCurrentModelType: vi.fn(() => 'loras'),
+  isValidModelType: vi.fn(() => true),
+  DOWNLOAD_ENDPOINTS: {},
+  HF_ENDPOINTS: {},
+  WS_ENDPOINTS: {},
+}));
+
+vi.mock(API_FACTORY_MODULE, () => ({
+  resetAndReload: vi.fn(),
+}));
+
+vi.mock(SIDEBAR_MANAGER_MODULE, () => ({
+  sidebarManager: { refresh: vi.fn() },
+}));
+
+describe('BaseModelApiClient.deleteModel undo contract', () => {
+  beforeEach(() => {
+    showToastMock.mockReset();
+    removeItemByFilePathMock.mockReset();
+    showSimpleLoadingMock.mockReset();
+    hideLoadingMock.mockReset();
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  async function createClient() {
+    const { BaseModelApiClient } = await import(BASE_MODEL_API_MODULE);
+    class TestClient extends BaseModelApiClient {}
+    return new TestClient('loras');
+  }
+
+  it('returns the batch id and suppresses the legacy success toast when staged', async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true, deleted_files: [], batch_id: 'batch-42' }),
+    });
+
+    const client = await createClient();
+    const result = await client.deleteModel('/models/foo.safetensors');
+
+    expect(result).toEqual({ success: true, batch_id: 'batch-42' });
+    // The card is still removed from the scroller — the file is gone either way
+    expect(removeItemByFilePathMock).toHaveBeenCalledWith('/models/foo.safetensors');
+    // No legacy toast: the caller shows the undo action toast instead
+    expect(showToastMock).not.toHaveBeenCalledWith(
+      'toast.api.deleteSuccess',
+      expect.anything(),
+      expect.anything()
+    );
+    expect(hideLoadingMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps the legacy success toast when the delete was not staged', async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true, deleted_files: ['/models/foo.safetensors'] }),
+    });
+
+    const client = await createClient();
+    const result = await client.deleteModel('/models/foo.safetensors');
+
+    expect(result).toEqual({ success: true, batch_id: null });
+    expect(removeItemByFilePathMock).toHaveBeenCalledWith('/models/foo.safetensors');
+    expect(showToastMock).toHaveBeenCalledWith('toast.api.deleteSuccess', { type: 'LoRA' }, 'success');
+  });
+
+  it('returns a truthy result so undo-blind callers keep working (ModelVersionsTab)', async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: true, deleted_files: [], batch_id: 'batch-7' }),
+    });
+
+    const client = await createClient();
+    const result = await client.deleteModel('/models/v2.safetensors');
+
+    // ModelVersionsTab.js:1136-1144 awaits deleteModel and treats any truthy
+    // result as success — the new object must satisfy that check shape.
+    expect(result).toBeTruthy();
+    expect(Boolean(result && result.success)).toBe(true);
+  });
+
+  it('returns false and shows the failure toast when the server reports failure', async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ success: false, error: 'disk error' }),
+    });
+
+    const client = await createClient();
+    const result = await client.deleteModel('/models/foo.safetensors');
+
+    expect(result).toBe(false);
+    expect(removeItemByFilePathMock).not.toHaveBeenCalled();
+    expect(showToastMock).toHaveBeenCalledWith(
+      'toast.api.deleteFailed',
+      expect.objectContaining({ type: 'LoRA' }),
+      'error'
+    );
+  });
+});
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Will Miao	94dd08646d	chore(release): bump version to v1.2.1	2026-08-16 19:47:15 +08:00
Will Miao	658f88ca48	feat(recipes): add toolbar toggle and settings preview for masonry layout	2026-08-16 15:23:30 +08:00
Will Miao	f53352efb2	feat(metadata): collect generation params from Krea two/three stage samplers	2026-08-16 09:53:08 +08:00
Will Miao	38809a9d1b	feat(recipes): add filename fallback tier to recipe rematch	2026-08-16 09:17:59 +08:00
Will Miao	395682509c	feat(autocomplete): replace /af and /ac toggle abbreviations with full command names	2026-08-15 22:03:54 +08:00
Will Miao	ef3e7d7bf4	feat(update): detect CivitAI paidAccess versions and add hide paid updates (#1060 ) CivitAI's PaidAccess cutover deprecated the availability=EarlyAccess and earlyAccessEndsAt signals; gated versions now report availability=Public with a paidAccess DTO that LoRA Manager previously ignored, so "Hide Early Access Updates" missed paid/early-access models and downloads failed with 401. Parse and persist paidAccess from model-level, bulk, and by-hash responses; treat timed paid gates as early access and permanent paid versions as a distinct is_paid state; add a hide_paid_updates setting with a "Paid" badge in the versions tab; warn before downloading gated versions. Includes SQLite migration, i18n for all locales, and backend/frontend tests.	2026-08-15 18:08:14 +08:00
Will Miao	c85b6b64a1	feat(recipes): add recently opened sort with modal open tracking Track recipe modal opens in a separate stats file (never touching recipe JSON/EXIF), expose a fire-and-forget POST endpoint, and add an 'opened' sort that hides never-opened recipes as a true recently-opened view. Includes i18n for all locales and backend/frontend tests.	2026-08-15 11:37:46 +08:00
Will Miao	34c87d4934	refactor(sort): extract seeded random sort helpers into SortDropdown	2026-08-15 09:53:28 +08:00
Will Miao	93472e5d67	feat(recipes): add sort by random option with seeded stable pagination	2026-08-15 09:50:46 +08:00
Will Miao	ae185ee714	fix(loaders): correct random checkpoint loader return type annotation load_checkpoint returns a 4-tuple (MODEL, CLIP, VAE, model_name) since the random loader exposes the selected model name; the annotation still claimed a 3-tuple.	2026-08-15 08:51:39 +08:00
Martial Michel	795036275a	feat(loaders): add random model selection by base model to checkpoint/unet loaders Add dedicated Random Checkpoint/Unet Loader (LoraManager) nodes that pick a random model from the indexed pool on every run, optionally filtered by base_model, and expose the selected model name via a STRING output.	2026-08-15 08:48:57 +08:00
Will Miao	d43ab6e32f	fix(vue-widgets): make text widget clear button undoable via Ctrl+Z (#1056 )	2026-08-14 23:16:12 +08:00
Will Miao	280181f92e	feat(metadata-overwrite): support wired SAMPLER input on sampler field The sampler field now accepts either a manual string or a SAMPLER connection. When wired, the sampler name is extracted from the KSAMPLER object's sampler_function __name__ (sample_euler -> euler), with special-casing for dpm_fast/dpm_adaptive local closures and uni_pc/uni_pc_bh2 function names. - sampler input declared as "STRING,SAMPLER" with widgetType STRING, mirroring the existing model field union pattern - shared collect_overwrite_params() handles the non-str branch so the node and the metadata extractor conversion logic stay in sync; unrecognized sampler functions are logged and skipped - note: ddim is constructed by ComfyUI as euler with random inpaint, so the ddim name is unrecoverable and extracts as euler	2026-08-14 15:21:28 +08:00
Will Miao	f8d98934ad	feat(ui): set preview via drag and drop on model cards (#1034 )	2026-08-14 13:01:10 +08:00
Will Miao	303cca0d85	fix(download): accept newer CivitAI file types for primary file selection Downloads failed with "No suitable file found in metadata" for models whose only file uses newer CivitAI file types (e.g. 'Enhancement LoRA' for Anima/AIR image-editing LoRAs) because the primary-file allowlist only covered legacy types. - unify the weights-type allowlist as MODEL_WEIGHT_FILE_TYPES (py/utils/constants.py) and apply it across download, recipe and metadata-refresh lookups - mirror CivitAI's getPrimaryFile() semantics: prefer weights-type primary, fall back to weights files, then trust CivitAI's primary flag (excluding non-downloadable artifacts like Config/Archive/Workflow) - mirror the allowlist in the frontend via shared isModelWeightFile() helper - add regression tests for the Enhancement LoRA primary-file download, primary-flag fallback and weights-over-non-weights-primary preference	2026-08-12 21:14:23 +08:00
Will Miao	c2f16784b3	fix(metadata): keep identity selectors from leaking unselected prompts	2026-08-12 19:44:43 +08:00
Will Miao	5bc6d8286c	fix(metadata): exclude scalar fields from conditioning provenance inputs	2026-08-12 19:18:46 +08:00
Luna_K	3f8381ffee	Fix prompt tracking through conditioning transforms	2026-08-12 19:16:30 +08:00
Will Miao	1ca99294c9	feat(delete): shorten undo window to 20s and make undo toast dismissible	2026-08-12 19:15:03 +08:00
Will Miao	680f0a57f5	fix(update): resolve template path when updating to a different base model (#1059 ) Version-tab updates reused the current version's folder, so updating a LoRA to a version with a different base model (e.g. Illustrious -> Anima) ignored the download path template and landed in the old version's directory. When the target version's base model differs from the current local version and a path template is configured, re-resolve the template under the same model root. The backend keeps an explicitly provided root when use_save_dir_as_root is set, so regular downloads still use the default root.	2026-08-12 18:45:54 +08:00
Will Miao	94e3f54571	feat(workflow): exclude text-capable nodes with connected text from send targets CLIP Text Encode and friends whose text widget is backed by a connected input cannot have their text changed via the widget (execution reads the linked input), so sending to them was a silent no-op. - Registry: compute text_widget_connected capability from the widget's backing input link state; has_text_widget drops to false when wired; include the flag in the registration fingerprint so link changes re-register the affected nodes - Registry: hook link connect/disconnect (graph events on new litegraph, onAfterChange fallback for classic) on root and subgraphs, plus subgraph-created for future subgraphs - applyWidgetUpdate: skip inject_text when the target widget is connected and self-heal the registry instead of writing a value that is ignored - Web UI: drop text_widget_connected nodes from prompt/embedding send candidates; show a Mark as -> Send Prompt Target hint toast when no candidates remain (new uiHelpers.workflow.noPromptTargets key, synced to all locales; zh-CN/zh-TW translated) - Extract shared resolveTextWidget() used by both the candidate-set logic and the write path so the two cannot drift apart - Tests: workflow registry connection-state registration, subgraph handling, fingerprint re-registration, inject_text write/skip paths, setup link-change hooks; uiHelpers candidate filtering and hint toast	2026-08-12 16:50:07 +08:00
Will Miao	5c2b2aedcc	fix(i18n): complete recipe delete undo warning translations Translate modals.deleteRecipe.recoverableWarning in all 9 non-English locales (de, es, fr, he, ja, ko, ru, zh-CN, zh-TW)	2026-08-11 21:20:54 +08:00
Will Miao	ebc31fb963	fix(i18n): translate recipe delete undo warning Move the recipe delete modal's undo warning into modals.deleteRecipe. recoverableWarning instead of hardcoded English; sync placeholders into all 9 non-English locales	2026-08-11 21:18:36 +08:00
Will Miao	9659df6ad9	refactor(delete): make undo unconditional, remove undo toggle and button delay - Remove delete_undo_enabled setting (backend default, frontend state, settings modal UI, 10 locales); staged deletes with 30s undo are now the only delete path and stale settings keys are silently ignored - Remove the 1500ms delete-button arm delay (armDeleteButton) from all delete modals; misclicks are recoverable via the undo toast - Delete modal always shows the recoverable warning - Log the first staged file path in staging log lines for easier support	2026-08-11 21:15:59 +08:00
Will Miao	04d131e9dc	docs(delete): correct same-volume guarantee after symlink fix	2026-08-11 19:01:44 +08:00
Will Miao	78fe6282c7	test(delete): symlink and restart regression for staged deletes	2026-08-11 19:00:28 +08:00
Will Miao	0c00ee22fc	fix(delete): stage model deletes into the model folder (avoid EXDEV)	2026-08-11 18:48:03 +08:00
Will Miao	5fd4946b1f	fix(delete): track staged batches in-process; reconcile at startup	2026-08-11 18:36:30 +08:00
Will Miao	f1d3ac0cdc	fix(metadata): fill local file facts when self-heal recreates sidecar Refresh after manual .metadata.json deletion rebuilds the payload without file_name/size/modified, which are required by BaseModelMetadata.from_dict. The recreated sidecar then fails to parse and the scanner skips the model. - load_metadata_payload fills missing file facts from os.stat - hydrate_model_data restores every missing key from the cache snapshot only when the sidecar is missing entirely (disk stays authoritative otherwise), preferring the cached import timestamp for modified - save_metadata fills file facts on write so no write path can produce an unparseable sidecar	2026-08-11 14:57:23 +08:00
Will Miao	e2c45905f0	test(recipe): await background resort deterministically in pagination tests	2026-08-11 14:09:24 +08:00
Will Miao	b2c68e6a65	feat(delete): add undo toasts and harden delete modals	2026-08-11 14:09:10 +08:00
Will Miao	eb0f6dd3b6	feat(settings): add delete_undo_enabled toggle	2026-08-11 14:08:55 +08:00
Will Miao	0bf87f9092	chore(i18n): add undo-delete and delete-confirmation strings	2026-08-11 14:08:41 +08:00
Will Miao	1da2433bb2	feat(delete): add undo-delete endpoint and purge scheduling	2026-08-11 14:08:28 +08:00
Will Miao	2d6cf545b9	feat(delete): stage model and recipe deletes for 30s undo	2026-08-11 14:08:15 +08:00
Will Miao	6a259a14fa	feat(nodes): flag missing local models at queue and load time (#1057 )	2026-08-10 12:31:36 +08:00
Will Miao	41e1fd1e1f	feat(download): expose aria2 disk write failure root cause at INFO level Promote aria2 stderr lines that indicate disk write failures (e.g. the 'cause: No space left on device' line following 'Write disk cache flush failure') from DEBUG to INFO so the root cause is visible in default logs, including Windows-specific phrases (file locked by another process, sharing violation). The same line is rate-limited to one INFO report per 60s window and the report map is pruned on insert so repeated failures cannot spam the log or grow memory. All other stderr output stays at DEBUG.	2026-08-10 09:45:13 +08:00
Will Miao	95fb3c7fc9	feat(recipes): add prompt-aware duplicate detection toggle	2026-08-10 00:07:14 +08:00
Will Miao	8237e5f9ea	feat(ui): mark repair recipe data entries as deprecated Add (Deprecated) label suffix to the three context menu entries for repairing recipe data (global, bulk, single) ahead of their removal.	2026-08-09 15:50:02 +08:00
Will Miao	aa75986178	fix(ui): hide context menu separator with no visible items	2026-08-09 15:44:10 +08:00
Will Miao	b887922055	fix(i18n): translate rematch metadata strings	2026-08-09 15:33:24 +08:00
Will Miao	68fa0f29c7	feat(recipes): report rematch results with aggregate logs and toast feedback	2026-08-09 14:37:23 +08:00
Will Miao	d9d362c9c9	fix(download): self-heal aria2 transfers lost on daemon restart	2026-08-09 12:48:36 +08:00
Will Miao	d0bc4be0dc	chore(skill): harden lora-manager-e2e for sandboxed E2E	2026-08-09 11:31:04 +08:00
Will Miao	420530f532	feat(ui): add global, bulk and per-recipe rematch actions	2026-08-09 11:31:00 +08:00
Will Miao	3001f0f0ef	feat(recipes): add recipe rematch API endpoints	2026-08-09 11:30:50 +08:00
Will Miao	b2a1307d23	feat(recipes): add recipe rematch WebSocket progress channel	2026-08-09 11:30:46 +08:00
Will Miao	64da845a58	feat(recipes): add local-only recipe rematch to scanner	2026-08-09 11:30:43 +08:00