test(inspector): cover every plain-first-stage outcome on both resolvers (#381 )

The frontend coverage gate found local-resolver-stages.mjs branches at 92.44% (< 93). Each way an earlier stage stops being a plain first stage (no latent, literal, missing or cyclic latent, a sampler-shaped node, a detailer) is now a resolver test and an anchor-first-stage-* parity vector.
fix(inspector): skip only plain first stages on shared links; an unfinished prefix scan anchors nothing (#381 )
2026-10-27 08:20:24 -07:00 · 2026-10-27 07:24:46 -07:00 · 2026-10-27 07:17:44 -07:00 · 2026-10-27 06:36:48 -07:00 · 2026-10-27 06:36:40 -07:00 · 2026-10-27 06:28:42 -07:00
185 changed files with 5822 additions and 19669 deletions
@@ -1,12 +1,19 @@
 {
  "required_status_checks": {
-    "strict": false,
+    "strict": true,
    "contexts": [
      "py3.12 on ubuntu-latest",
+      "py3.13 on ubuntu-latest",
+      "py3.14 on ubuntu-latest",
+      "py3.12 on windows-latest",
+      "py3.13 on windows-latest",
+      "py3.14 on windows-latest",
+      "py3.12 on macos-latest",
+      "py3.13 on macos-latest",
+      "py3.14 on macos-latest",
      "coverage gate (85%)",
      "black and flake8",
      "frontend modules",
-      "all tests",
      "viewerjs",
      "real ComfyUI compatibility",
      "bandit (high severity)"
@@ -4,7 +4,6 @@ permissions:
  contents: read

 on:
-  merge_group:
  push:
    branches: [main]
  pull_request:
@@ -1,55 +0,0 @@
-name: Windows and macOS
-
-permissions:
-  contents: read
-
-# Non-blocking portability runs (#420): never on pull requests or in the merge queue, and no context
-# here is a required check. A red run is fixed at its cause before the workspace cutover (#334).
-on:
-  push:
-    branches: [main]
-  schedule:
-    - cron: "17 3 * * *"
-  workflow_dispatch:
-
-# Every run gets its own group (run_id), so no main commit's run is ever cancelled or dropped as pending.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.run_id }}
-  cancel-in-progress: false
-
-env:
-  PYTHONFAULTHANDLER: "1"
-
-# Time limit rule as in test.yml: ceil(1.5 x the slowest of three recent green runs on main) + 3
-# minutes, never under 5. Measured 2026-10-26 in test.yml on runs 40257217681 (3be0ada),
-# 40240706568 (fb9134f), 40228167328 (f9835aa), before these legs moved here in #420:
-#   slowest py3.10 on windows-latest: 12m43s / 15m54s / 14m53s -> 27 min
-#     (macos 6m14s-8m30s, windows 11m42s-15m54s)
-jobs:
-  test:
-    name: py${{ matrix.python-version }} on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 27
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [windows-latest, macos-latest]
-        python-version: ["3.12", "3.13", "3.14"]
-
-    steps:
-      - uses: actions/checkout@v7
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v7
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: pip
-          cache-dependency-path: requirements-dev.txt
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements-dev.txt
-
-      - name: Run tests
-        run: python -m tests.run_suite -v
@@ -4,7 +4,6 @@ permissions:
  contents: read

 on:
-  merge_group:
  pull_request:
    branches: [main]
  push:
@@ -28,18 +27,10 @@ env:
 #   py matrix, slowest py3.10 on windows-latest: 12m43s / 15m54s / 14m53s -> 27 min
 #     (ubuntu 5m27s-6m27s, macos 6m14s-8m30s, windows 11m42s-15m54s)
 #     3.10 and 3.11 left the matrix and 3.14 joined it in #356; re-measure after three green main runs.
-#     Windows and macOS moved to portability.yml (#420), which keeps this 27-minute limit; this
-#     Linux-only matrix keeps it too until it is re-measured.
 #   real ComfyUI compatibility: 13m32s / 8m55s / 11m46s -> 24 min
 #   coverage gate (85%): 7m26s / 7m22s / 7m54s -> 15 min
 #   perf budget 30s / 29s / 27s, black and flake8 39s / 37s / 39s,
 #   frontend modules 23s / 19s / 29s -> 5 min (the floor)
-#   all tests: a result check without setup, 5 min (the floor)
-#
-# Pull requests run a fast subset (#420): Python 3.12 on ubuntu-latest, coverage, lint and frontend
-# modules. The merge queue (merge_group), pushes to main and manual runs add Python 3.13 and 3.14 on
-# Linux and the real ComfyUI job. "all tests" is the required gate that holds the queue to that set.
-# Windows and macOS run in portability.yml (push to main, nightly, on demand) and never gate a merge.
 jobs:
  test:
    name: py${{ matrix.python-version }} on ${{ matrix.os }}
@@ -48,8 +39,8 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-latest]
-        python-version: ${{ github.event_name == 'pull_request' && fromJSON('["3.12"]') || fromJSON('["3.12", "3.13", "3.14"]') }}
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.12", "3.13", "3.14"]

    steps:
      - uses: actions/checkout@v7
@@ -71,22 +62,17 @@ jobs:

  comfyui:
    name: real ComfyUI compatibility
-    # Merge queue, main and manual runs only. A job skipped by its condition reports Success, so this
-    # required context never blocks a pull request; "all tests" fails if it is skipped anywhere else.
-    if: github.event_name != 'pull_request'
    runs-on: ubuntu-latest
-    # Chromium and its system libraries come from the pinned Playwright image (tag = @playwright/test in
-    # tools/vendor/package-lock.json; tests/vendor/browser-image.test.mjs checks it). The runner install
-    # pulled them from Ubuntu's apt mirror on every run, and three runs (#349, #378, #382) crawled at
-    # ~26 kB/s for 11-12 minutes until the job hit its limit after every test had passed.
-    container:
-      image: mcr.microsoft.com/playwright:v1.64.1-noble
-      options: --user 1001
    timeout-minutes: 24
    steps:
      - uses: actions/checkout@v7
        with:
          persist-credentials: false
+      - uses: actions/setup-node@v7
+        with:
+          node-version: "24"
+          cache: npm
+          cache-dependency-path: tools/vendor/package-lock.json
      - name: Read the reviewed runtime pins
        id: runtime
        run: |
@@ -111,42 +97,21 @@ jobs:
          ref: ${{ steps.runtime.outputs.kikoRevision }}
          path: .ci-kikotools
          persist-credentials: false
-      # The image's own Python and Node 24: setup-python/setup-node install the runner's toolcache builds,
-      # whose entry points name host paths that do not exist in the container. The image has no ensurepip
-      # and the job has no root, so a checksum-pinned pip wheel bootstraps a user-space venv. The image
-      # Python must be the reviewed host Python, so a pin or image bump that disagrees fails here.
-      - name: Python environment on the reviewed host Python
-        env:
-          PIP_WHEEL: https://files.pythonhosted.org/packages/f3/6e/1736e5b4ae2b778ef2f81c47d797de9f891d4d8acb047a24ca37a60294dd/pip-26.2.1-py3-none-any.whl
-          PIP_SHA256: 71138adf1f4ca900cdb7d289c21b7494329f2332b6d85f0e1c42108c0384ed3e
-          PINNED_PYTHON: ${{ steps.runtime.outputs.pythonVersion }}
-        run: |
-          image="$(python3 -c 'import sys; print("%d.%d" % sys.version_info[:2])')"
-          [ "$image" = "$PINNED_PYTHON" ] || { echo "::error::image Python $image is not the pinned $PINNED_PYTHON"; exit 1; }
-          venv="$RUNNER_TEMP/venv" wheel="$RUNNER_TEMP/pip-26.2.1-py3-none-any.whl"
-          python3 -m venv --without-pip "$venv"
-          curl -fsSL --retry 3 -o "$wheel" "$PIP_WHEEL"
-          echo "$PIP_SHA256  $wheel" | sha256sum -c -
-          "$venv/bin/python" "$wheel/pip" install --no-index --no-cache-dir "$wheel"
-          echo "$venv/bin" >> "$GITHUB_PATH"
-      - run: python --version && node --version && node --version | grep -q '^v24\.'
-      # pip's download cache (torch alone is ~200 MB); inside the container ~ is the job's HOME (/github/home).
-      - name: Cache pip downloads
-        uses: actions/cache@v6
+      - uses: actions/setup-python@v7
        with:
-          path: ~/.cache/pip
-          key: pip-${{ runner.os }}-playwright-v1.64.1-${{ hashFiles('requirements-dev.txt', '.ci-comfyui/requirements.txt', 'tools/vendor/comfyui-runtime.json') }}
+          python-version: ${{ steps.runtime.outputs.pythonVersion }}
+          cache: pip
+          cache-dependency-path: |
+            requirements-dev.txt
+            .ci-comfyui/requirements.txt
+            tools/vendor/comfyui-runtime.json
      - name: Install CPU runtime and test dependencies
        run: |
+          python -m pip install --upgrade pip
          pip install "torch==${{ steps.runtime.outputs.torchVersion }}" "torchvision==${{ steps.runtime.outputs.torchvisionVersion }}" --index-url https://download.pytorch.org/whl/cpu
          pip install -r .ci-comfyui/requirements.txt -r requirements-dev.txt "torch==${{ steps.runtime.outputs.torchVersion }}" "torchvision==${{ steps.runtime.outputs.torchvisionVersion }}"
-      # npm's download cache, keyed on the lockfile. node_modules itself is still built fresh by npm ci.
-      - name: Cache npm downloads
-        uses: actions/cache@v6
-        with:
-          path: ~/.npm
-          key: npm-${{ runner.os }}-playwright-v1.64.1-${{ hashFiles('tools/vendor/package-lock.json') }}
      - run: npm ci --prefix tools/vendor --ignore-scripts
+      - run: npx --prefix tools/vendor playwright install --with-deps chromium
      - name: Classic and Nodes 2.0 startup and compatibility
        env:
          PM_COMFY_ROOT: ${{ github.workspace }}/.ci-comfyui
@@ -232,10 +197,7 @@ jobs:
      - uses: actions/setup-python@v7
        with:
          python-version: "3.12"
-          cache: pip
-          cache-dependency-path: requirements-dev.txt
-      # The exact black and flake8 pins from requirements-dev.txt, so a new release cannot turn CI red.
-      - run: pip install $(grep -E '^(black|flake8)==' requirements-dev.txt)
+      - run: pip install black flake8
      - run: black --check .
      - run: flake8 .

@@ -249,8 +211,6 @@ jobs:
      - uses: actions/setup-node@v7
        with:
          node-version: "24"
-          cache: npm
-          cache-dependency-path: tools/vendor/package-lock.json

      - name: Check shipped extension and page modules parse
        run: |
@@ -264,32 +224,3 @@ jobs:

      - name: Run JS tests
        run: node --test tests/js/*.test.js
-
-  # The required context "all tests". A dropped matrix leg never reports a check at all, so the eight
-  # legs that pull requests skip cannot be required by name; this gate requires them instead. Every
-  # job must succeed; real ComfyUI must be skipped on a pull request and succeed on every other event.
-  all-tests:
-    name: all tests
-    needs: [test, comfyui, coverage, lint, js-test]
-    if: always()
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: Require every test job for this event
-        env:
-          EVENT_NAME: ${{ github.event_name }}
-          TEST_RESULT: ${{ needs.test.result }}
-          COMFYUI_RESULT: ${{ needs.comfyui.result }}
-          COVERAGE_RESULT: ${{ needs.coverage.result }}
-          LINT_RESULT: ${{ needs.lint.result }}
-          JS_RESULT: ${{ needs.js-test.result }}
-        run: |
-          queue_only=success
-          if [ "$EVENT_NAME" = pull_request ]; then queue_only=skipped; fi
-          echo "event: $EVENT_NAME (real ComfyUI must be $queue_only)"
-          echo "test matrix: $TEST_RESULT"
-          echo "comfyui: $COMFYUI_RESULT"
-          echo "coverage: $COVERAGE_RESULT"
-          echo "lint: $LINT_RESULT"
-          echo "js-test: $JS_RESULT"
-          test "$TEST_RESULT" = success && test "$COVERAGE_RESULT" = success && test "$LINT_RESULT" = success && test "$JS_RESULT" = success && test "$COMFYUI_RESULT" = "$queue_only"
@@ -1,7 +1,6 @@
 name: Viewer.js vendor and compatibility

 on:
-  merge_group:
  pull_request:
    branches: [main]
  push:
@@ -165,8 +164,6 @@ jobs:

  browser-workflows:
    name: page workflows (${{ matrix.browser }}, shard ${{ matrix.shard }}/2)
-    # Merge queue, main and manual runs only (#420); pull requests run the Chromium/touch coverage shards.
-    if: github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    # Layout comparisons depend on the fonts each browser falls back to, so browser jobs run in the
    # same pinned Playwright image as local runs (tag = @playwright/test in tools/vendor/package-lock.json;
@@ -221,9 +218,8 @@ jobs:
          retention-days: 14

  # Branch protection requires the exact context "viewerjs". This job keeps that
-  # name and fails unless every coverage shard and the coverage merge succeeded and
-  # the browser shards succeeded, or, on a pull request only, were skipped (#420).
-  # Any failure, cancellation or other skip fails it.
+  # name and fails unless every frontend job above succeeded (every shard, the
+  # coverage merge and every browser shard), including when one was cancelled or skipped.
  viewerjs:
    needs: [frontend-coverage, frontend-coverage-merge, browser-workflows]
    if: always()
@@ -232,15 +228,11 @@ jobs:
    steps:
      - name: Require every frontend job to succeed
        env:
-          EVENT_NAME: ${{ github.event_name }}
          COVERAGE_RESULT: ${{ needs.frontend-coverage.result }}
          MERGE_RESULT: ${{ needs.frontend-coverage-merge.result }}
          WORKFLOWS_RESULT: ${{ needs.browser-workflows.result }}
        run: |
-          queue_only=success
-          if [ "$EVENT_NAME" = pull_request ]; then queue_only=skipped; fi
-          echo "event: $EVENT_NAME (browser-workflows must be $queue_only)"
          echo "frontend-coverage: $COVERAGE_RESULT"
          echo "frontend-coverage-merge: $MERGE_RESULT"
          echo "browser-workflows: $WORKFLOWS_RESULT"
-          test "$COVERAGE_RESULT" = success && test "$MERGE_RESULT" = success && test "$WORKFLOWS_RESULT" = "$queue_only"
+          test "$COVERAGE_RESULT" = success && test "$MERGE_RESULT" = success && test "$WORKFLOWS_RESULT" = success
@@ -13,11 +13,9 @@ repos:
        language: system
        types: [python]

-      # Fails at the severity CI enforces (code-quality.yml: -lll, high only), never stricter.
-      # pre-commit appends the staged files, so no shell wrapper can drop the first one.
      - id: bandit
        name: bandit
-        entry: bandit -lll -q
+        entry: bash -c 'bandit "$@" -ll -q 2>&1; true'
        language: system
        types: [python]
        exclude: ^(tests/|reference/)
@@ -56,7 +56,7 @@ Both nodes include the complete PromptManager feature set:
 - **📊 Analytics**: Track prompt usage patterns and effectiveness over time
 - **🔬 Workflow Analysis**: Extract and analyze ComfyUI workflow data from PNG images
 - **📋 Metadata Viewer**: Standalone tool for analyzing ComfyUI-generated images
- **🛠️ System Management**: Built-in diagnostics, backup/restore, and maintenance tools in System
+- **🛠️ System Management**: Built-in diagnostics, backup/restore, and maintenance tools
 - **🏷️ AI AutoTag**: Automatically tag your image collection using WD14 or JoyCaption vision models
 - **🔗 LoRA Manager Integration**: Import LoRA metadata and preview images from [ComfyUI-Lora-Manager](https://github.com/willmiao/ComfyUI-Lora-Manager)

@@ -206,11 +206,14 @@ match Classic and Focused.
 - **Responsive Design**: Works on desktop, tablet, and mobile devices
 - **Real-time Search**: Instant search results as you type
 - **Bulk Operations**: Edit multiple prompts simultaneously with batch tools
- **Settings and System tools live in System**: the dashboard's **Settings** opens System › Overview, **Maintenance** opens System › Maintenance, **Backup DB** and **Restore DB** open System › Backup & export, and **Diagnostics** and **View Logs** open System › Diagnostics & logs, each in a new tab. System reviews every destructive operation before it runs it as an Activity job.
- **Page options**: the list header's **Page options** keeps the prompt list's Infinite Scrolling default
- **Dashboard tools**:
+- **Settings Panel**: Configure behavior and display options
+- **System Management**: Complete toolset for database operations:
  - **🔍 Metadata Viewer**: Launch standalone PNG analysis tool
-  - **📸 Scan Images**: Bulk scan output directories for ComfyUI images (with a quick backup first)
+  - **📸 Scan Images**: Bulk scan output directories for ComfyUI images
+  - **💾 Backup/Restore**: Database backup and recovery operations
+  - **🔧 Maintenance**: Database optimization and cleanup tools including orphaned prompt removal
+  - **📋 Logs**: Comprehensive logging system with download capability
+  - **🔍 Diagnostics**: System health checks and troubleshooting
 - **Export Tools**: Download prompts and metadata in various formats
 - **Progress Tracking**: Real-time progress indicators for long operations
 - **Error Handling**: Graceful error display with recovery suggestions
@@ -330,11 +333,14 @@ The comprehensive gallery system provides complete access to all your ComfyUI ou

 #### **⚙️ Gallery Settings**

-The gallery's **Settings** opens System › Appearance in a new tab: image quality, details on cards, collapsed viewer details, video autoplay/mute/loop, metadata loading and file paths are set there and apply to this page too.
+Configure your viewing experience in the settings panel:

-The gallery's **Page options** keep the page's own settings: the thumbnail check at startup, lazy loading, items per page, grid columns, infinite scrolling, debug mode and API timeout. Reset puts back only these.
-
-Thumbnail generation, the server thumbnail and browser cache clears, refreshing the file listing and finding duplicate images are in System › Sources & scans and System › Maintenance (Page options links both); each runs as an Activity job you can follow after closing the page.
+- **Display Settings**: Default view, items per page, grid columns, media info, infinite scrolling
+- **Performance Settings**: Image quality, lazy loading
+- **Video Settings**: Autoplay, mute by default, loop videos
+- **Thumbnail Management**: Generate optimized thumbnails for faster loading (runs on the configured worker threads; a run that stops at the per-run cap tells you how many remain)
+- **Find Duplicate Images**: Hashes every file on the worker threads with a progress bar; close the window and it keeps running, results wait in a pill
+- **Rescan Output Folder**: Drops the server-side listing cache and rewalks the folders

 #### **🖼️ Image Viewing Experience**

@@ -392,7 +398,7 @@ Import existing ComfyUI images into your database:
   - Any errors or issues encountered
 5. **Access imported data** through the normal gallery interface

-The scan reads PNG text chunks and A1111-style parameters, and, when `ffprobe` is installed, the prompt ComfyUI's video savers embed in MP4/MOV/WebM files. Files are read on the number of **worker threads** set in System › Sources & scans (default: half your cores), which makes a large library several times faster.
+The scan reads PNG text chunks and A1111-style parameters, and, when `ffprobe` is installed, the prompt ComfyUI's video savers embed in MP4/MOV/WebM files. Files are read on the number of **worker threads** set in Settings → Performance (default: half your cores), which makes a large library several times faster.

 ### 🏷️ AI AutoTag

@@ -408,7 +414,7 @@ Automatically tag your entire image collection using AI vision models:

 1. **AutoTag (Batch Mode)**: Tag your entire collection automatically
   - Click **"🏷️ AutoTag"** in the admin dashboard
-   - Choose your model type (FP16 or GGUF). A model that is not downloaded yet shows **Manage in System**: download (or unload) it in System › Auto-tagging, then reopen the dialog
+   - Choose your model type (FP16 or GGUF)
   - Select how to handle already-tagged images:
     - **Skip images with existing tags**: Preserve your meticulous manual tagging work
     - **Re-tag all images**: Overwrite existing tags with fresh AI analysis
@@ -439,7 +445,7 @@ Adjust the system prompt to match your tagging style:
 #### **Requirements**

 - Sufficient VRAM for the chosen model (FP16 requires more, GGUF is lighter)
- Models are downloaded in System › Auto-tagging
+- Models are downloaded automatically on first use
 - Feature requests and improvements are welcome!

 ### 📁 Folder Filter
@@ -464,18 +470,18 @@ If you use [ComfyUI-Lora-Manager](https://github.com/willmiao/ComfyUI-Lora-Manag

 #### **Enabling the Integration**

-1. Open System › Integrations (the admin dashboard's **Settings** opens System)
-2. PromptManager auto-detects whether LoRA Manager is installed
+1. Open the admin dashboard and click **Settings**
+2. Scroll to the **Integrations** section — PromptManager will auto-detect if LoRA Manager is installed

 ![LoRA Enabled](images/pm-lora-enabled.png)

 3. Toggle the **LoraManager** switch to enable
 4. Optionally enable **Auto-inject trigger words** to automatically append LoRA trigger words when `<lora:name:weight>` is detected in your prompts
-5. Click **Save preferences** (requires a ComfyUI restart to take effect)
+5. Click **Save Settings** (requires a ComfyUI restart to take effect)

 #### **Importing LoRA Data**

-Click **Review import** in System › Integrations; Start runs the import as an Activity job:
+Click **Import LoRA Data** in the settings panel to start the import. A progress popup shows real-time status as each LoRA is processed:

 - Reads LoRA Manager's own settings the way LoRA Manager does: from the folder in `LORA_MANAGER_SETTINGS_DIR`, from the plugin's `settings.json` in portable mode, or from your user config folder, and only the keys that say where its files are
 - Finds each LoRA's metadata in both storage modes: beside the model (the default) or in the central sidecar folder, and imports only LoRAs whose model file still exists in a LoRA folder (the review says how many metadata files it skipped)
@@ -496,7 +502,7 @@ A CivitAI API key is **required if your library contains NSFW LoRAs** — CivitA

 To add your key:
 1. Get your API key from [civitai.com/user/account](https://civitai.com/user/account)
-2. Paste it into the **CivitAI API key** field in System › Integrations
+2. Paste it into the **CivitAI API Key** field in the Integrations settings
 3. Save and re-import to download any previously skipped images

 The key is sent only over HTTPS to CivitAI's own hosts. CivitAI serves images through a redirect to its storage host; PromptManager follows such a redirect only over HTTPS to a host on CivitAI's own `civitai.com`, `civitai.red` or `civitai.green` domains, at most three hops, and never sends the key with it. When downloads fail, the import's status line says how many; when none could be downloaded, it starts with a warning. The server log has one warning per failed image with the reason (HTTP status, refused redirect, size cap, unreadable image, timeout or network error).
@@ -511,20 +517,23 @@ The comprehensive web interface provides:
 - **Filter Options**: Filter by category, tags, rating, and date
 - **Bulk Operations**: Select multiple prompts for batch editing
 - **Export Tools**: Download your prompt collection
- **Settings**: System (new tab) for settings, maintenance, backups and diagnostics; **Page options** for the page's own display settings
+- **Settings Panel**: Configure auto-save and display options
+- **Diagnostics**: System health checks and troubleshooting

 ### 🔧 Database Maintenance

-Keep your database optimized in System › Maintenance (the admin dashboard's **Maintenance** opens it in a new tab):
+Keep your database optimized with built-in maintenance tools:

- **Duplicate prompt text**: merge duplicate prompts while preserving images
- **Optimize database**: reclaim unused SQLite space
- **Missing-file links**: remove image records for missing files
- **Unused prompt components**: remove prompts nothing uses
- **Run health checks**: verify database integrity and relationships (the Health report)
- **Database size and prompt counts**: System › Diagnostics & logs (Database) and the Overview's Statistics
-
-Each operation opens a review that shows what it will change and the safety backup it takes, then runs as an Activity job.
+1. **Open the admin dashboard** and click **"🔧 Maintenance"**
+2. **Select maintenance operations**:
+   - **Remove Duplicates**: Find and merge duplicate prompts while preserving images
+   - **Vacuum Database**: Optimize database file size and performance
+   - **Clean Orphaned Images**: Remove image records for missing files
+   - **🚮 Prune Orphaned Prompts**: Remove prompts that have no linked images
+   - **Check Consistency**: Verify database integrity and relationships
+   - **Database Statistics**: Generate detailed database reports
+3. **Run selected operations** and monitor progress in real-time
+4. **Review results** showing detailed information about each operation

 ### Database Location

@@ -826,8 +835,8 @@ Before upgrading or changing this setting:
 1. Identify the database your current installation actually uses and confirm its
   library contents. Check both the configured path and the prior fallback
   `<extension>/prompts.db`; keep track of which existing file you intend to use.
-2. Preserve a consistent backup of the active database with
-   System › Backup & export's Back up or SQLite's online backup API. Do not copy only
+2. Preserve a consistent backup of the active database with the dashboard's
+   Backup/Restore backup action or SQLite's online backup API. Do not copy only
   the main file of a live SQLite database: committed data may still be in its
   `-wal` file. For a filesystem copy, stop ComfyUI cleanly first and preserve any
   remaining `-wal` file together with the main database.
@@ -355,44 +355,6 @@ async def _stop_background_work_on_cleanup(app):
    _stop_background_work()


-def _kill_encoders_at_exit():
-    """Run by the exit hook before Python joins the executor threads (#376):
-    a JPEG XL or ffmpeg encoder (no console on Windows, so Ctrl+C never
-    reaches it) is killed instead of being waited for."""
-    from .py.api.thumbnail_encode import shutdown_encoders
-
-    shutdown_encoders()
-
-
-def _abort_downloads_at_exit():
-    """Run by the exit hook (#376): huggingface_hub's Xet transfers ignore
-    the chunk checkpoint, so they are aborted the way hub aborts on Ctrl+C."""
-    import sys
-
-    if "huggingface_hub" not in sys.modules:
-        return  # no download ever ran: import nothing at exit
-    from .py.autotag import abort_hub_downloads
-
-    abort_hub_downloads()
-
-
-try:
-    # Before the executor join: running jobs stop at their next file, item or
-    # chunk (#376). The teardown below still runs from atexit afterwards.
-    from .utils import exit_signal as _exit_signal
-
-    _exit_signal.install(_kill_encoders_at_exit)
-    _exit_signal.install(_abort_downloads_at_exit)
-except Exception as e:
-    try:
-        from .utils.logging_config import get_logger
-
-        get_logger("prompt_manager.init").error(
-            f"Failed to register the exit signal: {e}"
-        )
-    except Exception:
-        pass
-
 try:
    atexit.register(_stop_background_work)
    from .py.config import server_instance as _teardown_server
@@ -19,11 +19,6 @@ links (``PromptDatabase._move_tag_links``).
 Cheap reads (spec amendment S1) treat a byte record as *current* only while
 the file's present ``(size, mtime_ns)`` equals the record's verified
 fingerprint; a file without a current record shows no image tags.
-
-A write made from a tagging model's result passes ``mark_autotagged`` (#379):
-the byte record is then marked auto-tagged (``media_image_autotags``) in the
-same transaction, so a mark never exists without the write it records. Hand
-tags never mark.
 """

 import re
@@ -39,7 +34,6 @@ from .annotation_schema import (
    MAX_LOCATOR_LENGTH,
    METADATA_TABLE,
 )
-from .autotag_schema import AUTOTAG_TABLE
 from .library_commands import _UUID, LibraryCommandError, _validate_epoch
 from .models import utc_now_iso
 from .vocabulary import validate_vocabulary_tag_name
@@ -102,24 +96,12 @@ _TAGS_OF = (
    "JOIN tags t ON t.id=mit.tag_id WHERE mit.byte_id IN ({marks}) "
    "ORDER BY mit.byte_id,mit.position"
 )
-_MARK = f"INSERT OR IGNORE INTO {AUTOTAG_TABLE}(byte_id) VALUES(?)"  # nosec B608
-_MARKED_OF = (
-    f"SELECT byte_id FROM {AUTOTAG_TABLE} WHERE byte_id IN ({{marks}})"  # nosec B608
-)
-_MARKED_LOCATORS = (
-    f"SELECT DISTINCT f.locator FROM {AUTOTAG_TABLE} m "  # nosec B608
-    f"JOIN {BYTES_TABLE} b ON b.id=m.byte_id JOIN {FILES_TABLE} f ON f.id=b.file_id"
-)
-# Tag search (#379): the names that tag at least one image (the tag index
-# answers the EXISTS), then the locators carrying chosen names (by tag_id).
-_IMAGE_TAG_NAMES = (
-    "SELECT t.id,t.name FROM tags t WHERE EXISTS "  # nosec B608
-    f"(SELECT 1 FROM {IMAGE_TAGS_TABLE} mit WHERE mit.tag_id=t.id)"
-)
-_TAG_LOCATORS = (
-    f"SELECT DISTINCT f.locator FROM {IMAGE_TAGS_TABLE} mit "  # nosec B608
-    f"JOIN {BYTES_TABLE} b ON b.id=mit.byte_id "
-    f"JOIN {FILES_TABLE} f ON f.id=b.file_id WHERE mit.tag_id IN ({{marks}})"
+_RECORDS = (
+    "SELECT f.locator,b.id,b.size,b.mtime_ns,t.name "  # nosec B608
+    f"FROM {FILES_TABLE} f JOIN {BYTES_TABLE} b ON b.file_id=f.id "
+    f"LEFT JOIN {IMAGE_TAGS_TABLE} mit ON mit.byte_id=b.id "
+    "LEFT JOIN tags t ON t.id=mit.tag_id "
+    "ORDER BY f.locator,b.first_seen_at,b.id,mit.position"
 )


@@ -319,17 +301,14 @@ class AnnotationOperations:
        expected_epoch: str,
        expected_tag_revision: int,
        tags: list,
-        mark_autotagged: bool = False,
    ) -> dict:
        """Replace the set of these exact bytes, guarded by epoch and revision.

        Creates the owner and byte record when the bytes are new (an explicit
        empty set is a real save). The identical set at the current revision,
        or one behind it (a lost-response retry), is ``replayed`` and writes
-        no tag; any other revision mismatch is ``tag-conflict`` with the
-        current set and no writes. ``mark_autotagged`` marks the bytes
-        auto-tagged on a saved or replayed receipt (the Tag image dialog's
-        save after Generate suggestions).
+        nothing; any other revision mismatch is ``tag-conflict`` with the
+        current set and no writes.
        """
        _validate_target(locator, sha256, size, mtime_ns)
        _validate_epoch(expected_epoch)
@@ -350,8 +329,6 @@ class AnnotationOperations:
            ):
                if refingerprinted:
                    conn.execute(_BUMP_INDEX)
-                if mark_autotagged:
-                    conn.execute(_MARK, (byte_id,))
                return _receipt(epoch, sha256, current, revision, True)
            if expected_tag_revision != revision:
                raise AnnotationCommandError(
@@ -360,8 +337,6 @@ class AnnotationOperations:
                    {"sha256": sha256, "tags": current, "tag_revision": revision},
                )
            revision = self._write_image_tags(conn, byte_id, tags)
-            if mark_autotagged:
-                conn.execute(_MARK, (byte_id,))
            return _receipt(epoch, sha256, tags, revision, False)

    def add_image_tags(
@@ -373,22 +348,16 @@ class AnnotationOperations:
        mtime_ns: int,
        expected_epoch: str,
        tags: list,
-        mark_autotagged: bool = False,
    ) -> dict:
        """Union ``tags`` into the set of these exact bytes, keeping stored spelling.

        ``added`` counts the names that were new (case-insensitively). A union
        over ``MAX_IMAGE_TAGS`` is ``tag-limit`` with the current set and no
        writes; a union that adds nothing to an existing record is ``replayed``.
-        ``mark_autotagged`` (a tagging model's result) also marks the bytes
-        auto-tagged, replayed or not; only such a call may pass no tags (the
-        model found none: the image is marked and its set is unchanged).
        """
        _validate_target(locator, sha256, size, mtime_ns)
        _validate_epoch(expected_epoch)
        tags = normalize_image_tags(tags)
-        if not tags and not mark_autotagged:
-            raise ValueError("tags must name at least one tag")
        with self._pair_transaction() as conn:
            epoch = self._library_epoch(conn, expected_epoch)
            now = utc_now_iso()
@@ -406,8 +375,6 @@ class AnnotationOperations:
                    epoch,
                    {"sha256": sha256, "tags": current, "tag_revision": revision},
                )
-            if mark_autotagged:
-                conn.execute(_MARK, (byte_id,))
            if not created and not added:
                if refingerprinted:
                    conn.execute(_BUMP_INDEX)
@@ -436,41 +403,6 @@ class AnnotationOperations:
                conn.execute(_BUMP_INDEX)
            return cursor.rowcount > 0

-    @staticmethod
-    def _validated_stats(stats: object) -> dict:
-        if not isinstance(stats, dict):
-            raise ValueError(
-                "stats must map locators to (size, mtime_ns) integer pairs"
-            )
-        for locator, fingerprint in stats.items():
-            _validate_fingerprint(locator, fingerprint)
-        return stats
-
-    @staticmethod
-    def _current_byte_records(conn: sqlite3.Connection, stats: dict) -> dict:
-        """``{locator: byte_id}`` of each locator's current byte record.
-
-        The one rule every cheap read uses: a record is current while its
-        verified ``(size, mtime_ns)`` equals the file's present fingerprint
-        in ``stats``; the most recently verified wins (ties on ``(verified_at,
-        byte_id)``). A locator without a current record is left out. Lookups
-        go in chunks of 500 locators.
-        """
-        locators = list(stats)
-        chosen: dict[str, tuple[tuple[str, str], str]] = {}
-        for start in range(0, len(locators), _LOOKUP_CHUNK):
-            chunk = locators[start : start + _LOOKUP_CHUNK]
-            marks = ",".join("?" * len(chunk))
-            for locator, byte_id, size, mtime_ns, verified_at in conn.execute(
-                _FINGERPRINTS.format(marks=marks), chunk
-            ):
-                if (size, mtime_ns) != stats[locator]:
-                    continue
-                key = (verified_at, byte_id)
-                if locator not in chosen or key > chosen[locator][0]:
-                    chosen[locator] = (key, byte_id)
-        return {locator: byte_id for locator, (_key, byte_id) in chosen.items()}
-
    def current_image_tags(self, stats: dict) -> dict:
        """Image tags of the files whose current ``(size, mtime_ns)`` is verified.

@@ -479,11 +411,29 @@ class AnnotationOperations:
        exactly that verified fingerprint; the most recently verified record
        wins when several do. Lookups go in chunks of 500 locators.
        """
-        stats = self._validated_stats(stats)
+        if not isinstance(stats, dict):
+            raise ValueError(
+                "stats must map locators to (size, mtime_ns) integer pairs"
+            )
+        for locator, fingerprint in stats.items():
+            _validate_fingerprint(locator, fingerprint)
+        locators = list(stats)
+        chosen: dict[str, tuple[tuple[str, str], str]] = {}
+        result: dict[str, list[str]] = {}
        with self._annotation_read() as conn:
-            current = self._current_byte_records(conn, stats)
-            owners = {byte_id: locator for locator, byte_id in current.items()}
-            result: dict[str, list[str]] = {locator: [] for locator in current}
+            for start in range(0, len(locators), _LOOKUP_CHUNK):
+                chunk = locators[start : start + _LOOKUP_CHUNK]
+                marks = ",".join("?" * len(chunk))
+                for locator, byte_id, size, mtime_ns, verified_at in conn.execute(
+                    _FINGERPRINTS.format(marks=marks), chunk
+                ):
+                    if (size, mtime_ns) != stats[locator]:
+                        continue
+                    key = (verified_at, byte_id)
+                    if locator not in chosen or key > chosen[locator][0]:
+                        chosen[locator] = (key, byte_id)
+            owners = {byte_id: locator for locator, (_key, byte_id) in chosen.items()}
+            result = {locator: [] for locator in chosen}
            byte_ids = list(owners)
            for start in range(0, len(byte_ids), _LOOKUP_CHUNK):
                chunk = byte_ids[start : start + _LOOKUP_CHUNK]
@@ -492,60 +442,20 @@ class AnnotationOperations:
                    result[owners[byte_id]].append(name)
        return result

-    def autotag_state(self, stats: dict) -> dict:
-        """``{locator: bool}``: is each file's current byte record auto-tagged?
+    def iter_image_tag_records(self) -> Iterator[tuple[str, int, int, list[str]]]:
+        """Stream every byte record as ``(locator, size, mtime_ns, tags)``.

-        ``stats`` as for :meth:`current_image_tags`, whose rule picks the
-        current record; a locator without one is False. One read snapshot.
+        One SELECT ordered by locator, then by the bytes' first sighting, with
+        each set's names in position order.
        """
-        stats = self._validated_stats(stats)
-        with self._annotation_read() as conn:
-            current = self._current_byte_records(conn, stats)
-            byte_ids = list(dict.fromkeys(current.values()))
-            marked: set[str] = set()
-            for start in range(0, len(byte_ids), _LOOKUP_CHUNK):
-                chunk = byte_ids[start : start + _LOOKUP_CHUNK]
-                marks = ",".join("?" * len(chunk))
-                marked.update(
-                    row[0]
-                    for row in conn.execute(_MARKED_OF.format(marks=marks), chunk)
-                )
-        return {locator: current.get(locator) in marked for locator in stats}
-
-    def autotagged_locators(self) -> set:
-        """Locators with at least one auto-tagged byte record, current or not.
-
-        No fingerprint is checked (the Tag output images review's estimate).
-        """
-        with self._annotation_read() as conn:
-            return {row[0] for row in conn.execute(_MARKED_LOCATORS)}
-
-    def image_tag_ids(self, wanted, query: str) -> list[int]:
-        """Ids of the tag names on at least one image that a search wants.
-
-        A name counts when it is in ``wanted`` exactly (the Tags filter) or
-        contains ``query`` case-folded (the text search; ``query`` is
-        already folded). One read of the names that tag an image.
-        """
-        wanted = set(wanted)
-        with self._annotation_read() as conn:
-            return [
-                tag_id
-                for tag_id, name in conn.execute(_IMAGE_TAG_NAMES)
-                if name in wanted or (query and query in name.casefold())
-            ]
-
-    def image_tag_locators(self, tag_ids) -> set[str]:
-        """Locators with any byte record (current or not) carrying one of
-        ``tag_ids``, through the tag index, in chunks of 500 ids."""
-        ids = list(dict.fromkeys(tag_ids))
-        found: set[str] = set()
-        with self._annotation_read() as conn:
-            for start in range(0, len(ids), _LOOKUP_CHUNK):
-                chunk = ids[start : start + _LOOKUP_CHUNK]
-                marks = ",".join("?" * len(chunk))
-                found.update(
-                    row[0]
-                    for row in conn.execute(_TAG_LOCATORS.format(marks=marks), chunk)
-                )
-        return found
+        conn = self.model.get_connection()
+        current: tuple | None = None
+        for locator, byte_id, size, mtime_ns, name in conn.execute(_RECORDS):
+            if current is None or current[0] != byte_id:
+                if current is not None:
+                    yield current[1]
+                current = (byte_id, (locator, size, mtime_ns, []))
+            if name is not None:
+                current[1][3].append(name)
+        if current is not None:
+            yield current[1]
@@ -1,140 +0,0 @@
-"""Auto-tagged marks (#379): which image bytes a tagging model has handled.
-
-One table, ``media_image_autotags``: one row per byte record of the image
-annotation group (``media_annotation_bytes``) means "a tagging model looked at
-these exact bytes and its result was stored", or that the bytes were found to
-be untaggable. "Skip already tagged" skips an image whose current byte record
-is marked; hand tags never mark. Rows are written only by the image tag store
-(``database/annotations.py``), in the transaction of the tag write they
-record.
-
-The group installs like ``image_favorites``: optional in old backups,
-required once a database is current, and never backfilled. Like the Needs
-review group it is valid only beside a valid image annotation group, because
-every mark cites one byte record (``ON DELETE CASCADE``). Validation reads
-only: the catalog compared after whitespace compaction, the columns and the
-foreign key through the PRAGMAs, then one bounded value pass and the foreign
-key check.
-"""
-
-import re
-import sqlite3
-from typing import Optional
-
-from .annotation_schema import BYTES_TABLE
-from .annotation_schema import TABLES as ANNOTATION_TABLES
-from .annotation_schema import _catalog as _annotation_catalog
-from .annotation_schema import _uuid, annotation_schema_error
-
-AUTOTAG_TABLE = "media_image_autotags"
-_DDL = (
-    f"CREATE TABLE {AUTOTAG_TABLE} (byte_id TEXT PRIMARY KEY "
-    f"REFERENCES {BYTES_TABLE}(id) ON DELETE CASCADE) WITHOUT ROWID"
-)
-# (cid, name, declared type, not null, default, primary key position): the
-# key of a WITHOUT ROWID table is implicitly NOT NULL.
-_COLUMNS = [(0, "byte_id", "TEXT", 1, None, 1)]
-# (column, parent table, parent column, on delete)
-_FOREIGN_KEYS = {("byte_id", BYTES_TABLE, "id", "CASCADE")}
-
-NEEDS_ANNOTATIONS = "Image auto-tag marks need the image annotation tables"
-INVALID_SCHEMA = "Image auto-tag marks have an invalid schema"
-INVALID_VALUES = "Image auto-tag marks contain invalid values"
-MISSING = "Missing image auto-tag marks schema"
-
-
-def _compact(sql: str) -> str:
-    return re.sub(r"\s+", "", sql).lower()
-
-
-def _catalog(conn: sqlite3.Connection) -> list:
-    return conn.execute(
-        "SELECT type,name,sql FROM sqlite_master WHERE name=? OR tbl_name=?",
-        (AUTOTAG_TABLE, AUTOTAG_TABLE),
-    ).fetchall()
-
-
-def autotag_without_annotations_error(conn: sqlite3.Connection) -> Optional[str]:
-    """Catalog only: the marks table present without its annotation tables.
-
-    Startup asks this before the annotation group installs, which would make
-    a marks table copied without it look valid. It reads no rows.
-    """
-    if not _catalog(conn):
-        return None
-    present = {
-        name for kind, name, _sql in _annotation_catalog(conn) if kind == "table"
-    }
-    if present != set(ANNOTATION_TABLES):
-        return NEEDS_ANNOTATIONS
-    return None
-
-
-def autotag_schema_error(
-    conn: sqlite3.Connection,
-    *,
-    allow_missing: bool = True,
-    annotations_valid: bool = False,
-) -> Optional[str]:
-    """Reject an unsupported marks table or invalid marks; reads only.
-
-    A database without the table is acceptable for backups that predate it
-    unless ``allow_missing`` is false. A present table requires a present,
-    valid image annotation group; ``annotations_valid`` says the caller has
-    just validated it (startup's annotation install), so only its presence is
-    checked again.
-    """
-    objects = _catalog(conn)
-    if not objects:
-        return None if allow_missing else MISSING
-    if annotations_valid:
-        if autotag_without_annotations_error(conn):
-            return NEEDS_ANNOTATIONS
-    elif annotation_schema_error(conn, allow_missing=False):
-        return NEEDS_ANNOTATIONS
-    actual = {(kind, name, _compact(sql or "")) for kind, name, sql in objects}
-    if actual != {("table", AUTOTAG_TABLE, _compact(_DDL))}:
-        return INVALID_SCHEMA
-    columns = [
-        (row[0], row[1], row[2].upper(), row[3], row[4], row[5])
-        for row in conn.execute(f"PRAGMA table_info({AUTOTAG_TABLE})")
-    ]
-    if columns != _COLUMNS:
-        return INVALID_SCHEMA
-    foreign_keys = {
-        (row[3], row[2], row[4], row[6])
-        for row in conn.execute(f"PRAGMA foreign_key_list({AUTOTAG_TABLE})")
-    }
-    if foreign_keys != _FOREIGN_KEYS:
-        return INVALID_SCHEMA
-    # Only this module's constants are interpolated into the SQL below.
-    if conn.execute(
-        f"SELECT 1 FROM {AUTOTAG_TABLE} "  # nosec B608
-        f"WHERE NOT ({_uuid('byte_id')}) LIMIT 1"
-    ).fetchone():
-        return INVALID_VALUES
-    if conn.execute(f"PRAGMA foreign_key_check({AUTOTAG_TABLE})").fetchone():
-        return INVALID_VALUES
-    return None
-
-
-def migrate_autotag_state(conn: sqlite3.Connection) -> None:
-    """Install the table atomically; validate before and after creating it.
-
-    Runs after ``migrate_annotation_state`` (which has just validated the
-    annotation group). Creates one empty table: no row is read or copied.
-    """
-    conn.execute("SAVEPOINT media_autotag_schema")
-    try:
-        error = autotag_schema_error(conn, annotations_valid=True)
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute(_DDL.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1))
-        error = autotag_schema_error(conn, allow_missing=False, annotations_valid=True)
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute("RELEASE media_autotag_schema")
-    except BaseException:
-        conn.execute("ROLLBACK TO media_autotag_schema")
-        conn.execute("RELEASE media_autotag_schema")
-        raise
@@ -11,8 +11,6 @@ IMMEDIATE`` transaction, so no row ever names a deleted file:
 - its favorite;
 - its image tags (``media_image_tags`` of its byte record), joined onto the
  kept copy's byte record as their union, in order;
- its own image category (#332), copied to the kept copy when that copy has
-  none; the removed copy's row is kept, so a give-back loses nothing;
 - its pending Needs review items, settled: only an item still ``pending`` at
  revision 0 with no decision row is removed (``review._SETTLE_ITEM``), so a
  decided item is never touched.
@@ -24,8 +22,6 @@ import os

 from .annotation_schema import BYTES_TABLE, FILES_TABLE
 from .annotations import _BUMP_INDEX
-from .image_categories import COPY_SQL as COPY_CATEGORY_SQL
-from .image_categories import copy_image_category
 from .models import normalize_image_path, utc_now_iso
 from .review import _BUMP_REVIEW_INDEX, _PENDING_OF_LOCATOR, _SETTLE_ITEM
 from .review_changes import notify_review_change
@@ -80,7 +76,6 @@ FILE_LINK_SQL = (
    COPY_BYTE_SQL,
    COPY_TAG_COUNT_SQL,
    PENDING_COUNT_SQL,
-    COPY_CATEGORY_SQL,
 )


@@ -142,10 +137,8 @@ class DuplicateCopyOperations:
        removed key, kept root key, kept key)`` per listed root holding the
        file), ``removed_locator``,
        ``kept_locator``, ``sha256`` and the kept copy's ``kept_size`` and
-        ``kept_mtime_ns``; ``categories``: ``(removed file key, kept file
-        key)`` pairs of the image categories (#332). Returns ``{moved,
-        merged, favorites, tags, review, categories}`` (``categories``: the
-        image categories copied to the kept copy).
+        ``kept_mtime_ns``. Returns ``{moved, merged, favorites, tags,
+        review}``.
        """
        counts = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
        kept_keys = [normalize_image_path(path) for path in move["kept"]]
@@ -181,10 +174,6 @@ class DuplicateCopyOperations:
            for favorite in move.get("favorites", ()):
                counts["favorites"] += _move_favorite(conn, *favorite)
            counts["tags"] = self._move_copy_tags(conn, move)
-            counts["categories"] = sum(
-                copy_image_category(conn, removed, kept)
-                for removed, kept in move.get("categories", ())
-            )
            for (item_id,) in conn.execute(
                _PENDING_OF_LOCATOR, (move["removed_locator"],)
            ).fetchall():
@@ -1,249 +0,0 @@
-"""Image categories (#332): an image file's own category.
-
-An image shows its own category when it has one, otherwise the category its
-link supplies (its recipe's, else its positive prompt's); this table holds
-only the own values. A row is keyed by the file key: the deepest configured
-output source that contains the file (its real, case-normalized path) and the
-path below it, case-folded where the OS folds case
-(``py/api/images.py`` ``image_category_key``). Without nested sources the key
-equals a favorite's key. Nothing follows a moved file: its row stays and is
-hidden until a file appears at the same path again.
-
-Writes validate strictly (the route strips the value and applies
-``validate_category``). Startup checks the structure only, so a value saved
-under older rules never stops the library opening; restore also checks the
-values. Optional in old backups, required once a database is current.
-"""
-
-import re
-import sqlite3
-from typing import Iterable
-
-TABLE = "image_categories"
-INDEX = "idx_image_categories_category"
-MAX_KEY_LENGTH = 4096
-MAX_CATEGORY_LENGTH = 100
-_DDL = (
-    f"CREATE TABLE {TABLE} (root_key TEXT NOT NULL, relative_path TEXT NOT NULL, "
-    "category TEXT NOT NULL, updated_at TEXT NOT NULL, "
-    "PRIMARY KEY (root_key, relative_path))"
-)
-_INDEX_DDL = f"CREATE INDEX {INDEX} ON {TABLE}(category)"
-_AUTOINDEX = f"sqlite_autoindex_{TABLE}_1"
-_COLUMNS = (
-    ("root_key", "TEXT", 1, 1),
-    ("relative_path", "TEXT", 1, 2),
-    ("category", "TEXT", 1, 0),
-    ("updated_at", "TEXT", 1, 0),
-)
-# A category may not hold a character below U+0020 (validate_category).
-_CONTROL_GLOB = "*[" + "".join(chr(code) for code in range(1, 32)) + "]*"
-
-CATEGORY_OF_SQL = (
-    f"SELECT category FROM {TABLE} WHERE root_key = ? AND relative_path = ?"
-)
-CATEGORIES_OF_ROOT_SQL = (
-    f"SELECT relative_path, category FROM {TABLE} WHERE root_key = ?"
-)
-UPSERT_SQL = (
-    f"INSERT INTO {TABLE} (root_key, relative_path, category, updated_at) "
-    "VALUES (?, ?, ?, ?) ON CONFLICT(root_key, relative_path) "
-    "DO UPDATE SET category = excluded.category, updated_at = excluded.updated_at"
-)
-DELETE_SQL = f"DELETE FROM {TABLE} WHERE root_key = ? AND relative_path = ?"
-# The duplicate cleanup's copy (#332 MC11): the removed copy's row is copied
-# to the kept copy only when the kept copy has none; it is never deleted.
-COPY_SQL = (
-    f"INSERT OR IGNORE INTO {TABLE} (root_key, relative_path, category, updated_at) "
-    f"SELECT ?, ?, category, updated_at FROM {TABLE} "
-    "WHERE root_key = ? AND relative_path = ?"
-)
-STATEMENTS = (CATEGORY_OF_SQL, CATEGORIES_OF_ROOT_SQL, UPSERT_SQL, DELETE_SQL, COPY_SQL)
-
-
-def _compact(sql: str) -> str:
-    return re.sub(r"\s+", "", sql or "").lower()
-
-
-def _structure_error(
-    conn: sqlite3.Connection, allow_missing: bool, allow_missing_index: bool = False
-) -> str | None:
-    objects = conn.execute(
-        "SELECT type,name,sql FROM sqlite_master WHERE name=? "
-        "OR (type IN ('index','trigger') AND tbl_name=?)",
-        (TABLE, TABLE),
-    ).fetchall()
-    if not objects:
-        return None if allow_missing else "Missing image categories schema"
-    tables = [sql for kind, _name, sql in objects if kind == "table"]
-    others = {(kind, name) for kind, name, _sql in objects if kind != "table"}
-    expected = {("index", _AUTOINDEX), ("index", INDEX)}
-    # Before its install, a table without the category index is repaired by
-    # CREATE INDEX IF NOT EXISTS rather than refused.
-    if allow_missing_index and others == {("index", _AUTOINDEX)}:
-        expected = others
-    if len(tables) != 1 or others != expected:
-        return "Image categories name is reserved by an unsupported schema object"
-    if _compact(tables[0]) != _compact(_DDL):
-        return "Image categories has an invalid table definition"
-    index_sql = next((sql for kind, name, sql in objects if name == INDEX), None)
-    if ("index", INDEX) in expected and _compact(index_sql) != _compact(_INDEX_DDL):
-        return "Image categories has an invalid index"
-    autoindex_sql = next(sql for kind, name, sql in objects if name == _AUTOINDEX)
-    if autoindex_sql is not None:
-        return "Image categories has an invalid index"
-    columns = tuple(
-        (row[1], row[2].upper(), row[3], row[5])
-        for row in conn.execute(f"PRAGMA table_info({TABLE})")
-    )
-    if columns != _COLUMNS:
-        return "Image categories has invalid columns"
-    return None
-
-
-def _values_error(conn: sqlite3.Connection) -> str | None:
-    # Bytes bound characters from above (UTF-8 is at most 4 bytes each).
-    limit = MAX_KEY_LENGTH * 4
-    if conn.execute(
-        f"SELECT 1 FROM {TABLE} WHERE typeof(root_key) != 'text' "  # nosec B608
-        "OR typeof(relative_path) != 'text' OR typeof(category) != 'text' "
-        "OR typeof(updated_at) != 'text' "
-        f"OR length(CAST(root_key AS BLOB)) > {limit} "
-        f"OR length(CAST(relative_path AS BLOB)) > {limit} "
-        "OR length(CAST(updated_at AS BLOB)) > 64 "
-        "OR instr(CAST(category AS BLOB), x'00') > 0 "
-        f"OR length(category) < 1 OR length(category) > {MAX_CATEGORY_LENGTH} "
-        "OR category != TRIM(category) OR category GLOB ? LIMIT 1",
-        (_CONTROL_GLOB,),
-    ).fetchone():
-        return "Image categories contains invalid values"
-    for root, path in conn.execute(
-        f"SELECT CAST(root_key AS BLOB), CAST(relative_path AS BLOB) "  # nosec B608
-        f"FROM {TABLE} WHERE length(CAST(root_key AS BLOB)) > {MAX_KEY_LENGTH} "
-        f"OR length(CAST(relative_path AS BLOB)) > {MAX_KEY_LENGTH}"
-    ):
-        for raw in (root, path):
-            if len(bytes(raw).decode("utf-8", "replace")) > MAX_KEY_LENGTH:
-                return "Image categories contains invalid values"
-    return None
-
-
-def image_categories_schema_error(
-    conn: sqlite3.Connection,
-    *,
-    allow_missing: bool = True,
-    check_values: bool = True,
-) -> str | None:
-    """Reject an unsupported image categories schema (and, optionally, values).
-
-    Reads only. A missing table is acceptable for backups that predate it
-    unless ``allow_missing`` is false. ``check_values`` also refuses a stored
-    value the write path could never have written.
-    """
-    error = _structure_error(conn, allow_missing)
-    if error is not None or not check_values:
-        return error
-    exists = conn.execute(
-        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (TABLE,)
-    ).fetchone()
-    return _values_error(conn) if exists else None
-
-
-def migrate_image_categories(conn: sqlite3.Connection) -> None:
-    """Install the table and its index atomically; structure is checked
-    before and after. Reads only ``sqlite_master`` and this table's PRAGMAs
-    and writes only its own two objects (no backfill)."""
-    conn.execute("SAVEPOINT image_categories_schema")
-    try:
-        error = _structure_error(conn, True, allow_missing_index=True)
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute(_DDL.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1))
-        conn.execute(
-            _INDEX_DDL.replace("CREATE INDEX", "CREATE INDEX IF NOT EXISTS", 1)
-        )
-        error = image_categories_schema_error(
-            conn, allow_missing=False, check_values=False
-        )
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute("RELEASE image_categories_schema")
-    except BaseException:
-        conn.execute("ROLLBACK TO image_categories_schema")
-        conn.execute("RELEASE image_categories_schema")
-        raise
-
-
-def copy_image_category(conn: sqlite3.Connection, removed_key, kept_key) -> int:
-    """Give the kept copy the removed copy's category when it has none.
-
-    Runs inside the caller's transaction; never deletes the removed copy's
-    row, so a give-back or a failed delete loses nothing. Returns 1 when a
-    row was inserted, else 0.
-    """
-    if tuple(removed_key) == tuple(kept_key):
-        return 0
-    return max(conn.execute(COPY_SQL, (*kept_key, *removed_key)).rowcount, 0)
-
-
-class ImageCategoryOperations:
-    """PromptDatabase mixin: set, clear and read images' own categories.
-
-    Never reads or writes ``prompts``, ``prompt_pairs`` or
-    ``generated_images``.
-    """
-
-    def image_category(self, root_key: str, relative_key: str) -> str | None:
-        """One file's own category, or None."""
-        row = (
-            self.model.get_connection()
-            .execute(CATEGORY_OF_SQL, (root_key, relative_key))
-            .fetchone()
-        )
-        return row[0] if row else None
-
-    def own_categories_of(self, root_keys: Iterable[str]) -> dict:
-        """``{(root key, relative key): category}`` under the given sources.
-
-        One primary-key range read per source.
-        """
-        found = {}
-        conn = self.model.get_connection()
-        for root_key in dict.fromkeys(root_keys):
-            for relative, category in conn.execute(CATEGORIES_OF_ROOT_SQL, (root_key,)):
-                found[(root_key, relative)] = category
-        return found
-
-    def set_image_categories(self, file_keys, category: str) -> dict:
-        """Set *category* on every file key, in one transaction.
-
-        ``file_keys``: ``(root key, relative key)`` pairs from any number of
-        sources. Returns ``{updated, unchanged}``; a file that already had
-        exactly this value is ``unchanged`` and keeps its ``updated_at``.
-        """
-        from .models import utc_now_iso  # models imports this module's schema
-
-        keys = list(dict.fromkeys(tuple(key) for key in file_keys))
-        counts = {"updated": 0, "unchanged": 0}
-        now = utc_now_iso()
-        with self._pair_transaction() as conn:
-            for key in keys:
-                row = conn.execute(CATEGORY_OF_SQL, key).fetchone()
-                if row is not None and row[0] == category:
-                    counts["unchanged"] += 1
-                    continue
-                conn.execute(UPSERT_SQL, (*key, category, now))
-                counts["updated"] += 1
-        return counts
-
-    def clear_image_categories(self, file_keys) -> int:
-        """Remove the own category of every file key (one transaction).
-
-        Returns the number of rows removed.
-        """
-        keys = list(dict.fromkeys(tuple(key) for key in file_keys))
-        removed = 0
-        with self._pair_transaction() as conn:
-            for key in keys:
-                removed += conn.execute(DELETE_SQL, key).rowcount
-        return removed
@@ -23,18 +23,12 @@ from . import restore_stage
 from .library_schema import library_schema_error, migrate_library_state
 from .image_favorites import image_favorites_schema_error, migrate_image_favorites
 from .annotation_schema import annotation_schema_error, migrate_annotation_state
-from .autotag_schema import (
-    autotag_schema_error,
-    autotag_without_annotations_error,
-    migrate_autotag_state,
-)
 from .review_schema import (
    migrate_review_state,
    review_schema_error,
    review_without_annotations_error,
 )
 from .saved_views import migrate_saved_views, saved_views_schema_error
-from .image_categories import image_categories_schema_error, migrate_image_categories
 from .workflow_documents import (
    DOCUMENT_ID_COLUMNS,
    migrate_workflow_documents,
@@ -344,15 +338,8 @@ class PromptModel:
        review_error = review_without_annotations_error(conn)
        if review_error:
            raise sqlite3.DatabaseError(review_error)
-        # The auto-tag marks cite annotation bytes the same way (#379).
-        autotag_error = autotag_without_annotations_error(conn)
-        if autotag_error:
-            raise sqlite3.DatabaseError(autotag_error)
        migrate_annotation_state(conn)
        migrate_review_state(conn)
-        migrate_autotag_state(conn)
-        # Image categories (#332): independent of every table above.
-        migrate_image_categories(conn)
        # Last: the older generated_images rebuilds run only before file_path.
        migrate_workflow_documents(conn)

@@ -1158,9 +1145,8 @@ class PromptModel:
        Args:
            path: File to inspect
            require_library_state: Also require the tables every current
-                database has (Library state, image favorites, image
-                categories, saved views, image annotations and the review
-                queue), as a migrated
+                database has (Library state, image favorites, saved views,
+                image annotations and the review queue), as a migrated
                restore stage must; old backups may lack them.
            documents: Read every workflow document and refuse a damaged
                one. A restore checks its upload without it and repairs
@@ -1224,11 +1210,6 @@ class PromptModel:
            )
            if favorites_error:
                return False, favorites_error
-            categories_error = image_categories_schema_error(
-                conn, allow_missing=not require_library_state
-            )
-            if categories_error:
-                return False, categories_error
            views_error = saved_views_schema_error(
                conn, allow_missing=not require_library_state
            )
@@ -1244,11 +1225,6 @@ class PromptModel:
            )
            if review_error:
                return False, review_error
-            autotag_error = autotag_schema_error(
-                conn, allow_missing=not require_library_state
-            )
-            if autotag_error:
-                return False, autotag_error
            documents_error = workflow_documents_schema_error(
                conn, allow_missing=not require_library_state, documents=documents
            )
@@ -7,12 +7,7 @@ import json
 import math
 import datetime
 import os
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple
-
-try:
-    from ..utils.inspection_response import inherited_category
-except ImportError:
-    from utils.inspection_response import inherited_category
+from typing import Optional, List, Dict, Any, Set, Tuple

 from .models import PromptModel, normalize_image_path, utc_now_iso
 from .pairs import PairDependencyError, PairOperations  # noqa: F401 (re-exported)
@@ -32,7 +27,6 @@ from .health import HealthOperations, iter_consistency_issues
 from .duplicate_copies import DuplicateCopyOperations
 from .workflow_storage import WorkflowStorageOperations
 from .category_import import CategoryImportOperations, EmptyReplacement  # noqa: F401
-from .image_categories import ImageCategoryOperations
 from .workflow_documents import (
    DocumentReader,
    documents_of_rows,
@@ -243,17 +237,12 @@ LEFT JOIN prompt_library_state pls ON pls.prompt_id = pp.positive_prompt_id
 WHERE gi.image_path IN ({marks}) OR gi.file_path IN ({marks}){fallback}"""
 # One image row describes a card only when no other row claims the same file
 # (as in get_image_link_summaries, several rows are ambiguous). The pair scope
-# and the linked positive follow _LINK_SUMMARY_SQL; rating, tags and the
-# searchable text and titles come from that positive (spec D12/D13). The raw
-# recipe and positive categories are read for the inherited category, which
-# Python decides (``inherited_category``, #332 MC4); SQL never filters by
-# category. Every
+# and the linked positive follow _LINK_SUMMARY_SQL; category, rating, tags and
+# the searchable text and titles come from that positive (spec D12/D13). Every
 # writer since the 3.2.4 migration stores file_path, so it is the path key.
 # The prompt-level conditions are uncorrelated IN sets SQLite builds once, and
 # the CASE evaluates the per-row ambiguity probe only for admitted rows.
-_LINK_FILTER_SQL = """SELECT gi.file_path AS file_path, p.rating AS rating,
-       {hit} AS matched, p.id AS positive, pp.id IS NOT NULL AS has_pair,
-       pp.category AS pair_category, p.category AS category
+_LINK_FILTER_SQL = """SELECT gi.file_path, p.rating, {hit}, p.id
 FROM generated_images gi
 LEFT JOIN prompt_pairs pp ON pp.id = (
    SELECT CASE WHEN COUNT(DISTINCT ip.pair_id) = 1 THEN MIN(ip.pair_id) END
@@ -262,31 +251,10 @@ JOIN prompts p ON p.id = COALESCE(pp.positive_prompt_id, gi.prompt_id)
 WHERE gi.file_path IS NOT NULL AND CASE WHEN {admit} THEN NOT EXISTS (
    SELECT 1 FROM generated_images other
    WHERE other.file_path = gi.file_path AND other.id <> gi.id) ELSE 0 END"""
-# _LINK_FILTER_SQL's rows as one JSON array, built by SQLite in one step (#354).
-# Python's sqlite3 releases and retakes the GIL around every step, so a read
-# that steps once per linked row waits on a busy ComfyUI thread thousands of
-# times. A BLOB value (no writer stores one) makes the value NULL (or
-# json_array refuses it), and the read streams instead. The raw categories are
-# put in only for a category read (#332), so plain reads stay as small as #354
-# measured them.
-_LINK_MATCHES_JSON_SQL = """SELECT CASE
-    WHEN max({blob}) THEN NULL
-    ELSE json_group_array(json_array({columns})) END
-FROM ({select})"""
-_LINK_PLAIN_COLUMNS = ("file_path", "rating", "matched", "positive")
-_LINK_CATEGORY_COLUMNS = _LINK_PLAIN_COLUMNS + ("has_pair", "pair_category", "category")
-# The columns a BLOB can reach: matched, positive and has_pair are computed.
-_LINK_STORED_COLUMNS = ("file_path", "rating", "pair_category", "category")
-# Set when this SQLite has no JSON functions: every later read streams.
-_one_step_unsupported = False
-# One warning per process when a read falls back to streaming.
-_one_step_warned = False
 # The linked positive of each given path (one unambiguous link, pair scope as
-# in _LINK_FILTER_SQL) with the raw categories of its inherited category; {hit}
-# as in link_filter_query. Used for the few files whose current image tags meet
-# a Tags filter (#249 B3).
-_LINK_FACTS_SQL = """SELECT gi.file_path, p.rating, {hit}, p.id,
-pp.id IS NOT NULL, pp.category, p.category
+# in _LINK_FILTER_SQL) with its category; {hit} as in link_filter_query. Used
+# for the few files whose current image tags meet a Tags filter (#249 B3).
+_LINK_FACTS_SQL = """SELECT gi.file_path, p.rating, {hit}, p.id, p.category
 FROM generated_images gi
 LEFT JOIN prompt_pairs pp ON pp.id = (
    SELECT CASE WHEN COUNT(DISTINCT ip.pair_id) = 1 THEN MIN(ip.pair_id) END
@@ -315,24 +283,8 @@ _LINK_FILTER_TAG = (
 )


-# One unambiguously linked image's facts for the Images filters, a plain tuple
-# (hit, rating, positive id, inherited category): built per linked row, so no
-# NamedTuple. The category is the inherited one (#332 MC4: the recipe's when
-# set, else the positive's), never the image's own category.
-LinkMatch = Tuple[bool, Optional[int], int, Any]
-
-
-def _link_match(rating, matched, positive, has_pair, pair_category, category):
-    inherited, _scope = inherited_category(category, pair_category, bool(has_pair))
-    return (bool(matched), rating, positive, inherited)
-
-
 def link_filter_query(
-    q: str,
-    tags: List[str],
-    *,
-    every_link: bool = False,
-    category: Optional[str] = None,
+    q: str, category: Optional[str], tags: List[str], *, every_link: bool = False
 ) -> Tuple[str, Dict[str, Any]]:
    """The workspace filter SELECT and its named parameters (all bound).

@@ -346,9 +298,7 @@ def link_filter_query(
        params["pattern"] = f"%{escape_like(q)}%"
    admitted = []
    if category is not None:
-        # Only narrows: an inherited category is one of the two raw values;
-        # which one is decided in Python (inherited_category, #332 MC4).
-        admitted.append("(p.category = :category OR pp.category = :category)")
+        admitted.append("p.category = :category")
        params["category"] = category
    for index, tag in enumerate(tags):
        admitted.append(_LINK_FILTER_TAG.format(index=index))
@@ -359,50 +309,6 @@ def link_filter_query(
    return sql, params


-def link_matches_json_query(sql: str, categories: bool = False) -> str:
-    """*sql* from link_filter_query, wrapped to return its rows as one JSON value.
-
-    With *categories* each row also carries the raw values the inherited
-    category is decided from; otherwise only path, rating, hit and positive.
-    """
-    columns = _LINK_CATEGORY_COLUMNS if categories else _LINK_PLAIN_COLUMNS
-    blob = " OR ".join(
-        f"typeof({name}) = 'blob'" for name in _LINK_STORED_COLUMNS if name in columns
-    )
-    return _LINK_MATCHES_JSON_SQL.format(
-        blob=blob, columns=", ".join(columns), select=sql
-    )
-
-
-def _link_matches_from_rows(
-    rows: Iterable[Sequence[Any]], categories: bool, wanted: Optional[Set[str]]
-) -> Dict[str, LinkMatch]:
-    """LinkMatch per wanted path from link rows (one-step or streamed).
-
-    Without *categories* the inherited category is None, as the caller then
-    never compares it.
-    """
-    matches: Dict[str, LinkMatch] = {}
-    for path, rating, matched, positive, *raw in rows:
-        if wanted is None or path in wanted:
-            if categories:
-                matches[path] = _link_match(rating, matched, positive, *raw[:3])
-            else:
-                matches[path] = (bool(matched), rating, positive, None)
-    return matches
-
-
-def _streamed_link_matches(
-    conn: sqlite3.Connection,
-    sql: str,
-    params: Dict[str, Any],
-    wanted: Optional[Set[str]],
-    categories: bool = False,
-) -> Dict[str, LinkMatch]:
-    """The link read stepped once per row (the fallback of the one-step read)."""
-    return _link_matches_from_rows(conn.execute(sql, params), categories, wanted)
-
-
 _ASCII_FOLD = str.maketrans("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz")


@@ -462,7 +368,6 @@ class PromptDatabase(
    DuplicateCopyOperations,
    WorkflowStorageOperations,
    CategoryImportOperations,
-    ImageCategoryOperations,
 ):
    """Database operations class for managing prompts."""

@@ -1903,6 +1808,37 @@ class PromptDatabase(
            reader = DocumentReader(conn)
            return [self._image_row_to_dict(row, reader) for row in cursor]

+    def autotag_batch_candidates(self) -> List[Dict[str, Any]]:
+        """The images a Tag output images batch looks at (#328).
+
+        ``{id, image_path, prompt_id, prompt_tags}`` for every image with a
+        stored path that is linked to a prompt, newest first (the
+        ``get_all_images`` order, ties newest row first). Never reads
+        ``workflow_data`` or the other documents: a batch needs none of them.
+        """
+        sql = (
+            "SELECT gi.id, gi.image_path, gi.prompt_id, "
+            "(SELECT GROUP_CONCAT(t.name, '|||') FROM prompt_tags pt "
+            "JOIN tags t ON pt.tag_id = t.id WHERE pt.prompt_id = gi.prompt_id) "
+            "AS prompt_tags "
+            "FROM generated_images gi "
+            "INNER JOIN prompts p ON gi.prompt_id = p.id "
+            "WHERE gi.image_path IS NOT NULL AND gi.image_path != '' "
+            "ORDER BY gi.generation_time DESC, gi.id DESC"
+        )
+        with self.model.get_connection() as conn:
+            return [
+                {
+                    "id": row["id"],
+                    "image_path": row["image_path"],
+                    "prompt_id": row["prompt_id"],
+                    "prompt_tags": (
+                        row["prompt_tags"].split("|||") if row["prompt_tags"] else []
+                    ),
+                }
+                for row in conn.execute(sql)
+            ]
+
    def get_all_images(
        self,
        limit: int = 0,
@@ -2636,94 +2572,38 @@ class PromptDatabase(
    def get_image_link_matches(
        self,
        q: str,
+        category: Optional[str],
        tags: List[str],
        *,
        every_link: bool = False,
        wanted: Optional[Set[str]] = None,
-        category: Optional[str] = None,
-    ) -> Dict[str, LinkMatch]:
-        """Map normalized paths of unambiguously linked images to a LinkMatch
-        (hit, rating, positive id, inherited category).
+    ) -> Dict[str, Tuple[bool, Optional[int], int]]:
+        """Map normalized paths of unambiguously linked images to
+        (hit, rating, positive id).

-        Rows are limited to images whose linked positive has every tag in
-        *tags* (exact names). The category filter is applied by the caller to
-        the effective category (#332). ``hit`` says whether *q* occurs in
+        Rows are limited to images whose linked positive has *category* and
+        every tag in *tags* (exact names). ``hit`` says whether *q* occurs in
        the positive's text, Library title or a tag name; a pair's own title
        names its negative variant and is not searched.
-        Without tags only hits are returned, unless *every_link*
+        Without category or tags only hits are returned, unless *every_link*
        asks for every linked image (the rating sort and the positive count).
-        The positive id is the card's linked positive. With *category* only
-        links whose raw recipe or positive category is that value are read (a
-        superset of the links that inherit it; the caller compares the
-        inherited value) and the inherited category is decided per row;
-        otherwise it is None, which keeps the plain reads cheap.
-
-        One SELECT, returned as one JSON value (#354): SQLite steps once, so
-        the read takes the GIL back a constant two or three times instead of
-        once per linked row while ComfyUI generates. Peak memory therefore
-        grows with the database's matching linked rows (about 530 bytes each,
-        more with the raw categories of a category read, freed on return); the
-        result is bounded by *wanted* (the listing's normalized paths) when
-        given. Where the JSON step fails (no JSON functions, a BLOB value, a
-        JSON text over SQLite's length limit) the rows are streamed as before.
+        The positive id is the card's linked positive. One SELECT whose rows
+        are streamed; with *wanted* (the listing's normalized paths) only those
+        paths are kept, so memory is bounded by the listing, not the database.
        """
-        sql, params = link_filter_query(
-            q, tags, every_link=every_link, category=category
-        )
-        categories = category is not None
+        sql, params = link_filter_query(q, category, tags, every_link=every_link)
+        matches: Dict[str, Tuple[bool, Optional[int], int]] = {}
        with self.model.get_connection() as conn:
-            rows = None
-            if not _one_step_unsupported:
-                rows = self._one_step_link_rows(conn, sql, params, categories)
-            if rows is None:
-                return _streamed_link_matches(conn, sql, params, wanted, categories)
-        return _link_matches_from_rows(rows, categories, wanted)
-
-    def _one_step_link_rows(
-        self,
-        conn: sqlite3.Connection,
-        sql: str,
-        params: Dict[str, Any],
-        categories: bool = False,
-    ) -> Optional[List[List[Any]]]:
-        """*sql*'s rows from one JSON value, or None when this read must stream.
-
-        An interrupted read (Move library retiring the connection) is raised
-        as before, never retried row by row.
-        """
-        global _one_step_unsupported, _one_step_warned
-        error: Optional[str] = None
-        try:
-            cursor = conn.execute(link_matches_json_query(sql, categories), params)
-            try:
-                ((document,),) = cursor.fetchall()
-            finally:
-                cursor.close()  # resets the statement: its snapshot ends now
-        except (sqlite3.OperationalError, sqlite3.DataError) as failure:
-            # DataError: the JSON text is longer than SQLITE_LIMIT_LENGTH.
-            error = str(failure)
-            if error == "interrupted":
-                raise
-            if error.startswith("no such function"):
-                _one_step_unsupported = True
-        else:
-            if document is not None:
-                return json.loads(document)
-            error = "a BLOB value"
-        if not _one_step_warned:
-            _one_step_warned = True
-            self.logger.warning(
-                "Reading image links row by row (slower while ComfyUI "
-                "generates); the one-step read failed: %s",
-                error,
-            )
-        return None
+            for path, rating, matched, positive in conn.execute(sql, params):
+                if wanted is None or path in wanted:
+                    matches[path] = (bool(matched), rating, positive)
+        return matches

    def get_image_link_facts(
        self, paths: List[str], q: str = ""
-    ) -> Dict[str, Tuple[bool, Optional[int], int, Any, Tuple[str, ...]]]:
+    ) -> Dict[str, Tuple[bool, Optional[int], int, Optional[str], Tuple[str, ...]]]:
        """Map each normalized path with one unambiguous link to its positive's
-        (hit, rating, positive id, inherited category, tag names).
+        (hit, rating, positive id, category, tag names).

        The link is resolved as in get_image_link_matches, and ``hit`` says
        whether *q* occurs in the positive's text, Library title or a tag
@@ -2734,7 +2614,7 @@ class PromptDatabase(
        if q:
            hit = _LINK_FILTER_HIT
            params["pattern"] = f"%{escape_like(q)}%"
-        rows: Dict[str, LinkMatch] = {}
+        rows: Dict[str, Tuple[bool, Optional[int], int, Optional[str]]] = {}
        names: Dict[int, List[str]] = {}
        unique = list(dict.fromkeys(paths))
        with self.model.get_connection() as conn:
@@ -2743,8 +2623,10 @@ class PromptDatabase(
                bound = {f"path{i}": path for i, path in enumerate(chunk)}
                marks = ",".join(f":{key}" for key in bound)
                sql = _LINK_FACTS_SQL.format(hit=hit, marks=marks)
-                for path, *row in conn.execute(sql, {**params, **bound}):
-                    rows[path] = _link_match(*row)
+                for path, rating, matched, positive, category in conn.execute(
+                    sql, {**params, **bound}
+                ):
+                    rows[path] = (bool(matched), rating, positive, category)
            positives = sorted({row[2] for row in rows.values()})
            for start in range(0, len(positives), _FACTS_CHUNK):
                chunk = positives[start : start + _FACTS_CHUNK]
@@ -2757,16 +2639,20 @@ class PromptDatabase(
            path: (*row, tuple(names.get(row[2], ()))) for path, row in rows.items()
        }

-    def get_image_paths_matching(self, q: str, tags: List[str]) -> Set[str]:
-        """Normalized paths whose linked positive matches *q* and *tags*.
+    def get_image_paths_matching(
+        self, q: str, category: Optional[str], tags: List[str]
+    ) -> Set[str]:
+        """Normalized paths whose linked positive matches *q*, *category* and *tags*.

        See get_image_link_matches; an empty *q* matches every linked image
-        the tags admit.
+        the category and tags admit.
        """
        return {
            path
-            for path, match in self.get_image_link_matches(q, tags).items()
-            if match[0] or not q
+            for path, (hit, _rating, _positive) in self.get_image_link_matches(
+                q, category, tags
+            ).items()
+            if hit or not q
        }

    def get_prompt_id_for_image(self, image_path: str) -> Optional[int]:
@@ -229,15 +229,13 @@ def evidence_offers_choice(evidence: Any) -> bool:
    """
    if not isinstance(evidence, dict):
        return False
-    # The saver anchor's one pair (#390) is a suggestion to confirm.
-    needed = 1 if evidence.get("anchor") == "saver" else MIN_CHOOSABLE
    if evidence.get("limited"):
        total = evidence.get("candidate_total")
-        return type(total) is int and total >= needed
+        return type(total) is int and total >= MIN_CHOOSABLE
    candidates = evidence.get("candidates")
    if not isinstance(candidates, list):
        return False
-    return sum(1 for c in candidates if choosable(c)) >= needed
+    return sum(1 for c in candidates if choosable(c)) >= MIN_CHOOSABLE


 def evidence_digest(text: str) -> str:
@@ -15,10 +15,6 @@ only when all of this holds:

 Anything else returns None: the caller leaves the file unlinked. Read-only.

-``recorded_output`` applies the first two rules and returns, for the
-inspector (#386), the one output node (save node) that run reported the file
-from and the texts PromptManager recorded at execution per sampler.
-
 Lookups are batched (``stored_run_prompts``): one parameterized query per
 chunk of at most ``LOOKUP_CHUNK`` distinct file names, matched in memory. The
 history schema is left exactly as it is (no extra index), so older builds can
@@ -30,7 +26,6 @@ import os
 import sqlite3
 import threading
 import weakref
-from dataclasses import dataclass
 from typing import Any, Callable, Dict, Iterable, List, Optional

 try:
@@ -50,8 +45,7 @@ LOOKUP_CHUNK = 500

 _RUNS_FOR_NAMES = (
    "SELECT DISTINCT o.filename, o.subfolder, o.root_key, o.path_style, o.run_id, "
-    "r.observed_dequeue_at, COALESCE(r.terminal_event_at, r.observed_callback_at), "
-    "o.output_node_id "
+    "r.observed_dequeue_at, COALESCE(r.terminal_event_at, r.observed_callback_at) "
    "FROM execution_run_outputs o JOIN execution_runs r ON r.run_id = o.run_id "
    "WHERE o.folder_type = 'output' AND o.filename IN ({marks})"
 )
@@ -144,10 +138,9 @@ def stored_run_prompt(


 def _runs_by_location(db: Any, names: List[str]) -> Optional[Dict[tuple, dict]]:
-    """``{(filename, subfolder, root_key, style): {run_id: (start, end, nodes)}}``.
+    """``{(filename, subfolder, root_key, style): {run_id: (start, end)}}``.

-    ``nodes`` is the set of output node ids that reported the location in that
-    run. One query per ``LOOKUP_CHUNK`` names; None without history tables.
+    One query per ``LOOKUP_CHUNK`` names; None without history tables.
    """
    found: Dict[tuple, dict] = {}
    conn = db.model.get_connection()
@@ -158,49 +151,12 @@ def _runs_by_location(db: Any, names: List[str]) -> Optional[Dict[tuple, dict]]:
            rows = conn.execute(query, chunk).fetchall()  # nosec B608
        except sqlite3.Error:
            return None  # no history tables (a library without history)
-        for name, subfolder, root_key, style, run_id, began, ended, node in rows:
+        for name, subfolder, root_key, style, run_id, began, ended in rows:
            runs = found.setdefault((name, subfolder, root_key, style), {})
-            runs.setdefault(run_id, (began, ended, set()))[2].add(node)
+            runs[run_id] = (began, ended)
    return found


-def _recorded_runs(
-    db: Any,
-    image_paths: Iterable[str],
-    output_root: Optional[str],
-    path_style: Optional[str],
-) -> Dict[str, tuple]:
-    """``{path: (run_id, output node ids)}`` for each file history attributes.
-
-    A file is attributed when exactly one recorded run reported its location
-    and it was last written while that run executed.
-    """
-    paths = list(dict.fromkeys(path for path in image_paths if path))
-    if not paths or not output_root:
-        return {}
-    style = path_style or ("windows" if os.name == "nt" else "posix")
-    located = {}
-    for path in paths:
-        location = _location(path, output_root, style)
-        if location is not None:
-            located[path] = location
-    if not located:
-        return {}
-    names = sorted({filename for _key, _sub, filename in located.values()})
-    runs = _runs_by_location(db, names)
-    if not runs:
-        return {}
-    attributed = {}
-    for path, (root_key, subfolder, filename) in located.items():
-        reported = runs.get((filename, subfolder, root_key, style), {})
-        if len(reported) != 1:
-            continue
-        ((run_id, (began, ended, nodes)),) = reported.items()
-        if _written_during(path, began, ended):
-            attributed[path] = (run_id, nodes)
-    return attributed
-
-
 def _named_prompt(db: Any, run_id: str) -> Optional[int]:
    contexts = db.get_execution_contexts(run_id).get("contexts") or []
    named = {
@@ -227,115 +183,35 @@ def stored_run_prompts(
    """
    paths = list(dict.fromkeys(path for path in image_paths if path))
    result: Dict[str, Optional[int]] = dict.fromkeys(paths)
+    if not paths or not output_root:
+        return result
+    style = path_style or ("windows" if os.name == "nt" else "posix")
+    located = {}
+    for path in paths:
+        location = _location(path, output_root, style)
+        if location is not None:
+            located[path] = location
+    if not located:
+        return result
+    names = sorted({filename for _key, _sub, filename in located.values()})
+    runs = _runs_by_location(db, names)
+    if not runs:
+        return result
    prompts: Dict[str, Optional[int]] = {}
-    for path, (run_id, _nodes) in _recorded_runs(
-        db, paths, output_root, path_style
-    ).items():
+    for path, (root_key, subfolder, filename) in located.items():
+        reported = runs.get((filename, subfolder, root_key, style), {})
+        if len(reported) != 1:
+            continue
+        ((run_id, (began, ended)),) = reported.items()
+        if not _written_during(path, began, ended):
+            continue
        if run_id not in prompts:
            prompts[run_id] = _named_prompt(db, run_id)
        result[path] = prompts[run_id]
    return result


-@dataclass(frozen=True)
-class RecordedOutput:
-    """What recorded history knows about the run that wrote one file (#386).
-
-    ``saver_id`` is the one output node the run reported the file from (None
-    when several did). ``texts`` maps each sampler anchor of the run to the
-    effective texts PromptManager recorded at execution for its roles
-    (``{"positive": text or None, "negative": text or None}``); a role whose
-    text was only inferred from the graph is None.
-    """
-
-    saver_id: Optional[str]
-    texts: Dict[str, Dict[str, Optional[str]]]
-
-
-def _recorded_texts(db: Any, run_id: str) -> Dict[str, Dict[str, Optional[str]]]:
-    texts = {}
-    for context in db.get_execution_contexts(run_id).get("contexts") or []:
-        evidence = context.get("evidence") or {}
-        roles = {}
-        for role in ("positive", "negative"):
-            values = context.get(role) or {}
-            proof = (evidence.get(role) or {}).get("effective") or {}
-            value = values.get("effective")
-            recorded = proof.get("provenance") == "recorded"
-            roles[role] = value if recorded and isinstance(value, str) else None
-        texts[context["anchor_id"]] = roles
-    return texts
-
-
-def recorded_output(
-    db: Any,
-    image_path: str,
-    output_root: Optional[str],
-    path_style: Optional[str] = None,
-) -> Optional[RecordedOutput]:
-    """The recorded run facts for ``image_path``, else None (#386).
-
-    The file must be attributed to one run (``_recorded_runs``: one run
-    reported its location and it was written during that run). Read-only; it
-    never links anything.
-    """
-    if not image_path:
-        return None
-    conn = db.model.get_connection()
-    own_transaction = not conn.in_transaction
-    if own_transaction:  # outputs and texts from one state of history
-        conn.execute("BEGIN")
-    try:
-        found = _recorded_runs(db, [image_path], output_root, path_style)
-        if image_path not in found:
-            return None
-        run_id, nodes = found[image_path]
-        saver = next(iter(nodes)) if len(nodes) == 1 else None
-        return RecordedOutput(saver, _recorded_texts(db, run_id))
-    finally:
-        if own_transaction:
-            conn.rollback()
-
-
 _LOGGER = logging.getLogger("prompt_manager.run_attribution")
-
-
-def recorded_output_lookup(
-    db: Any, *, close: bool = False, reference: Optional[dict] = None
-) -> Callable[[Any], Any]:
-    """``lookup(path) -> RecordedOutput or None`` for the inspect routes (#386).
-
-    Uses ComfyUI's output folder. Any failure (no history, a locked library)
-    is logged and names no node, so the file is judged from its own metadata.
-    ``close`` closes the calling thread's connection afterwards, for routes
-    that close theirs after reading. ``reference`` (a history occurrence's
-    output reference) spells the file as history recorded it: the route's
-    target is case-normalized on Windows, and history matches names exactly.
-    """
-
-    def lookup(path: Any) -> Optional[RecordedOutput]:
-        root = host_output_directory()
-        if reference is not None:
-            if reference.get("folder_type") != "output" or not root:
-                return None
-            path = os.path.join(
-                root, reference.get("subfolder") or "", reference.get("filename") or ""
-            )
-        try:
-            return recorded_output(db, str(path), root)
-        except (sqlite3.Error, OSError, ValueError):
-            _LOGGER.warning("Recorded run lookup failed", exc_info=True)
-            return None
-        except Exception:
-            _LOGGER.exception("Recorded run lookup failed unexpectedly")
-            return None
-        finally:
-            if close:
-                db.model.close()
-
-    return lookup
-
-
 _SEALED_LISTENERS: List[weakref.WeakMethod] = []
 _SEALED_LOCK = threading.Lock()

@@ -13,9 +13,7 @@ same connection before commit. Owner rows and their timestamps never change.

 Category consolidation is previewed in one ``library_snapshot`` and applied in
 one ``_pair_transaction`` that recomputes the owner projection and requires the
-preview's ``impact_token``; only rows carrying the exact source change. Image
-rows holding the source (``image_categories``, #332) are owners too: they are
-counted, hashed into the token and renamed with the prompts and pairs.
+preview's ``impact_token``; only rows carrying the exact source change.
 """

 import sqlite3
@@ -99,30 +97,16 @@ def _validate_tag_id(tag_id: object) -> None:
        raise ValueError("Invalid tag ID")


-# Category values in Tags & categories (#332 §7): the prompt-backed values
-# (nonblank values on eligible parents or on active pairs, grouped exactly, so
-# whitespace and case variants stay distinct; /library/options lists the same
-# prompt-backed set with its own query) plus the values only image rows hold.
-# A prompt-backed value is ordered by its oldest owning positive; an image-only
-# value sorts after all of them (first_pid is SQLite's INTEGER maximum, above
-# any prompt id), then by value. ``image_count`` counts stored rows, including
-# files missing on disk. No FULL OUTER JOIN, so it runs on SQLite 3.31+.
-_IMAGE_ONLY_FIRST_PID = 2**63 - 1
-_CATEGORY_ROWS = (
+# The /library/options universe: nonblank values on eligible parents or on
+# active pairs, grouped exactly (whitespace and case variants stay distinct).
+_CATEGORY_GROUPS = (
    "WITH owners(value,pid) AS ("
    "SELECT p.category,p.id FROM prompts p WHERE p.category IS NOT NULL "
    "AND TRIM(p.category)!='' AND " + _ELIGIBLE + " "
    "UNION SELECT pp.category,pp.positive_prompt_id FROM prompt_pairs pp "
    "WHERE pp.archived=0 AND pp.category IS NOT NULL AND TRIM(pp.category)!=''),"
-    "image_values(value,image_count) AS ("
-    "SELECT category,COUNT(*) FROM image_categories GROUP BY category),"
-    "grouped(value,first_pid,prompt_count) AS ("
-    "SELECT value,MIN(pid),COUNT(DISTINCT pid) FROM owners GROUP BY value "
-    "UNION ALL SELECT value," + str(_IMAGE_ONLY_FIRST_PID) + ",0 FROM image_values "
-    "WHERE value NOT IN (SELECT value FROM owners)),"
-    "counted AS (SELECT g.value,g.first_pid,g.prompt_count,"
-    "COALESCE(i.image_count,0) AS image_count FROM grouped g "
-    "LEFT JOIN image_values i ON i.value=g.value) "
+    "grouped AS (SELECT value,MIN(pid) AS first_pid,"
+    "COUNT(DISTINCT pid) AS prompt_count FROM owners GROUP BY value) "
 )


@@ -133,23 +117,15 @@ _CATEGORY_COMPONENTS = (
    "WHERE p.category=? ORDER BY p.id"
 )
 _CATEGORY_PAIRS = "SELECT id,archived FROM prompt_pairs WHERE category=? ORDER BY id"
-# Image rows holding one exact value (#332 DC7), an index search.
-_IMAGE_CATEGORY_ROWIDS = (
-    "SELECT rowid FROM image_categories WHERE category=? ORDER BY rowid"
-)
 _CATEGORY_EXISTS = (
    "SELECT EXISTS(SELECT 1 FROM prompts WHERE category=:v)"
    " OR EXISTS(SELECT 1 FROM prompt_pairs WHERE category=:v)"
-    " OR EXISTS(SELECT 1 FROM image_categories WHERE category=:v)"
 )

-# Pairs after components and image rows last, so a failing update rolls every
-# earlier one back. An image row is keyed by its file, never by its value, so
-# merging into a value other files already hold cannot conflict.
+# Pairs after components, so a failing pair update rolls both back.
 _CATEGORY_UPDATES = (
    "UPDATE prompts SET category=?,updated_at=? WHERE category=?",
    "UPDATE prompt_pairs SET category=?,updated_at=? WHERE category=?",
-    "UPDATE image_categories SET category=?,updated_at=? WHERE category=?",
 )


@@ -160,15 +136,8 @@ def category_impact_token(
    target_exists: bool,
    components: list,
    pairs: list,
-    *,
-    images: list = (),
 ) -> str:
-    """Hash a category projection like ``library_edit_token`` (no secret).
-
-    ``images`` are the rowids of the image rows holding ``source`` (#332 DC7).
-    With none the preimage has no ``images`` key, so a prompt-only token keeps
-    the value it had before image categories existed.
-    """
+    """Hash a category projection like ``library_edit_token`` (no secret)."""
    preimage = {
        "epoch": epoch,
        "source": source,
@@ -177,8 +146,6 @@ def category_impact_token(
        "components": sorted([int(i), bool(flag)] for i, flag in components),
        "pairs": sorted([int(i), bool(flag)] for i, flag in pairs),
    }
-    if images:
-        preimage["images"] = sorted(int(i) for i in images)
    return canonical_token(_CATEGORY_DOMAIN, preimage)


@@ -358,8 +325,7 @@ class VocabularyOperations:
        pairs = [
            [row[0], bool(row[1])] for row in conn.execute(_CATEGORY_PAIRS, (source,))
        ]
-        images = [row[0] for row in conn.execute(_IMAGE_CATEGORY_ROWIDS, (source,))]
-        if not components and not pairs and not images:
+        if not components and not pairs:
            raise LibraryCommandError("vocabulary-conflict", epoch)
        target_exists = bool(
            conn.execute(_CATEGORY_EXISTS, {"v": target}).fetchone()[0]
@@ -373,10 +339,9 @@ class VocabularyOperations:
                "other_prompts": len(components) - eligible,
                "negative_variants": len(pairs) - archived,
                "archived_negative_variants": archived,
-                "images": len(images),
            },
            "impact_token": category_impact_token(
-                epoch, source, target, target_exists, components, pairs, images=images
+                epoch, source, target, target_exists, components, pairs
            ),
        }

@@ -400,8 +365,7 @@ class VocabularyOperations:
    def apply_vocabulary_category(
        self, *, expected_epoch: str, source: str, target: str, impact_token: str
    ) -> dict:
-        """Set the exact ``source`` to ``target`` on every component, pair
-        and image row.
+        """Set the exact ``source`` to ``target`` on every component and pair.

        The recomputed projection must still match the preview's token; a
        mismatch is ``vocabulary-conflict`` with nothing written.
@@ -458,15 +422,15 @@ class VocabularyOperations:
        _limit(limit)
        key = _category_after(after)
        total = conn.execute(
-            _CATEGORY_ROWS + "SELECT COUNT(*) FROM counted"
+            _CATEGORY_GROUPS + "SELECT COUNT(*) FROM grouped"
        ).fetchone()[0]
        where, params = "", []
        if key is not None:
            where = " WHERE first_pid>? OR (first_pid=? AND value>?)"
            params = [key[0], key[0], key[1]]
        rows = conn.execute(
-            _CATEGORY_ROWS
-            + "SELECT value,first_pid,prompt_count,image_count FROM counted"
+            _CATEGORY_GROUPS
+            + "SELECT value,first_pid,prompt_count FROM grouped"
            + where
            + " ORDER BY first_pid,value LIMIT ?",
            [*params, limit + 1],
@@ -476,11 +440,7 @@ class VocabularyOperations:
        return {
            "library_epoch": epoch,
            "categories": [
-                {
-                    "value": row["value"],
-                    "prompt_count": row["prompt_count"],
-                    "image_count": row["image_count"],
-                }
+                {"value": row["value"], "prompt_count": row["prompt_count"]}
                for row in rows
            ],
            "total": total,
@@ -72,7 +72,6 @@ from .diagnostics_report import DiagnosticsReportMixin
 from .autotag_routes import AutotagRoutesMixin
 from .lora_integration import LoraIntegrationMixin
 from .lora_import_routes import LoraImportRoutesMixin
-from .image_categories import ImageCategoryRoutesMixin

 try:
    from ...database.operations import PromptDatabase
@@ -296,10 +295,6 @@ async def _gzip_middleware(request, handler):
    if len(compressed) >= len(body):
        return response

-    # A length the handler declared is the uncompressed one: drop it so the
-    # compressed body's own length is sent (#329: a stale length made the
-    # browser wait for bytes that never came).
-    response.headers.pop("Content-Length", None)
    response.body = compressed
    response.headers["Content-Encoding"] = "gzip"
    response.headers["Vary"] = "Accept-Encoding"
@@ -337,7 +332,6 @@ class PromptManagerAPI(
    AutotagRoutesMixin,
    LoraIntegrationMixin,
    LoraImportRoutesMixin,
-    ImageCategoryRoutesMixin,
 ):
    """REST API handler for PromptManager operations and web interface.

@@ -365,9 +359,6 @@ class PromptManagerAPI(
        # Private media captures of the annotation routes (py/api/annotations.py),
        # created on first use with their restore subscription.
        self._captures = None
-        # Capture tokens Generate suggestions ran on: a save of one marks the
-        # image auto-tagged (#379).
-        self._suggested_tokens = set()
        self._captures_unsubscribe = None
        # Set by close_annotation_captures (shutdown): no store is recreated.
        self._captures_closed = False
@@ -702,7 +693,6 @@ class PromptManagerAPI(
        self._register_autotag_routes(routes)
        self._register_lora_routes(routes)
        self._register_lora_import_routes(routes)
-        self._register_image_category_routes(routes)

        # Register gzip compression middleware (once)
        global _gzip_registered
@@ -1110,3 +1100,196 @@ class PromptManagerAPI(
                        result["parameters"][field] = metadata[field]

        return result
+
+    def _extract_readable_prompt(self, parsed_data):
+        """Extract human-readable prompt text from ComfyUI/A1111 data."""
+
+        def safe_to_string(value):
+            if isinstance(value, str):
+                return value
+            elif isinstance(value, list):
+                return " ".join(str(item) for item in value if item)
+            elif value is not None:
+                return str(value)
+            return None
+
+        # First check if we already extracted a positive prompt (A1111 format)
+        if parsed_data.get("positive_prompt"):
+            return parsed_data["positive_prompt"]
+
+        # Check if prompt is already a string
+        if isinstance(parsed_data.get("prompt"), str):
+            return parsed_data["prompt"]
+
+        # Check if prompt is a simple value that can be converted
+        if parsed_data.get("prompt") and not isinstance(
+            parsed_data.get("prompt"), dict
+        ):
+            return safe_to_string(parsed_data["prompt"])
+
+        prompt_data = parsed_data.get("prompt")
+        if isinstance(prompt_data, dict):
+            # Use the enhanced logic from parse-metadata.py
+            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
+                prompt_data
+            )
+            if positive_prompt:
+                return positive_prompt
+
+        # Check workflow data if available
+        workflow_data = parsed_data.get("workflow")
+        if isinstance(workflow_data, dict):
+            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
+                workflow_data
+            )
+            if positive_prompt:
+                return positive_prompt
+
+        # Check parameters for positive prompt
+        if parsed_data.get("parameters", {}).get("positive"):
+            return safe_to_string(parsed_data["parameters"]["positive"])
+
+        return None
+
+    def _get_node_inputs(self, node):
+        """Safely get inputs from a node, handling both dict and list formats.
+
+        Old format: inputs is a dict with direct key-value pairs
+            inputs = {"text": "my prompt", "seed": 123}
+
+        New format: inputs is a list of connection objects
+            inputs = [
+                {"name": "text", "type": "STRING", "link": null,
+                 "widget": {"name": "text"}},
+                {"name": "clip", "type": "CLIP", "link": 11}
+            ]
+        """
+        if not isinstance(node, dict):
+            return {}
+
+        inputs = node.get("inputs", {})
+
+        # If inputs is already a dict, return it
+        if isinstance(inputs, dict):
+            return inputs
+
+        # If inputs is a list, convert to dict format
+        if isinstance(inputs, list):
+            inputs_dict = {}
+            for input_item in inputs:
+                if isinstance(input_item, dict) and "name" in input_item:
+                    name = input_item["name"]
+                    inputs_dict[name] = input_item
+            return inputs_dict
+
+        return {}
+
+    def _find_text_in_node(self, node):
+        """Try to find text content in a node using various strategies.
+
+        Handles both old and new workflow formats.
+        """
+        if not isinstance(node, dict):
+            return None
+
+        # Strategy 1: Check normalized inputs for 'text' field
+        inputs = self._get_node_inputs(node)
+        if "text" in inputs and isinstance(inputs["text"], str):
+            return inputs["text"]
+
+        # Strategy 2: For text encoder nodes, check widgets_values
+        class_type = node.get("class_type", node.get("type", ""))
+        text_encoder_types = [
+            "CLIPTextEncode",
+            "CLIPTextEncodeSDXL",
+            "CLIPTextEncodeSDXLRefiner",
+            "CLIPTextEncodeFlux",
+            "PromptManager",
+            "PromptManagerText",
+            "BNK_CLIPTextEncoder",
+            "Text Encoder",
+            "CLIP Text Encode",
+        ]
+
+        if any(
+            encoder_type.lower() in class_type.lower()
+            for encoder_type in text_encoder_types
+        ):
+            widgets_values = node.get("widgets_values", [])
+            if widgets_values and len(widgets_values) > 0:
+                if isinstance(widgets_values[0], str) and widgets_values[0].strip():
+                    return widgets_values[0]
+
+        return None
+
+    def _extract_positive_prompt_from_comfyui_data(self, data):
+        """Extract positive prompt from ComfyUI data.
+
+        Handles both old and new formats.
+        """
+        if not isinstance(data, dict):
+            return None
+
+        # Build nodes dictionary
+        nodes_by_id = {}
+        if "nodes" in data:
+            # Handle nodes array format
+            for node in data["nodes"]:
+                if isinstance(node, dict):
+                    nid = node.get("id")
+                    if nid is not None:
+                        nodes_by_id[nid] = node
+        else:
+            # Handle flat dictionary format (node_id -> node_data)
+            for nid_str, node in data.items():
+                try:
+                    nid = int(nid_str)
+                except (ValueError, TypeError):
+                    nid = nid_str
+                if isinstance(node, dict):
+                    if "id" in node:
+                        nid = node["id"]
+                    nodes_by_id[nid] = node
+
+        if not nodes_by_id:
+            return None
+
+        # First, try to find positive/negative connection pattern
+        pos_id = None
+        for node in nodes_by_id.values():
+            if isinstance(node, dict):
+                inputs = self._get_node_inputs(node)
+                if "positive" in inputs and "negative" in inputs:
+                    try:
+                        pos_input = inputs["positive"]
+                        if isinstance(pos_input, list) and len(pos_input) > 0:
+                            pos_id = int(pos_input[0])
+                            break
+                    except (ValueError, TypeError, IndexError):
+                        continue
+
+        # Get text from the positive node
+        if pos_id is not None and pos_id in nodes_by_id:
+            text_val = self._find_text_in_node(nodes_by_id[pos_id])
+            if text_val:
+                return text_val
+
+        # Fallback: find any text encoder node with text content
+        text_nodes = []
+        for node in nodes_by_id.values():
+            if isinstance(node, dict):
+                text_val = self._find_text_in_node(node)
+                if text_val:
+                    # Try to determine if this is positive or negative
+                    node_title = node.get("title", "").lower()
+                    if "neg" not in node_title and "negative" not in node_title:
+                        # Prioritize non-negative prompts
+                        text_nodes.insert(0, text_val)
+                    else:
+                        text_nodes.append(text_val)
+
+        # Return the first positive-looking prompt
+        if text_nodes:
+            return text_nodes[0]
+
+        return None
@@ -34,11 +34,6 @@ try:
 except ImportError:
    from utils.parallel import map_parallel

-try:
-    from ...utils import exit_signal
-except ImportError:
-    from utils import exit_signal
-
 try:
    from ...database.pair_ingestion import blank_positive, ingest_resolved_pair
    from ...database.run_attribution import (
@@ -52,7 +47,7 @@ try:
        extract_generation_params,
        parse_page_json,
    )
-    from ...utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
+    from ...utils.prompt_pair_resolver import resolve_prompt_pair
    from ...utils.review_capture import reviewable
 except ImportError:
    from database.pair_ingestion import blank_positive, ingest_resolved_pair
@@ -67,7 +62,7 @@ except ImportError:
        extract_generation_params,
        parse_page_json,
    )
-    from utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
+    from utils.prompt_pair_resolver import resolve_prompt_pair
    from utils.review_capture import reviewable


@@ -123,7 +118,6 @@ def _collect_media_files(output_dirs, extensions):
        if not os.path.isdir(root):
            continue
        for current, dirnames, filenames in os.walk(root, followlinks=False):
-            exit_signal.checkpoint()  # #376: stop between directories at exit
            depth = 0 if current == root else len(Path(current).relative_to(root).parts)
            dirnames[:] = sorted(
                d
@@ -1636,14 +1630,7 @@ class AdminRoutesMixin:
                if self._review_file_linked(media_file, roots):
                    outcome = "unchanged"  # already linked: not a review case
                else:
-                    # The records name the item versions that count; the
-                    # saver anchor (#390) is checked on the captured bytes.
-                    self._record_scanned_review(
-                        media_file,
-                        roots,
-                        review,
-                        scanned=(records.get("canonical"), None),
-                    )
+                    self._record_scanned_review(media_file, roots, review)
            elif untraced and outcome == "unresolved":
                # Untraced by the default profile: the inspection profile may
                # still offer a choice (queued for review, never linked).
@@ -1704,9 +1691,9 @@ class AdminRoutesMixin:
        ``"ambiguous"`` (nothing linked it) is a Needs review case. An
        ambiguous result with nothing to choose (``reviewable`` is False: fewer
        than two candidates carry a prompt) that nothing links returns
-        ``"unresolved"`` instead, and ``media_file`` goes to ``untraced``.
-        The parsed records of either ambiguous file go to
-        ``records["canonical"]`` when ``records`` is a dict.
+        ``"unresolved"`` instead, and ``media_file`` goes to ``untraced``;
+        its parsed records go to ``records["canonical"]`` when ``records`` is
+        a dict.
        """
        if not metadata:
            # No prompt metadata (--disable-metadata, bare savers): only the
@@ -1736,8 +1723,6 @@ class AdminRoutesMixin:
                records["canonical"] = canonical
        elif resolution["state"] == "ambiguous" and ambiguous is not None:
            ambiguous.append(media_file)
-            if records is not None:
-                records["canonical"] = canonical
        if resolution["state"] == "resolved":
            result = ingest_resolved_pair(
                self.db, str(media_file), canonical, resolution
@@ -1769,24 +1754,13 @@ class AdminRoutesMixin:
            canonical.get("parameters"), str
        ):
            return resolution["state"]
-        elif canonical.get("prompt"):
-            # No node takes a positive or negative input (a guider or wrapper
-            # graph): the one wired text, never a guess (#252).
-            found = sampler_less_prompt(canonical["prompt"])
-            prompt_text = found["text"]
-            if prompt_text is None and isinstance(canonical.get("parameters"), str):
-                # A metadata saver also wrote A1111 text: its positive prompt.
-                parsed = self._parse_comfyui_prompt(metadata)["positive_prompt"]
-                prompt_text = parsed.strip() if parsed and parsed.strip() else None
-            if prompt_text is None:
-                linked = self._link_recorded_run(
-                    media_file, canonical, detailed, history
-                )
-                if linked is not None:
-                    return linked
-                return "unresolved" if found["state"] == "ambiguous" else "found"
        else:
-            prompt_text = self._parse_comfyui_prompt(metadata)["positive_prompt"]
+            parsed = self._parse_comfyui_prompt(metadata)
+            if not (parsed.get("prompt") or parsed.get("parameters")):
+                return None
+            prompt_text = self._extract_readable_prompt(parsed)
+            if prompt_text is not None and not isinstance(prompt_text, str):
+                prompt_text = str(prompt_text)
            if not (prompt_text and prompt_text.strip()):
                return "found"
            prompt_text = prompt_text.strip()
@@ -27,12 +27,7 @@ from .annotation_suggest import (
    validate_options,
 )
 from .autotag_routes import model_busy_response
-
-# The target check is shared with the collection routes (#331); both names
-# stay importable from here.
-from .media_target import MAX_TARGET_PATH  # noqa: F401
-from .media_target import media_target as _target
-from .images import _unavailable_link, _verified_title
+from .images import _forbidden, _has_traversal, _unavailable_link, _verified_title
 from .prompts import bad_request
 from .. import model_gate

@@ -45,7 +40,7 @@ try:
    )
    from ...database.execution_history import subscribe_history_restore
    from ...database.library_commands import LibraryCommandError
-    from ...utils.media_capture import CaptureError, CaptureStore
+    from ...utils.media_capture import CAPTURE_EXTENSIONS, CaptureError, CaptureStore
 except ImportError:
    from database.annotations import (
        MAX_IMAGE_TAGS,
@@ -55,13 +50,15 @@ except ImportError:
    )
    from database.execution_history import subscribe_history_restore
    from database.library_commands import LibraryCommandError
-    from utils.media_capture import CaptureError, CaptureStore
+    from utils.media_capture import CAPTURE_EXTENSIONS, CaptureError, CaptureStore

 # Request bodies of the annotation routes are small (a target plus a tag set).
 MAX_BODY_BYTES = 64 * 1024
+MAX_TARGET_PATH = 1024
 CAPTURE_URL = "/prompt_manager/image-annotations/capture/"
 _PREVIEW_CHUNK = 64 * 1024

+_TARGET_FIELDS = frozenset({"root_index", "root_scope", "path"})
 _OBSERVE_FIELDS = frozenset({"target"})
 _SAVE_FIELDS = frozenset(
    {
@@ -191,6 +188,37 @@ def _capture_error(exc: CaptureError) -> web.Response:
    return _coded(exc.code, _MESSAGES.get(exc.code) or str(exc))


+def _target(data: object):
+    """``((index, scope, relative), None)`` for a target, else ``(None, error)``.
+
+    Only the listing identity is accepted: an int root index, the root's
+    64-hex scope and a bounded root-relative POSIX media path, never an
+    absolute, drive-qualified, backslash or ``..`` path. Nothing here touches
+    the filesystem or the database.
+    """
+    if not isinstance(data, dict) or set(data) != _TARGET_FIELDS:
+        return None, bad_request("target must name root_index, root_scope and path")
+    index, scope, relative = data["root_index"], data["root_scope"], data["path"]
+    if type(index) is not int or index < 0:
+        return None, bad_request("Invalid gallery root")
+    if not isinstance(scope, str) or _HEX64.fullmatch(scope) is None:
+        return None, bad_request("Invalid gallery root scope")
+    if not isinstance(relative, str) or not relative or len(relative) > MAX_TARGET_PATH:
+        return None, bad_request("path must be a relative media path")
+    parts = relative.split("/")
+    if (
+        "\0" in relative
+        or "\\" in relative
+        or relative.startswith("/")
+        or _has_traversal(relative)
+        or any(part in ("", ".", "..") or ":" in part for part in parts)
+    ):
+        return None, _forbidden()
+    if os.path.splitext(parts[-1])[1].lower() not in CAPTURE_EXTENSIONS:
+        return None, _forbidden("Only media files can be tagged")
+    return (index, scope, relative), None
+
+
 def _expires_at(seconds: float | None) -> str:
    moment = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(
        seconds=max(0.0, seconds or 0.0)
@@ -268,7 +296,6 @@ class AnnotationRoutesMixin:
                self._captures_closed = True
            unsubscribe, self._captures_unsubscribe = self._captures_unsubscribe, None
            store, self._captures = self._captures, None
-            self._suggested_tokens = set()
        if unsubscribe is not None:
            unsubscribe()
        if store is not None:
@@ -488,7 +515,6 @@ class AnnotationRoutesMixin:
        store = self._captures
        if store is not None and _TOKEN.fullmatch(token) is not None:
            store.release(token)
-        self._suggested_tokens.discard(token)
        return web.json_response(
            {"success": True}, headers={"Cache-Control": "no-store"}
        )
@@ -538,9 +564,6 @@ class AnnotationRoutesMixin:
            return _coded("capture-expired", _OTHER_FILE)
        if facts.sha256 != capture.sha256:
            return _coded("file-changed")
-        # A save after Generate suggestions ran on this capture marks the
-        # image auto-tagged (#379), so a Skip batch leaves the review alone.
-        suggested = token in self._suggested_tokens
        try:
            receipt = await self._run_in_executor(
                self.db.replace_image_tags,
@@ -551,7 +574,6 @@ class AnnotationRoutesMixin:
                expected_epoch=expected_epoch,
                expected_tag_revision=revision,
                tags=tags,
-                mark_autotagged=suggested,
            )
        except AnnotationCommandError as exc:
            current = exc.current or {}
@@ -568,23 +590,10 @@ class AnnotationRoutesMixin:
        except Exception:
            self.logger.exception("Image tag save failed")
            return _error(500, "save-failed", "The tags could not be saved.")
-        # Dropped only after a saved or replayed receipt: a retry after a
-        # tag-conflict still marks.
-        self._suggested_tokens.discard(token)
        return web.json_response(
            {"success": True, **receipt}, headers={"Cache-Control": "no-store"}
        )

-    def _remember_suggested(self, store, token: str) -> None:
-        """Note that Generate ran on *token*; forget tokens whose capture is
-        gone. ``expires_in`` does not reset a capture's idle clock."""
-        self._suggested_tokens = {
-            kept
-            for kept in self._suggested_tokens
-            if store.expires_in(kept) is not None
-        }
-        self._suggested_tokens.add(token)
-
    # -- suggest ---------------------------------------------------------------

    async def suggest_image_tags(self, request: web.Request) -> web.Response:
@@ -666,7 +675,6 @@ class AnnotationRoutesMixin:
        finally:
            if not started:
                store.release_use(token)
-        self._remember_suggested(store, token)
        return web.json_response(
            {
                "success": True,
@@ -483,59 +483,13 @@ class BackupRestoreRoutesMixin:
            self.logger.info(f"Removed {len(removed)} old safety backups")

    async def _publish(self, model, staged):
-        """Publish ``staged``; on a page-copy failure prune and re-raise.
-
-        A cancel (server stop) waits for the publishing thread (#360): the
-        caller's cleanup and its registry admission must outlive it. When the
-        copy then succeeded the library was replaced, so it is adopted
-        (``_after_publish``, itself run to its end) before the cancel goes
-        on; a copy that failed is handled as usual, then the cancel goes on.
-        """
-        future = self._in_executor_task(model.publish_staged, staged)
-        cancelled = await _outlive_cancel(future)
+        """Publish ``staged``; on a page-copy failure prune and re-raise."""
        try:
-            backup_path = future.result()
+            return await self._run_in_executor(model.publish_staged, staged)
        except sqlite3.OperationalError as exc:
            if getattr(exc, "_prompt_manager_restore_backup_created", False) is True:
                await self._prune_after(model.db_path, failed=True)
-            if cancelled:
-                raise asyncio.CancelledError from exc
            raise
-        except Exception as exc:
-            if cancelled:
-                raise asyncio.CancelledError from exc
-            raise
-        if cancelled:
-            self.logger.info("The restore finished while the server was stopping")
-            # A second cancel (the loop's own shutdown) must not cut it short.
-            adopted = asyncio.ensure_future(self._after_publish(model.db_path))
-            await _outlive_cancel(adopted)
-            if not adopted.cancelled() and adopted.exception() is not None:
-                self.logger.error(
-                    "Could not adopt the restored library",
-                    exc_info=adopted.exception(),
-                )
-            raise asyncio.CancelledError
-        return backup_path
-
-    async def _stage_to_end(self, model, temp_path):
-        """Stage ``temp_path``; a cancel waits for the worker (#360).
-
-        The upload stays until the staging thread is done with it, and a
-        stage it finished after the cancel is removed before the cancel goes
-        on.
-        """
-        future = self._in_executor_task(model.stage_restore, temp_path)
-        if await _outlive_cancel(future):
-            if not future.cancelled() and future.exception() is None:
-                await self._discard_held([_Orphan(future.result())])
-            raise asyncio.CancelledError
-        return future.result()
-
-    def _in_executor_task(self, func, *args):
-        """``_run_in_executor(func, *args)`` as a task ``_outlive_cancel`` can
-        wait for (shielded, the executor call is never cancelled)."""
-        return asyncio.ensure_future(self._run_in_executor(func, *args))

    async def _after_publish(self, db_path):
        """Everything after the copy replaced the library: best effort, logged.
@@ -655,7 +609,7 @@ class BackupRestoreRoutesMixin:
                    {"success": False, "error": REQUESTS_BUSY}, status=409
                )
            model = self.db.model
-            staged = await self._stage_to_end(model, temp_path)
+            staged = await self._run_in_executor(model.stage_restore, temp_path)
            try:
                backup_path = await self._publish(model, staged)
            finally:
@@ -973,30 +927,6 @@ class BackupRestoreRoutesMixin:
        job.update(progress=100, status_line=line)


-async def _outlive_cancel(future):
-    """Await ``future`` (an executor call's task) to its end, even through
-    cancels (#360).
-
-    A cancelled task cannot stop the worker thread, so the files it uses and
-    the registry admission it runs under must outlive it: the cancel is held
-    until the worker returned. Returns whether the task was cancelled
-    meanwhile; the caller reads the outcome from ``future`` and re-raises
-    ``CancelledError``. A future cancelled itself (an executor shut down) is
-    not a cancel of the task: ``future.result()`` raises it. Never catches
-    ``GeneratorExit``: a closed loop still closes the coroutine.
-    """
-    cancelled = False
-    while not future.done():
-        try:
-            await asyncio.shield(future)
-        except asyncio.CancelledError:
-            if not future.cancelled():
-                cancelled = True
-        except Exception:
-            pass  # the caller reads it from the future
-    return cancelled
-
-
 class _Orphan:
    """A stage with no store entry, in the shape ``_discard_held`` takes."""

@@ -589,7 +589,6 @@ class DuplicateFilesMixin:
        spellings = await self._run_in_executor(self._source_spellings)
        removed, failure, keepers = 0, None, {}
        totals = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
-        totals["categories"] = 0  # image categories kept on the kept copies (#332)
        for done, target in enumerate(targets, start=1):
            if failure is not None:
                self._record_target(job, "kept", target, NOT_ATTEMPTED)
@@ -636,9 +635,6 @@ class DuplicateFilesMixin:
            job.log_line(
                f"Added {_plural(totals['tags'], 'image tag')} to the kept copies"
            )
-        if totals.get("categories"):
-            kept = _plural(totals["categories"], "image category", "image categories")
-            job.log_line(f"Kept {kept} on the kept copies")
        if totals["review"]:
            job.log_line(
                f"Settled {_plural(totals['review'], 'Needs review item')} "
@@ -18,7 +18,7 @@ Blocking: each lookup stats the file's folders once (cached).
 import os
 from pathlib import Path

-from .images import _favorite_relative_key, _favorite_root_key, image_category_key
+from .images import _favorite_relative_key, _favorite_root_key


 def _identity(path):
@@ -78,15 +78,6 @@ class Spellings:
                )
        return spelled

-    @property
-    def listed_roots(self):
-        """The listed roots (the output sources), in order."""
-        return [root for root, _identity in self._listed]
-
-    def category_key(self, path):
-        """*path*'s image category file key (#332), or None outside every source."""
-        return image_category_key(self.listed_roots, path)
-
    def favorites(self, path):
        """``{listed root: path below it (POSIX)}`` for each listed root holding it."""
        path = os.path.abspath(str(path))
@@ -134,23 +125,9 @@ def copy_move(target, kept_stat, spellings):
        "targets": targets,
        "kept_path": target["keeper_abs"],
        "favorites": favorites,
-        "categories": _category_pairs(target, spellings),
        "removed_locator": target["locator"],
        "kept_locator": target["keeper_locator"],
        "sha256": target["hash"],
        "kept_size": kept_stat.st_size,
        "kept_mtime_ns": kept_stat.st_mtime_ns,
    }
-
-
-def _category_pairs(target, spellings):
-    """``[(removed file key, kept file key)]`` for the image category (#332).
-
-    From the two absolute paths, not the favorites tuples: those follow the
-    listed root, which differs from the file key when sources nest.
-    """
-    removed = spellings.category_key(target["abs"])
-    kept = spellings.category_key(target["keeper_abs"])
-    if removed is None or kept is None:
-        return []
-    return [(removed, kept)]
@@ -5,7 +5,6 @@ import base64
 import binascii
 from functools import wraps
 import json
-import os
 import re
 import sqlite3
 from typing import Callable
@@ -28,12 +27,10 @@ from .history_current import (
    snapshot_current_output_scope,
 )
 from .inspection_service import CurrentFileChanged, inspect_current_file
-from .images import image_category_key

 try:
    from ...database.execution_history import HistoryEpochChanged
    from ...database.history_gallery import read_history_gallery
-    from ...database.run_attribution import recorded_output_lookup
    from ...database.history_reads import (
        HistoryCaptureChanged,
        OutputPosition,
@@ -41,15 +38,10 @@ try:
        WindowPosition,
    )
    from ...utils.history_read_fence import HistoryReadFence
-    from ...utils.inspection_response import (
-        OWN_CATEGORY_UNREAD,
-        apply_own_category,
-        encode_history_inspection_response,
-    )
+    from ...utils.inspection_response import encode_history_inspection_response
 except ImportError:
    from database.execution_history import HistoryEpochChanged
    from database.history_gallery import read_history_gallery
-    from database.run_attribution import recorded_output_lookup
    from database.history_reads import (
        HistoryCaptureChanged,
        OutputPosition,
@@ -57,11 +49,7 @@ except ImportError:
        WindowPosition,
    )
    from utils.history_read_fence import HistoryReadFence
-    from utils.inspection_response import (
-        OWN_CATEGORY_UNREAD,
-        apply_own_category,
-        encode_history_inspection_response,
-    )
+    from utils.inspection_response import encode_history_inspection_response


 _RUN_MAX_BYTES = 8 * 1024 * 1024
@@ -687,32 +675,6 @@ class HistoryRoutesMixin:
    ) -> web.Response:
        return await self._history_current(request, "inspection")

-    def _history_own_category(self, reference: dict, scope):
-        """The recorded output's own category (#332), inside the snapshot.
-
-        The path is the symlink-resolved output folder plus the receipt's
-        subfolder and filename, keyed by ``image_category_key`` over the
-        configured output sources as Images keys it. A temp output or a path
-        no source holds has none. A failed read is OWN_CATEGORY_UNREAD.
-        """
-        if (
-            reference.get("folder_type") != "output"
-            or scope.canonical_output is None
-            or candidate_locator(reference, scope) is None
-        ):
-            return None
-        path = os.path.join(
-            str(scope.canonical_output), reference["subfolder"], reference["filename"]
-        )
-        try:
-            key = image_category_key(self._get_all_output_dirs(), path)
-            return None if key is None else self.db.image_category(*key)
-        except Exception:
-            self.logger.warning(
-                "History image category could not be read", exc_info=True
-            )
-            return OWN_CATEGORY_UNREAD
-
    async def _history_current(
        self, request: web.Request, kind: str
    ) -> web.StreamResponse:
@@ -737,7 +699,6 @@ class HistoryRoutesMixin:
                    if scope.current_scope != current_scope:
                        raise _current_stale()
                    result = db.get_history_occurrence(run_id, node, ordinal)
-                    own = None
                    if result is not None:
                        receipt = result["receipt"]
                        path = candidate_locator(receipt["reference"], scope)
@@ -745,10 +706,6 @@ class HistoryRoutesMixin:
                            db.model.get_connection(),
                            (path,) if path is not None else (),
                        )
-                        if kind == "inspection":
-                            own = self._history_own_category(
-                                receipt["reference"], scope
-                            )
            finally:
                db.model.close()
            if result is None:
@@ -767,19 +724,9 @@ class HistoryRoutesMixin:
                        resolved.canonical_target,
                        source_label=resolved.public["source_label"],
                        saved=saved.get("saved"),
-                        library=apply_own_category(
-                            saved.get(
-                                "library",
-                                {
-                                    "status": (
-                                        "unavailable" if saved_unavailable else "none"
-                                    )
-                                },
-                            ),
-                            own,
-                        ),
-                        recorded=recorded_output_lookup(
-                            db, close=True, reference=receipt["reference"]
+                        library=saved.get(
+                            "library",
+                            {"status": "unavailable" if saved_unavailable else "none"},
                        ),
                    )
                    _reauthorize_current_target(resolved, scope)
@@ -1,374 +0,0 @@
-"""Image category routes (#332): an image file's own category.
-
-``PUT /prompt_manager/images/category`` sets the own category of up to 500
-listed files; ``DELETE`` removes it (listed or not, so a missing file's
-category can still be removed); ``GET /prompt_manager/images/categories``
-lists the own-category values of files the sources list. Targets are the
-Images listing identity (``{root_index, root_scope, path}``, checked by
-``media_target``) of an output source; LoRA folders are not sources here.
-Instead of ``items`` a request may name ``filter``, the Images listing's own
-query ("Select all N matching", #392), resolved now up to 500 images.
-Each file is stored under its file key (``images.image_category_key``).
-These routes never read or write prompts, recipes or image links.
-"""
-
-import os
-from pathlib import Path
-
-from aiohttp import web
-
-from .image_tag_jobs import MAX_JOB_TARGETS, _parse_targets
-from .images import (
-    _favorite_relative_key,
-    _favorite_root_key,
-    _forbidden,
-    _json_body_or_error,
-    image_category_key,
-)
-from .prompts import bad_request
-
-try:
-    from ...database.image_categories import MAX_CATEGORY_LENGTH, MAX_KEY_LENGTH
-    from ...database.models import normalize_image_path
-    from ...utils.validators import validate_category
-except ImportError:
-    from database.image_categories import MAX_CATEGORY_LENGTH, MAX_KEY_LENGTH
-    from database.models import normalize_image_path
-    from utils.validators import validate_category
-
-CATEGORY_MEDIA_MESSAGE = "Only media files can have a category"
-_PUT_FIELDS = frozenset({"category"})
-_DELETE_FIELDS = frozenset()
-TOO_MANY = f"Select at most {MAX_JOB_TARGETS} images."
-SOURCE_CHANGED_MESSAGE = "The sources changed. Refresh the images and try again."
-WRITE_FAILED = "The category could not be changed."
-READ_FAILED = "Image categories could not be read."
-
-
-def _coded(status: int, code: str, message: str) -> web.Response:
-    return web.json_response(
-        {"success": False, "code": code, "error": message},
-        status=status,
-        headers={"Cache-Control": "no-store"},
-    )
-
-
-def _category_value(raw) -> tuple[str | None, web.Response | None]:
-    """The stripped category, or a 400 (an empty value is a 400: use DELETE)."""
-    if not isinstance(raw, str):
-        return None, bad_request("category must be a string")
-    value = raw.strip()
-    if not value:
-        return None, bad_request("category must not be empty")
-    if len(value) > MAX_CATEGORY_LENGTH:
-        return None, bad_request(
-            f"Category cannot exceed {MAX_CATEGORY_LENGTH} characters"
-        )
-    try:
-        value.encode("utf-8")
-        validate_category(value)
-    except UnicodeEncodeError:
-        return None, bad_request("category must be valid text")
-    except ValueError as exc:
-        return None, bad_request(str(exc))
-    return value, None
-
-
-class _KeyRefused(Exception):
-    """A target has no storable file key (outside every source, or too long)."""
-
-    def __init__(self, message: str = "Access denied"):
-        super().__init__(message)
-        self.message = message
-
-
-def _file_key(roots, root, relative) -> tuple[str, str]:
-    """The target's file key (blocking: resolves the sources)."""
-    key = image_category_key(roots, Path(root) / relative)
-    if key is None:
-        raise _KeyRefused()
-    if max(len(key[0]), len(key[1])) > MAX_KEY_LENGTH:
-        raise _KeyRefused("Path is too long")
-    return key
-
-
-def _nested_sources(root: Path, sources) -> list[tuple[str, str]]:
-    """``[(relative key prefix, source root key)]`` of sources inside *root*.
-
-    Deepest first, so the first prefix that matches is the file's source.
-    """
-    base = os.path.join(os.path.normcase(os.path.realpath(str(root))), "")
-    nested = []
-    for source in sources:
-        real = os.path.realpath(str(source))
-        if not os.path.normcase(real).startswith(base):
-            continue
-        relative = os.path.relpath(real, os.path.realpath(str(root)))
-        nested.append(
-            (
-                _favorite_relative_key(relative.replace(os.sep, "/")),
-                _favorite_root_key(source),
-            )
-        )
-    nested.sort(key=lambda item: item[0].count("/"), reverse=True)
-    return nested
-
-
-def _source_prefix(relative_key: str, nested) -> str | None:
-    """The prefix of the deepest nested source holding *relative_key*."""
-    for prefix, _source_key in nested:
-        if relative_key.startswith(prefix + "/"):
-            return prefix
-    return None
-
-
-class ImageCategoryRoutesMixin:
-    """Routes for images' own categories (#332)."""
-
-    def _register_image_category_routes(self, routes):
-        # Fixed paths beside DELETE /prompt_manager/images/{image_id}, as the
-        # favorite routes are. Registered after it, they still win: aiohttp
-        # (3.10+) looks fixed paths up before dynamic resources
-        # (test_delete_category_never_reaches_delete_image).
-        @routes.put("/prompt_manager/images/category")
-        async def set_image_category_route(request):
-            return await self.set_image_category(request)
-
-        @routes.delete("/prompt_manager/images/category")
-        async def clear_image_category_route(request):
-            return await self.clear_image_category(request)
-
-        @routes.get("/prompt_manager/images/categories")
-        async def list_image_categories_route(request):
-            return await self.list_image_categories(request)
-
-    # -- reading ---------------------------------------------------------------
-
-    def _own_category_map(self, sources, listings) -> dict:
-        """``{normalized listed path: own category}`` for the listed files (blocking).
-
-        One primary-key range read per source; each stored row is matched to
-        the listing of every selected root that holds its source, so the work
-        follows the stored rows, not the files. A file under a nested source
-        is keyed by the deepest one (``image_category_key``). A row whose file
-        is gone matches nothing. A failed read raises.
-        """
-        sources = list(sources)
-        rows = self.db.own_categories_of(_favorite_root_key(s) for s in sources)
-        if not rows:
-            return {}
-        by_source: dict[str, dict[str, str]] = {}
-        for (root_key, relative), category in rows.items():
-            by_source.setdefault(root_key, {})[relative] = category
-        found = {}
-        for _index, root, files in listings:
-            listing = self._favorite_listing(root, files)
-            root_key = _favorite_root_key(root)
-            # normalize_image_path(root / listed) without a call per file: the
-            # listed spellings are clean relative POSIX paths. Windows abspath
-            # also drops a component's trailing dots and spaces, so it keeps
-            # the call there.
-            base = os.path.join(normalize_image_path(str(root)), "")
-
-            def normalized(listed, base=base, root=root):
-                if os.name == "nt":
-                    return normalize_image_path(str(root / listed))
-                return base + os.path.normcase(listed.replace("/", os.sep))
-
-            nested = [
-                item for item in _nested_sources(root, sources) if item[1] != root_key
-            ]
-            for relative, category in by_source.get(root_key, {}).items():
-                listed = listing.get(relative)
-                if listed is not None and _source_prefix(relative, nested) is None:
-                    found[normalized(listed)] = category
-            for prefix, source_key in nested:
-                for relative, category in by_source.get(source_key, {}).items():
-                    full = f"{prefix}/{relative}"
-                    listed = listing.get(full)
-                    if listed is not None and _source_prefix(full, nested) == prefix:
-                        found[normalized(listed)] = category
-        return found
-
-    async def _source_listings(self, roots) -> list[tuple]:
-        return [
-            (index, root, await self._get_gallery_files(root))
-            for index, root in enumerate(roots)
-        ]
-
-    async def list_image_categories(self, request):
-        """GET: the own-category values of listed files, sorted."""
-        try:
-            roots = list(self._get_all_output_dirs())
-            listings = await self._source_listings(roots)
-            found = await self._run_in_executor(self._own_category_map, roots, listings)
-        except Exception:
-            self.logger.exception("Image categories read failed")
-            return _coded(500, "categories-failed", READ_FAILED)
-        return web.json_response(
-            {"success": True, "categories": sorted(set(found.values()))},
-            headers={"Cache-Control": "no-store"},
-        )
-
-    # -- writing ---------------------------------------------------------------
-
-    async def _filter_targets(self, raw):
-        """``(targets, None)`` for an Images listing filter, else ``(None, error)``.
-
-        "Select all N matching" (#392) sends the listing's own query; it is
-        resolved now, up to 500 images (a 400 ``too-many-images`` above).
-        """
-        from .images import ListingSourceChanged, parse_listing_filter
-
-        try:
-            selection = await self.resolve_listing_filter(
-                parse_listing_filter(raw), MAX_JOB_TARGETS
-            )
-        except ListingSourceChanged:
-            return None, _coded(409, "source-changed", SOURCE_CHANGED_MESSAGE)
-        except ValueError as exc:
-            return None, bad_request(str(exc))
-        if selection.truncated:
-            return None, _coded(400, "too-many-images", TOO_MANY)
-        return tuple(selection.targets), None
-
-    async def _category_request(self, request, fields: frozenset):
-        """``(data, targets, roots, None)`` or ``(None, None, None, error)``.
-
-        The images are ``items`` (1 to 500 targets) or ``filter`` (all images
-        an Images listing filter admits), besides *fields*.
-        """
-        data, error = await _json_body_or_error(request)
-        if error is not None:
-            return None, None, None, error
-        names = set(data) - fields
-        if set(data) & fields != fields or names not in ({"items"}, {"filter"}):
-            return (
-                None,
-                None,
-                None,
-                bad_request(
-                    "Request must contain "
-                    + ", ".join(sorted(fields))
-                    + (" and " if fields else "")
-                    + "either items or filter"
-                ),
-            )
-        if "filter" in data:
-            targets, error = await self._filter_targets(data["filter"])
-            if error is not None:
-                return None, None, None, error
-            return data, targets, list(self._get_all_output_dirs()), None
-        items = data["items"]
-        if not isinstance(items, list) or not 1 <= len(items) <= MAX_JOB_TARGETS:
-            return (
-                None,
-                None,
-                None,
-                bad_request(f"items must list 1 to {MAX_JOB_TARGETS} images"),
-            )
-        targets, error = _parse_targets(items, media_message=CATEGORY_MEDIA_MESSAGE)
-        if error is not None:
-            return None, None, None, error
-        try:
-            for _index, _scope, relative in targets:
-                relative.encode("utf-8")
-        except UnicodeEncodeError:
-            return None, None, None, bad_request("path must be valid text")
-        roots = list(self._get_all_output_dirs())
-        for index, scope in dict.fromkeys((t[0], t[1]) for t in targets):
-            if index >= len(roots):
-                return None, None, None, bad_request("Invalid gallery root")
-            error = self._gallery_scope_error(
-                {"root_scope": scope, "root": str(index)}, roots
-            )
-            if error is not None:
-                if error.status == 409:
-                    error = _coded(409, "source-changed", SOURCE_CHANGED_MESSAGE)
-                return None, None, None, error
-        return data, targets, roots, None
-
-    def _listed_file_keys(self, roots, targets, files) -> tuple[list, list]:
-        """``(listed keys, unlisted keys)`` of the targets (blocking).
-
-        A target counts as listed when its source's listing holds it; its key
-        then follows the listed spelling. Targets folding to one key count
-        once, and a key that is listed through any target is listed.
-        """
-        listings, listed, missing = {}, {}, {}
-        for index, _scope, relative in targets:
-            root = roots[index]
-            if index not in listings:
-                listings[index] = self._favorite_listing(root, files[index])
-            spelled = listings[index].get(_favorite_relative_key(relative))
-            key = _file_key(roots, root, spelled or relative)
-            (missing if spelled is None else listed)[key] = True
-        return list(listed), [key for key in missing if key not in listed]
-
-    async def set_image_category(self, request):
-        """PUT ``{items, category}``: set the own category of listed files."""
-        data, targets, roots, error = await self._category_request(request, _PUT_FIELDS)
-        if error is not None:
-            return error
-        category, error = _category_value(data["category"])
-        if error is not None:
-            return error
-        try:
-            files = {}
-            for index in dict.fromkeys(t[0] for t in targets):
-                files[index] = await self._get_gallery_files(roots[index])
-            listed_keys, missing_keys = await self._run_in_executor(
-                self._listed_file_keys, roots, targets, files
-            )
-        except _KeyRefused as refused:
-            return _forbidden(refused.message)
-        except Exception:
-            self.logger.exception("Image category update failed")
-            return _coded(500, "category-failed", WRITE_FAILED)
-        try:
-            if not listed_keys:
-                return _coded(
-                    404,
-                    "files-not-found",
-                    "None of the selected images could be found.",
-                )
-            counts = await self._run_in_executor(
-                self.db.set_image_categories, listed_keys, category
-            )
-        except Exception:
-            self.logger.exception("Image category update failed")
-            return _coded(500, "category-failed", WRITE_FAILED)
-        return web.json_response(
-            {
-                "success": True,
-                "category": category,
-                "updated": counts["updated"],
-                "unchanged": counts["unchanged"],
-                "not_found": len(missing_keys),
-            },
-            headers={"Cache-Control": "no-store"},
-        )
-
-    async def clear_image_category(self, request):
-        """DELETE ``{items}``: remove the own category, listed or not."""
-        _data, targets, roots, error = await self._category_request(
-            request, _DELETE_FIELDS
-        )
-        if error is not None:
-            return error
-        try:
-            keys = await self._run_in_executor(
-                lambda: list(
-                    dict.fromkeys(_file_key(roots, roots[i], r) for i, _s, r in targets)
-                )
-            )
-            cleared = await self._run_in_executor(self.db.clear_image_categories, keys)
-        except _KeyRefused as refused:
-            return _forbidden(refused.message)
-        except Exception:
-            self.logger.exception("Image category removal failed")
-            return _coded(500, "category-failed", WRITE_FAILED)
-        return web.json_response(
-            {"success": True, "cleared": cleared},
-            headers={"Cache-Control": "no-store"},
-        )
@@ -2,9 +2,7 @@

 ``POST /prompt_manager/jobs/image-tags`` starts one ``image-tags`` job over
 1..500 listed images, named by the listing identity ``{root_index,
-root_scope, path}``, or over every image a listing ``filter`` admits (at most
-10,000, resolved at start in the listing's order; "Select all N matching",
-#392). The job is record-changing (it writes image tag sets and
+root_scope, path}``. The job is record-changing (it writes image tag sets and
 new vocabulary names), so it never runs beside the metadata scan.

 - **Add tags** (``mode: "add"``) hashes each current file and unions a fixed
@@ -20,21 +18,13 @@ the suggestion worker and the storage call ``add_image_tags``. Files are
 handled one at a time and the job stops at a file boundary when cancelled,
 keeping what it already wrote. Rows and log lines carry root-relative paths
 and public root labels only.
-
-Auto-tag marks each image it ran the model on as auto-tagged (#379), with the
-union of its tags. The ``autotag`` job ("Tag output images", started by
-``POST /jobs/autotag``) runs the same per-file loop over every still image the
-output folders list (:meth:`ImageTagJobsMixin._run_autotag_batch`): image
-tags only, never a prompt tag or prompt text.
 """

 import asyncio
-import dataclasses
 import functools
 import os
 import time
 from dataclasses import dataclass, field
-from typing import NamedTuple

 from aiohttp import web

@@ -55,24 +45,10 @@ from .annotations import (
    _submit,
    _target,
 )
-from .autotag_routes import BATCH_CANCELLED, MODEL_BUSY_ERROR, model_busy_response
-from .images import (
-    MAX_LISTING_SELECTION,
-    ListingSourceChanged,
-    _current_fingerprint,
-    _listing_posix,
-    _public_path,
-    parse_listing_filter,
-)
+from .autotag_routes import model_busy_response
+from .images import _public_path
 from .job_routes import busy_response
-from .jobs import (
-    AUTOTAG_BATCH_JOB_KIND,
-    AUTOTAG_GROUP_NAMES,
-    IMAGE_TAG_GROUP_NAMES,
-    IMAGE_TAG_JOB_KIND,
-    JobBusy,
-)
-from .maintenance import disk_plan, short_space_message
+from .jobs import IMAGE_TAG_GROUP_NAMES, IMAGE_TAG_JOB_KIND, JobBusy
 from .prompts import bad_request

 try:
@@ -99,11 +75,6 @@ except ImportError:
    from utils.video_metadata import is_video_path

 MAX_JOB_TARGETS = 500
-# A filter start resolves on the server, so the request body does not bound it.
-MAX_FILTER_TARGETS = MAX_LISTING_SELECTION
-NO_IMAGES = "No images match this view."
-FILTER_LISTING_FAILED = "The matching images could not be listed. Try again."
-TOO_MANY_IMAGES = "Narrow the view to at most {cap:,} images."
 # 500 maximal targets plus the options: a path of MAX_TARGET_PATH code points
 # takes at most 6 bytes each on the wire (a \uXXXX escape; raw UTF-8 is at most
 # 4), and the root index and scope fit in 256. The annotation routes' 64 KiB
@@ -117,10 +88,9 @@ ADD_TITLE = "Add tags to images"
 AUTO_TITLE = "Auto-tag images"
 GATE_OWNER_KIND = "image-tag-job"

-# Each mode's fields besides the images, named by ``targets`` or ``filter``.
 _FIELDS = {
-    "add": frozenset({"mode", "tags"}),
-    "auto": frozenset({"mode", "model_type", "options"}),
+    "add": frozenset({"mode", "targets", "tags"}),
+    "auto": frozenset({"mode", "targets", "model_type", "options"}),
 }
 _VERBS = {"add": "Add tags", "auto": "Auto-tag"}
 _LOG_PREFIXES = {"tagged": "+", "unchanged": "=", "skipped": "-", "errors": "!"}
@@ -137,14 +107,6 @@ READ_FAILED = "The file could not be read."
 SOURCE_CHANGED = "The source changed. Refresh the image collection."
 STORAGE_RESTORED = "Prompt storage was restored; start the job again."
 BUSY_RETRY = "The file could not be read now. Run the job again for it."
-# Tag output images (#379): the per-image batch.
-ALREADY_AUTOTAGGED = "Already auto-tagged"
-LISTING_FAILED = "The output folders could not be listed. Try again."
-LISTING_STATUS = "Listing output images…"
-_INTERNAL_ERROR = "An internal error occurred. Check server logs for details."
-# The pre-pass stats and looks up this many targets at a time, checking for a
-# cancel between chunks.
-PREPASS_CHUNK = 500

 _monotonic = time.monotonic  # the job's clock (a test can fake it)

@@ -179,8 +141,6 @@ class _Spec:
    tags: tuple = ()
    model_type: str | None = None
    options: dict | None = None
-    # A listing filter the start resolves into ``targets`` (#392).
-    filter: dict | None = None

    @property
    def title(self) -> str:
@@ -193,17 +153,13 @@ class _Spec:
        return scope


-def _parse_targets(raw, **target_options):
-    """Unique validated targets in request order, or ``(None, error)``.
-
-    ``target_options`` reach the target check (the image category routes
-    pass their own ``media_message``, #332).
-    """
+def _parse_targets(raw):
+    """Unique validated targets in request order, or ``(None, error)``."""
    if not isinstance(raw, list) or not 1 <= len(raw) <= MAX_JOB_TARGETS:
        return None, bad_request(f"targets must list 1 to {MAX_JOB_TARGETS} images")
    seen, targets = set(), []
    for item in raw:
-        target, error = _target(item, **target_options)
+        target, error = _target(item)
        if error is not None:
            return None, error
        if target not in seen:
@@ -243,35 +199,21 @@ def parse_image_tag_request(data: dict):
    """A :class:`_Spec` for a start body, or ``(None, error response)``.

    ``{mode:"add", targets, tags}`` or ``{mode:"auto", targets, model_type,
-    options}`` exactly; options follow the Tag dialog's Generate rules. A
-    ``filter`` (a listing query object, parse_listing_filter) may stand in for
-    ``targets``; the start resolves it.
+    options}`` exactly; options follow the Tag dialog's Generate rules.
    """
    fields = _FIELDS.get(data.get("mode"))
    if fields is None:
        return None, bad_request('mode must be "add" or "auto"')
-    fields = fields | {"filter" if "filter" in data else "targets"}
    if set(data) != fields:
        return None, bad_request(
            "Request must contain exactly " + ", ".join(sorted(fields))
        )
-    listing_filter, targets = None, ()
-    if "filter" in data:
-        try:
-            listing_filter = parse_listing_filter(data["filter"])
-        except ValueError as exc:
-            return None, bad_request(str(exc))
-    else:
-        targets, error = _parse_targets(data["targets"])
-        if error is not None:
-            return None, error
+    targets, error = _parse_targets(data["targets"])
+    if error is not None:
+        return None, error
    if data["mode"] == "add":
-        spec, error = _parse_add(targets, data)
-    else:
-        spec, error = _parse_auto(targets, data)
-    if spec is not None and listing_filter is not None:
-        spec = dataclasses.replace(spec, filter=listing_filter)
-    return spec, error
+        return _parse_add(targets, data)
+    return _parse_auto(targets, data)


 def _capture_outcome(exc: CaptureError, root, relative: str):
@@ -304,92 +246,6 @@ async def _capacity_retried(job, attempt):
    return await attempt()


-class Refusal(NamedTuple):
-    """Why a Tag output images start was refused.
-
-    ``response`` is the native route's JSON answer; ``message`` the sentence
-    a legacy stream frame carries.
-    """
-
-    status: int
-    code: str
-    message: str
-    response: web.Response
-
-
-@dataclass(frozen=True)
-class AutotagRun:
-    """What one Tag output images job runs with (validated at its start)."""
-
-    model_type: str
-    existing: str
-    options: dict
-    keep_in_memory: bool
-    backup_on: bool
-    owner: object
-
-
-@dataclass(frozen=True)
-class _BatchTarget:
-    """One still image of the batch: the job target and its private keys."""
-
-    target: tuple  # (root_index, root_scope, relative): the image-tags target
-    path: str  # the listed file, for the pre-pass stat (never sent out)
-    locator: str  # the image tag key: normcase(join(realpath(root), relative))
-    label: str  # the root's public label
-
-
-def _still_targets(api, index, root, files, seen: set) -> list:
-    """Worker thread: one root's listed still images as _BatchTargets.
-
-    Newest first (the listing's order). A locator an earlier root already
-    produced (overlapping roots) is dropped; ``seen`` collects them.
-    """
-    scope = api._gallery_root_scope(root, index)
-    label = _public_path(root)
-    real = os.path.realpath(root)
-    prefix = os.path.join(str(root), "")
-    found = []
-    for path, _mtime in files:
-        relative = _listing_posix(root, prefix, path)
-        if is_video_path(relative):
-            continue
-        locator = os.path.normcase(os.path.join(real, *relative.split("/")))
-        if locator in seen:
-            continue
-        seen.add(locator)
-        found.append(_BatchTarget((index, scope, relative), str(path), locator, label))
-    return found
-
-
-def _prepass_chunk(db, chunk, skip_marked: bool, max_file: int):
-    """Worker thread: ``(remaining, skips)`` for a chunk of _BatchTargets.
-
-    Stats each file (no open, no hash): gone is "File not found", over the
-    capture limit "Too large to verify"; under "Skip already tagged" a file
-    whose current bytes are marked is "Already auto-tagged". ``skips`` are
-    ``(target, detail)`` pairs in target order.
-    """
-    stats, skips, alive = {}, [], []
-    for item in chunk:
-        fingerprint = _current_fingerprint(item.path)
-        if fingerprint is None:
-            skips.append((item, FILE_NOT_FOUND))
-        elif fingerprint[0] > max_file:
-            skips.append((item, TOO_LARGE))
-        else:
-            stats[item.locator] = fingerprint
-            alive.append(item)
-    marked = db.autotag_state(stats) if skip_marked and stats else {}
-    remaining = []
-    for item in alive:
-        if marked.get(item.locator):
-            skips.append((item, ALREADY_AUTOTAGGED))
-        else:
-            remaining.append(item)
-    return remaining, skips
-
-
 def _load_model(service, model_type: str, use_gpu: bool) -> None:
    """Worker thread: load (or swap to) *model_type*; never downloads."""
    if service.is_model_loaded() and service.get_loaded_model_type() == model_type:
@@ -398,25 +254,6 @@ def _load_model(service, model_type: str, use_gpu: bool) -> None:
        raise RuntimeError(f"{model_type} could not be loaded")


-def _refusal(status: int, code: str, message: str) -> Refusal:
-    response = web.json_response(
-        {"success": False, "code": code, "error": message}, status=status
-    )
-    return Refusal(status, code, message, response)
-
-
-def _busy_refusal(busy: JobBusy) -> Refusal:
-    title = getattr(busy.running, "title", "") or "Another job"
-    return Refusal(409, "busy", f"{title} already running", busy_response(busy))
-
-
-def _batch_cancelled(job) -> str:
-    """Say the batch was cancelled; its end state (the runner ends the job)."""
-    job.update(status_line=BATCH_CANCELLED)
-    job.log_line(BATCH_CANCELLED)
-    return "cancelled"
-
-
 class ImageTagJobsMixin:
    """The ``image-tags`` job kind: start route and runner."""

@@ -433,10 +270,6 @@ class ImageTagJobsMixin:
        spec, error = parse_image_tag_request(data)
        if error is not None:
            return error
-        if spec.filter is not None:
-            spec, error = await self._resolve_job_filter(spec)
-            if error is not None:
-                return error
        roots = await self._run_in_executor(self._job_roots, spec.targets)
        if any(root is None for root, _label in roots.values()):
            return _coded("source-changed")
@@ -468,246 +301,6 @@ class ImageTagJobsMixin:
            job.task.add_done_callback(lambda _task: model_gate.release(owner))
        return web.json_response({"success": True, "job": job.summary()}, status=202)

-    # -- Tag output images (#379) ---------------------------------------------
-
-    async def _autotag_targets(self) -> list:
-        """Every still image the output folders list, as _BatchTargets.
-
-        Root by root in configured order, each newest first (the shared
-        listing, ``_get_gallery_files``, used as it is even when stale). Videos
-        are not targets; a file under two overlapping roots is one target.
-        """
-        seen: set = set()
-        found = []
-        for index, root in enumerate(list(self._get_all_output_dirs())):
-            files = await self._get_gallery_files(root)
-            found.extend(
-                await self._run_in_executor(
-                    _still_targets, self, index, root, files, seen
-                )
-            )
-        return found
-
-    async def _start_autotag(
-        self, *, model_type, existing, options, keep_in_memory, title, owner_kind
-    ):
-        """Register a Tag output images job: ``(job, None)`` or ``(None, Refusal)``.
-
-        ``options`` are already validated (``validate_options``). The checks
-        run in this order: 409 ``model-unavailable``; 507
-        ``insufficient-space`` (only when the safety backup is on); 409
-        ``busy`` (another records job); 409 ``model-busy``. No await follows
-        the busy check. The gate is taken before the job registers and
-        released when the task ends, also before its runner ever starts.
-        """
-        from ..autotag import MODELS, get_autotag_service
-
-        backup_on = self._safety_backup_policy() == "on"
-        status = await self._run_in_executor(get_autotag_service().get_models_status)
-        _disk, short, _size = await self._run_in_executor(
-            functools.partial(
-                disk_plan, self.db.model.db_path, backup=backup_on, vacuum=False
-            )
-        )
-        label = MODELS[model_type]["label"]
-        if not (status.get(model_type) or {}).get("downloaded"):
-            message = (
-                f"{label} is not downloaded. Download it in System › Auto-tagging."
-            )
-            return None, _refusal(409, "model-unavailable", message)
-        if backup_on and short is not None:
-            return None, _refusal(507, "insufficient-space", short_space_message(short))
-        busy = self._jobs.blocker(AUTOTAG_BATCH_JOB_KIND, admission="records")
-        if busy is not None:
-            return None, _busy_refusal(JobBusy(busy))
-        owner = model_gate.new_owner(owner_kind)
-        if not model_gate.try_acquire(owner):
-            response = model_busy_response()
-            return None, Refusal(409, "model-busy", MODEL_BUSY_ERROR, response)
-        run = AutotagRun(
-            model_type, existing, options, keep_in_memory, backup_on, owner
-        )
-        try:
-            job = self._jobs.start(
-                AUTOTAG_BATCH_JOB_KIND,
-                title,
-                admission="records",
-                cancellable=True,
-                scope={"model_type": model_type, "existing": existing, "label": label},
-                groups=AUTOTAG_GROUP_NAMES,
-                runner=functools.partial(self._run_autotag_batch, run),
-            )
-        except BaseException as refused:
-            model_gate.release(owner)
-            if isinstance(refused, JobBusy):
-                return None, _busy_refusal(refused)
-            raise
-        job.task.add_done_callback(lambda _task: model_gate.release(owner))
-        return job, None
-
-    async def _run_autotag_batch(self, run: AutotagRun, job) -> None:
-        """The ``autotag`` job: backup, model, listing, pre-pass, per-image loop.
-
-        ``job.cancelled`` is checked between phases (and per pre-pass chunk
-        and per image). Each phase publishes ``{"type": "phase", "phase"}``.
-        With ``keep_in_memory`` false the model is unloaded under the gate.
-        The job ends only after that cleanup and the gate release, so a job
-        that reads as ended never still holds the gate.
-        """
-        state = "failed"
-        try:
-            state = await self._autotag_batch_phases(run, job)
-        except Exception:
-            self.logger.exception("Tag output images failed")
-            job.update(status_line=_INTERNAL_ERROR)
-            job.log_line(f"Tagging failed · {_INTERNAL_ERROR}")
-        finally:
-            try:
-                if not run.keep_in_memory:
-                    await self._unload_batch_model(run.owner)
-                if run.backup_on:
-                    await self._prune_backup_pool(job, self.db)
-            finally:
-                model_gate.release(run.owner)
-                job.publish({"type": state, "progress": job.progress})
-                job.finish(state)
-
-    async def _unload_batch_model(self, owner) -> None:
-        from ..autotag import get_autotag_service
-
-        service = get_autotag_service()
-        try:
-            if service.is_model_loaded():
-                await model_gate.run(owner, service.unload_model)
-        except Exception:
-            self.logger.exception("The tagging model could not be unloaded")
-
-    async def _autotag_batch_phases(self, run: AutotagRun, job) -> str:
-        """Run the phases; the job's end state (the caller ends the job)."""
-        job.publish({"type": "phase", "phase": "backup"})
-        ok, _backup = await self._safety_backup_step(job, self.db, run.backup_on)
-        if not ok:
-            return "failed"
-        if job.cancelled:
-            return _batch_cancelled(job)
-        job.publish({"type": "phase", "phase": "model"})
-        job.update(status_line="Loading the tagging model")
-        spec = _Spec("auto", (), model_type=run.model_type, options=run.options)
-        service = await self._prepare_tagging_model(job, spec, run.owner)
-        if service is None:
-            return "failed"
-        if job.cancelled:
-            return _batch_cancelled(job)
-        job.publish({"type": "phase", "phase": "listing"})
-        job.update(status_line=LISTING_STATUS)
-        epoch = await self._run_in_executor(self.db.get_execution_epoch)
-        try:
-            targets = await self._autotag_targets()
-        except Exception:
-            self.logger.exception("Tag output images could not list the outputs")
-            job.update(status_line=LISTING_FAILED)
-            job.log_line(f"! {LISTING_FAILED}")
-            return "failed"
-        total = len(targets)
-        job.scope["images"] = total
-        job.update(total=total)
-        policy = (
-            "skip images already auto-tagged" if run.existing == "skip" else "merge"
-        )
-        job.log_line(
-            f"Tagging started · {job.scope.get('label') or run.model_type} · "
-            f"{_plural(total, 'image')} · {policy}"
-        )
-        if job.cancelled:
-            return _batch_cancelled(job)
-        remaining = await self._autotag_prepass(job, targets, run.existing == "skip")
-        if remaining is None:
-            return _batch_cancelled(job)
-        done = total - len(remaining)
-        spec = dataclasses.replace(
-            spec, targets=tuple(item.target for item in remaining)
-        )
-        loop_run = _Run(job, spec, epoch, run.owner, service)
-        if not await self._tag_each_file(loop_run, done_before=done):
-            job.update(status_line=STORAGE_RESTORED)
-            job.log_line(f"Tagging stopped · {STORAGE_RESTORED}")
-            return "failed"
-        if job.cancelled:
-            return _batch_cancelled(job)
-        finished = f"Tagged {_plural(job.counters.get('tagged', 0), 'image')}"
-        job.update(status_line=finished, progress=100)
-        job.log_line(finished)
-        return "finished"
-
-    async def _autotag_prepass(self, job, targets, skip_marked: bool):
-        """The targets left for the model, or None when cancelled meanwhile.
-
-        Opens and hashes nothing: one stat per file and one indexed read per
-        chunk. Skips are counted with ``record_counted`` (exact counters, rows
-        up to the cap, no log line each).
-        """
-        max_file = self._capture_store().max_file
-        remaining, skipped = [], 0
-        total = len(targets)
-        for start in range(0, total, PREPASS_CHUNK):
-            if job.cancelled:
-                return None
-            chunk = targets[start : start + PREPASS_CHUNK]
-            left, skips = await self._run_in_executor(
-                _prepass_chunk, self.db, chunk, skip_marked, max_file
-            )
-            remaining.extend(left)
-            if skips:
-                job.record_counted(
-                    "skipped",
-                    len(skips),
-                    [
-                        {
-                            "path": item.target[2],
-                            "root": item.label,
-                            "root_index": item.target[0],
-                            "detail": detail,
-                        }
-                        for item, detail in skips
-                    ],
-                )
-                skipped += len(skips)
-                job.update(processed=skipped, progress=skipped * 100 // total)
-                job.publish({"type": "progress", "progress": job.progress})
-        if skipped:
-            job.log_line(f"Skipped {_plural(skipped, 'image')} before tagging")
-        return remaining
-
-    async def _resolve_job_filter(self, spec: _Spec):
-        """``spec`` with its filter resolved into targets, or ``(None, error)``.
-
-        The listing's own identities, in its order, kept only where a target
-        could have named them (a media path the job can tag).
-        """
-        cap = MAX_FILTER_TARGETS
-        try:
-            selection = await self.resolve_listing_filter(spec.filter, cap)
-        except ListingSourceChanged:
-            return None, _coded("source-changed")
-        except ValueError as exc:
-            return None, bad_request(str(exc))
-        except Exception:
-            # Never echo it: it can carry SQL or database text.
-            self.logger.error("A tagging filter could not be resolved", exc_info=True)
-            return None, _error(500, "listing-failed", FILTER_LISTING_FAILED)
-        if selection.truncated:
-            return None, _error(400, "too-many-images", TOO_MANY_IMAGES.format(cap=cap))
-        targets = []
-        for index, scope, relative in selection.targets:
-            target, error = _target(
-                {"root_index": index, "root_scope": scope, "path": relative}
-            )
-            if error is None:
-                targets.append(target)
-        if not targets:
-            return None, _error(400, "no-images", NO_IMAGES)
-        return dataclasses.replace(spec, targets=tuple(targets)), None
-
    # -- runner ----------------------------------------------------------------

    def _job_roots(self, targets) -> dict:
@@ -738,39 +331,28 @@ class ImageTagJobsMixin:
                    job.finish("failed")
                    return
            if not await self._tag_each_file(run):
-                job.update(status_line=STORAGE_RESTORED)
                job.log_line(f"{verb} stopped · {STORAGE_RESTORED}")
                job.finish("failed")
                return
            state = "cancelled" if job.cancelled else "finished"
-            # An ended job never keeps the loop's "about X min left" (#379).
-            ended = f"{verb} {state} · {_plural(job.processed, 'file')} processed"
-            job.update(status_line=ended)
-            job.log_line(ended)
+            job.log_line(f"{verb} {state} · {_plural(job.processed, 'file')} processed")
            job.publish({"type": state, "progress": job.progress})
            job.finish(state)
        finally:
            if owner is not None:
                model_gate.release(owner)

-    async def _tag_each_file(self, run: _Run, *, done_before: int = 0) -> bool:
-        """Tag the targets in order; False when the job had to stop.
-
-        ``done_before`` files were already counted (the batch's pre-pass): file
-        n of this loop is "file done_before + n" of the job, and the time left
-        uses this loop's rate only.
-        """
-        job, count = run.job, len(run.spec.targets)
-        total = done_before + count
+    async def _tag_each_file(self, run: _Run) -> bool:
+        """Tag the targets in order; False when the job had to stop."""
+        job, total = run.job, len(run.spec.targets)
        run.roots = await self._run_in_executor(self._job_roots, run.spec.targets)
        started = _monotonic()
        for number, target in enumerate(run.spec.targets, 1):
            if job.cancelled:
                break
            # The scan's estimate (D56), with each finished file as one batch.
-            left = _time_left(number - 1, count, number - 1, _monotonic() - started)
-            shown = done_before + number
-            job.update(status_line=f"Processing file {shown:,} of {total:,}{left}")
+            left = _time_left(number - 1, total, number - 1, _monotonic() - started)
+            job.update(status_line=f"Processing file {number:,} of {total:,}{left}")
            job.publish({"type": "progress", "progress": job.progress})
            stopped = False
            try:
@@ -781,7 +363,7 @@ class ImageTagJobsMixin:
                self.logger.exception("Image tagging failed for one file")
                group, detail = "errors", SAVE_FAILED
            self._record_tag_outcome(run, target, group, detail)
-            job.update(processed=shown, progress=shown * 100 // total)
+            job.update(processed=number, progress=number * 100 // total)
            if stopped:
                return False
        return True
@@ -857,17 +439,9 @@ class ImageTagJobsMixin:
            store.release(capture.token)

    async def _auto_tag_capture(self, run: _Run, store, capture, root, relative):
-        """Suggest on the capture, then union only onto the same current bytes.
-
-        The bytes are marked auto-tagged with the union, also when the model
-        returned no names; captured bytes no model can read are marked too
-        (and stay skipped), so a "Skip already tagged" run passes them by.
-        """
+        """Suggest on the capture, then union only onto the same current bytes."""
        if not capture.inferable:
-            group, detail = await self._union_image_tags(
-                capture, [], run.epoch, mark_autotagged=True
-            )
-            return (group, detail) if group == "errors" else ("skipped", NOT_A_STILL)
+            return "skipped", NOT_A_STILL
        if store.acquire(capture.token) is None:
            raise _JobStopped  # every capture was invalidated (restore)
        spec = run.spec
@@ -893,30 +467,21 @@ class ImageTagJobsMixin:
        if facts.locator != capture.locator or facts.sha256 != capture.sha256:
            return "skipped", FILE_CHANGED
        names = [str(name) for name, _score in pairs]
-        return await self._union_image_tags(
-            facts, names, run.epoch, mark_autotagged=True
-        )
+        if not names:
+            return "unchanged", NO_NEW_TAGS
+        return await self._union_image_tags(facts, names, run.epoch)

-    async def _union_image_tags(
-        self, facts, tags: list, epoch: str, *, mark_autotagged: bool = False
-    ):
-        """``add_image_tags`` on the verified bytes, as a (group, detail).
-
-        ``mark_autotagged`` (a model's result) marks the bytes auto-tagged in
-        the same write; then ``tags`` may be empty.
-        """
+    async def _union_image_tags(self, facts, tags: list, epoch: str):
+        """``add_image_tags`` on the verified bytes, as a (group, detail)."""
        try:
            receipt = await self._run_in_executor(
-                functools.partial(
-                    self.db.add_image_tags,
-                    locator=facts.locator,
-                    sha256=facts.sha256,
-                    size=facts.size,
-                    mtime_ns=facts.mtime_ns,
-                    expected_epoch=epoch,
-                    tags=tags,
-                    mark_autotagged=mark_autotagged,
-                )
+                self.db.add_image_tags,
+                locator=facts.locator,
+                sha256=facts.sha256,
+                size=facts.size,
+                mtime_ns=facts.mtime_ns,
+                expected_epoch=epoch,
+                tags=tags,
            )
        except LibraryCommandError as exc:
            if exc.code == "storage-changed":
@@ -61,13 +61,10 @@ try:
    from ...database.image_favorites import MAX_KEY_LENGTH
    from ...database.library import display_title
    from ...database.models import normalize_image_path
-    from ...database.run_attribution import recorded_output_lookup
    from ...utils.card_seed import card_seed, header_params, parsed_positive
    from ...utils.parallel import map_parallel
    from ...utils.json_strict import dumps_strict
    from ...utils.inspection_response import (
-        OWN_CATEGORY_UNREAD,
-        apply_own_category,
        encode_inspection_response,
        library_metadata,
    )
@@ -84,13 +81,10 @@ except ImportError:
    from database.image_favorites import MAX_KEY_LENGTH
    from database.library import display_title
    from database.models import normalize_image_path
-    from database.run_attribution import recorded_output_lookup
    from utils.card_seed import card_seed, header_params, parsed_positive
    from utils.parallel import map_parallel
    from utils.json_strict import dumps_strict
    from utils.inspection_response import (
-        OWN_CATEGORY_UNREAD,
-        apply_own_category,
        encode_inspection_response,
        library_metadata,
    )
@@ -569,8 +563,7 @@ class _ImageTagMatch(NamedTuple):

    tags: bool  # every filter tag is in its image tags or linked positive tags
    query: bool  # ``q`` is a case-folded substring of one image tag name
-    # (hit, rating, positive id, inherited category) of its unambiguous link
-    link: tuple | None
+    link: tuple | None  # (hit, rating, positive id) of its unambiguous link


 def _current_fingerprint(path: Path) -> tuple[int, int] | None:
@@ -582,6 +575,12 @@ def _current_fingerprint(path: Path) -> tuple[int, int] | None:
    return observed.st_size, observed.st_mtime_ns


+def _image_tags_relevant(names: list, wanted: set, query: str) -> bool:
+    if wanted and not wanted.isdisjoint(names):
+        return True
+    return bool(query) and any(query in name.casefold() for name in names)
+
+
 def _workspace_key(entry: tuple, order: str) -> tuple:
    """The keyset sort key of *entry* (a _Listed or a 4-tuple entry)."""
    if not isinstance(entry, _Listed):
@@ -807,53 +806,6 @@ def _favorite_root_key(root) -> str:
    return _favorite_relative_key(os.path.realpath(str(root)))


-def _source_depth(source: str) -> int:
-    return len([part for part in re.split(r"[\\/]+", source) if part])
-
-
-def deepest_source(sources, absolute_path):
-    """``(source, POSIX path below it)`` of the deepest source holding the path.
-
-    A source matches by its real path or by its spelling as configured (a
-    detected output folder can be a symlink), and the deepest real path wins.
-    The path is compared lexically after ``normpath`` and never resolved, so a
-    symlinked subfolder keeps its listed spelling. Containment folds case
-    where the OS does. *source* is the real path. None when no source
-    contains the path.
-    """
-    path = os.path.normpath(str(absolute_path))
-    folded = os.path.normcase(path)
-    best = None
-    for source in sources:
-        real = os.path.normpath(os.path.realpath(str(source)))
-        for spelling in dict.fromkeys((real, os.path.normpath(str(source)))):
-            prefix = os.path.join(os.path.normcase(spelling), "")
-            if not folded.startswith(prefix):
-                continue
-            if best is None or _source_depth(real) > _source_depth(best[0]):
-                best = (real, spelling)
-            break
-    if best is None:
-        return None
-    relative = os.path.relpath(path, best[1])
-    return best[0], relative.replace(os.sep, "/")
-
-
-def image_category_key(sources, absolute_path):
-    """The file key of an image's own category (#332), or None.
-
-    ``(root key, relative key)``: the deepest output source that contains the
-    file and the path below it, keyed with the favorites helpers. Without
-    nested sources it equals the file's favorite key. A path no source
-    contains has no key (and so no own category).
-    """
-    found = deepest_source(sources, absolute_path)
-    if found is None:
-        return None
-    source, relative = found
-    return _favorite_root_key(source), _favorite_relative_key(relative)
-
-
 def _name_suffix(name):
    """``Path(name).suffix`` as Python 3.10-3.13 compute it.

@@ -1153,101 +1105,37 @@ def _workspace_filters(query: Mapping) -> dict:
    }


-# The listing parameters a bulk request may name as its filter (#392): the
-# workspace query without mode, limit, cursor and the Activity-only ``path``,
-# plus the chosen root's ``root_scope`` (a renumbered source is refused).
-LISTING_FILTER_KEYS = frozenset(
-    {
-        "q",
-        "subfolder",
-        "category",
-        "tags",
-        "root",
-        "root_scope",
-        "media",
-        "sort",
-        "favorites",
-    }
-)
-MAX_LISTING_FILTER_VALUE = 2048
-# The most images "Select all N matching" acts on in one request (#392).
-MAX_LISTING_SELECTION = 10_000
-
-
-def parse_listing_filter(raw: object) -> dict:
-    """A bulk request's listing filter (#392): the listing's own query as an object.
-
-    Keys are a subset of LISTING_FILTER_KEYS, each value a string of at most
-    MAX_LISTING_FILTER_VALUE characters, validated as the listing validates its
-    query. The root's bounds need the current roots, so resolve_listing_filter
-    checks those. Raises ValueError.
-    """
-    if not isinstance(raw, dict) or not set(raw) <= LISTING_FILTER_KEYS:
-        raise ValueError("filter must be an object of listing parameters")
-    if any(
-        not isinstance(value, str) or len(value) > MAX_LISTING_FILTER_VALUE
-        for value in raw.values()
-    ):
-        raise ValueError("filter values must be short strings")
-    if "root_scope" in raw and "root" not in raw:
-        raise ValueError("root_scope needs root")
-    _workspace_filters(raw)
-    return dict(raw)
-
-
-class ListingSourceChanged(Exception):
-    """A listing filter's ``root_scope`` no longer names its root (#392)."""
-
-
-class ListingSelection(NamedTuple):
-    """Every image a listing filter admits, in the listing's order (#392).
-
-    ``targets`` are listing identities ``(root_index, root_scope, path)``;
-    ``positive_ids`` the distinct linked positives (first seen), ``unlinked``
-    the admitted images without one, and ``truncated`` that more than the cap
-    matched (the lists then stop at the cap).
-    """
-
-    targets: list
-    positive_ids: list
-    unlinked: int
-    truncated: bool
-
-
 # A plain listing's cursor page leaves positive_count out (see
 # _select_workspace_page); None instead means the count could not be read.
 _COUNT_OMITTED = object()


-def _admitted_entries(
+def _filtered_page(
    entries: list,
+    start: int,
+    size: int,
    filters: dict,
    links: dict | None,
    favorites: frozenset | None = None,
    image_tags: dict | None = None,
-    own_categories: dict | None = None,
-):
-    """Yield ``(position, entry, link match)`` for each entry the filters admit.
+) -> tuple[int, list, int | None]:
+    """Count the *entries* the filters admit and take *size* from *start* on.

-    *links* maps normalized paths to (hit, rating, positive id, inherited
-    category) for every unambiguously linked image (see
-    PromptDatabase.get_image_link_matches); a tag filter admits only those,
-    and ``q`` admits a filename match or a linked-positive hit. A category
-    admits a file whose effective category equals it (#332 MC5): its own
-    category (*own_categories*, ``{normalized path: category}``) when it has one,
-    else the inherited one, so an unlinked file with its own category is
-    admitted. *favorites*, when given, admits only those listed
-    paths (``favorites=1``). *image_tags* maps normalized paths to their
-    _ImageTagMatch: a tag filter also admits a file whose current image tags
-    (with its linked positive's tags) carry every tag, and ``q`` also admits an
-    image tag name hit.
+    *links* maps normalized paths to (hit, rating, positive id) for every
+    unambiguously linked image (see PromptDatabase.get_image_link_matches); a
+    category or tag filter admits only those, and ``q`` admits a filename match
+    or a linked-positive hit. Returns the total, the page and the number of
+    distinct linked positives among all admitted entries (None without links).
+    *favorites*, when given, admits only those listed paths (``favorites=1``).
+    *image_tags* maps normalized paths to their _ImageTagMatch: a tag filter
+    also admits a file whose current image tags (with its linked positive's
+    tags) carry every tag, and ``q`` also admits an image tag name hit.
    """
    query, media, folder = filters["query"], filters["media"], filters["folder"]
-    category = filters["category"]
-    members_only = bool(filters["tags"])
-    own = own_categories or {}
+    members_only = filters["category"] is not None or bool(filters["tags"])
    native_folder = folder.replace("/", os.sep)
    nested = native_folder + os.sep
+    total, page, positives = 0, [], set()
    exact = filters.get("path", "")
    for position, entry in enumerate(entries):
        if exact and entry.folded != exact:
@@ -1264,12 +1152,6 @@ def _admitted_entries(
        image = None if image_tags is None else image_tags.get(entry.normalized)
        if members_only and match is None and not (image and image.tags):
            continue
-        if category is not None:
-            effective = own.get(entry.normalized) if own else None
-            if effective is None and match is not None:
-                effective = match[3]
-            if effective != category:
-                continue
        if (
            query
            and query not in entry.folded
@@ -1277,29 +1159,6 @@ def _admitted_entries(
            and not (image and image.query)
        ):
            continue
-        yield position, entry, match
-
-
-def _filtered_page(
-    entries: list,
-    start: int,
-    size: int,
-    filters: dict,
-    links: dict | None,
-    favorites: frozenset | None = None,
-    image_tags: dict | None = None,
-    own_categories: dict | None = None,
-) -> tuple[int, list, int | None]:
-    """Count the *entries* the filters admit and take *size* from *start* on.
-
-    Admission is _admitted_entries'. Returns the total, the page and the number
-    of distinct linked positives among all admitted entries (None without
-    links).
-    """
-    total, page, positives = 0, [], set()
-    for position, entry, match in _admitted_entries(
-        entries, filters, links, favorites, image_tags, own_categories
-    ):
        total += 1
        if match is not None:
            positives.add(match[2])
@@ -2232,27 +2091,26 @@ class ImageRoutesMixin:
    def _image_tag_matches(self, listings: list[tuple], filters: dict) -> dict:
        """Normalized path -> _ImageTagMatch for files whose image tags count.

-        Looks the relevant tag names up (exact under Tags, a case-folded
-        substring for ``q``) and their files through the tag index, keeping
-        only listed locators; only those candidates are
+        Streams the tagged byte records once and keeps only listed locators
+        carrying a filter tag or a ``q`` hit; only those candidates are
        stat'ed (never every listed file), and a candidate's tags count only
        while a byte record is verified at its present ``(size, mtime_ns)``
        (spec amendment S1). Under a Tags filter the candidates' linked
-        positives are read too, so their tags combine; the category is checked
-        once, on the effective category, by _admitted_entries (#332).
+        positives are read too, so their tags and category combine.
        """
-        tags, query = filters["tags"], filters["query"]
+        tags, query, category = filters["tags"], filters["query"], filters["category"]
        wanted = set(tags)
        located = self._workspace_locators(listings)
-        # The tag index answers which files carry a relevant name (#379); no
-        # read streams every image tag row.
-        tag_ids = self.db.image_tag_ids(wanted, query)
        candidates = {}
-        if tag_ids:
-            for locator in self.db.image_tag_locators(tag_ids):
+        records = self.db.iter_image_tag_records()
+        try:
+            for locator, _size, _mtime_ns, names in records:
                entry = located.get(locator)
-                if entry is not None:
-                    candidates[locator] = entry
+                if entry is not None and locator not in candidates:
+                    if _image_tags_relevant(names, wanted, query):
+                        candidates[locator] = entry
+        finally:
+            records.close()
        stats = {}
        for locator, entry in candidates.items():
            fingerprint = _current_fingerprint(entry.path)
@@ -2271,43 +2129,56 @@ class ImageRoutesMixin:
            link = facts.get(entry.normalized)
            carried = set(names).union(link[4] if link else ())
            matches[entry.normalized] = _ImageTagMatch(
-                bool(wanted) and wanted <= carried,
+                bool(wanted)
+                and wanted <= carried
+                and (category is None or (link is not None and link[3] == category)),
                bool(query) and any(query in name.casefold() for name in names),
-                tuple(link[:4]) if link else None,
+                link[:3] if link else None,
            )
        return matches

-    def _workspace_admission(
-        self, listings: list[tuple], filters: dict, *, read_links: bool, strict=False
+    def _select_workspace_page(
+        self,
+        listings: list[tuple],
+        filters: dict,
+        after: tuple | None,
+        limit: int,
+        scope: str,
    ) -> tuple:
-        """The ordered entries and what admits them (blocking; run in executor).
+        """One keyset page of the filtered listing (blocking; run in executor).

-        Returns ``(entries, key, links, image_tags, favorites, own)``: the
-        listing in the filters' order, its keyset key, and the link, image-tag,
-        favorite and own-category maps _admitted_entries reads. One SELECT
-        (get_image_link_matches) reads every linked positive when *read_links*;
-        under a category it keeps only links whose raw recipe or positive
-        category is that value (the inherited one is decided in Python), and
-        the links of files whose own category is that value are read by path,
-        so their rating and positive still count (#332). A failed read raises when the
-        filters need it (category, tags, the rating sort) or *strict*; else the
-        listing stays usable without links (a search then matches filenames
-        only). A failed image-tag read raises under a Tags filter; a search then
-        matches without image tags.
+        One SELECT (get_image_link_matches) reads every linked positive of the
+        listing: the filters, the rating sort and the positive count share it.
+        A plain listing (no ``q``, category, tags or rating sort) reads it only
+        for its first page; its cursor pages read no links and the returned
+        count is _COUNT_OMITTED, so the response leaves ``positive_count`` out
+        and the frontend keeps the first page's value. On that plain first
+        page a failed read leaves the listing usable and the count unknown
+        (None); so does a failed read under ``q`` alone, whose search then
+        matches filenames only (as before the linked search existed).
        """
        order, category, tags = filters["order"], filters["category"], filters["tags"]
+        needed = (
+            bool(filters["query"])
+            or category is not None
+            or bool(tags)
+            or order == "rating"
+        )
        links = None
-        if read_links:
+        if needed or after is None:
            try:
                links = self.db.get_image_link_matches(
                    filters["text"],
+                    category,
                    tags,
                    every_link=True,
                    wanted=self._workspace_wanted(listings),
-                    category=category,
                )
            except Exception:
-                if strict or category is not None or tags or order == "rating":
+                # Category, tags and the rating sort cannot be served without
+                # the links. A plain listing and a filename search can: the
+                # search then matches filenames only, and the count is None.
+                if category is not None or tags or order == "rating":
                    raise
                self.logger.warning(
                    "Workspace prompt links could not be read; %s",
@@ -2318,18 +2189,13 @@ class ImageRoutesMixin:
                    ),
                    exc_info=True,
                )
-        own = None
-        if category is not None:
-            # A failed read raises: an unfiltered page must never pass for the
-            # category (DC6).
-            own = self._own_category_map(self._get_all_output_dirs(), listings)
-            if links is not None:
-                links = self._own_category_links(links, own, filters)
        image_tags = None
        if filters["query"] or tags:
            try:
                image_tags = self._image_tag_matches(listings, filters)
            except Exception:
+                # A Tags filter cannot be served without them (as without the
+                # links); a search then matches without image tags.
                if tags:
                    raise
                self.logger.warning(
@@ -2368,64 +2234,6 @@ class ImageRoutesMixin:
            def key(entry):
                return _workspace_key(entry, order)

-        favorites = (
-            self._workspace_favorite_paths(listings) if filters["favorites"] else None
-        )
-        return entries, key, links, image_tags, favorites, own
-
-    def _own_category_links(self, links: dict, own: dict, filters: dict) -> dict:
-        """*links* plus the links of files whose own category is the filter's.
-
-        Their inherited category differs, so the category's link read left
-        them out; read by path (get_image_link_facts), kept only when their
-        positive has every filter tag, as the link read would.
-        """
-        category, wanted = filters["category"], set(filters["tags"])
-        missing = [
-            path
-            for path, value in own.items()
-            if value == category and path not in links
-        ]
-        if not missing:
-            return links
-        facts = self.db.get_image_link_facts(missing, filters["text"])
-        extra = {
-            path: tuple(fact[:4])
-            for path, fact in facts.items()
-            if wanted <= set(fact[4])
-        }
-        return {**links, **extra} if extra else links
-
-    def _select_workspace_page(
-        self,
-        listings: list[tuple],
-        filters: dict,
-        after: tuple | None,
-        limit: int,
-        scope: str,
-    ) -> tuple:
-        """One keyset page of the filtered listing (blocking; run in executor).
-
-        The filters, the rating sort and the positive count share one link
-        read (_workspace_admission). A plain listing (no ``q``, category, tags
-        or rating sort) reads it only for its first page; its cursor pages read
-        no links and the returned count is _COUNT_OMITTED, so the response
-        leaves ``positive_count`` out and the frontend keeps the first page's
-        value. On that plain first page a failed read leaves the listing usable
-        and the count unknown (None); so does a failed read under ``q`` alone,
-        whose search then matches filenames only (as before the linked search
-        existed).
-        """
-        order = filters["order"]
-        needed = (
-            bool(filters["query"])
-            or filters["category"] is not None
-            or bool(filters["tags"])
-            or order == "rating"
-        )
-        entries, key, links, image_tags, favorites, own = self._workspace_admission(
-            listings, filters, read_links=needed or after is None
-        )
        start = 0
        if after is not None:
            if order == "name-desc":
@@ -2433,8 +2241,11 @@ class ImageRoutesMixin:
                start = len(entries) - bisect_left(ascending, after, key=key)
            else:
                start = bisect_right(entries, after, key=key)
+        favorites = (
+            self._workspace_favorite_paths(listings) if filters["favorites"] else None
+        )
        total, page, positive_count = _filtered_page(
-            entries, start, limit + 1, filters, links, favorites, image_tags, own
+            entries, start, limit + 1, filters, links, favorites, image_tags
        )
        if not needed and after is not None:
            positive_count = _COUNT_OMITTED
@@ -2449,61 +2260,6 @@ class ImageRoutesMixin:
            positive_count,
        )

-    def _select_workspace_matches(
-        self, listings: list[tuple], filters: dict, cap: int
-    ) -> ListingSelection:
-        """Every admitted entry, up to *cap*, as a ListingSelection (blocking).
-
-        The links are read strictly: the positives must be the listing's own.
-        """
-        entries, _key, links, image_tags, favorites, own = self._workspace_admission(
-            listings, filters, read_links=True, strict=True
-        )
-        targets, positives, unlinked, scopes = [], {}, 0, {}
-        for _position, entry, match in _admitted_entries(
-            entries, filters, links, favorites, image_tags, own
-        ):
-            if len(targets) == cap:
-                return ListingSelection(targets, list(positives), unlinked, True)
-            scope = scopes.get(entry.index)
-            if scope is None:
-                scope = scopes[entry.index] = self._gallery_root_scope(
-                    entry.root, entry.index
-                )
-            relative = entry.path.relative_to(entry.root).as_posix()
-            targets.append((entry.index, scope, relative))
-            if match is None or match[2] is None:
-                unlinked += 1
-            else:
-                positives.setdefault(match[2])
-        return ListingSelection(targets, list(positives), unlinked, False)
-
-    async def resolve_listing_filter(
-        self, params: Mapping, cap: int = MAX_LISTING_SELECTION
-    ) -> ListingSelection:
-        """The images a parse_listing_filter result admits right now (#392).
-
-        Raises ValueError for a root outside the current roots, and
-        ListingSourceChanged when the filter's ``root_scope`` no longer names
-        its root (the sources were renumbered since the listing).
-        """
-        output_dirs = list(self._get_all_output_dirs())
-        root_index = _workspace_root(params, output_dirs)
-        error = self._gallery_scope_error(params, output_dirs)
-        if error is not None:
-            if error.status == 409:
-                raise ListingSourceChanged()
-            raise ValueError("Invalid gallery root scope")
-        filters = _workspace_filters(params)
-        listings = [
-            (index, root, await self._get_gallery_files(root))
-            for index, root in enumerate(output_dirs)
-            if root_index is None or index == root_index
-        ]
-        return await self._run_in_executor(
-            self._select_workspace_matches, listings, filters, cap
-        )
-
    async def serve_image(self, request):
        """Serve the actual image file using streamed FileResponse."""
        try:
@@ -3780,25 +3536,17 @@ class ImageRoutesMixin:
                    except Exception:
                        # The link stays known; only its title is withheld.
                        self.logger.warning("Inspection link title could not be read")
-                # An output file's own category (#332); LoRA roots have none.
-                own = (
-                    self._read_own_category(outputs, path)
-                    if index < len(outputs)
-                    else None
-                )
                try:
                    observed = inspect_current_file(
                        path,
                        source_label=_public_path(roots[index]),
                        saved=saved,
-                        library=apply_own_category(
-                            self._inspection_library(saved, unavailable=unavailable),
-                            own,
+                        library=self._inspection_library(
+                            saved, unavailable=unavailable
                        ),
                        image_tags=self._inspection_image_tags(
                            roots[index], Path(relative).parts
                        ),
-                        recorded=recorded_output_lookup(self.db),
                    )
                except CurrentFileChanged:
                    return None
@@ -3861,19 +3609,6 @@ class ImageRoutesMixin:

        return read

-    def _read_own_category(self, sources, path):
-        """One file's own category, None, or OWN_CATEGORY_UNREAD (blocking).
-
-        Keyed by ``image_category_key`` over the output sources, as Images
-        writes it. A failed read is logged and hides the category (DC5).
-        """
-        try:
-            key = image_category_key(sources, path)
-            return None if key is None else self.db.image_category(*key)
-        except Exception:
-            self.logger.warning("Image category could not be read", exc_info=True)
-            return OWN_CATEGORY_UNREAD
-
    def _inspection_library(self, saved: dict | None, *, unavailable: bool) -> dict:
        """The inspector's Library facts; the route sets the title afterwards."""
        result = {
@@ -3,7 +3,7 @@
 import os
 import stat
 from pathlib import Path
-from typing import Any, Callable
+from typing import Callable

 try:
    from ...utils.prompt_inspector import (
@@ -100,23 +100,18 @@ def inspect_current_file(
    saved: dict | None,
    library: dict,
    image_tags: Callable[[int, int], dict] | None = None,
-    recorded: Callable[[Path], Any] | None = None,
 ) -> dict:
    """Current-file evidence read between two equal stats of *path*.

    *image_tags*, when given, is called once with that stable
    ``(st_size, st_mtime_ns)`` and its facet is returned as ``image_tags``
    (spec amendment S1: tags of a byte record verified at exactly that stat).
-    *recorded*, when given, is asked within the same stat window for what
-    recorded run history knows about *path* (``RecordedOutput`` or None: the
-    save node that wrote it and the texts PromptManager recorded, #386).
    """
    before = _current_file_facts(path)
    try:
        inspection = read_inspection_file(path)
    except MetadataReadError:
        inspection = None
-    run = recorded(path) if recorded is not None and inspection is not None else None
    after = _current_file_facts(path)
    fields = ("st_dev", "st_ino", "st_mode", "st_size", "st_mtime_ns", "st_ctime_ns")
    if any(getattr(before, key) != getattr(after, key) for key in fields):
@@ -134,15 +129,9 @@ def inspect_current_file(
        profile = (
            PREVIEW_INSPECTION_PROFILE if _in_host_temp(path) else INSPECTION_PROFILE
        )
-        # The file name anchors on the saver that wrote it (#381); recorded run
-        # history names that saver when the file alone cannot (#386).
+        # The file name anchors on the saver that wrote it (#381).
        evidence = inspect_prompt_evidence(
-            inspection.metadata,
-            role_saved,
-            profile=profile,
-            file_name=path.name,
-            recorded_saver_id=run.saver_id if run is not None else None,
-            recorded_texts=run.texts if run is not None else None,
+            inspection.metadata, role_saved, profile=profile, file_name=path.name
        )
    return {
        "file": {
@@ -47,11 +47,6 @@ import time
 import uuid
 from pathlib import PurePosixPath, PureWindowsPath

-try:
-    from ...utils import exit_signal
-except ImportError:  # tests import the package top-level
-    from utils import exit_signal
-
 logger = logging.getLogger(__name__)
 # Start and finish order: wall-clock times can tie (coarse Windows clocks).
 _sequence = itertools.count()
@@ -200,21 +195,11 @@ class Job:
        self.counters = dict.fromkeys(groups, 0)
        self.outcomes = {group: [] for group in groups}
        self.log = []
-        self._cancel_requested = False
+        self.cancelled = False
        self.last_event = None
        self.task = None
        self._subscribers = set()

-    @property
-    def cancelled(self):
-        """Cancel was requested, or the interpreter is exiting (#376): every
-        check a job already makes between files also stops it at exit."""
-        return self._cancel_requested or exit_signal.requested()
-
-    @cancelled.setter
-    def cancelled(self, value):
-        self._cancel_requested = bool(value)
-
    @property
    def record_changing(self):
        return self.admission == "records"
@@ -11,11 +11,6 @@ import stat

 from aiohttp import web

-try:
-    from ...utils.logging_config import ClearRefused, parse_confirmed
-except ImportError:  # loaded as the top-level ``py`` package (tests)
-    from utils.logging_config import ClearRefused, parse_confirmed
-
 # Keys PromptManagerLogger.update_config() understands. Anything else is
 # rejected so a client cannot inject arbitrary entries into the logging config.
 LOG_CONFIG_KEYS = frozenset(
@@ -268,43 +263,10 @@ class LoggingRoutesMixin:
            )

    async def truncate_logs(self, request):
-        """Clear all logs: what ``{"expected": [...]}`` lists, or all (#389).
-
-        ``expected`` holds the ``{name, identity}`` rows of ``/logs/files`` the
-        confirmation showed. Without a body (the legacy admin page, whose
-        confirmation lists nothing) every rotated copy present now is deleted.
-        A malformed list is 400; a clear that would empty or delete what was
-        not confirmed changes nothing and is 409 with the reason's ``code``.
-        """
+        """Truncate all log files."""
        try:
-            args = ()
-            if request.can_read_body:
-                data, error_response = await self._read_json_body(request)
-                if error_response is not None:
-                    return error_response
-                if "expected" in data:
-                    try:
-                        parse_confirmed(data["expected"])
-                    except ValueError:
-                        return web.json_response(
-                            {
-                                "success": False,
-                                "error": "expected must list name and identity"
-                                " rows from /logs/files",
-                            },
-                            status=400,
-                        )
-                    args = (data["expected"],)
            logger_manager = self._get_logger_manager()
-            try:
-                results = await self._run_in_executor(
-                    logger_manager.truncate_logs, *args
-                )
-            except ClearRefused as refused:
-                return web.json_response(
-                    {"success": False, "error": str(refused), "code": refused.code},
-                    status=409,
-                )
+            results = await self._run_in_executor(logger_manager.truncate_logs)

            return web.json_response(
                {
@@ -1,54 +0,0 @@
-"""The listing identity of one media file, as a request names it.
-
-Shared by the image-annotation routes and the collection routes (#331): a
-target is ``{root_index, root_scope, path}``, checked here without touching
-the filesystem or the database. The scope is compared with the current roots
-by the caller.
-"""
-
-import os
-import re
-
-from .images import _forbidden, _has_traversal
-from .prompts import bad_request
-
-try:
-    from ...utils.media_capture import CAPTURE_EXTENSIONS
-except ImportError:
-    from utils.media_capture import CAPTURE_EXTENSIONS
-
-MAX_TARGET_PATH = 1024
-TARGET_FIELDS = frozenset({"root_index", "root_scope", "path"})
-_HEX64 = re.compile(r"[0-9a-f]{64}")
-TAGGING_MEDIA_MESSAGE = "Only media files can be tagged"
-
-
-def media_target(data: object, *, media_message: str = TAGGING_MEDIA_MESSAGE):
-    """``((index, scope, relative), None)`` for a target, else ``(None, error)``.
-
-    Only the listing identity is accepted: an int root index, the root's
-    64-hex scope and a bounded root-relative POSIX media path, never an
-    absolute, drive-qualified, backslash or ``..`` path (a 400 for a malformed
-    shape, a 403 for an unsafe or non-media path, carrying *media_message*).
-    """
-    if not isinstance(data, dict) or set(data) != TARGET_FIELDS:
-        return None, bad_request("target must name root_index, root_scope and path")
-    index, scope, relative = data["root_index"], data["root_scope"], data["path"]
-    if type(index) is not int or index < 0:
-        return None, bad_request("Invalid gallery root")
-    if not isinstance(scope, str) or _HEX64.fullmatch(scope) is None:
-        return None, bad_request("Invalid gallery root scope")
-    if not isinstance(relative, str) or not relative or len(relative) > MAX_TARGET_PATH:
-        return None, bad_request("path must be a relative media path")
-    parts = relative.split("/")
-    if (
-        "\0" in relative
-        or "\\" in relative
-        or relative.startswith("/")
-        or _has_traversal(relative)
-        or any(part in ("", ".", "..") or ":" in part for part in parts)
-    ):
-        return None, _forbidden()
-    if os.path.splitext(parts[-1])[1].lower() not in CAPTURE_EXTENSIONS:
-        return None, _forbidden(media_message)
-    return (index, scope, relative), None
@@ -1178,8 +1178,6 @@ class PromptRoutesMixin:
                return web.json_response(
                    {"success": False, "error": "Expected a JSON object"}, status=400
                )
-            if "images_filter" in data:
-                return await self._bulk_category_by_filter(data)
            if not data.get("prompt_ids"):
                return web.json_response(
                    {"success": False, "error": "No prompt IDs provided"}, status=400
@@ -1216,66 +1214,6 @@ class PromptRoutesMixin:
                status=500,
            )

-    async def _bulk_category_by_filter(self, data: dict) -> web.Response:
-        """Set the category on every linked positive a listing filter admits.
-
-        #392 "Select all N matching": ``{images_filter, category}``, the filter
-        being the Images listing's own query (parse_listing_filter), resolved
-        now. The answer adds ``prompt_count`` (the distinct linked positives)
-        and ``skipped`` (matching images without one); none linked changes
-        nothing.
-        """
-        from .images import (
-            MAX_LISTING_SELECTION,
-            ListingSourceChanged,
-            parse_listing_filter,
-        )
-
-        def refused(message, **extra):
-            return web.json_response(
-                {"success": False, "error": message, **extra}, status=400
-            )
-
-        if set(data) != {"images_filter", "category"}:
-            return refused("Request must contain exactly category, images_filter")
-        category = data["category"]
-        try:
-            params = parse_listing_filter(data["images_filter"])
-            validate_category(category)
-            selection = await self.resolve_listing_filter(params)
-        except ListingSourceChanged:
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": "source-changed",
-                    "error": "The source changed. Refresh the image collection.",
-                },
-                status=409,
-            )
-        except ValueError as exc:
-            return refused(str(exc))
-        if selection.truncated:
-            return refused(
-                f"Narrow the view to at most {MAX_LISTING_SELECTION:,} images.",
-                code="too-many-images",
-            )
-        category = (category or "").strip()
-        ids = selection.positive_ids
-        updated = (
-            await self._run_in_executor(self.db.bulk_set_category, ids, category)
-            if ids
-            else 0
-        )
-        return web.json_response(
-            {
-                "success": True,
-                "message": f"Set category for {updated} prompts",
-                "updated_count": updated,
-                "prompt_count": len(ids),
-                "skipped": selection.unlinked,
-            }
-        )
-
    def _all_prompts_for_export(self):
        """Every prompt, fetched in EXPORT_PAGE_SIZE pages (blocking)."""
        prompts, offset = [], 0
@@ -677,14 +677,7 @@ def _verify_and_read(store, capture, item, root, need_metadata: bool):
    facts = store.verify(root, relative)
    captured = None
    if need_metadata:
-        # The file's own name, so an inspection item resolves anchored on its
-        # saver as it was recorded (#390).
-        captured = captured_review(
-            store,
-            capture,
-            item_profile(item["evidence"]),
-            relative.rsplit("/", 1)[-1],
-        )
+        captured = captured_review(store, capture, item_profile(item["evidence"]))
    return relative, facts, captured


@@ -730,9 +723,6 @@ def _candidate_still_offered(resolution: dict, choice: str) -> bool:
    that rewords the top-level reason or reorders candidates leaves a
    pending item applicable.
    """
-    if isinstance(resolution, dict) and resolution.get("anchor") == "saver":
-        # Only the saver anchor resolves the bytes (#390): its pair alone.
-        resolution = {"state": "ambiguous", "candidates": [resolution]}
    if not isinstance(resolution, dict) or resolution.get("state") != "ambiguous":
        return False
    evidence, _count, limited = review_evidence(resolution)
@@ -88,8 +88,7 @@ class ReviewRecordingMixin:
    def _record_scanned_review(self, media_file, roots, review=None, scanned=None):
        """Record one ambiguous, unlinked scanned file (logged and counted).

-        ``scanned`` is the scan's ``(metadata, inspection_resolution)``; the
-        resolution is None when the scan did not run the inspection profile.
+        ``scanned`` is the scan's ``(metadata, inspection_resolution)``.
        """
        try:
            outcome = self._record_review_sync(
@@ -200,7 +199,7 @@ class ReviewRecordingMixin:
        key = _memory_key(locator)
        if state is not None and memory.get(key) == state:
            return None
-        resolution = review_capture.inspection_choice(canonical, media_file.name)
+        resolution = review_capture.inspection_choice(canonical)
        if resolution is not None:
            memory.pop(key, None)
            return canonical, resolution
@@ -88,14 +88,9 @@ from .thumbnail_encode import shutdown_encoders, writer_settings
 from .thumbnail_jobs import ThumbnailOptions

 try:
-    from ...utils.parallel import map_parallel, note_refusal, refused_at_shutdown
+    from ...utils.parallel import map_parallel
 except ImportError:  # tests import the package top-level
-    from utils.parallel import map_parallel, note_refusal, refused_at_shutdown
-
-try:
-    from ...utils.exit_signal import ExitRequested
-except ImportError:  # tests import the package top-level
-    from utils.exit_signal import ExitRequested
+    from utils.parallel import map_parallel

 # The placeholder frame a video without a preview is answered with (JPEG
 # bytes, never written to disk); written previews follow the settings.
@@ -415,8 +410,7 @@ class AutoThumbnailer:

    def enqueue(self, src, dst, is_video):
        """Queue *dst*'s preview for the worker; False when already queued,
-        full, closed or its worker is refused at interpreter exit. Never
-        blocks on a write."""
+        full or closed. Never blocks on a write."""
        key = _dst_key(dst)
        with self._changed:
            if self._closed or key in self._queued:
@@ -426,47 +420,34 @@ class AutoThumbnailer:
            self._queued.add(key)
            self._queue.append((key, Path(src), Path(dst), bool(is_video)))
            self._busy = True
-            started = True
            if self._start_worker and not self._worker_running:
-                started = self._start_worker_locked()
-            if not started:
-                # Refused at interpreter exit: no worker will take it (#375).
-                self._queue.pop()
-                self._queued.discard(key)
+                self._start_worker_locked()
            self._changed.notify_all()
-        return started
+        return True

    def _start_worker_locked(self):
-        """Start the worker (lock held); False only when the interpreter is
-        exiting (#375: logged once at DEBUG, the caller drops the file).
-        Another start failure leaves the file queued and the next enqueue
-        tries again."""
+        """Start the worker (lock held). A start that fails leaves the file
+        queued and the next enqueue tries again."""
        worker = threading.Thread(target=self._run, name=WORKER_NAME, daemon=True)
        worker.pm_preview_token = _MODULE_TOKEN
        worker.pm_preview_close = self.close
        self._worker_running = True
        try:
            worker.start()
-        except RuntimeError as error:
+        except RuntimeError:
            self._worker_running = False
            self._busy = False
-            if refused_at_shutdown(error):
-                note_refusal(self._logger, "The automatic preview worker")
-                return False
            self._logger.warning(
                "The automatic preview worker could not start; the next output "
                "tries again",
                exc_info=True,
            )
-            return True
+            return
        self._worker = worker
-        return True

    def _run(self):
        try:
            self._drain()
-        except ExitRequested:
-            pass  # #376: the interpreter is exiting; queued files are dropped
        except Exception:
            self._logger.warning("The automatic preview worker stopped", exc_info=True)
        finally:
@@ -809,8 +790,8 @@ class AutoThumbnailMixin:

        Returns ``queued``, ``fresh`` (its preview is current) or ``skipped``
        (not a media file under a current root, a link, a preview itself,
-        already queued, after the app's cleanup, or when its worker is refused
-        at interpreter exit). Never writes on the caller's thread.
+        already queued, or after the app's cleanup). Never writes on the
+        caller's thread.
        """
        if self._auto_thumbnails_shut:
            return "skipped"
@@ -7,7 +7,6 @@ Refactored from standalone_tagger.py for integration with PromptManager API.

 import errno
 import gc
-import inspect
 import os
 import sys
 from pathlib import Path
@@ -33,54 +32,6 @@ try:
 except ImportError:
    from py.tagging_defaults import DEFAULT_TAG_TEMPLATE

-try:
-    from ..utils import exit_signal
-except ImportError:
-    from utils import exit_signal
-
-
-def abort_hub_downloads() -> None:
-    """Abort huggingface_hub's Xet transfers (run by the exit hook, #376).
-
-    Xet downloads report progress from native code, which ignores an
-    exception raised in ``tqdm.update``; huggingface_hub aborts them itself
-    on Ctrl+C with ``abort_xet_session``. Nothing happens when
-    huggingface_hub was never imported or has no Xet support.
-    """
-    if "huggingface_hub" not in sys.modules:
-        return
-    try:
-        from huggingface_hub.utils import _xet
-    except ImportError:
-        return
-    abort = getattr(_xet, "abort_xet_session", None)
-    if callable(abort):
-        abort()
-
-
-def _stop_at_exit(download) -> Dict[str, Any]:
-    """Keyword arguments that stop a huggingface_hub download at its next
-    chunk once the interpreter is exiting (#376), or none when this
-    huggingface_hub does not take ``tqdm_class``.
-
-    huggingface_hub 1.x removes its partial temp file on any failure; older
-    versions keep their resumable ``.incomplete`` file. The model's own path
-    is only written by the final rename either way.
-    """
-    try:
-        if "tqdm_class" not in inspect.signature(download).parameters:
-            return {}
-        from huggingface_hub.utils import tqdm as hub_tqdm
-    except (ImportError, TypeError, ValueError):
-        return {}
-
-    class StopAtExit(hub_tqdm):
-        def update(self, n=1):
-            exit_signal.checkpoint()
-            return super().update(n)
-
-    return {"tqdm_class": StopAtExit}
-

 def _autotag_config():
    """The saved defaults; imported late, as config needs ComfyUI's server."""
@@ -446,7 +397,6 @@ class AutoTagService:
                    filename=filename,
                    local_dir=str(model_dir),
                    local_dir_use_symlinks=False,
-                    **_stop_at_exit(hf_hub_download),
                )

        if progress_callback:
@@ -591,13 +541,6 @@ class AutoTagService:
            else:
                return self._download_hf_model(progress_callback)
        except Exception as e:
-            if exit_signal.requested():
-                # ExitRequested between chunks, or the Xet session aborted
-                # by the exit hook (abort_hub_downloads).
-                self.logger.info(
-                    f"Model download stopped: ComfyUI is exiting ({model_type})"
-                )
-                return False
            self.logger.error(f"Download failed: {e}")
            if progress_callback:
                progress_callback(f"Error: {str(e)}", 0)
@@ -627,7 +570,6 @@ class AutoTagService:
                filename=config["filename"],
                local_dir=str(gguf_dir),
                local_dir_use_symlinks=False,
-                **_stop_at_exit(hf_hub_download),
            )
            self.logger.info("GGUF model downloaded")

@@ -645,7 +587,6 @@ class AutoTagService:
                filename=config["mmproj_filename"],
                local_dir=str(gguf_dir),
                local_dir_use_symlinks=False,
-                **_stop_at_exit(hf_hub_download),
            )
            self.logger.info("mmproj downloaded")

@@ -672,7 +613,6 @@ class AutoTagService:
                repo_id=config["repo"],
                local_dir=str(model_dir),
                local_dir_use_symlinks=False,
-                **_stop_at_exit(snapshot_download),
            )
            self.logger.info("HF model downloaded")

@@ -816,24 +756,6 @@ class AutoTagService:

            self.logger.info("Model unloaded, memory freed")

-    def wd14_device(self) -> str:
-        """``"gpu"`` when WD14 runs (or would run) on CUDA, else ``"cpu"``.
-
-        A loaded WD14 session answers from its own first provider; otherwise
-        ONNX Runtime's available providers say whether CUDA would be offered
-        (a session can still fall back to the processor). Loads no model.
-        """
-        tagger = self._tagger
-        if tagger is not None and tagger[0] == "wd14":
-            providers = tagger[1][0].get_providers()
-            return "gpu" if providers[:1] == ["CUDAExecutionProvider"] else "cpu"
-        try:
-            import onnxruntime as ort
-        except ImportError:
-            return "cpu"
-        available = ort.get_available_providers()
-        return "gpu" if "CUDAExecutionProvider" in available else "cpu"
-
    def is_model_loaded(self) -> bool:
        """Check if a model is currently loaded."""
        return self._tagger is not None
@@ -44,10 +44,8 @@ from .lora_manager_layout import (
 )

 try:
-    from ..utils import exit_signal
    from ..utils.hashing import generate_prompt_hash
 except ImportError:  # pragma: no cover - flat test imports
-    from utils import exit_signal
    from utils.hashing import generate_prompt_hash

 LORA_CATEGORY = "lora-manager"
@@ -191,15 +189,14 @@ def stage(
    downloads its CivitAI example images. A sidecar that cannot be read, or
    whose record fails to build, is skipped by its name, as are the
    centralized sidecars discovery could not parse. ``cancelled()`` is asked
-    before each sidecar, and so is the exit signal (#376: the legacy scan's
-    ``cancelled`` does not read it); either raises ImportCancelled. ``on_record(index,
+    before each sidecar (raises ImportCancelled); ``on_record(index,
    record_or_None, staged)`` follows each one.
    """
    sidecars = discovery.sidecars
    staged = StagedImport(total=len(sidecars))
    staged.skipped.extend(discovery.unreadable)
    for index, sidecar in enumerate(sidecars):
-        if cancelled() or exit_signal.requested():
+        if cancelled():
            raise ImportCancelled()
        record = None
        path = sidecar.metadata_path
@@ -13,23 +13,7 @@ LLM_MODEL_TYPES = frozenset({"gguf", "hf"})
 MODEL_TYPES = WD14_MODEL_TYPES | LLM_MODEL_TYPES
 MAX_INSTRUCTION_CHARS = 4000
 MAX_INSTRUCTION_BYTES = 16 * 1024
-# Tag output images' review estimate (#379): seconds per image for the WD14
-# engines, by where ONNX Runtime runs them. The graphics card figure was
-# measured in PR 1's live check (RTX 4090, CUDA: Auto-tag selected on 100
-# images in 16.7 s with the model load, 0.167 s/image). The processor figure
-# is an upper bound from the maintainer's cancelled CPU run (19 min / 697
-# images, backup, model load and skips included), kept as the fallback. The
-# language-model engines have no figure.
-WD14_SECONDS_PER_IMAGE = 1.6
-WD14_GPU_SECONDS_PER_IMAGE = 0.17
-
-
-def wd14_seconds_per_image(device: str) -> float:
-    """The estimate's rate for ``"gpu"`` or ``"cpu"`` (anything else)."""
-    return WD14_GPU_SECONDS_PER_IMAGE if device == "gpu" else WD14_SECONDS_PER_IMAGE
-
-
-# What a batch does with an image that already has tags (#328, #379).
+# What a batch does with a prompt that already has tags (#328).
 EXISTING_POLICIES = ("skip", "merge", "replace_after_review")

 # The language-model tag template every page starts from until one is saved.
@@ -8,8 +8,8 @@ coverage>=7.16.2
 numpy>=2.2.6  # WD14 engine tests

 # Code quality
-black==26.10.1
-flake8==7.4.1
+black>=26.10.1
+flake8>=7.4.1

 # Security scanning
 bandit[toml]>=1.9.4
@@ -676,73 +676,3 @@ export function measureInspector(selector) {
            primary:node.classList.contains('ca-primary'),minHeight:getComputedStyle(node).minHeight})),
    };
 }
-
-// #249 System S7 Task 20, shared since S12 (#329): the maintenance plan dialog's measurement and its D100 mapping,
-// moved unchanged from system-maintenance-concept.spec.mjs so the rotated-log review uses the same ones.
-/** Runs in the page: the open review dialog (plan or duplicates): its title, body and the concept's tokens. */
-export function measureReview() {
-    const dialog = document.querySelector('dialog#modal[open]');
-    const css = (node, ...keys) => node ? Object.fromEntries(keys.map(key => [key, getComputedStyle(node)[key]])) : null;
-    const name = node => [node.localName, ...[...node.classList].sort()].join('.');
-    const text = node => node?.textContent.trim() ?? null;
-    const body = dialog.querySelector('#modal-body');
-    const grid = body.querySelector(':scope > dl.meta-grid');
-    const compare = body.querySelector('.compare-grid');
-    const item = compare?.querySelector('.compare-item');
-    const notes = [...body.querySelectorAll(':scope > p.small')];
-    const note = notes.at(-1);
-    const actions = body.querySelector(':scope > .dialog-actions');
-    return {
-        title: text(dialog.querySelector('#modal-title')),
-        tree: [...body.children].map(name),
-        heading: body.querySelector(':scope > h3') && { text: text(body.querySelector(':scope > h3')),
-            ...css(body.querySelector(':scope > h3'), 'fontSize', 'fontWeight', 'color', 'marginBottom') },
-        grid: grid && { rows: [...grid.children].map(row => [text(row.querySelector('dt')), text(row.querySelector('dd'))]),
-            ...css(grid, 'display', 'gridTemplateColumns', 'columnGap', 'rowGap'),
-            dt: css(grid.querySelector('dt'), 'fontSize', 'color', 'textTransform'), dd: css(grid.querySelector('dd'), 'fontSize', 'color') },
-        details: body.querySelector(':scope > details') && { summary: text(body.querySelector(':scope > details > summary')),
-            tree: [...body.querySelector(':scope > details').children].map(name) },
-        backup: body.querySelector(':scope > .notice') && { tree: [...body.querySelector(':scope > .notice').children].map(name),
-            text: [...body.querySelectorAll(':scope > .notice > div:first-child > *')].map(node => [node.localName, text(node)]),
-            buttons: [...body.querySelectorAll(':scope > .notice button')].map(text) },
-        compare: compare && { tree: [...compare.children].map(name), ...css(compare, 'display', 'gridTemplateColumns', 'columnGap'),
-            items: [...compare.children].map(entry => ({ tree: [...entry.children].map(name), label: text(entry.querySelector('label')),
-                checked: entry.querySelector('input[type=radio]').checked, image: entry.querySelector('img')?.className ?? null })),
-            item: css(item, 'paddingTop', 'paddingLeft', 'backgroundColor', 'borderTopWidth', 'borderTopColor', 'borderTopLeftRadius'),
-            image: css(item.querySelector('img'), 'width', 'objectFit'),
-            label: css(item.querySelector('label'), 'fontSize', 'color'),
-            radio: { name: item.querySelector('input[type=radio]').name.startsWith('keep-') ? 'keep-*' : 'other',
-                type: item.querySelector('input').type } },
-        note: note && { text: text(note), ...css(note, 'fontSize', 'color', 'marginTop') },
-        actions: { tree: [...actions.children].map(name), ...css(actions, 'display', 'justifyContent', 'columnGap', 'marginTop'),
-            buttons: [...actions.children].map(item => ({ text: text(item), className: item.className,
-                ...css(item, 'backgroundColor', 'color', 'fontSize', 'paddingTop', 'paddingLeft', 'borderTopColor') })) },
-    };
-}
-
-export const BACKUP_BOX = Object.freeze({ tree: ['div', 'div.row-actions'], text: [['h3', 'Back up the database first (recommended)'],
-    ['p', 'Downloads a copy of the prompts database before this operation changes any records.']], buttons: ['Back up now'] });
-
-/**
- * D100: the server's plan in the concept's dialog: the operation's row title as its `h3` (the concept prints its
- * `data-plan` name), the four rows with the plan's values, the listed records (`details`), the hold line in the
- * concept's `p.small`, the D55 backup box before the actions, and "Apply reviewed operation". No sample note.
- */
-export function mapPlanConcept(reference, title, plan) {
-    const backup = plan.backup.policy === 'off' ? 'No safety backup (the policy is off)'
-        : `Create and verify before changes (${plan.backup.destination_label})`;
-    const tree = ['h3', 'dl.meta-grid', ...(plan.details.length ? ['details'] : []), 'p.small', 'div.notice', 'div.dialog-actions'];
-    const [cancel, apply] = reference.actions.buttons;
-    return {
-        ...reference,
-        tree,
-        heading: { ...reference.heading, text: title },
-        grid: { ...reference.grid, rows: [['Scope', plan.scope.label],
-            ['Protected', plan.protected.reasons.length ? plan.protected.reasons.join(' · ') : 'Nothing is protected'],
-            ['Backup', backup], ['Media on disk', plan.media.label]] },
-        details: plan.details.length ? { summary: `Listed records (${plan.details.length})`, tree: ['summary', 'pre'] } : null,
-        backup: BACKUP_BOX,
-        note: { ...reference.note, text: 'Nothing changes until you apply. This review holds for 15 minutes.' },
-        actions: { ...reference.actions, buttons: [cancel, { ...apply, text: 'Apply reviewed operation' }] },
-    };
-}
@@ -1,283 +0,0 @@
-"""Run a browser-test fixture seeder off the live database, then publish once (#384).
-
-The seeders make hundreds of small commits. On a slow CI disk the live
-database's commits queue behind WAL checkpoint syncs and a reset took over
-30 s. ``ScratchSeeder.run`` instead:
-
-1. copies the live database into a scratch database (SQLite backup API) whose
-   connections never sync (a crash loses only the copy);
-2. runs the unchanged seeder against an API proxy whose ``db`` is the scratch
-   database; everything else (files, thumbnails, caches, command state) is
-   the live API's, written exactly as before;
-3. replaces the rows of every table the seed changed in the live database, in
-   one transaction on the live connection. Tables the seed left alone are not
-   touched, so state another fixture owns stays as it was.
-
-A commit by any other live connection while the seed ran fails the reset
-instead of being overwritten (``PRAGMA data_version``).
-"""
-
-from __future__ import annotations
-
-import hashlib
-import os
-import shutil
-import sqlite3
-import tempfile
-import weakref
-from pathlib import Path
-from typing import Any, Callable, TypeVar
-
-T = TypeVar("T")
-
-# Set to 1 to run seeders on the live database as before #384 (the equivalence
-# proof, tests/browser/reset_equivalence.py, compares both ways).
-SEED_ON_LIVE_ENV = "PM_TEST_SEED_ON_LIVE"
-SCRATCH_SCHEMA = "reset_seed"
-# API calls a seed makes that must see the published rows (see _SeedApi).
-DEFERRED_CALLS = frozenset({"invalidate_gallery_cache"})
-# Linux's shared-memory tmpfs (present in the Playwright image and on runners).
-MEMORY_ROOT = Path("/dev/shm")
-# The largest fixtures' scratch copy is about 8 MB (database plus a WAL that
-# autocheckpoints near 4 MB). Docker's default /dev/shm is 64 MB, shared with
-# the browsers and the other workers; with less free than this, the scratch
-# copy goes on disk instead.
-MEMORY_FREE_BYTES = 32 * 1024 * 1024
-# Scratch folders are named <prefix><owner pid>-<random>.
-SCRATCH_PREFIX = "pm-reset-"
-
-
-def _quote(name: str) -> str:
-    return '"' + name.replace('"', '""') + '"'
-
-
-def _tables(conn: sqlite3.Connection, schema: str = "main") -> list[str]:
-    rows = conn.execute(
-        f"SELECT name, sql FROM {schema}.sqlite_master WHERE type = 'table' "
-        "ORDER BY name"
-    ).fetchall()
-    for name, sql in rows:
-        if sql and sql.lstrip().upper().startswith("CREATE VIRTUAL"):
-            raise NotImplementedError(f"virtual table {name} cannot be copied")
-    return [name for name, _sql in rows]
-
-
-def _columns(conn: sqlite3.Connection, table: str, schema: str = "main") -> list[str]:
-    """Writable columns (hidden and generated ones excluded), plus ``rowid``
-    when the table has a rowid that no INTEGER PRIMARY KEY column carries."""
-    info = conn.execute(f"PRAGMA {schema}.table_xinfo({_quote(table)})").fetchall()
-    columns = [row[1] for row in info if row[6] == 0]
-    keys = [row for row in info if row[5]]
-    sql = conn.execute(
-        f"SELECT sql FROM {schema}.sqlite_master WHERE type = 'table' AND name = ?",
-        (table,),
-    ).fetchone()[0]
-    without_rowid = sql is not None and "WITHOUT ROWID" in sql.upper()
-    integer_key = len(keys) == 1 and str(keys[0][2]).upper() == "INTEGER"
-    if not without_rowid and not integer_key and table != "sqlite_sequence":
-        columns.insert(0, "rowid")
-    return columns
-
-
-def table_digests(conn: sqlite3.Connection, schema: str = "main") -> dict[str, str]:
-    """A digest of every table's rows (rowids included), by table name."""
-    result = {}
-    for table in _tables(conn, schema):
-        selected = ", ".join(
-            _quote(c) if c != "rowid" else "rowid"
-            for c in _columns(conn, table, schema)
-        )
-        digest = hashlib.sha256()
-        rows = conn.execute(f"SELECT {selected} FROM {schema}.{_quote(table)}")
-        for row in sorted(repr(tuple(row)) for row in rows):
-            digest.update(row.encode("utf-8", "surrogatepass"))
-            digest.update(b"\n")
-        result[table] = digest.hexdigest()
-    return result
-
-
-def _process_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-    except ProcessLookupError:
-        return False
-    except OSError:
-        return True  # it exists but belongs to someone else
-    return True
-
-
-def remove_orphaned_scratch(root: Path) -> None:
-    """Remove scratch folders of servers that died without cleaning up.
-
-    A server killed outright (SIGKILL, a crash) never runs ``close``, and
-    tmpfs keeps its folder in memory until reboot. The folder name carries
-    the owner's process id; a folder whose process is gone is removed.
-    """
-    if os.name != "posix":
-        return  # os.kill(pid, 0) would terminate the process on Windows
-    for folder in root.glob(f"{SCRATCH_PREFIX}*-*"):
-        pid = folder.name[len(SCRATCH_PREFIX) :].split("-", 1)[0]
-        if pid.isdigit() and not _process_alive(int(pid)):
-            shutil.rmtree(folder, ignore_errors=True)
-
-
-class _SeedApi:
-    """The live API, except that ``db`` is the scratch database.
-
-    Cache drops the seed asks for (``DEFERRED_CALLS``) are recorded and made
-    after the publish: dropped earlier, a request in between would cache the
-    live database's old rows again.
-    """
-
-    def __init__(self, api: Any, db: Any) -> None:
-        object.__setattr__(self, "_api", api)
-        object.__setattr__(self, "db", db)
-        object.__setattr__(self, "deferred", [])
-
-    def __getattr__(self, name: str) -> Any:
-        if name in DEFERRED_CALLS:
-
-            def record(*args: Any, **kwargs: Any) -> None:
-                self.deferred.append((name, args, kwargs))
-
-            return record
-        return getattr(self._api, name)
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        setattr(self._api, name, value)
-
-
-class ScratchSeeder:
-    """Seed into a scratch copy and publish the changed tables in one commit."""
-
-    def __init__(
-        self,
-        api: Any,
-        directory: Path,
-        *,
-        on_live: bool = False,
-        memory_root: Path | None = MEMORY_ROOT,
-    ) -> None:
-        self._api = api
-        self._fallback = Path(directory)
-        self._memory_root = memory_root
-        self._directory: Path | None = None
-        self._on_live = on_live
-        self._scratch = None
-        self._unsynced: "weakref.WeakSet[sqlite3.Connection]" = weakref.WeakSet()
-
-    def run(self, seed: Callable[[Any], T]) -> T:
-        """Run ``seed(api)`` (blocking; call it in an executor thread)."""
-        if self._on_live:
-            return seed(self._api)
-        live = self._api.db.model.get_connection()
-        if live.in_transaction:
-            raise RuntimeError("the live connection has an open transaction")
-        version = live.execute("PRAGMA data_version").fetchone()[0]
-        scratch = self._scratch_database()
-        target = self._scratch_connection(scratch)
-        with target.using():
-            live.backup(target)
-        before = table_digests(target)
-        target_api = _SeedApi(self._api, scratch)
-        result = seed(target_api)
-        target = self._scratch_connection(scratch)
-        if target.in_transaction:
-            raise RuntimeError("the seed left a scratch transaction open")
-        after = table_digests(target)
-        changed = [table for table in after if after[table] != before.get(table)]
-        if set(before) != set(after):
-            raise RuntimeError("the seed changed the database schema")
-        if live.execute("PRAGMA data_version").fetchone()[0] != version:
-            raise RuntimeError("the live database changed while the seed ran")
-        self._publish(live, scratch.model.db_path, changed, version)
-        for name, args, kwargs in target_api.deferred:
-            getattr(self._api, name)(*args, **kwargs)
-        return result
-
-    def _scratch_database(self):
-        if self._scratch is None:
-            from database.operations import PromptDatabase
-
-            self._directory = self._scratch_directory()
-            self._scratch = PromptDatabase(str(self._directory / "seed.db"))
-        return self._scratch
-
-    def _scratch_connection(self, scratch) -> sqlite3.Connection:
-        """The calling thread's scratch connection, set never to sync."""
-        conn = scratch.model.get_connection()
-        if conn not in self._unsynced:
-            conn.execute("PRAGMA synchronous = OFF")
-            self._unsynced.add(conn)
-        return conn
-
-    @staticmethod
-    def _publish(
-        live: sqlite3.Connection, path: str, tables: list[str], version: int
-    ) -> None:
-        """Replace ``tables`` with the scratch rows in one live transaction.
-
-        ``version`` is the live ``data_version`` read before the seed. It is
-        checked again under the write lock: a writer whose transaction was
-        open during the seed commits before ``BEGIN IMMEDIATE`` returns, and
-        its rows must fail the reset instead of being overwritten.
-        """
-        if not tables:
-            return
-        foreign_keys = live.execute("PRAGMA foreign_keys").fetchone()[0]
-        # Rows are copied as they are; no cascade may reach a table left alone.
-        live.execute("PRAGMA foreign_keys = OFF")
-        try:
-            live.execute(f"ATTACH DATABASE ? AS {SCRATCH_SCHEMA}", (path,))
-            try:
-                live.execute("BEGIN IMMEDIATE")
-                try:
-                    if live.execute("PRAGMA data_version").fetchone()[0] != version:
-                        raise RuntimeError(
-                            "the live database changed while the seed ran"
-                        )
-                    for table in tables:
-                        columns = ", ".join(
-                            _quote(c) if c != "rowid" else "rowid"
-                            for c in _columns(live, table)
-                        )
-                        name = _quote(table)
-                        live.execute(f"DELETE FROM main.{name}")
-                        live.execute(
-                            f"INSERT INTO main.{name} ({columns}) "
-                            f"SELECT {columns} FROM {SCRATCH_SCHEMA}.{name}"
-                        )
-                    live.commit()
-                except BaseException:
-                    live.rollback()
-                    raise
-            finally:
-                live.execute(f"DETACH DATABASE {SCRATCH_SCHEMA}")
-        finally:
-            live.execute(f"PRAGMA foreign_keys = {int(foreign_keys)}")
-
-    def close(self) -> None:
-        """Close every scratch connection, then remove the scratch files."""
-        if self._on_live:
-            return
-        if self._scratch is not None:
-            self._scratch.close_all()
-            self._scratch = None
-        if self._directory is not None:
-            shutil.rmtree(self._directory, ignore_errors=True)
-            self._directory = None
-
-    def _scratch_directory(self) -> Path:
-        """A folder in memory (tmpfs) where there is one, else ``directory``.
-
-        Even unsynced, scratch writes on the runner's disk wait whenever the
-        kernel is writing back the pages they rewrite.
-        """
-        root = self._memory_root
-        if root is not None and root.is_dir() and os.access(root, os.W_OK):
-            remove_orphaned_scratch(root)
-            if shutil.disk_usage(root).free >= MEMORY_FREE_BYTES:
-                prefix = f"{SCRATCH_PREFIX}{os.getpid()}-"
-                return Path(tempfile.mkdtemp(prefix=prefix, dir=root))
-        self._fallback.mkdir(parents=True, exist_ok=True)
-        return self._fallback
@@ -1,78 +0,0 @@
-"""Empty a browser-test media folder without waiting for the disk (#384).
-
-A reset used to ``shutil.rmtree`` the output and input folders the last
-fixture wrote. Unlinking a file whose pages are still being written back
-waits for that write, so on a slow CI disk a reset stalled in ``rmtree``.
-``replace_folder`` renames the old folder into ``<parent>/reset-trash`` (one
-metadata change) and makes a new empty one; a background thread deletes the
-trash, and ``close_trash`` stops that thread and removes what is left before
-the server's temp root goes.
-"""
-
-from __future__ import annotations
-
-import queue
-import shutil
-import threading
-import uuid
-from pathlib import Path
-
-TRASH_NAME = "reset-trash"
-
-
-class _Trash:
-    def __init__(self, directory: Path) -> None:
-        self.directory = directory
-        self._queue: "queue.SimpleQueue[Path | None]" = queue.SimpleQueue()
-        self._thread = threading.Thread(
-            target=self._work, name="pm-reset-trash", daemon=True
-        )
-        self._thread.start()
-
-    def _work(self) -> None:
-        while (folder := self._queue.get()) is not None:
-            shutil.rmtree(folder, ignore_errors=True)
-
-    def discard(self, folder: Path) -> None:
-        self.directory.mkdir(exist_ok=True)
-        moved = self.directory / f"{folder.name}-{uuid.uuid4().hex}"
-        folder.rename(moved)
-        self._queue.put(moved)
-
-    def close(self) -> None:
-        self._queue.put(None)
-        self._thread.join()
-        shutil.rmtree(self.directory, ignore_errors=True)
-
-
-_trashes: dict[Path, _Trash] = {}
-# Trash folders whose server has cleaned up: a reset still running then
-# deletes in place instead of starting a thread nobody would stop.
-_closed: set[Path] = set()
-_lock = threading.Lock()
-
-
-def replace_folder(folder: Path) -> None:
-    """Make ``folder`` an empty folder; its old content is deleted later."""
-    folder = Path(folder)
-    if folder.exists():
-        directory = folder.parent / TRASH_NAME
-        with _lock:
-            trash = _trashes.get(directory)
-            if trash is None and directory not in _closed:
-                trash = _trashes[directory] = _Trash(directory)
-            if trash is not None:
-                trash.discard(folder)
-        if folder.exists():
-            shutil.rmtree(folder)
-    folder.mkdir()
-
-
-def close_trash(parent: Path) -> None:
-    """Stop deleting under ``parent``'s trash and remove it (blocking)."""
-    directory = Path(parent) / TRASH_NAME
-    with _lock:
-        _closed.add(directory)
-        trash = _trashes.pop(directory, None)
-    if trash is not None:
-        trash.close()
@@ -286,8 +286,7 @@ const continuationText=page=>page.locator('.infinite-continuation > p').first().
 async function searchOf(page,term) {
    const before=await countText(page);
    await page.locator('#search').fill(term);
-    // Production's caption reads "Loading images…" until the search's listing answers (#391); the concept's is instant.
-    await expect.poll(async()=>{const text=await countText(page);return text!==before&&text!=='Loading images…';}).toBe(true);
+    await expect.poll(()=>countText(page)).not.toBe(before);
    await expect.poll(()=>page.locator(CARDS).count()).toBeLessThan(FIXTURE_IMAGES);
    await settle(page);
    const result={count:await countText(page),continuation:await continuationText(page),cards:await page.locator(`${CARDS} .image-open`).evaluateAll(nodes=>nodes.map(node=>node.getAttribute('aria-label')))};
@@ -228,8 +228,7 @@ async function productionSendOf(page,context) {
 async function tagOf(page) {
    const before=await page.locator('#result-count').textContent();
    await panelOf(page).locator('.detail-inner > .tags').last().getByRole('button',{name:'cinematic',exact:true}).click();
-    // Production's caption reads "Loading images…" until the tag's listing answers (#391); the concept's search is instant.
-    await expect.poll(async()=>{const text=await page.locator('#result-count').textContent();return text!==before&&text!=='Loading images…';}).toBe(true);
+    await expect.poll(()=>page.locator('#result-count').textContent()).not.toBe(before);
    await settle(page);
    return {count:await page.locator('#result-count').textContent(),
        cards:await page.locator(`${CARDS} .image-open`).evaluateAll(nodes=>nodes.map(node=>node.getAttribute('aria-label')))};
@@ -329,25 +328,6 @@ test('a recipe-linked image without recipe metadata shows its positive prompt me
    await expect(panelOf(page).locator('.detail-footer button')).toHaveText(['Send to ComfyUI','Prompt history']);
 });

-// #391: a tag chip replaces the collection; until its listing answers the caption says it is loading, never that the
-// filter matched nothing ("0 of 0 images" was painted before the response and read by a fast reader).
-test('a tag chip collection reads as loading, not empty, until its listing answers (#391)',async({page})=>{
-    await page.setViewportSize({width:1600,height:1100});
-    await openProductionPanel(page,'dark');
-    let release,arrived;
-    const held=new Promise(resolve=>{release=resolve;}),reached=new Promise(resolve=>{arrived=resolve;});
-    await page.route(url=>url.pathname==='/prompt_manager/images/output'&&url.searchParams.get('tags')==='cinematic',
-        async route=>{arrived();await held;await route.continue();},{times:1});
-    const count=page.locator('#result-count');
-    await panelOf(page).locator('.detail-inner > .tags').last().getByRole('button',{name:'cinematic',exact:true}).click();
-    await reached;
-    await expect(count).toHaveText('Loading images…');
-    await expect(page.locator(CARDS)).toHaveCount(0);
-    release();
-    await expect(count).toHaveText(countCopy('8 of 8 images · 2 positive prompts'));
-    await expect(page.locator(CARDS)).toHaveCount(8);
-});
-
 // Task C3 (D88, #249 PR C): the concept's chip row is the image's own tags (`i.tags`, app.js a402). With those names
 // saved as the file's current image tags, production draws the row from them (Tags filter buttons in the panel, plain
 // in the viewer, the linked positive's equal tags not repeated) and still equals the concept, in both sizes.
@@ -1,9 +1,11 @@
-// #328: the legacy admin and gallery auto-tag batch and review keep working beside System › Auto-tagging. Since #330
-// the pages download and unload models only through System (legacy-system-links.spec.mjs); a batch never downloads
-// one. The fixture's fake download (`/__test__/tagging/download`) is held so nothing is ever fetched.
+// #328: the legacy admin and gallery auto-tag tools keep working beside System › Auto-tagging. The model download is
+// the `model_download` Activity job; the pages' stream attaches to it. No model is ever downloaded: the fixture's
+// fake download waits until the test releases it (`/__test__/tagging/download`).
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';

+const TITLE = 'Tagging model download · WD14 ViT';
+
 async function post(request, url, data) {
    await expect(await request.post(url, data === undefined ? {} : { data })).toBeOK();
 }
@@ -31,6 +33,61 @@ test.afterEach(async ({ page, request, browserName }) => {
    await post(request, '/__test__/jobs/restart');
 });

+async function startDownload(page, request) {
+    await page.locator('#autoTagBtn').click();
+    const status = page.locator('#wd14VitModelStatus');
+    await status.getByRole('button', { name: 'Download', exact: true }).click();
+    const modal = page.locator('#autoTagDownloadModal');
+    await expect(modal).toBeVisible();
+    await expect(page.locator('#downloadStatus')).toHaveText('Downloading…');
+    await expect(page.locator('#downloadProgressBar')).toHaveClass(/animate-pulse/);
+    await expect(modal).toContainText('The download continues in Activity.');
+    await expect(page.locator('#cancelDownloadBtn')).toHaveText('Close');
+    const running = (await downloads(request)).filter(job => job.state === 'running');
+    expect(running.map(job => [job.title, job.cancellable])).toEqual([[TITLE, false]]);
+    return { modal, status };
+}
+
+test('admin download modal closes on complete and Activity lists the job without Cancel', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    const { modal, status } = await startDownload(page, request);
+
+    await page.goto('/prompt_manager/workspace#/activity');
+    const item = page.locator('#workspace-main section.surface > .activity-item')
+        .filter({ has: page.getByRole('link', { name: new RegExp(`${TITLE}$`) }) });
+    await expect(item.locator('.chip')).toHaveText('Running');
+    await expect(item.locator('progress')).not.toHaveAttribute('value');
+    await expect(item.getByRole('button', { name: 'Cancel job', exact: true })).toHaveCount(0);
+
+    // Back on the admin page a second download of the same model attaches to the running job.
+    await page.goto('/prompt_manager/admin');
+    await startDownload(page, request);
+    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
+    await expect(modal).toBeHidden();
+    await expect(status).toContainText('Downloaded');
+    expect((await downloads(request)).map(job => [job.title, job.state])).toEqual([[TITLE, 'finished']]);
+});
+
+test('gallery download modal closes on complete', async ({ page, request }) => {
+    await page.goto('/prompt_manager/gallery');
+    const { modal, status } = await startDownload(page, request);
+    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
+    await expect(modal).toBeHidden();
+    await expect(page.locator('#autoTagModal')).toBeVisible();
+    await expect(status).toContainText('Downloaded');
+    expect((await downloads(request)).map(job => job.state)).toEqual(['finished']);
+});
+
+test('a failed download closes the modal and says so', async ({ page, request }) => {
+    await page.goto('/prompt_manager/gallery');
+    const { modal, status } = await startDownload(page, request);
+    await post(request, '/__test__/tagging/download', { mode: 'fail' });
+    await expect(modal).toBeHidden();
+    await expect(page.getByText('Download failed: Download failed')).toBeVisible();
+    await expect(status.getByRole('button', { name: 'Download', exact: true })).toBeVisible();
+    expect((await downloads(request)).map(job => job.state)).toEqual(['failed']);
+});
+
 // (wd14-vit is not downloaded in these tests: beforeEach marks it so the download tests can offer it.)
 // The gallery's batch reader keyed on `data.status` values the server never sends, so its modal never moved or
 // closed (#328 Problem 5). It now reads `type` frames as the admin page does.
@@ -38,14 +95,8 @@ async function watchProgress(page) {
    await page.evaluate(() => {
        window.progressSeen = [];
        const node = document.getElementById('autoTagProgressPercent');
-        // Each change from its own record: frames that land in one task share one
-        // callback, and the node's text by then is only the last of them.
-        new MutationObserver(records => {
-            for (const record of records) {
-                if (record.type === 'characterData') window.progressSeen.push(record.target.data);
-                for (const added of record.addedNodes) window.progressSeen.push(added.textContent);
-            }
-        }).observe(node, { childList: true, characterData: true, subtree: true });
+        new MutationObserver(() => window.progressSeen.push(node.textContent))
+            .observe(node, { childList: true, characterData: true, subtree: true });
    });
 }

@@ -57,126 +108,45 @@ async function runGalleryBatch(page) {
    await page.locator('#startAutoTagBtn').click();
    await done;
    await expect(page.locator('#autoTagProgressModal')).toBeHidden();
-    // #379: the batch counts images, never prompts.
-    await expect(page.getByText(/^Auto tagging complete! Tagged \d+ images?\.$/)).toBeVisible();
-}
-
-const CLOSE_NOTE = 'Closing this window stops tagging. Tags already added are kept. Prompt Manager\'s Activity page shows the '
-    + 'time left.';
-
-async function serverJobs(request) {
-    const response = await request.get('/prompt_manager/jobs');
-    await expect(response).toBeOK();
-    return (await response.json()).jobs;
-}
-
-async function runNativeBatch(request) {
-    const started = await request.post('/prompt_manager/jobs/autotag', { data: { model_type: 'wd14-swinv2', existing: 'skip',
-        options: { general_threshold: 0.35, character_threshold: 0.85 } } });
-    expect(started.status()).toBe(202);
-    const { job } = await started.json();
-    await expect.poll(async () => (await serverJobs(request)).find(item => item.id === job.id)?.state).toBe('finished');
+    await expect(page.getByText(/^Auto tagging complete! Applied tags to \d+ prompts\.$/)).toBeVisible();
 }

 test('gallery batch modal counts progress and closes on complete', async ({ page, request }) => {
    await page.goto('/prompt_manager/gallery');
    await runGalleryBatch(page);
    const seen = await page.evaluate(() => window.progressSeen);
-    // The phase frames (model 5%, listing 8%) then the per-image frames (from 10%) move the bar.
-    expect(seen).toContain('8%');
-    expect(seen.some(value => parseInt(value, 10) >= 10)).toBe(true);
-    await expect(page.locator('#autoTagCloseNote')).toHaveText(CLOSE_NOTE);
-    // The batch ran as the autotag job of the legacy page.
-    expect((await serverJobs(request)).filter(job => job.kind === 'autotag').map(job => [job.title, job.state]))
-        .toEqual([['Tag output images (legacy page)', 'finished']]);
+    // The fixture's prompts are already tagged, so the batch skips them; its progress frames still move the bar.
+    expect(seen).toContain('95%');
    expect((await downloads(request)).length).toBe(0);
 });

-test('admin batch copy names images, not prompts (#379)', async ({ page }) => {
-    await page.goto('/prompt_manager/admin');
-    await page.locator('#autoTagBtn').click();
-    await expect(page.locator('input[name="autoTagMode"][value="skip"] + span')).toHaveText('Skip images already auto-tagged');
-    await expect(page.getByText('"auto-scanned" is not counted as a real tag')).toHaveCount(0);
-    await expect(page.locator('#autoTagCloseNote')).toHaveText(CLOSE_NOTE);
-    await expect(page.locator('#retagConfirmModal h3')).toHaveText('Image Already Auto-tagged');
-    await expect(page.locator('#retagConfirmModal')).toContainText('A tagging model already tagged this image. Generate new tags?');
-});
-
 test('admin review opens the first image', async ({ page }) => {
    await page.goto('/prompt_manager/admin');
    await page.locator('#autoTagBtn').click();
    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
    await page.locator('#startReviewBtn').click();
-    // #379: no image is auto-tagged yet (prompt tags no longer count), so the review opens on the first image.
-    await expect(page.locator('#retagConfirmModal')).toBeHidden();
+    // The first image's prompt is already tagged: confirm a new pass, then the review opens on that image.
+    await page.locator('#retagConfirmBtn').click();
    await expect(page.locator('#autoTagReviewModal')).toBeVisible();
    await expect(page.locator('#reviewImageName')).not.toHaveText(/^(image_name\.png|Unknown|)$/);
    await expect(page.getByText('Failed to start review mode')).toHaveCount(0);
 });

-/** The admin review lists every row, videos too: Skip any image that is not one until the confirmation shows. */
-async function untilAutoTagged(page, confirm) {
-    // Each image's skip check answers before its confirmation or its error shows.
-    const failed = page.locator('#reviewTagsVisible .text-pm-error');
-    for (let tries = 0; tries < 5; tries++) {
-        await expect.poll(async () => (await confirm.isVisible()) || (await failed.count()) > 0).toBe(true);
-        if (await confirm.isVisible()) return;
-        const answered = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/single'));
-        await page.locator('#skipReviewBtn').click();
-        await answered;
-    }
-    await expect(confirm).toBeVisible();
-}
-
-// #379: the admin review asks before re-tagging an image a model already tagged, and Apply & Next writes that image's
-// tags (its bytes, never its prompt).
-test('admin review: an auto-tagged image asks first; Re-tag then Apply & Next tags the image', async ({ page, request }) => {
-    await runNativeBatch(request);
-    await page.goto('/prompt_manager/admin');
-    await page.locator('#autoTagBtn').click();
-    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
-    await page.locator('#startReviewBtn').click();
-    const confirm = page.locator('#retagConfirmModal');
-    await untilAutoTagged(page, confirm);
-    await expect(confirm.locator('#retagExistingTags span').first()).toHaveText('sandstone');
-    await page.locator('#retagConfirmBtn').click();
-    await expect(page.locator('#autoTagReviewModal')).toBeVisible();
-    await expect(page.locator('#reviewTagsVisible .tag-chip').first()).toContainText('sandstone');
-    const applied = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/apply'));
-    const answer = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/apply'));
-    await page.locator('#applyReviewBtn').click();
-    const body = (await applied).postDataJSON();
-    expect(body.prompt_id).toBeUndefined();
-    expect(body.sha256).toMatch(/^[0-9a-f]{64}$/);
-    expect((await answer).status()).toBe(200);
-});
-
-test('admin review: Skip All Tagged passes every auto-tagged image', async ({ page, request }) => {
-    await runNativeBatch(request);
-    await page.goto('/prompt_manager/admin');
-    await page.locator('#autoTagBtn').click();
-    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
-    await page.locator('#startReviewBtn').click();
-    const confirm = page.locator('#retagConfirmModal');
-    await untilAutoTagged(page, confirm);
-    await page.locator('#retagSkipAllBtn').click();
-    await expect(page.locator('#retagConfirmModal')).toBeHidden();
-    await expect(page.getByText('Review complete!')).toBeVisible();
-});
-
-test('gallery review: Apply & Next tags the image by its path and bytes', async ({ page }) => {
+test('gallery unload works and is refused while the gate is held', async ({ page, request }) => {
    await page.goto('/prompt_manager/gallery');
+    await runGalleryBatch(page); // keeps the model in memory
    await page.locator('#autoTagBtn').click();
-    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
-    const suggested = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/single'));
-    await page.locator('#startReviewBtn').click();
-    expect((await suggested).postDataJSON().existing).toBe('merge');
-    await expect(page.locator('#reviewTagsContainer .tag-chip').first()).toContainText('sandstone');
-    const applied = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/apply'));
-    const answer = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/apply'));
-    await page.locator('#applyReviewBtn').click();
-    const body = (await applied).postDataJSON();
-    expect(Object.keys(body).sort()).toEqual(['path', 'root_index', 'sha256', 'tags'].filter(key => key in body).sort());
-    expect(body.prompt_id).toBeUndefined();
-    expect((await answer).status()).toBe(200);
+    const unload = page.locator('#unloadModelBtn');
+    await expect(unload).toBeVisible();
+
+    // A held download owns the model gate: Unload is refused with the server's error.
+    const held = await request.post('/prompt_manager/jobs/model-download', { data: { model_type: 'gguf' } });
+    expect(held.status()).toBe(202);
+    await unload.click();
+    await expect(page.getByText(/^Failed to unload model: A tagging model is busy/)).toBeVisible();
+
+    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
+    await expect.poll(async () => (await downloads(request)).map(job => job.state)).toEqual(['finished']);
+    await unload.click();
+    await expect(page.getByText('WD14-SWINV2 model unloaded successfully')).toBeVisible();
 });
@@ -1,286 +0,0 @@
-// System S13 (#330): the legacy admin and gallery pages open native System for their System tools. Each replaced
-// control is a plain link (`workspace#/system/<id>`, a new tab), and the legacy flows S13 keeps still work.
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-const PAGES = Object.freeze({ admin: '/prompt_manager/admin', gallery: '/prompt_manager/gallery' });
-const LABELS = Object.freeze({
-    overview: 'Overview',
-    appearance: 'Appearance',
-    sources: 'Sources & scans',
-    integrations: 'Integrations',
-    tagging: 'Auto-tagging',
-    maintenance: 'Maintenance',
-    backups: 'Backup & export',
-    diagnostics: 'Diagnostics & logs',
-});
-
-async function openPageOptions(page) {
-    await page.locator('#pageOptionsBtn').click();
-    await expect(page.locator('#settingsModal')).toBeVisible();
-}
-
-/** The auto-tag modal with its model rows read from /autotag/models. */
-async function openAutoTag(page) {
-    const read = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/models'));
-    await page.locator('#autoTagBtn').click();
-    await read;
-    await expect(page.locator('#autoTagModal')).toBeVisible();
-}
-
-const notDownloaded = (page, request) => post(request, '/__test__/tagging/models', { unavailable: ['gguf'] });
-const modelLoaded = (page, request) => post(request, '/__test__/tagging/loaded', { model: 'wd14-vit' });
-
-// One row per System link of the design's §2 map: the page, the control's label, how to find it, the section it opens
-// and what a test must arrange before the control shows.
-const LINKS = Object.freeze([
-    { page: 'admin', label: 'Settings', locate: page => page.locator('#settingsBtn'), section: 'overview' },
-    { page: 'admin', label: 'Maintenance', locate: page => page.locator('#maintenanceBtn'), section: 'maintenance' },
-    { page: 'admin', label: 'Backup DB', locate: page => page.locator('#backupBtn'), section: 'backups' },
-    { page: 'admin', label: 'Restore DB', locate: page => page.locator('#restoreBtn'), section: 'backups' },
-    { page: 'gallery', label: 'Settings', locate: page => page.locator('#settingsBtn'), section: 'appearance' },
-    { page: 'admin', label: 'Manage in System (model row)', arrange: notDownloaded, reveal: openAutoTag,
-        locate: page => page.locator('#ggufModelStatus a'), section: 'tagging' },
-    { page: 'gallery', label: 'Manage in System (model row)', arrange: notDownloaded, reveal: openAutoTag,
-        locate: page => page.locator('#ggufModelStatus a'), section: 'tagging' },
-    { page: 'gallery', label: 'Manage in System (Unload Model)', arrange: modelLoaded, reveal: openAutoTag,
-        locate: page => page.locator('#unloadModelBtn'), section: 'tagging' },
-    { page: 'gallery', label: 'Page options Maintenance', reveal: openPageOptions,
-        locate: page => page.locator('#pageOptionsMaintenanceLink'), section: 'maintenance' },
-    { page: 'gallery', label: 'Page options Sources & scans', reveal: openPageOptions,
-        locate: page => page.locator('#pageOptionsSourcesLink'), section: 'sources' },
-    { page: 'admin', label: 'Diagnostics', locate: page => page.locator('#diagnosticsBtn'), section: 'diagnostics' },
-    { page: 'admin', label: 'View Logs', locate: page => page.locator('#logsBtn'), section: 'diagnostics' },
-]);
-
-async function post(request, url, data) {
-    await expect(await request.post(url, data === undefined ? {} : { data })).toBeOK();
-}
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await post(request, '/__test__/reset');
-    await post(request, '/__test__/system/reset');
-    await post(request, '/__test__/tagging/reset');
-    // The 3.2.0 update notice would cover the admin page's toolbar.
-    await page.addInitScript(() => { localStorage.setItem('pm_update_notice_dismissed', '3.2.0'); });
-    page.legacyErrors = [];
-    page.on('pageerror', error => page.legacyErrors.push(error.message));
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    await post(request, '/__test__/tagging/reset');
-    await post(request, '/__test__/system/reset');
-    expect(page.legacyErrors).toEqual([]);
-});
-
-/** Opens the legacy page with the link showing; returns the link. */
-async function openLink(page, request, link) {
-    if (link.arrange) await link.arrange(page, request);
-    await page.goto(PAGES[link.page]);
-    if (link.reveal) await link.reveal(page);
-    const control = link.locate(page);
-    await expect(control).toBeVisible();
-    return control;
-}
-
-// Each row opens its section in a new tab and sends no request from the legacy page (the design's `a System link sends
-// no request from the legacy page`, checked per row so one slow page never times out the whole table).
-for (const link of LINKS) {
-    test(`legacy ${link.page} ${link.label} opens System ${link.section}`, async ({ page, context, request }) => {
-        // The gallery's thumbnail startup check (K9) reads its status on a timer of its own; it is off here.
-        await page.addInitScript(() => {
-            localStorage.setItem('gallerySettings', JSON.stringify({ checkThumbnailsAtStartup: false }));
-        });
-        const control = await openLink(page, request, link);
-        const legacyUrl = page.url();
-        await expect(control).toHaveAttribute('href', `workspace#/system/${link.section}`);
-        await expect(control).toHaveAttribute('target', '_blank');
-        await expect(control).toHaveAttribute('rel', 'noopener');
-        // The page's own start-up reads (list, film strips, settings) finish first; then the click must add none.
-        // Lazy thumbnails may still load whenever the layout changes; they are not the click's.
-        await page.waitForLoadState('networkidle');
-        const sent = [];
-        const record = item => { if (item.resourceType() !== 'image') sent.push(`${item.method()} ${item.url()}`); };
-        page.on('request', record);
-        const opened = context.waitForEvent('page');
-        await control.click();
-        const system = await opened;
-        await expect(system).toHaveURL(new RegExp(`/prompt_manager/workspace#/system/${link.section}$`));
-        page.off('request', record);
-        expect(sent, 'a System link sends no request from the legacy page').toEqual([]);
-        // System's page heading is "System"; the open section is the pressed button of its section switcher.
-        const main = system.locator('#workspace-main');
-        await expect(main.getByRole('heading', { level: 1, name: 'System', exact: true })).toBeVisible();
-        await expect(main.getByRole('group', { name: 'System sections', exact: true })
-            .getByRole('button', { name: LABELS[link.section], exact: true })).toHaveAttribute('aria-pressed', 'true');
-        expect(page.url()).toBe(legacyUrl);
-        await system.close();
-    });
-}
-
-test('kept admin flows still work', async ({ page, context }) => {
-    await page.goto(PAGES.admin);
-    const texts = page.locator('#resultsList .prompt-text');
-    await expect(texts.first()).toBeVisible();
-
-    // K1: sorting reorders the list.
-    for (const [value, order] of [['text_asc', 1], ['text_desc', -1]]) {
-        const listed = page.waitForResponse(item => /\/prompt_manager\/(recent|search)\?/.test(item.url()) && item.url().includes(`sort=${value}`));
-        await page.locator('#sortBy').selectOption(value);
-        await listed;
-        await expect.poll(async () => {
-            const shown = await texts.allTextContents();
-            // The server sorts case-insensitively (SQLite NOCASE), not by locale.
-            const key = text => text.toLowerCase();
-            const sorted = [...shown].sort((a, b) => order * (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0));
-            return shown.length > 1 && shown.join('\n') === sorted.join('\n');
-        }).toBe(true);
-    }
-    // K3: Add Prompt saves a prompt the list then shows.
-    await page.locator('#addPromptBtn').click();
-    await page.locator('#addPromptText').fill('Kept flow lighthouse');
-    const saved = page.waitForResponse(item => item.request().method() === 'POST' && item.url().endsWith('/prompt_manager/save'));
-    await page.locator('#saveNewPromptBtn').click();
-    expect((await saved).ok()).toBe(true);
-    await expect(page.locator('#addPromptModal')).toBeHidden();
-    await expect(texts.filter({ hasText: 'Kept flow lighthouse' })).toBeVisible();
-
-    // K1: a search narrows the list, and a selection enables the bulk buttons.
-    const all = await texts.allTextContents();
-    const word = all[0].trim().split(/\s+/)[0];
-    const searched = page.waitForResponse(item => item.url().includes('/prompt_manager/search?') && item.url().includes('text='));
-    await page.locator('#searchText').fill(word);
-    await page.locator('#searchBtn').click();
-    await searched;
-    await expect.poll(async () => {
-        const shown = await texts.allTextContents();
-        return shown.length > 0 && shown.length < all.length && shown.every(text => text.toLowerCase().includes(word.toLowerCase()));
-    }).toBe(true);
-    await expect(page.locator('#bulkDeleteBtn')).toBeDisabled();
-    await page.locator('#resultsList .prompt-checkbox').first().check();
-    for (const id of ['#bulkDeleteBtn', '#bulkTagBtn', '#bulkCategoryBtn']) await expect(page.locator(id)).toBeEnabled();
-
-    // K4: Stats reads the statistics again; Export downloads the prompts.
-    const stats = page.waitForResponse(item => item.url().endsWith('/prompt_manager/stats') && item.ok());
-    await page.locator('#statsBtn').click();
-    await stats;
-    await expect(page.getByText('Stats refreshed successfully!')).toBeVisible();
-    const download = page.waitForEvent('download');
-    await page.locator('#exportBtn').click();
-    expect((await download).suggestedFilename()).toMatch(/^prompts-\d{4}-\d{2}-\d{2}\.json$/);
-
-    // K5: Scan Images opens its dialog (with the quick backup) without starting a scan.
-    await page.locator('#scanBtn').click();
-    await expect(page.locator('#scanModal')).toBeVisible();
-    await expect(page.locator('#quickBackupBtn')).toBeVisible();
-    await page.locator('#cancelScan').click();
-    await expect(page.locator('#scanModal')).toBeHidden();
-
-    // K7: Metadata and Gallery open their pages in a new tab.
-    for (const [id, path] of [['#metadataBtn', '/prompt_manager/gallery.html'], ['#galleryBtn', '/prompt_manager/gallery']]) {
-        const opened = context.waitForEvent('page');
-        await page.locator(id).click();
-        const tab = await opened;
-        await tab.waitForLoadState('domcontentloaded');
-        expect(new URL(tab.url()).pathname).toBe(path);
-        await tab.close();
-    }
-});
-
-test('Page options keeps the page-only settings admin', async ({ page, request }) => {
-    const before = (await (await request.get('/prompt_manager/settings')).json()).settings;
-    await page.goto(PAGES.admin);
-    await expect(page.locator('#resultsList .prompt-text').first()).toBeVisible();
-    await page.locator('#pageOptionsBtn').click();
-    const dialog = page.locator('#settingsModal');
-    await expect(dialog).toBeVisible();
-    await expect(dialog.locator('h3')).toHaveText('Page options');
-    // Exactly the page-only setting (G5): the list's Infinite Scrolling default.
-    expect(await dialog.locator('input, select, textarea').evaluateAll(fields => fields.map(field => field.id)))
-        .toEqual(['infiniteScrollDefault']);
-    await expect(page.locator('#infiniteScrollDefault')).not.toBeChecked();
-    await page.locator('#infiniteScrollDefault').check();
-    const saved = page.waitForRequest(item => item.method() === 'POST' && item.url().endsWith('/prompt_manager/settings'));
-    await page.locator('#saveSettings').click();
-    expect((await saved).postDataJSON()).toEqual({ infinite_scroll: true });
-    await expect(dialog).toBeHidden();
-    // The list header follows the saved default at once; nothing else changed.
-    await expect(page.locator('#infiniteScrollSession')).toBeChecked();
-    const after = (await (await request.get('/prompt_manager/settings')).json()).settings;
-    expect(after).toEqual({ ...before, infinite_scroll: true });
-    await page.reload();
-    // The dialog shows the saved default once the page has read it (the header follows it first).
-    await expect(page.locator('#infiniteScrollSession')).toBeChecked();
-    await page.locator('#pageOptionsBtn').click();
-    await expect(page.locator('#infiniteScrollDefault')).toBeChecked();
-});
-
-test('Page options keeps the page-only settings gallery', async ({ page }) => {
-    // Native Appearance keys and the startup prompt's own keys are in the shared object before the page opens.
-    const stored = { imageQuality: 'high', showImageInfo: false, videoMute: false,
-        autoLoadMetadata: false, workspaceLayout: 'masonry', thumbnailPromptDismissed: 'sig', thumbnailsGenerated: true,
-        checkThumbnailsAtStartup: false, defaultViewMode: 'list' };
-    await page.addInitScript(value => {
-        if (!sessionStorage.getItem('seeded')) {
-            sessionStorage.setItem('seeded', '1');
-            localStorage.setItem('gallerySettings', value);
-        }
-    }, JSON.stringify(stored));
-    const listed = page.waitForResponse(item => item.url().includes('/prompt_manager/images/output?'));
-    await page.goto(PAGES.gallery);
-    await listed;
-    // With no Page options control, a stored default view still opens the page in it.
-    await expect(page.locator('#listViewBtn')).toHaveClass(/bg-pm-accent/);
-    await openPageOptions(page);
-    const dialog = page.locator('#settingsModal');
-    await expect(dialog.locator('h3')).toHaveText('Page options');
-    // Exactly the page-only settings (G5); the default view is System › Appearance's Default layout.
-    expect(await dialog.locator('input, select, textarea').evaluateAll(fields => fields.map(field => field.id))).toEqual([
-        'checkThumbnailsAtStartup', 'lazyLoadingToggle', 'defaultLimitSelect', 'gridColumnsSelect',
-        'infiniteScrollToggle', 'debugModeToggle', 'apiTimeoutInput']);
-    await expect(dialog.getByText('Default View Mode')).toHaveCount(0);
-    await page.locator('#defaultLimitSelect').selectOption('50');
-    await page.locator('#debugModeToggle').check();
-    await page.locator('#saveSettingsBtn').click();
-    await expect(dialog).toBeHidden();
-    const read = () => page.evaluate(() => JSON.parse(localStorage.getItem('gallerySettings')));
-    let saved = await read();
-    expect(saved).toMatchObject({ ...stored, defaultLimit: 50, debugMode: true });
-
-    // Reset puts back only the page options' defaults; the Appearance, startup-prompt and default-view keys stay.
-    await openPageOptions(page);
-    page.once('dialog', dialog => dialog.accept());
-    await page.locator('#resetSettingsBtn').click();
-    await expect(page.getByText('Page options reset to defaults')).toBeVisible();
-    await expect(page.locator('#defaultLimitSelect')).toHaveValue('100');
-    saved = await read();
-    expect(saved).toMatchObject({ defaultViewMode: 'list', imageQuality: 'high', showImageInfo: false, videoMute: false,
-        autoLoadMetadata: false, workspaceLayout: 'masonry', thumbnailPromptDismissed: 'sig', thumbnailsGenerated: true,
-        defaultLimit: 100, debugMode: false, checkThumbnailsAtStartup: true, lazyLoading: true, gridColumns: 8,
-        infiniteScroll: false, apiTimeout: 30 });
-});
-
-test('the legacy auto-tag modal stays open after Manage in System', async ({ page, context, request }) => {
-    for (const legacy of ['admin', 'gallery']) {
-        await post(request, '/__test__/tagging/models', { unavailable: ['gguf'] });
-        await page.goto(PAGES[legacy]);
-        await openAutoTag(page);
-        const link = page.locator('#ggufModelStatus').getByRole('link', { name: 'Manage in System', exact: true });
-        await expect(link).toHaveAttribute('title', 'Opens System › Auto-tagging in a new tab');
-        // A downloaded model keeps its status text.
-        await expect(page.locator('#wd14VitModelStatus')).toHaveText('\u2713 Downloaded');
-        const opened = context.waitForEvent('page');
-        await link.click();
-        const system = await opened;
-        await expect(system).toHaveURL(/#\/system\/tagging$/);
-        await expect(page.locator('#autoTagModal')).toBeVisible();
-        await system.close();
-        // Downloaded in System meanwhile: reopening the modal reads the models again (CUJ 4).
-        await post(request, '/__test__/tagging/models', { unavailable: [] });
-        await page.goto(PAGES[legacy]);
-        await openAutoTag(page);
-        await expect(page.locator('#ggufModelStatus')).toHaveText('\u2713 Downloaded');
-    }
-});
@@ -1,279 +0,0 @@
-"""Prove the scratch-seeded resets leave the state the old resets left (#384).
-
-Run by hand on Linux (the browser server's platform):
-
-    python -m tests.browser.reset_equivalence
-
-It starts the browser server three times: twice seeding on the live database
-as before #384 (``PM_TEST_SEED_ON_LIVE=1``) and once with the scratch seeder.
-Each server gets the same sequence: every reset kind of ``/__test__/reset``
-and ``/__test__/concept/reset``, with other fixtures' resets and API writes
-between them. After every reset it reads every table's rows (by rowid), the
-output and input file trees (size, SHA-256, mtime) and the response body.
-
-Values that differ between the two old runs are wall-clock values (created_at,
-an unpinned concept "now", file mtimes); they are masked. Everything else must
-be equal between the old runs and the new one. Exit status 0 means equal.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import os
-import sqlite3
-import subprocess
-import sys
-import tempfile
-import time
-import urllib.request
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-READY_TIMEOUT_S = 60
-CLOCK = "<clock>"
-
-RESETS = [
-    ("/__test__/reset", {}),
-    ("/__test__/reset", {"extra_images": 2}),
-    ("/__test__/reset", {"extra_images": 108}),
-    ("/__test__/reset", {"include_video": True}),
-    ("/__test__/reset", {"prompt_inspector": True}),
-    ("/__test__/reset", {"native_library": True}),
-    ("/__test__/reset", {"native_library": True, "extra_prompts": 125}),
-    ("/__test__/reset", {"native_library": True, "extra_variants": 41}),
-    ("/__test__/reset", {"workspace_visual": True}),
-    ("/__test__/reset", {"full_inspector": True}),
-    (
-        "/__test__/reset",
-        {"full_inspector": True, "include_video": True, "extra_images": 2},
-    ),
-    ("/__test__/reset", {"chronological_history": True}),
-    ("/__test__/reset", {"chronological_history": True, "history_runs": 85}),
-    ("/__test__/concept/reset", {}),
-    ("/__test__/concept/reset", {"extra_images": 100}),
-    ("/__test__/concept/reset", {"seedless_images": 2, "short_seedless": True}),
-    ("/__test__/concept/reset", {"now": 1_780_000_000}),
-]
-# Writes by other fixtures and the API between resets; the resets must keep or
-# replace them exactly as before.
-DIRTY = [
-    ("/__test__/tagging/reset", {}),
-    ("/__test__/system/reset", None),
-    (
-        "/__test__/saved-views/raw",
-        {"page": "images", "name": "dirty", "state": "{}"},
-    ),
-]
-
-
-class Server:
-    def __init__(self, on_live: bool) -> None:
-        self.tmp = tempfile.TemporaryDirectory(prefix="pm-equivalence-")
-        env = {**os.environ, "TMPDIR": self.tmp.name}
-        env.update(TEMP=self.tmp.name, TMP=self.tmp.name)
-        env.pop("PM_TEST_SEED_ON_LIVE", None)
-        if on_live:
-            env["PM_TEST_SEED_ON_LIVE"] = "1"
-        self.process = subprocess.Popen(
-            [
-                sys.executable,
-                "-m",
-                "tests.browser.server",
-                "--port",
-                "0",
-                "--exit-on-stdin-eof",
-            ],
-            cwd=REPO_ROOT,
-            env=env,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-        )
-        line = self.process.stdout.readline().decode()
-        if not line.startswith("PM_TEST_SERVER_PORT="):
-            raise RuntimeError(f"no port line: {line!r}")
-        self.base = f"http://127.0.0.1:{int(line.split('=', 1)[1])}"
-        deadline = time.monotonic() + READY_TIMEOUT_S
-        while True:
-            try:
-                self.post_json("GET", "/prompt_manager/test", None)
-                break
-            except OSError:
-                if time.monotonic() > deadline or self.process.poll() is not None:
-                    raise
-                time.sleep(0.1)
-        (self.root,) = Path(self.tmp.name).glob("pm-browser-*")
-
-    def post_json(self, method: str, path: str, data) -> dict:
-        body = None if data is None else json.dumps(data).encode()
-        request = urllib.request.Request(
-            self.base + path,
-            data=body if method == "POST" else None,
-            method=method,
-            headers={"Content-Type": "application/json"} if body else {},
-        )
-        with urllib.request.urlopen(request, timeout=120) as response:  # nosec B310
-            text = response.read().decode()
-        try:
-            return json.loads(text)
-        except ValueError:
-            return {"text": text[:200]}
-
-    def stop(self) -> None:
-        self.process.stdin.close()
-        self.process.wait(timeout=READY_TIMEOUT_S)
-        self.process.stdout.close()
-        self.tmp.cleanup()
-
-
-def read_tables(path: Path) -> dict:
-    conn = sqlite3.connect(path.as_uri() + "?mode=ro", uri=True)
-    try:
-        tables = {}
-        names = [
-            row[0]
-            for row in conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-            )
-        ]
-        for name in names:
-            quoted = '"' + name.replace('"', '""') + '"'
-            columns = [row[1] for row in conn.execute(f"PRAGMA table_info({quoted})")]
-            try:
-                cursor = conn.execute(f"SELECT rowid, * FROM {quoted} ORDER BY rowid")
-                columns = ["rowid", *columns]
-            except sqlite3.OperationalError:
-                cursor = conn.execute(f"SELECT * FROM {quoted} ORDER BY 1")
-            rows = [
-                [value.hex() if isinstance(value, bytes) else value for value in row]
-                for row in cursor
-            ]
-            tables[name] = {"columns": columns, "rows": rows}
-        return tables
-    finally:
-        conn.close()
-
-
-def read_files(root: Path) -> dict:
-    files = {}
-    for top in ("output", "input"):
-        for path in sorted((root / top).rglob("*")):
-            if path.is_file():
-                stat = path.stat()
-                files[path.relative_to(root).as_posix()] = [
-                    stat.st_size,
-                    hashlib.sha256(path.read_bytes()).hexdigest(),
-                    stat.st_mtime_ns,
-                ]
-    return files
-
-
-def flatten(value, prefix="") -> dict:
-    if isinstance(value, dict):
-        out = {}
-        for key, item in value.items():
-            out.update(flatten(item, f"{prefix}/{key}"))
-        return out
-    if isinstance(value, list):
-        out = {f"{prefix}#len": len(value)}
-        for index, item in enumerate(value):
-            out.update(flatten(item, f"{prefix}[{index}]"))
-        return out
-    return {prefix: value}
-
-
-def snapshot(server: Server, response: dict) -> dict:
-    flat = {}
-    for table, data in read_tables(server.root / "browser.db").items():
-        flat[f"table {table}#rows"] = len(data["rows"])
-        for index, row in enumerate(data["rows"]):
-            for column, value in zip(data["columns"], row):
-                flat[f"table {table}[{index}].{column}"] = value
-    for name, (size, digest, mtime) in read_files(server.root).items():
-        flat[f"file {name}"] = [size, digest]
-        flat[f"file {name}#mtime"] = mtime
-    flat["files#count"] = sum(
-        1 for key in flat if key.startswith("file ") and "#" not in key
-    )
-    for key, value in flatten(response).items():
-        flat[f"response{key}"] = value
-    # Each server has its own temp root and a random storage epoch; name them
-    # instead of masking every column that carries them.
-    epoch = flat.get("table execution_history_metadata[0].storage_epoch")
-    names = [(str(server.root), "<root>")]
-    if isinstance(epoch, str) and epoch:
-        names.append((epoch, "<epoch>"))
-    for key, value in flat.items():
-        if isinstance(value, str):
-            for text, name in names:
-                value = value.replace(text, name)
-            flat[key] = value
-    return flat
-
-
-def run(on_live: bool) -> list[dict]:
-    server = Server(on_live)
-    try:
-        states = []
-        for index, (path, data) in enumerate(RESETS * 2):
-            dirty_path, dirty_data = DIRTY[index % len(DIRTY)]
-            server.post_json("POST", dirty_path, dirty_data)
-            started = time.monotonic()
-            response = server.post_json("POST", path, data)
-            elapsed = time.monotonic() - started
-            print(f"  {'old' if on_live else 'new'} {path} {data}: {elapsed:.2f}s")
-            states.append(snapshot(server, response))
-        return states
-    finally:
-        server.stop()
-
-
-def column_key(key: str) -> str:
-    """``table t[3].created_at`` -> ``table t.created_at`` (mask whole columns)."""
-    if key.startswith("table ") and "[" in key:
-        head, _, tail = key.partition("[")
-        return head + tail.partition("]")[2]
-    return key
-
-
-def main() -> int:
-    old_a, old_b, new = run(True), run(True), run(False)
-    failures = 0
-    masked_all = set()
-    for step, (path, data) in enumerate(RESETS * 2):
-        a, b, n = old_a[step], old_b[step], new[step]
-        masked = {
-            column_key(key)
-            for key in set(a) | set(b)
-            if a.get(key, CLOCK) != b.get(key, CLOCK)
-        }
-        masked_all |= masked
-        keys = set(a) | set(n)
-        diffs = [
-            key
-            for key in sorted(keys)
-            if column_key(key) not in masked
-            and a.get(key, "<missing>") != n.get(key, "<missing>")
-        ]
-        tables = len(
-            {k.split("[")[0].split("#")[0] for k in a if k.startswith("table ")}
-        )
-        status = "EQUAL" if not diffs else f"DIFFERENT ({len(diffs)} values)"
-        print(
-            f"{status}: {path} {json.dumps(data)}: {tables} tables, "
-            f"{a['files#count']} files, {len(keys)} values, "
-            f"{len(masked)} masked columns"
-        )
-        for key in diffs[:20]:
-            old, now = a.get(key, "<missing>"), n.get(key, "<missing>")
-            print(f"    {key}: old {old!r} new {now!r}")
-        failures += bool(diffs)
-    print("masked (differ between the two old runs):")
-    for key in sorted(masked_all):
-        print(f"    {key}")
-    return 1 if failures else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -19,10 +19,8 @@ from aiohttp.web_runner import GracefulExit
 from PIL import Image
 from PIL.PngImagePlugin import PngInfo

-from tests.browser.folder_trash import close_trash, replace_folder
 from tests.browser.request_hold import register_request_holds
 from tests.browser import slow_reset_watch
-from tests.browser.fast_reset import SEED_ON_LIVE_ENV, ScratchSeeder
 from tests.browser.workspace_activity_fixture import register_activity_commands
 from tests.browser.workspace_system_fixture import register_system_commands
 from tests.browser.workspace_integrations_fixture import (
@@ -47,10 +45,6 @@ from tests.browser.workspace_library_editor_fixture import (
 from tests.browser.workspace_vocabulary_fixture import register_vocabulary_commands
 from tests.browser.workspace_tagging_fixture import register_tagging_commands
 from tests.browser.workspace_review_fixture import register_review_commands
-from tests.browser.workspace_diagnostics_fixture import (
-    register_diagnostics_commands,
-    repoint_logs,
-)

 CANONICAL_ROOT = Path(__file__).resolve().parents[2]
 CANONICAL_ASSETS = {
@@ -205,8 +199,6 @@ def create_app(root: Path) -> web.Application:
        directory.mkdir()
        setattr(folder_paths, f"get_{name}_directory", lambda path=directory: str(path))
    sys.modules["folder_paths"] = folder_paths
-    # S12: the logger writes into this server's root before any record is written.
-    repoint_logs(root)

    from py.config import GalleryConfig, PromptManagerConfig

@@ -231,13 +223,8 @@ def create_app(root: Path) -> web.Application:
    register_activity_commands(app, routes, api)
    register_system_commands(app, routes, api, root)
    register_integrations_commands(app, routes, api, root)
-    reset_logs = register_diagnostics_commands(app, routes, api, root)
    request_holds = register_request_holds(app, routes)
    slow_reset_watch.install(app, api)
-    # Resets seed a scratch copy and publish it in one commit (#384).
-    seeder = ScratchSeeder(
-        api, root / "reset-scratch", on_live=os.environ.get(SEED_ON_LIVE_ENV) == "1"
-    )

    async def canonical_asset(request: web.Request) -> web.Response:
        filename, content_type = CANONICAL_ASSETS[request.path]
@@ -251,7 +238,6 @@ def create_app(root: Path) -> web.Application:
        routes.get(path)(canonical_asset)

    def seed(
-        target,
        extra_images: int = 0,
        include_video: bool = False,
        prompt_inspector: bool = False,
@@ -259,7 +245,7 @@ def create_app(root: Path) -> web.Application:
        extra_prompts: int = 0,
        extra_variants: int = 0,
    ) -> None:
-        with target.db.model.get_connection() as conn:
+        with api.db.model.get_connection() as conn:
            for table in (
                "saved_views",
                "image_favorites",
@@ -268,7 +254,6 @@ def create_app(root: Path) -> web.Application:
                "media_image_tags",
                "media_annotation_bytes",
                "media_annotation_files",
-                "image_categories",
                "image_prompt_pairs",
                "prompt_pair_tags",
                "prompt_pairs",
@@ -279,7 +264,8 @@ def create_app(root: Path) -> web.Application:
            ):
                conn.execute(f"DELETE FROM {table}")
        for name in ("output", "input"):
-            replace_folder(root / name)
+            shutil.rmtree(root / name)
+            (root / name).mkdir()
        for index, (directory, text, tag) in enumerate(
            [
                ("output", "Cat portrait", "cats"),
@@ -322,30 +308,28 @@ def create_app(root: Path) -> web.Application:
                    image.save(image_path, pnginfo=info)
            stamp = time.time() - index * 10
            os.utime(image_path, (stamp, stamp))
-            pid = target.db.save_prompt(
+            pid = api.db.save_prompt(
                text, tags=[tag], prompt_hash=generate_prompt_hash(text)
            )
-            target.db.link_image_to_prompt(pid, str(image_path))
+            api.db.link_image_to_prompt(pid, str(image_path))
            if index == 0:
                video_prompt_id = pid
                for number in range(extra_images):
                    extra = root / directory / "bulk" / f"{number:04}.png"
                    extra.parent.mkdir(exist_ok=True)
                    shutil.copyfile(image_path, extra)
-                    target.db.link_image_to_prompt(pid, str(extra))
+                    api.db.link_image_to_prompt(pid, str(extra))
        if native_library:
-            positive = target.db.get_prompt_by_hash(
-                generate_prompt_hash("Cat portrait")
-            )
+            positive = api.db.get_prompt_by_hash(generate_prompt_hash("Cat portrait"))
            positive_id = positive["id"]
-            target.db.update_prompt_metadata(
+            api.db.update_prompt_metadata(
                positive_id, category="Animals", tags=["cats", "studio"]
            )
            variants = []
            for index, negative in enumerate(
                ["blurry, watermark", "low quality", "low contrast", ""]
            ):
-                pair_id = target.db.save_prompt_pair(
+                pair_id = api.db.save_prompt_pair(
                    "Cat portrait",
                    negative,
                    title=f"Portrait variant {index + 1}",
@@ -353,30 +337,28 @@ def create_app(root: Path) -> web.Application:
                    tags=["studio"] if index == 0 else ["outdoors"],
                )
                variants.append(pair_id)
-            with target.db.model.get_connection() as conn:
+            with api.db.model.get_connection() as conn:
                images = conn.execute(
                    "SELECT id FROM generated_images WHERE prompt_id=? ORDER BY id",
                    (positive_id,),
                ).fetchall()
            for index, image in enumerate(images[:2]):
-                target.db.link_image_to_pair(
+                api.db.link_image_to_pair(
                    variants[index], image["id"], {"source": "fixture", "anchor": index}
                )
-            target.db.link_image_to_pair(
+            api.db.link_image_to_pair(
                variants[0], images[0]["id"], {"source": "fixture second evidence"}
            )
-            target.db.record_prompt_pair_use(variants[0], times=3)
+            api.db.record_prompt_pair_use(variants[0], times=3)
            for number in range(extra_variants):
-                target.db.save_prompt_pair(
-                    "Cat portrait", f"Negative extra {number:04}"
-                )
+                api.db.save_prompt_pair("Cat portrait", f"Negative extra {number:04}")
            legacy = root / "output" / "legacy-unassigned.png"
            shutil.copyfile(root / "output" / "shared" / "same.png", legacy)
-            target.db.link_image_to_prompt(positive_id, str(legacy))
-            target.db.save_prompt("Dog landscape", category="Animals", tags=["dogs"])
-            target.db.save_prompt_pair("Dual role portrait", "Cat portrait")
+            api.db.link_image_to_prompt(positive_id, str(legacy))
+            api.db.save_prompt("Dog landscape", category="Animals", tags=["dogs"])
+            api.db.save_prompt_pair("Dual role portrait", "Cat portrait")
            for number in range(extra_prompts):
-                target.db.save_prompt(
+                api.db.save_prompt(
                    f"Library extra {number:04}", category="Bulk", tags=["bulk"]
                )
        if prompt_inspector:
@@ -397,8 +379,8 @@ def create_app(root: Path) -> web.Application:
        from py.api.thumbnail_settings import ThumbnailSettings

        # 150 px previews in the default format (#317 thumbnail settings).
-        target._generate_gallery_thumbnails_sync(
-            target._get_all_output_dirs(), ThumbnailSettings("webp", 80, 150)
+        api._generate_gallery_thumbnails_sync(
+            api._get_all_output_dirs(), ThumbnailSettings("webp", 80, 150)
        )
        if include_video:
            # Seed after thumbnail generation to exercise a real unthumbnailed video.
@@ -406,8 +388,8 @@ def create_app(root: Path) -> web.Application:
            shutil.copyfile(
                Path(__file__).resolve().parents[1] / "fixtures" / "tiny.webm", video
            )
-            target.db.link_image_to_prompt(video_prompt_id, str(video))
-        target.invalidate_gallery_cache()
+            api.db.link_image_to_prompt(video_prompt_id, str(video))
+        api.invalidate_gallery_cache()

    history_fixture = None

@@ -433,7 +415,6 @@ def create_app(root: Path) -> web.Application:
        # No preview queued by the last test may land in the new fixture.
        await api._run_in_executor(api.close_auto_thumbnails)
        library_editor_commands.reset()
-        await api._run_in_executor(reset_logs)
        data = await request.json() if request.can_read_body else {}
        if not isinstance(data, dict):
            raise web.HTTPBadRequest()
@@ -453,10 +434,7 @@ def create_app(root: Path) -> web.Application:
            raise web.HTTPBadRequest()
        if chronological_history:
            manifest = await api._run_in_executor(
-                seeder.run,
-                lambda target: seed_workspace_history(
-                    target, root, history_runs=history_runs
-                ),
+                lambda: seed_workspace_history(api, root, history_runs=history_runs)
            )
            history_fixture = manifest
            return web.json_response({"success": True, **manifest})
@@ -514,31 +492,25 @@ def create_app(root: Path) -> web.Application:
            raise web.HTTPBadRequest()
        if workspace_visual:
            history_fixture = None
-            await api._run_in_executor(
-                seeder.run, lambda target: seed_workspace_visual(target, root)
-            )
+            await api._run_in_executor(seed_workspace_visual, api, root)
            return web.json_response({"success": True})
        if full_inspector:
            history_fixture = None
            await api._run_in_executor(
-                seeder.run,
-                lambda target: seed_workspace_inspector(
-                    target, root, extra_images=extra, include_video=include_video
-                ),
+                lambda: seed_workspace_inspector(
+                    api, root, extra_images=extra, include_video=include_video
+                )
            )
            return web.json_response({"success": True})
        history_fixture = None
        await api._run_in_executor(
-            seeder.run,
-            lambda target: seed(
-                target,
-                extra,
-                include_video,
-                prompt_inspector,
-                native_library,
-                extra_prompts,
-                extra_variants,
-            ),
+            seed,
+            extra,
+            include_video,
+            prompt_inspector,
+            native_library,
+            extra_prompts,
+            extra_variants,
        )
        return web.json_response({"success": True})

@@ -578,15 +550,14 @@ def create_app(root: Path) -> web.Application:
        reveal_stub.reset()
        history_fixture = None
        manifest = await api._run_in_executor(
-            seeder.run,
-            lambda target: seed_workspace_concept(
-                target,
+            lambda: seed_workspace_concept(
+                api,
                root,
                extra_images=data.get("extra_images", 0),
                seedless_images=data.get("seedless_images", 0),
                short_seedless=data.get("short_seedless", False),
                now=data.get("now"),
-            ),
+            )
        )
        return web.json_response({"success": True, **manifest})

@@ -654,12 +625,9 @@ def create_app(root: Path) -> web.Application:
    async def cleanup(application: web.Application) -> None:
        # A scan of an ambiguous fixture file captures it for Needs review.
        api.close_annotation_captures()
-        seeder.close()
        api.db.close_all()
-        # Old media folders still waiting for deletion go before the temp root.
-        close_trash(root)

-    seed(api)
+    seed()
    # Open Needs review change streams end first, as on the real host.
    app.on_shutdown.append(api.close_review_events)
    app.on_cleanup.append(cleanup)
@@ -1,396 +0,0 @@
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-import { SIZES, THEMES, seedConcept, openConcept, openProduction, diffInventory, mutate, measureReview, mapPlanConcept }
-    from './concept-inventory.mjs';
-
-// #249 System S12 Task 7 (#329): System › Diagnostics & logs (app.js renderSystem 694–695) and its log cleanup review
-// (the concept's `maintenancePlan("rotated logs")`, 953–958) against the immutable concept, on the concept-shaped
-// fixture with the logger writing into this server's own root and seeded with the concept's sample (four lines, a
-// 1.4 MB active log, three rotated copies, console logging off). Each concept measurement is mapped only by the recorded
-// deviations (D109, D110, and D100 for the review), each commented where it applies; after that the difference must be
-// empty, and a removed term, a renamed button, a reordered option, a primary Refresh, a squeezed select or a swapped
-// token must be noticed.
-test.use({ locale: 'en-US', timezoneId: 'UTC' });
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await seedConcept(request);
-    await expect(await request.post('/__test__/system/reset')).toBeOK();
-    await expect(await request.post('/__test__/jobs/restart')).toBeOK();
-    await expect(await request.post('/__test__/logs/reset')).toBeOK();
-    await expect(await request.post('/__test__/logs/seed', { data: { mode: 'concept' } })).toBeOK();
-    page.conceptErrors = [];
-    page.on('pageerror', error => page.conceptErrors.push(error.message));
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    await request.post('/__test__/jobs/restart');
-    await request.post('/__test__/logs/reset');
-    await request.post('/__test__/system/reset');
-    expect(page.conceptErrors).toEqual([]);
-});
-
-const REPORT_URL = '/prompt_manager/system/diagnostics';
-const PREVIEW_URL = '/prompt_manager/maintenance/preview';
-const LINE_FORMAT = /^\d\d:\d\d:\d\d [A-Z]+ +\S/;
-
-/** Runs in the page: Diagnostics & logs under `mainSelector`: every surface's text, controls, geometry and tokens. */
-function measureDiagnostics([mainSelector, lineFormat]) {
-    const format = new RegExp(lineFormat);
-    const layout = document.querySelector(`${mainSelector} .settings-layout`);
-    const css = (node, ...keys) => node ? Object.fromEntries(keys.map(key => [key, getComputedStyle(node)[key]])) : null;
-    const tokens = (node, ...names) => Object.fromEntries(names.map(key => [key, getComputedStyle(node).getPropertyValue(key).trim()]));
-    const name = node => [node.localName, ...[...node.classList].sort()].join('.');
-    const text = node => node?.textContent.trim() ?? null;
-    const button = node => ({ text: text(node), className: node.className });
-    const control = row => {
-        const select = row.querySelector(':scope > select');
-        if (select) return { kind: 'select', id: select.id, options: [...select.options].map(option => option.textContent),
-            selected: select.selectedOptions[0]?.textContent ?? null, disabled: select.disabled };
-        const toggle = row.querySelector(':scope > * input[type="checkbox"]');
-        return toggle ? { kind: 'switch', id: toggle.id, wrapper: name(toggle.parentElement), checked: toggle.checked,
-            disabled: toggle.disabled } : null;
-    };
-    const operations = parent => [...parent.querySelectorAll(':scope > .operation')].map(row => ({ tree: [...row.children].map(name),
-        title: text(row.querySelector('h3')), description: text(row.querySelector('p')),
-        actions: [...row.querySelectorAll('.row-actions > button')].map(button) }));
-    const toolbarItem = node => ({ name: name(node), text: node.localName === 'select' || node.localName === 'input' ? null : text(node),
-        for: node.localName === 'label' ? node.htmlFor : null, id: node.id || null,
-        options: node.localName === 'select' ? [...node.options].map(option => option.textContent) : null,
-        // The chosen option, so a wrong default level is noticed.
-        selected: node.localName === 'select' ? node.selectedOptions[0]?.textContent ?? null : null,
-        input: node.localName === 'input' ? [node.type, node.min, node.max, node.value] : null,
-        className: node.localName === 'button' ? node.className : null });
-    const surfaces = [...layout.querySelectorAll(':scope > section.surface')];
-    const pre = layout.querySelector('pre');
-    const lines = (pre?.textContent ?? '').split('\n').filter(Boolean);
-    const details = layout.querySelector('details');
-    const firstRow = layout.querySelector('.setting-row');
-    const toolbar = layout.querySelector('.toolbar');
-    return {
-        layout: [...layout.children].map(name),
-        surfaces: surfaces.map(surface => {
-            const heading = surface.querySelector(':scope > .panel-heading');
-            const grid = surface.querySelector(':scope > .meta-grid');
-            return {
-                tree: [...surface.children].map(name),
-                heading: text(surface.querySelector(':scope > h2, :scope > .panel-heading > h2')),
-                panelHeading: heading && [...heading.children].map(node => [name(node), text(node)]),
-                grid: grid && [...grid.children].map(entry => [name(entry), text(entry.querySelector('dt')), text(entry.querySelector('dd'))]),
-                buttons: [...surface.querySelectorAll(':scope > button')].map(button),
-                toolbar: surface.querySelector(':scope > .toolbar') && [...surface.querySelector(':scope > .toolbar').children].map(toolbarItem),
-                pre: surface.querySelector(':scope > pre') && { tabIndex: pre.tabIndex, tree: [...pre.children].map(name), lines,
-                    format: lines.every(line => format.test(line)) },
-                notes: [...surface.querySelectorAll(':scope > p')].map(node => [name(node), text(node), node.getAttribute('role'),
-                    node.getAttribute('aria-label')]),
-                rows: [...surface.querySelectorAll(':scope > .setting-row')].map(row => ({ tree: [...row.children].map(name),
-                    text: [...row.firstElementChild.children].map(node => [name(node), text(node), node.localName === 'label' ? node.htmlFor : null]),
-                    control: control(row) })),
-                details: surface.querySelector(':scope > details') && {
-                    summary: text(details.querySelector(':scope > summary')), tree: [...details.children].map(name),
-                    notes: [...details.querySelectorAll(':scope > p')].map(node => [name(node), text(node)]),
-                    buttons: [...details.querySelectorAll(':scope > button')].map(button),
-                    files: [...details.querySelectorAll(':scope > .operation-list > .operation')].map(row => ({
-                        title: text(row.querySelector('h3')), detail: text(row.querySelector('p')), actions: [...row.querySelectorAll('.row-actions > button')].map(item =>
-                            [text(item), item.getAttribute('aria-label')]) })),
-                    operations: operations(details) },
-                operations: operations(surface),
-            };
-        }),
-        tokens: tokens(surfaces[0], '--line', '--panel', '--accent'),
-        surface: css(surfaces[1], 'paddingTop', 'paddingLeft', 'backgroundColor', 'borderTopWidth', 'borderTopColor', 'borderTopLeftRadius',
-            'marginTop'),
-        grid: css(layout.querySelector('.meta-grid'), 'display', 'gridTemplateColumns', 'columnGap', 'rowGap'),
-        toolbar: css(toolbar, 'display', 'flexWrap', 'alignItems', 'columnGap', 'rowGap', 'marginBottom'),
-        pre: css(pre, 'fontFamily', 'fontSize', 'backgroundColor', 'borderTopColor', 'borderTopLeftRadius', 'paddingTop', 'overflowX'),
-        row: css(firstRow, 'display', 'alignItems', 'justifyContent', 'columnGap', 'paddingTop', 'paddingBottom', 'borderTopWidth',
-            'borderTopColor'),
-        label: css(firstRow.querySelector('label'), 'fontSize', 'fontWeight', 'color'),
-        description: css(firstRow.querySelector('p'), 'fontSize', 'color', 'marginTop'),
-        select: css(firstRow.querySelector('select'), 'fontSize', 'minWidth', 'maxWidth', 'backgroundColor', 'color', 'borderTopColor'),
-        summary: css(details.querySelector('summary'), 'fontSize', 'fontWeight', 'color', 'cursor'),
-        small: css(details.querySelector(':scope > p.small'), 'fontSize', 'color'),
-        // Whether each select is as wide as the browser lays out a copy holding only its chosen option, i.e. it shows
-        // that option whole (the browser's own select sizing, arrow included).
-        selectsFit: [...layout.querySelectorAll('select')].map(select => {
-            const copy = select.cloneNode(false);
-            copy.removeAttribute('id');
-            copy.append(new Option(select.selectedOptions[0]?.textContent ?? ''));
-            Object.assign(copy.style, { position: 'absolute', visibility: 'hidden', width: 'max-content', minWidth: '0',
-                maxWidth: 'none', flex: 'none' });
-            select.parentElement.append(copy);
-            const needed = copy.getBoundingClientRect().width;
-            copy.remove();
-            return select.getBoundingClientRect().width + 0.5 >= needed;
-        }),
-        pageScroll: document.documentElement.scrollWidth > document.documentElement.clientWidth,
-    };
-}
-
-const plural = (count, one, many = `${one}s`) => `${count.toLocaleString('en-US')} ${count === 1 ? one : many}`;
-/** The server's size label (1 KB = 1024 bytes), as the section prints it. */
-function sizeText(bytes) {
-    if (bytes < 1024) return plural(bytes, 'byte');
-    if (bytes < 2 ** 20) return `${(bytes / 2 ** 10).toFixed(1)} KB`;
-    if (bytes < 2 ** 30) return `${(bytes / 2 ** 20).toFixed(1)} MB`;
-    return `${(bytes / 2 ** 30).toFixed(1)} GB`;
-}
-
-const KINDS = Object.freeze({ active: 'Active log', rotated: 'Rotated copy', other: 'Other file' });
-const RENDERER_NONE = 'No ComfyUI window is open in this browser, so its renderer is not known.';
-const COPY = Object.freeze({
-    testLink: 'Write a placeholder image record to check that linking works.',
-    runtimeLevel: 'How much the server writes to the log. Applied until the server restarts.',
-    console: 'Print Prompt Manager’s warnings and errors in the ComfyUI console (everything at DEBUG). Applied until the server restarts.',
-    clear: 'Empty the active log and delete its rotated copies.',
-    retention: 'Rotates at 10 MB · keeps 5 rotated copies · file logging on · memory buffer 1,000 entries',
-});
-
-/**
- * The concept's Diagnostics & logs with the recorded deviations applied, for the server's `report` and the seeded
- * `files` (`/logs/files`). The concept's own sample values the fixture reproduces stay as they are: the four log lines,
- * the Viewer.js line, "prompt_manager.log · 1.4 MB · rotated copies: 3", INFO and console logging off.
- */
-function mapDiagnosticsConcept(reference, { report, files, stats }) {
-    const [diagnostics, logs] = reference.surfaces;
-    const [levelLabel, level, refresh, download] = logs.toolbar;
-    const [runtime, consoleRow] = logs.rows;
-    const database = report.checks.database;
-    const { configured, watching, unavailable } = report.sources;
-    const sources = configured === 0 ? `ComfyUI output folder · ${watching ? 'watching' : 'manual scan'}`
-        : unavailable > 0 ? `${plural(configured, 'source')} · ${unavailable} not available`
-            : `${plural(configured, 'source')} · ${watching} watching`;
-    const errors = (stats.level_counts.ERROR ?? 0) + (stats.level_counts.CRITICAL ?? 0);
-    return {
-        ...reference,
-        surfaces: [
-            { ...diagnostics,
-                // D110: the Test image link operation follows the concept's Image-link diagnostics.
-                tree: [...diagnostics.tree, 'div.operation'],
-                // D110: live values. Database and Sources from `GET /system/diagnostics`, Host renderers is D106's
-                // renderer line (no ComfyUI window in this browser); the pinned Viewer.js line is the concept's own.
-                grid: diagnostics.grid.map(([entry, term, value]) => [entry, term, {
-                    Database: `Readable · ${sizeText(report.database_info.database_size_bytes)} · ${plural(database.image_count, 'image')}`,
-                    Sources: sources,
-                    'Host renderers': RENDERER_NONE }[term] ?? value]),
-                // D110: the buttons drop the concept's "sample".
-                buttons: diagnostics.buttons.map(item => ({ ...item, text: item.text.replace('Download sample diagnostic report',
-                    'Download diagnostic report') })),
-                operations: [
-                    // D110: "Inspect" opens the read-only Inspect a file page.
-                    ...diagnostics.operations.map(row => ({ ...row, actions: row.actions.map(item => ({ ...item, text: 'Inspect' })) })),
-                    // D110: the legacy synthetic link (S12-11), enabled: the fixture has a most recent prompt.
-                    { ...diagnostics.operations[0], title: 'Test image link', description: COPY.testLink,
-                        actions: [{ ...diagnostics.operations[0].actions[0], text: 'Create test link…' }] },
-                ] },
-            { ...logs,
-                // D109: the statistics line follows the viewer.
-                tree: [logs.tree[0], logs.tree[1], logs.tree[2], 'p.small', ...logs.tree.slice(3)],
-                toolbar: [
-                    levelLabel,
-                    // D109: all six minimum levels (the concept has three).
-                    { ...level, options: ['All levels', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'] },
-                    // D109: the added Lines control, 1–500, default 100.
-                    { name: 'label.small', text: 'Lines', for: 'log-limit', id: null, options: null, selected: null, input: null,
-                        className: null },
-                    { name: 'input', text: null, for: null, id: 'log-limit', options: null, selected: null,
-                        input: ['number', '1', '500', '100'], className: null },
-                    refresh,
-                    // D109: the active log, not a sample.
-                    { ...download, text: 'Download log' },
-                ],
-                // D109: "Log statistics" (errors are ERROR + CRITICAL).
-                notes: [['p.small', `${plural(stats.buffer_count, 'entry', 'entries')} in memory · ${plural(errors, 'error')} · `
-                    + `${plural(stats.level_counts.WARNING ?? 0, 'warning')} · ${plural(stats.log_files_count, 'file')} · `
-                    + `${sizeText(stats.total_log_size)} on disk`, 'status', 'Log statistics']],
-                rows: [
-                    // D109: CRITICAL after the concept's levels; the value lasts until the server restarts.
-                    { ...runtime, text: [runtime.text[0], ['p', COPY.runtimeLevel, null]],
-                        control: { ...runtime.control, options: [...runtime.control.options, 'CRITICAL'] } },
-                    // D109: what the console setting does and that it lasts until the server restarts (off, as the
-                    // concept's sample, by the fixture's seed).
-                    { ...consoleRow, text: [consoleRow.text[0], ['p', COPY.console, null]] },
-                ],
-                details: { ...logs.details,
-                    // D109: the retention line, the files and Clear all logs follow the concept's line and review.
-                    tree: [...logs.details.tree, 'p.small', 'div.operation-list', 'div.operation'],
-                    notes: [...logs.details.notes, ['p.small', COPY.retention]],
-                    files: files.map(row => ({ title: row.filename, detail: `${sizeText(row.size)} · ${row.modified.slice(0, 16)
-                        .replace('T', ' ')} · ${KINDS[row.kind]}`, actions: [['Download', `Download ${row.filename}`]] })),
-                    operations: [{ tree: ['div', 'div.row-actions'], title: 'Clear all logs', description: COPY.clear,
-                        actions: [{ text: 'Clear all logs…', className: 'danger' }] }] } },
-        ],
-    };
-}
-
-async function conceptDiagnostics(page, theme) {
-    await openConcept(page, 'system', theme);
-    await page.locator('#main .section-nav').getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
-    await expect(page.locator('#main .settings-layout > section.surface')).toHaveCount(2);
-    await page.mouse.move(0, 0);
-    return page.evaluate(measureDiagnostics, ['#main', LINE_FORMAT.source]);
-}
-
-/** Production's section once every read answered, with the server's report, files and statistics it shows. */
-async function productionDiagnostics(page, request, theme) {
-    await openProduction(page, 'system/diagnostics', theme);
-    const main = page.locator('#workspace-main');
-    await expect(main.locator('.settings-layout > section.surface')).toHaveCount(2);
-    await expect(main.locator('.meta-grid dd')).not.toContainText(['Loading…']);
-    await expect(main.locator('.meta-grid dd').last()).toHaveText(RENDERER_NONE);
-    await expect(main.locator('#log-lines')).not.toHaveText('Loading…');
-    await expect(main.locator('#log-stats')).not.toHaveText('Loading…');
-    await expect(main.locator('details > p.small')).not.toContainText(['Loading…']);
-    await expect(main.locator('#runtime-level')).toBeEnabled();
-    await expect(main.locator('.operation').filter({ hasText: 'Create test link…' }).locator('button')).not.toHaveAttribute('aria-disabled', 'true');
-    await page.mouse.move(0, 0);
-    const production = await page.evaluate(measureDiagnostics, ['#workspace-main', LINE_FORMAT.source]);
-    const read = async url => (await request.get(url)).json();
-    const report = await read(REPORT_URL);
-    const { files } = await read('/prompt_manager/logs/files');
-    const { stats } = await read('/prompt_manager/logs/stats');
-    return { production, report, files, stats };
-}
-
-for (const theme of THEMES) for (const [width, height] of SIZES) {
-    test(`diagnostics and logs match the concept ${theme} ${width}x${height}`, async ({ page, request }, testInfo) => {
-        await page.setViewportSize({ width, height });
-        const concept = await conceptDiagnostics(page, theme);
-        await page.screenshot({ path: testInfo.outputPath(`concept-diagnostics-${theme}-${width}.png`), fullPage: true });
-        const { production, ...live } = await productionDiagnostics(page, request, theme);
-        await page.screenshot({ path: testInfo.outputPath(`production-diagnostics-${theme}-${width}.png`), fullPage: true });
-        expect(diffInventory(mapDiagnosticsConcept(concept, live), production)).toEqual([]);
-        expect(production.surfaces[1].pre.format).toBe(true);
-        expect(production.pageScroll).toBe(false);
-    });
-}
-
-// Below the concept's smallest size: on a 320px phone the Level and Runtime log level selects still show their whole
-// option, without page scroll.
-for (const theme of THEMES) test(`diagnostics selects fit at 320 wide ${theme}`, async ({ page, request }) => {
-    await page.setViewportSize({ width: 320, height: 700 });
-    const { production } = await productionDiagnostics(page, request, theme);
-    expect(production.selectsFit).toEqual([true, true]);
-    expect(production.pageScroll).toBe(false);
-});
-
-/**
- * D100 with D109's rule for this plan: the server's `rotated_logs` plan in the concept's dialog, "Rotated log copies"
- * as its `h3`, the plan's grid values (its Backup row says none is needed), "Listed files (N)", the hold line, no D55
- * backup box (nothing in the library changes) and "Apply reviewed operation".
- */
-function mapCleanupConcept(reference, plan) {
-    const mapped = mapPlanConcept(reference, 'Rotated log copies', plan);
-    return {
-        ...mapped,
-        // D109: no backup box for a plan that changes no library record.
-        tree: mapped.tree.filter(item => item !== 'div.notice'),
-        grid: { ...mapped.grid, rows: mapped.grid.rows.map(([term, value]) =>
-            [term, term === 'Backup' ? 'Not needed: no library record changes' : value]) },
-        backup: null,
-        // D109: the plan lists files, not records.
-        details: { ...mapped.details, summary: `Listed files (${plan.details.length})` },
-    };
-}
-
-async function conceptCleanup(page, theme) {
-    await conceptDiagnostics(page, theme);
-    await page.locator('#main details > summary').click();
-    await page.locator('#main [data-plan="rotated logs"]').click();
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Review maintenance plan');
-    await page.mouse.move(0, 0);
-    return page.evaluate(measureReview);
-}
-
-async function productionCleanup(page, request, theme) {
-    await productionDiagnostics(page, request, theme);
-    await page.locator('#workspace-main details > summary').click();
-    const answer = page.waitForResponse(response => response.url().endsWith(PREVIEW_URL));
-    await page.locator('#workspace-main').getByRole('button', { name: 'Review log cleanup', exact: true }).click();
-    const plan = await (await answer).json();
-    await expect(page.locator('dialog#modal[open] #modal-body > h3')).toHaveText('Rotated log copies');
-    await page.mouse.move(0, 0);
-    return { plan, production: await page.evaluate(measureReview) };
-}
-
-for (const theme of THEMES) for (const [width, height] of SIZES) {
-    test(`log cleanup review matches the concept ${theme} ${width}x${height}`, async ({ page, request }, testInfo) => {
-        await page.setViewportSize({ width, height });
-        const concept = await conceptCleanup(page, theme);
-        expect(concept.heading.text).toBe('rotated logs');
-        expect(concept.tree).toEqual(['p.demo-note', 'h3', 'dl.meta-grid', 'p.small', 'div.dialog-actions']);
-        await page.screenshot({ path: testInfo.outputPath(`concept-log-cleanup-${theme}-${width}.png`) });
-        const { plan, production } = await productionCleanup(page, request, theme);
-        expect(plan.operation).toBe('rotated_logs');
-        await page.screenshot({ path: testInfo.outputPath(`production-log-cleanup-${theme}-${width}.png`) });
-        expect(diffInventory(mapCleanupConcept(concept, plan), production)).toEqual([]);
-    });
-}
-
-// Every path where production differs from the unmapped concept: D110's live values (Viewer.js is the concept's own),
-// renamed buttons and added operation, and D109's toolbar, statistics line, runtime rows and log files.
-const DEVIATED_PATHS = [
-    'surfaces.0.buttons.0', 'surfaces.0.grid.0', 'surfaces.0.grid.1', 'surfaces.0.grid.3', 'surfaces.0.operations.0',
-    'surfaces.0.operations.1', 'surfaces.0.operations.length', 'surfaces.0.tree.4', 'surfaces.0.tree.length',
-    'surfaces.1.details.files', 'surfaces.1.details.notes', 'surfaces.1.details.operations', 'surfaces.1.details.tree',
-    'surfaces.1.notes.0', 'surfaces.1.notes.length', 'surfaces.1.rows.0', 'surfaces.1.rows.1', 'surfaces.1.toolbar.1',
-    'surfaces.1.toolbar.2', 'surfaces.1.toolbar.3', 'surfaces.1.toolbar.4', 'surfaces.1.toolbar.5', 'surfaces.1.toolbar.length',
-    'surfaces.1.tree.3', 'surfaces.1.tree.5', 'surfaces.1.tree.6', 'surfaces.1.tree.length'].sort();
-
-test('diagnostics comparison detects mutations', async ({ page, request }) => {
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    const concept = await conceptDiagnostics(page, 'dark');
-    const { production, ...live } = await productionDiagnostics(page, request, 'dark');
-    const expected = mapDiagnosticsConcept(concept, live);
-    expect(diffInventory(expected, production)).toEqual([]);
-    // Unmapped, the section differs only where D109 and D110 are recorded.
-    expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 4).join('.'))
-        .filter((path, index, all) => all.indexOf(path) === index).sort()).toEqual(DEVIATED_PATHS);
-    const measure = () => page.evaluate(measureDiagnostics, ['#workspace-main', LINE_FORMAT.source]);
-    const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
-    // A removed term.
-    const undoTerm = await mutate(page, { remove: ['#workspace-main .meta-grid > div:nth-child(2)'] });
-    expect(await paths()).toEqual(expect.arrayContaining(['surfaces.0.grid.length']));
-    await undoTerm();
-    // A renamed button.
-    await page.evaluate(() => { document.querySelector('#workspace-main section.surface > button').textContent = 'Download report'; });
-    expect(await paths()).toEqual(['surfaces.0.buttons.0.text']);
-    await page.evaluate(() => { document.querySelector('#workspace-main section.surface > button').textContent = 'Download diagnostic report'; });
-    // A reordered level option.
-    await page.evaluate(() => { const select = document.querySelector('#workspace-main #log-level'); select.append(select.options[1]); });
-    expect(await paths()).toEqual(expect.arrayContaining(['surfaces.1.toolbar.1.options.1']));
-    await page.evaluate(() => { const select = document.querySelector('#workspace-main #log-level'); select.insertBefore(select.options[5], select.options[1]); });
-    // A wrong default level.
-    await page.evaluate(() => { document.querySelector('#workspace-main #log-level').value = 'INFO'; });
-    expect(await paths()).toEqual(['surfaces.1.toolbar.1.selected']);
-    await page.evaluate(() => { document.querySelector('#workspace-main #log-level').value = ''; });
-    // A primary Refresh.
-    await page.evaluate(() => { document.querySelectorAll('#workspace-main .toolbar > button')[0].classList.add('ca-primary'); });
-    expect(await paths()).toEqual(expect.arrayContaining(['surfaces.1.toolbar.4.className']));
-    await page.evaluate(() => { document.querySelectorAll('#workspace-main .toolbar > button')[0].classList.remove('ca-primary'); });
-    // A select squeezed until its chosen option is cut.
-    const undoSqueeze = await mutate(page, { css: '#workspace-main #runtime-level { max-width: 30px !important; min-width: 0 !important; }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['selectsFit.1']));
-    await undoSqueeze();
-    // A swapped token.
-    const undoToken = await mutate(page, { css: '#workspace-main .settings-layout { --line: rgb(255, 0, 0); }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['tokens.--line', 'row.borderTopColor']));
-    await undoToken();
-    expect(diffInventory(expected, await measure())).toEqual([]);
-
-    // The log cleanup review: a changed grid term, a backup box that came back and a grid token are noticed.
-    const conceptReview = await conceptCleanup(page, 'dark');
-    const { plan } = await productionCleanup(page, request, 'dark');
-    const expectedReview = mapCleanupConcept(conceptReview, plan);
-    const reviewPaths = async () => diffInventory(expectedReview, await page.evaluate(measureReview)).map(item => item.path);
-    expect(await reviewPaths()).toEqual([]);
-    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[2].textContent = 'Safety'; });
-    expect(await reviewPaths()).toEqual(['grid.rows.2.0']);
-    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[2].textContent = 'Backup'; });
-    const undoGrid = await mutate(page, { css: 'dialog#modal dl.meta-grid { column-gap: 3px; }' });
-    expect(await reviewPaths()).toEqual(expect.arrayContaining(['grid.columnGap']));
-    await undoGrid();
-    expect(await reviewPaths()).toEqual([]);
-});
-
@@ -1,7 +1,6 @@
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';
-import { SIZES, THEMES, seedConcept, openConcept, openProduction, diffInventory, mutate, measureReview, mapPlanConcept }
-    from './concept-inventory.mjs';
+import { SIZES, THEMES, seedConcept, openConcept, openProduction, diffInventory, mutate } from './concept-inventory.mjs';

 // #249 System S7 Task 20: System › Maintenance (app.js renderSystem 688–690), its plan dialog (`maintenancePlan`,
 // 953–958) for each operation and its duplicates dialog (`duplicates`, 1457–1461) against the immutable concept, on
@@ -104,6 +103,47 @@ for (const theme of THEMES) for (const [width, height] of SIZES) {
    });
 }

+/** Runs in the page: the open review dialog (plan or duplicates): its title, body and the concept's tokens. */
+function measureReview() {
+    const dialog = document.querySelector('dialog#modal[open]');
+    const css = (node, ...keys) => node ? Object.fromEntries(keys.map(key => [key, getComputedStyle(node)[key]])) : null;
+    const name = node => [node.localName, ...[...node.classList].sort()].join('.');
+    const text = node => node?.textContent.trim() ?? null;
+    const body = dialog.querySelector('#modal-body');
+    const grid = body.querySelector(':scope > dl.meta-grid');
+    const compare = body.querySelector('.compare-grid');
+    const item = compare?.querySelector('.compare-item');
+    const notes = [...body.querySelectorAll(':scope > p.small')];
+    const note = notes.at(-1);
+    const actions = body.querySelector(':scope > .dialog-actions');
+    return {
+        title: text(dialog.querySelector('#modal-title')),
+        tree: [...body.children].map(name),
+        heading: body.querySelector(':scope > h3') && { text: text(body.querySelector(':scope > h3')),
+            ...css(body.querySelector(':scope > h3'), 'fontSize', 'fontWeight', 'color', 'marginBottom') },
+        grid: grid && { rows: [...grid.children].map(row => [text(row.querySelector('dt')), text(row.querySelector('dd'))]),
+            ...css(grid, 'display', 'gridTemplateColumns', 'columnGap', 'rowGap'),
+            dt: css(grid.querySelector('dt'), 'fontSize', 'color', 'textTransform'), dd: css(grid.querySelector('dd'), 'fontSize', 'color') },
+        details: body.querySelector(':scope > details') && { summary: text(body.querySelector(':scope > details > summary')),
+            tree: [...body.querySelector(':scope > details').children].map(name) },
+        backup: body.querySelector(':scope > .notice') && { tree: [...body.querySelector(':scope > .notice').children].map(name),
+            text: [...body.querySelectorAll(':scope > .notice > div:first-child > *')].map(node => [node.localName, text(node)]),
+            buttons: [...body.querySelectorAll(':scope > .notice button')].map(text) },
+        compare: compare && { tree: [...compare.children].map(name), ...css(compare, 'display', 'gridTemplateColumns', 'columnGap'),
+            items: [...compare.children].map(entry => ({ tree: [...entry.children].map(name), label: text(entry.querySelector('label')),
+                checked: entry.querySelector('input[type=radio]').checked, image: entry.querySelector('img')?.className ?? null })),
+            item: css(item, 'paddingTop', 'paddingLeft', 'backgroundColor', 'borderTopWidth', 'borderTopColor', 'borderTopLeftRadius'),
+            image: css(item.querySelector('img'), 'width', 'objectFit'),
+            label: css(item.querySelector('label'), 'fontSize', 'color'),
+            radio: { name: item.querySelector('input[type=radio]').name.startsWith('keep-') ? 'keep-*' : 'other',
+                type: item.querySelector('input').type } },
+        note: note && { text: text(note), ...css(note, 'fontSize', 'color', 'marginTop') },
+        actions: { tree: [...actions.children].map(name), ...css(actions, 'display', 'justifyContent', 'columnGap', 'marginTop'),
+            buttons: [...actions.children].map(item => ({ text: text(item), className: item.className,
+                ...css(item, 'backgroundColor', 'color', 'fontSize', 'paddingTop', 'paddingLeft', 'borderTopColor') })) },
+    };
+}
+
 // The concept's plan names (`data-plan`) and production's operation, row and button for each.
 const PLANS = Object.freeze([
    ['duplicate prompts', 'duplicate_prompts', 'Duplicate prompt text'],
@@ -111,6 +151,32 @@ const PLANS = Object.freeze([
    ['unused prompt components', 'unused_components', 'Unused prompt components'],
    ['missing-file links', 'missing_links', 'Missing-file links'],
 ]);
+const BACKUP_BOX = Object.freeze({ tree: ['div', 'div.row-actions'], text: [['h3', 'Back up the database first (recommended)'],
+    ['p', 'Downloads a copy of the prompts database before this operation changes any records.']], buttons: ['Back up now'] });
+
+/**
+ * D100: the server's plan in the concept's dialog: the operation's row title as its `h3` (the concept prints its
+ * `data-plan` name), the four rows with the plan's values, the listed records (`details`), the hold line in the
+ * concept's `p.small`, the D55 backup box before the actions, and "Apply reviewed operation". No sample note.
+ */
+function mapPlanConcept(reference, title, plan) {
+    const backup = plan.backup.policy === 'off' ? 'No safety backup (the policy is off)'
+        : `Create and verify before changes (${plan.backup.destination_label})`;
+    const tree = ['h3', 'dl.meta-grid', ...(plan.details.length ? ['details'] : []), 'p.small', 'div.notice', 'div.dialog-actions'];
+    const [cancel, apply] = reference.actions.buttons;
+    return {
+        ...reference,
+        tree,
+        heading: { ...reference.heading, text: title },
+        grid: { ...reference.grid, rows: [['Scope', plan.scope.label],
+            ['Protected', plan.protected.reasons.length ? plan.protected.reasons.join(' · ') : 'Nothing is protected'],
+            ['Backup', backup], ['Media on disk', plan.media.label]] },
+        details: plan.details.length ? { summary: `Listed records (${plan.details.length})`, tree: ['summary', 'pre'] } : null,
+        backup: BACKUP_BOX,
+        note: { ...reference.note, text: 'Nothing changes until you apply. This review holds for 15 minutes.' },
+        actions: { ...reference.actions, buttons: [cancel, { ...apply, text: 'Apply reviewed operation' }] },
+    };
+}

 async function conceptPlan(page, theme, name) {
    await conceptMaintenance(page, theme);
@@ -33,7 +33,7 @@ test.afterEach(async ({ page, request, browserName }) => {
 const PREVIEW_URL = '/prompt_manager/autotag/batch/preview';
 const MODEL_OPTIONS = ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB'];
 const SUGGESTIONS = 'From 1 to 100: the most suggestions Generate shows for one image.';
-const BATCH = 'Tag each output image from its own pixels with the model above. Prompts are not changed. Review the scope first.';
+const BATCH = 'Add tags to each prompt from its linked output images with the model above. Review the scope first.';

 /** Runs in the page: Auto-tagging's surface under `mainSelector`: rows, field, actions, operation, geometry and tokens. */
 function measureTagging(mainSelector) {
@@ -127,9 +127,9 @@ function mapTaggingConcept(reference, { template, phone }) {
        actions: { ...reference.actions, buttons: [preview, ['Download again', ''], ['Unload', '']] },
        // D134: the prompt-tag batch, reviewed first.
        operations: [{ tree: ['div', 'div.row-actions'], title: 'Tag output images', description: BATCH, actions: [['Review', '']] }],
-        // D132 (#398): every select shows its whole chosen option at every width (at 390 the concept's 120px cap cuts
-        // them; production lets each grow past it).
-        selectsFit: reference.selectsFit.map(() => true),
+        // D132: the engine select shows its whole chosen option at every width (at 390 the concept's 120px cap cuts it;
+        // `#tag-model` alone may grow there). Existing tags keeps the concept's own fit, cut or not.
+        selectsFit: reference.selectsFit.map((fit, index) => (index === 0 ? true : fit)),
    };
 }

@@ -168,28 +168,16 @@ for (const theme of THEMES) for (const [width, height] of SIZES) {
    });
 }

-// D132 (#398) at phone width and below the concept's smallest size: every option of every select, once chosen, shows
-// whole, with no page scroll.
-for (const theme of THEMES) for (const width of [390, 320]) {
-    test(`auto-tagging selects fit every option at ${width} wide ${theme}`, async ({ page }, testInfo) => {
-        await page.setViewportSize({ width, height: 844 });
-        await productionTagging(page, theme);
-        await page.locator('#workspace-main #tag-existing').selectOption('replace_after_review');
-        await page.locator('#workspace-main section.surface').screenshot({ path: testInfo.outputPath(`production-tagging-selects-${theme}-${width}.png`) });
-        const selects = page.locator('#workspace-main section.surface > .setting-row > select');
-        await expect(selects).toHaveCount(2);
-        for (let index = 0; index < 2; index += 1) {
-            const select = selects.nth(index);
-            const values = await select.evaluate(node => [...node.options].map(option => option.value));
-            for (const value of values) {
-                await select.selectOption(value);
-                const measured = await page.evaluate(measureTagging, '#workspace-main');
-                expect(measured.selectsFit, `${await select.getAttribute('id')}=${value}`).toEqual([true, true]);
-                expect(measured.pageScroll, value).toBe(false);
-            }
-        }
-    });
-}
+// D132 below the concept's smallest size: on a 320px phone the engine select still shows its whole option.
+for (const theme of THEMES) test(`auto-tagging engine select fits at 320 wide ${theme}`, async ({ page }) => {
+    await page.setViewportSize({ width: 320, height: 700 });
+    const production = await productionTagging(page, theme);
+    for (const model of ['hf', 'gguf', 'wd14-swinv2']) {
+        await page.locator('#workspace-main #tag-model').selectOption(model);
+        expect((await page.evaluate(measureTagging, '#workspace-main')).selectsFit[0], model).toBe(true);
+    }
+    expect(production.pageScroll).toBe(false);
+});

 test('auto-tagging comparison detects mutations', async ({ page, request }) => {
    await page.setViewportSize({ width: 1600, height: 1100 });
@@ -234,9 +222,6 @@ test('auto-tagging comparison detects mutations', async ({ page, request }) => {
    const undoSqueeze = await mutate(page, { css: '#workspace-main #tag-model { max-width: 60px !important; min-width: 0 !important; }' });
    expect(await paths()).toEqual(expect.arrayContaining(['selectsFit.0']));
    await undoSqueeze();
-    const undoSqueezeExisting = await mutate(page, { css: '#workspace-main #tag-existing { max-width: 60px !important; min-width: 0 !important; }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['selectsFit.1']));
-    await undoSqueezeExisting();
    // A row that wraps where the concept's does not.
    const undoWrap = await mutate(page, { css: '#workspace-main .setting-row:has(> #tag-existing) { flex-wrap: wrap; }' });
    expect(await paths()).toEqual(['rows.1.flexWrap']);
@@ -248,14 +233,14 @@ test('auto-tagging comparison detects mutations', async ({ page, request }) => {
    expect(diffInventory(expected, await measure())).toEqual([]);
 });

-// D132 at phone width: only the engine row wraps; Existing tags grows beside its text instead (#398).
+// D132 at phone width, unmapped: only the engine row wraps; Existing tags keeps the concept's cut select.
 test('auto-tagging at 390 wraps only the engine row', async ({ page, request }) => {
    await page.setViewportSize({ width: 390, height: 844 });
    const concept = await conceptTagging(page, 'dark');
    const production = await productionTagging(page, 'dark');
    expect(diffInventory(mapTaggingConcept(concept, await savedTemplate(request, page)), production)).toEqual([]);
    expect(production.rows.map(row => row.flexWrap)).toEqual(['wrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap']);
-    expect(production.selectsFit).toEqual([true, true]);
+    expect(production.selectsFit[1]).toBe(concept.selectsFit[1]);
 });

 /** Runs in the page: the open review dialog: its title, body and the concept's tokens. */
@@ -287,19 +272,11 @@ function measureReview() {
 }

 const number = value => value.toLocaleString('en-US');
-/** DEC11 (#379): the Time row the preview's estimate reads as (WD14 on the test server's processor). */
-function timeRow(plan) {
-    const minutes = Math.max(1, Math.ceil(plan.estimate_seconds / 60));
-    const text = minutes < 90 ? `about ${minutes} min`
-        : `about ${Math.floor(minutes / 60)} h${minutes % 60 ? ` ${minutes % 60} min` : ''}`;
-    return `${text} on a processor; a graphics card can be faster.`;
-}

 /**
- * D134 (#379): the server's batch preview in the concept's review: "Review tag output images" with "Tag output images"
- * as its `h3`, the model, policy, image counts, time estimate and settings in the concept's `dl.meta-grid` (Backup in
- * the concept's wording), the estimate sentence in the concept's `p.small`, the D55 backup box and Cancel / "Start
- * tagging".
+ * D134: the server's batch preview in the concept's review: "Review tag output images" with "Tag output images" as its
+ * `h3`, the model, policy, counts and settings in the concept's `dl.meta-grid` (Backup in the concept's wording), the
+ * upper-bound sentence in the concept's `p.small`, the D55 backup box and Cancel / "Start tagging".
 */
 function mapBatchConcept(reference, plan) {
    const [cancel, start] = reference.actions.buttons;
@@ -309,14 +286,13 @@ function mapBatchConcept(reference, plan) {
        tree: ['h3', 'dl.meta-grid', 'p.small', 'div.notice', 'div.dialog-actions'],
        heading: { ...reference.heading, text: 'Tag output images' },
        grid: { ...reference.grid, rows: [['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Merge with existing'],
-            ['Images', number(plan.images)], ['Already auto-tagged', number(plan.already_tagged)],
-            ['Images to tag', `about ${number(plan.to_tag)}`], ['Time', timeRow(plan)],
-            ['Settings', `General 0.35 · Character 0.85 · up to ${number(plan.suggestion_limit)} tags per image`],
+            ['Images linked', number(plan.images)], ['Prompts', number(plan.prompts)], ['Already tagged', number(plan.already_tagged)],
+            ['Prompts to tag', `up to ${number(plan.to_tag)}`], ['Settings', 'General 0.35 · Character 0.85'],
            ['Backup', 'Create and verify before changes']] },
        backup: { tree: ['div', 'div.row-actions'], text: [['h3', 'Back up the database first (recommended)'],
            ['p', 'Downloads a copy of the prompts database before this operation changes any records.']], buttons: ['Back up now'] },
-        note: { ...reference.note, text: 'Nothing is written until you start. The number to tag is an estimate: images changed '
-            + 'since they were tagged are tagged again, and missing files are skipped. Activity reports what was tagged.' },
+        note: { ...reference.note, text: 'Nothing is written until you start. Missing files and files outside the output folders '
+            + 'are counted, so the prompts to tag are an upper bound; Activity reports what was tagged.' },
        actions: { ...reference.actions, buttons: [cancel, { ...start, text: 'Start tagging' }] },
    };
 }
@@ -332,8 +308,8 @@ async function conceptReview(page, theme) {

 async function productionReview(page, theme) {
    await productionTagging(page, theme);
-    // Merge reviews every listed still image (#379): a batch with work, the full review the concept's shell is compared
-    // with.
+    // Every concept-fixture prompt with an image is already tagged, so under the saved Skip there is nothing to start
+    // (the Cancel-only review). Merge reviews a batch with work: the full review the concept's shell is compared with.
    await page.locator('#workspace-main #tag-existing').selectOption('merge');
    const answer = page.waitForResponse(response => response.url().endsWith(PREVIEW_URL));
    await page.locator('#workspace-main .operation').getByRole('button', { name: 'Review', exact: true }).click();
@@ -350,9 +326,8 @@ for (const theme of THEMES) for (const [width, height] of SIZES) {
        expect(concept.tree).toEqual(['p.demo-note', 'h3', 'dl.meta-grid', 'p.small', 'div.dialog-actions']);
        await page.screenshot({ path: testInfo.outputPath(`concept-plan-review-${theme}-${width}.png`) });
        const { plan, production } = await productionReview(page, theme);
-        // Under Merge every listed still image is tagged again: the batch has work to review.
+        // Under Merge every prompt with a linked image is tagged again: the batch has work to review.
        expect(plan.to_tag).toBeGreaterThan(0);
-        expect(plan.estimate_device).toBe('cpu');
        await page.screenshot({ path: testInfo.outputPath(`production-tagging-review-${theme}-${width}.png`) });
        expect(diffInventory(mapBatchConcept(concept, plan), production)).toEqual([]);
    });
@@ -397,17 +372,9 @@ test('tag output images review comparison detects mutations', async ({ page }) =
    const expected = mapBatchConcept(concept, plan);
    const paths = async () => diffInventory(expected, await page.evaluate(measureReview)).map(item => item.path);
    expect(await paths()).toEqual([]);
-    // Every label of the grid is compared (#379's rows included): a changed one is named by its row.
-    for (const [index, [term]] of expected.grid.rows.entries()) {
-        await page.evaluate(([at, label]) => {
-            document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[at].textContent = label;
-        }, [index, `${term}!`]);
-        expect(await paths()).toEqual([`grid.rows.${index}.0`]);
-        await page.evaluate(([at, label]) => {
-            document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[at].textContent = label;
-        }, [index, term]);
-    }
-    expect(await paths()).toEqual([]);
+    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[5].textContent = 'To tag'; });
+    expect(await paths()).toEqual(['grid.rows.5.0']);
+    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[5].textContent = 'Prompts to tag'; });
    const undoGrid = await mutate(page, { css: 'dialog#modal dl.meta-grid { column-gap: 3px; }' });
    expect(await paths()).toEqual(expect.arrayContaining(['grid.columnGap']));
    await undoGrid();
@@ -1,54 +0,0 @@
-// A restore the open workspace page has not noticed yet (#413).
-//
-// Specs that restore through the API while a page is open check what the page does with a restore it did not see:
-// its next write is refused as "Prompt storage was restored since this dialog opened". But the page's Activity store
-// reads the job list every 15 s (activity-store.mjs POLL_MS), and a read the server answers while the restore job runs
-// makes the page follow it: when it finishes, the page is shown again from the restored data (S9, index.mjs
-// onRestoreFinished), which closes any open dialog. On a slow runner a restore can take longer than the time left to
-// the next read (CI run 40646112668: the restore took 16 s), so whether the page saw it depended on timing.
-//
-// `armUnseenRestores(page)`, before the page loads, passes every job-list read of the page through one route, so it
-// knows which reads the server has not answered yet. `unseenRestore(page, restoring)` then closes the gate, waits
-// for those reads' answers (sent before the restore began, they cannot list it), runs `restoring()`, and only after
-// it has answered lets the held reads go on: they read the restore as already ended, as a tab that read its job list
-// just before and just after the restore does. A restore that is never seen running never reloads the page.
-const JOBS = '**/prompt_manager/jobs';
-const gates = new WeakMap();
-
-/** Route `page`'s job-list reads through the restore gate. Call before the page's first navigation. */
-export async function armUnseenRestores(page) {
-    const gate = { closed: null, inFlight: 0, idle: [] };
-    gates.set(page, gate);
-    await page.route(JOBS, async route => {
-        if (gate.closed) {
-            await gate.closed;
-            return route.fallback();
-        }
-        gate.inFlight += 1;
-        try {
-            const response = await route.fetch();
-            await route.fulfill({ response }).catch(() => {});
-        } catch {
-            await route.abort().catch(() => {});
-        } finally {
-            gate.inFlight -= 1;
-            if (gate.inFlight === 0) for (const resolve of gate.idle.splice(0)) resolve();
-        }
-    });
-}
-
-/** Run `restoring()` (an API restore) unseen by `page`'s Activity store; resolves with what it resolves with. */
-export async function unseenRestore(page, restoring) {
-    const gate = gates.get(page);
-    if (!gate) throw new Error('armUnseenRestores(page) must run before the page loads');
-    let open;
-    gate.closed = new Promise(resolve => { open = resolve; });
-    try {
-        // Reads already on their way were sent before the restore: their answers cannot list it.
-        if (gate.inFlight > 0) await new Promise(resolve => gate.idle.push(resolve));
-        return await restoring();
-    } finally {
-        gate.closed = null;
-        open();
-    }
-}
@@ -42,13 +42,8 @@ test('actual gallery form saves a prompt that the admin page can edit and reload
    await page.locator(`[data-action="edit"][data-prompt-id="${id}"]`).click();
    const editor = page.locator(`.prompt-text[data-id="${id}"]`);
    await editor.fill('Browser edited portrait');
-    // The page shows the edit at once and saves it after: reload only once the save answered (a reload that wins the
-    // race abandons the PUT, as seen on WebKit in CI).
-    const savedEdit = page.waitForResponse(item => item.request().method() === 'PUT'
-        && item.url().endsWith(`/prompt_manager/prompts/${id}`));
    await editor.press('Enter');
    await expect(page.locator('.prompt-text').filter({ hasText: 'Browser edited portrait' })).toBeVisible();
-    expect((await savedEdit).ok()).toBe(true);
    await page.reload();
    await expect(page.locator('.prompt-text').filter({ hasText: 'Browser edited portrait' })).toBeVisible();
    const saved = await request.post('/prompt_manager/save', { data: { text: 'Browser saved landscape' } });
@@ -104,9 +99,35 @@ for (const leave of ['beforeunload', 'pagehide']) {
    });
 }

+// #222: the gallery's Clear cache clears the server's thumbnails by its own request and keeps this browser's
+// preferences and other tools' storage; nothing of Prompt Manager's is cached in a browser, and the toast says so.
+test('the gallery cache clear keeps preferences and other tools caches', async ({ page }) => {
+    await page.addInitScript(() => {
+        if (sessionStorage.getItem('seeded')) return;
+        sessionStorage.setItem('seeded', '1');
+        localStorage.setItem('pm_workspace_theme', 'light');
+        localStorage.setItem('other-tool-setting', 'keep');
+        localStorage.setItem('pm_other_tool', 'keep');
+    });
+    await page.goto('/prompt_manager/gallery');
+    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(2);
+    await page.evaluate(async () => { await (await caches.open('other-tool-gallery-thumbnails')).put('/x', new Response('x')); });
+    const clears = [];
+    page.on('request', req => { if (req.url().includes('/clear-thumbnails')) clears.push(req.method()); });
+    page.once('dialog', dialog => dialog.accept());
+    await page.locator('#settingsBtn').click();
+    await page.locator('#clearCacheBtn').click();
+    await expect(page.getByText("Thumbnails cleared; original images untouched. Nothing of Prompt Manager's is cached in this browser."))
+        .toBeVisible();
+    expect(clears).toEqual(['POST']);
+    expect(await page.evaluate(async () => ({
+        theme: localStorage.getItem('pm_workspace_theme'), other: localStorage.getItem('other-tool-setting'),
+        prefixed: localStorage.getItem('pm_other_tool'), notice: localStorage.getItem('pm_update_notice_dismissed'),
+        caches: await caches.keys(),
+    }))).toEqual({ theme: 'light', other: 'keep', prefixed: 'keep', notice: '3.2.0', caches: ['other-tool-gallery-thumbnails'] });
+});

-// #379: the reviewed tags are that image's own tags; no prompt changes.
-test('actual gallery review generates and persists tags for the selected root\'s image', async ({ page, request }) => {
+test('actual gallery review generates and persists tags for the selected root', async ({ page, request }) => {
    await page.goto('/prompt_manager/gallery');
    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(2);
    await page.locator('#autoTagBtn').click();
@@ -114,15 +135,13 @@ test('actual gallery review generates and persists tags for the selected root\'s
    await page.locator('#startReviewBtn').click();
    const generation = await generated;
    expect(generation.request().postDataJSON().root_index).toBe(0);
-    await expect(page.locator('#reviewTagsContainer')).toContainText('sandstone');
+    await expect(page.locator('#reviewTagsContainer')).toContainText('generated');
    const result = page.waitForResponse(response => response.url().endsWith('/prompt_manager/autotag/apply'));
    await page.locator('#applyReviewBtn').click();
    expect((await (await result).json()).success).toBe(true);
    const data = await (await request.get('/prompt_manager/recent?limit=20')).json();
-    expect(data.results.find(prompt => prompt.text === 'Cat portrait').tags).toEqual(['cats']);
-    expect(data.results.find(prompt => prompt.text === 'Dog landscape').tags).toEqual(['dogs']);
-    const tagged = await (await request.get('/prompt_manager/images/output?mode=workspace&tags=sandstone')).json();
-    expect(tagged.images.map(image => `${image.root_index}:${image.path}`)).toEqual(['0:shared/same.png']);
+    expect(data.results.find(prompt => prompt.text === 'Cat portrait').tags).toContain('generated');
+    expect(data.results.find(prompt => prompt.text === 'Dog landscape').tags).not.toContain('generated');
 });

 test('actual Tags page reloads the selected filter and opens its image viewer', async ({ page }) => {
@@ -199,7 +218,7 @@ test('gallery infinite scroll appends a real backend page while retaining existi
    await expect(await request.post('/__test__/reset', { data: { extra_images: 108 } })).toBeOK();
    await page.goto('/prompt_manager/gallery');
    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(100);
-    await page.locator('#pageOptionsBtn').click();
+    await page.locator('#settingsBtn').click();
    await page.locator('#infiniteScrollToggle').check();
    await page.locator('#saveSettingsBtn').click();
    await expect(page.locator('#settingsModal')).toBeHidden();
@@ -219,6 +238,37 @@ async function promptSnapshot(request) {
    })).sort((a, b) => a.id - b.id);
 }

+async function downloadBackup(page) {
+    const downloading = page.waitForEvent('download');
+    await page.locator('#backupBtn').click();
+    const download = await downloading;
+    expect(download.suggestedFilename()).toMatch(/^prompts_backup_.*\.db$/);
+    expect(await download.failure()).toBeNull();
+    const chunks = [];
+    for await (const chunk of await download.createReadStream()) chunks.push(chunk);
+    const buffer = Buffer.concat(chunks);
+    expect(buffer.subarray(0, 16).toString()).toBe('SQLite format 3\0');
+    return { name: download.suggestedFilename(), mimeType: 'application/octet-stream', buffer };
+}
+
+async function chooseRestore(page, file) {
+    await page.locator('#restoreBtn').click();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    await page.locator('#restoreFileInput').setInputFiles(file);
+}
+
+// Confirms the chosen restore and waits for the server's answer, not for a timer: a restore is disk-bound and can take
+// longer than an expect timeout on a slow runner (#359). The modal closes only after that answer.
+async function confirmRestoreAndWait(page) {
+    const restored = page.waitForResponse(response => response.url().endsWith('/prompt_manager/restore'));
+    await page.locator('#confirmRestore').click();
+    const response = await restored;
+    const body = await response.text();
+    expect(response.status(), body).toBe(200);
+    expect(JSON.parse(body)).toMatchObject({ success: true, prompt_count: 2, backup_created: expect.any(String) });
+    await expect(page.locator('#restoreModal')).toBeHidden();
+}
+
 function confirmNextDialog(page, accept, message) {
    page.once('dialog', async dialog => {
        expect(dialog.type()).toBe('confirm');
@@ -234,6 +284,88 @@ async function deletePromptButton(page, text) {
    return page.locator(`[data-action="delete"][data-prompt-id="${id}"]`);
 }

+test('downloaded backup restores deleted prompts, tags, and image links through the actual upload form', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    await expect(page.locator('.prompt-text')).toHaveCount(2);
+    const before = await promptSnapshot(request);
+    expect(before.map(prompt => prompt.tags)).toEqual([['cats'], ['dogs']]);
+    expect(before.every(prompt => prompt.images.length === 1)).toBe(true);
+    const backup = await downloadBackup(page);
+    const button = await deletePromptButton(page, 'Cat portrait');
+    confirmNextDialog(page, true, 'delete this prompt');
+    await button.click();
+    await expect(page.locator('.prompt-text')).toHaveCount(1);
+    await expect(await request.post('/prompt_manager/save', { data: { text: 'Added after backup', tags: ['temporary'] } })).toBeOK();
+    expect(await promptSnapshot(request)).not.toEqual(before);
+    await chooseRestore(page, backup);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    await expect(page.locator('.prompt-text')).toHaveCount(2);
+    await page.reload();
+    await expect(page.locator('.prompt-text').filter({ hasText: 'Cat portrait' })).toBeVisible();
+    await expect(page.locator('.prompt-text').filter({ hasText: 'Added after backup' })).toHaveCount(0);
+    expect(await promptSnapshot(request)).toEqual(before);
+    await page.goto('/prompt_manager/admin#/tags');
+    await page.locator('[data-tag-name="cats"]').click();
+    await expect(page.locator('#tagPromptsGrid')).toContainText('Cat portrait');
+    await page.locator('#tagPromptsGrid img').first().click();
+    await expect(page.locator('.viewer-canvas img')).toBeVisible();
+    await expect.poll(() => page.locator('.viewer-canvas img').evaluate(image => image.complete && image.naturalWidth > 0)).toBe(true);
+});
+
+test('restore validation and cancellation preserve live data and allow a valid retry', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    const before = await promptSnapshot(request);
+    const backup = await downloadBackup(page);
+    let uploads = 0;
+    page.on('request', request => { if (request.url().endsWith('/prompt_manager/restore')) uploads++; });
+    await page.locator('#restoreBtn').click();
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText('Please select a database file to restore', { exact: true })).toBeVisible();
+    await page.locator('#restoreFileInput').setInputFiles({ ...backup, name: 'backup.txt' });
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText('Please select a valid .db file', { exact: true })).toBeVisible();
+    expect(uploads).toBe(0);
+    await page.locator('#restoreFileInput').setInputFiles(backup);
+    confirmNextDialog(page, false, 'replace your current database');
+    await page.locator('#confirmRestore').click();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    expect(uploads).toBe(0);
+    await page.locator('#restoreFileInput').setInputFiles({ name: 'corrupt.db', mimeType: 'application/octet-stream', buffer: Buffer.from('not a SQLite database') });
+    confirmNextDialog(page, true, 'corrupt.db');
+    const rejected = page.waitForResponse(response => response.url().endsWith('/prompt_manager/restore'));
+    await page.locator('#confirmRestore').click();
+    expect((await rejected).status()).toBe(400);
+    await expect(page.getByText(/Restore failed:/)).toBeVisible();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    await expect(page.locator('#confirmRestore')).toBeEnabled();
+    expect(await promptSnapshot(request)).toEqual(before);
+    await page.locator('#restoreFileInput').setInputFiles(backup);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    expect(await promptSnapshot(request)).toEqual(before);
+});
+
+test('backup and restore recover from interrupted network requests without losing data', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    const before = await promptSnapshot(request);
+    await page.route('**/prompt_manager/backup', route => route.abort('failed'), { times: 1 });
+    await page.locator('#backupBtn').click();
+    await expect(page.getByText(/Backup failed:/)).toBeVisible();
+    const backup = await downloadBackup(page);
+    await chooseRestore(page, backup);
+    await page.route('**/prompt_manager/restore', route => route.abort('failed'), { times: 1 });
+    confirmNextDialog(page, true, backup.name);
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText(/Restore failed:/)).toBeVisible();
+    await expect(page.locator('#confirmRestore')).toBeEnabled();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    expect(await promptSnapshot(request)).toEqual(before);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    expect(await promptSnapshot(request)).toEqual(before);
+});
+
 test('prompt deletion requires confirmation and can retry after a network failure', async ({ page, request }) => {
    await page.goto('/prompt_manager/admin');
    const before = await promptSnapshot(request);
@@ -261,3 +393,98 @@ test('prompt deletion requires confirmation and can retry after a network failur
        await expect(await request.get(url)).toBeOK();
    }
 });
+
+// The duplicate scan reads the output root only, but the fixture's input root holds a different
+// shared/same.png. A bare /images/serve/<path> URL tries every gallery root in turn, so once the
+// output copy is deleted it answers 200 with the input copy: check each file in its own root.
+const serveIn = (root, path) => `/prompt_manager/images/serve/${path.split(/[\\/]/).map(encodeURIComponent).join('/')}?root=${root}`;
+const rootOf = url => new URL(url, 'http://gallery.test').searchParams.get('root');
+
+// Which copy the scan keeps depends on file times: the fixture stamps shared/same.png with the
+// wall clock, and the kernel can stamp its bulk copies a fraction of a millisecond earlier.
+// listOrder rewrites the finished scan's groups so a test can pick the order it needs.
+async function openDuplicateScan(page, request, listOrder = null) {
+    await expect(await request.post('/__test__/reset', { data: { extra_images: 2 } })).toBeOK();
+    if (listOrder) {
+        await page.route('**/prompt_manager/scan_duplicates/stream', async route => {
+            const response = await route.fetch();
+            const body = (await response.text()).replace(/^data: (.*)$/gm, (line, json) => {
+                const event = JSON.parse(json);
+                if (event.type !== 'complete') return line;
+                for (const group of event.duplicates) group.images = listOrder(group.images);
+                return `data: ${JSON.stringify(event)}`;
+            });
+            await route.fulfill({ response, body });
+        });
+    }
+    await page.goto('/prompt_manager/gallery');
+    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(4);
+    const originals = await page.locator('#galleryGrid img[data-original]').evaluateAll(images => images.map(image => image.dataset.original));
+    const output = rootOf(originals.find(url => url.includes('/bulk/')));
+    const input = rootOf(originals.find(url => url.includes('/shared/same.png') && rootOf(url) !== output));
+    expect(output).not.toBeNull();
+    expect(input).not.toBeNull();
+    await page.locator('#settingsBtn').click();
+    await page.locator('#scanDuplicatesBtn').click();
+    await expect(page.locator('#duplicatesCount')).toHaveText('1');
+    const candidates = page.locator('.duplicate-checkbox');
+    await expect(candidates).toHaveCount(2);
+    return { originals, output, input, candidates };
+}
+
+async function expectOnlySelectedGone(page, request, { originals, output, input }, selected, retained) {
+    expect((await request.get(serveIn(output, selected))).status()).toBe(404);
+    await expect(await request.get(serveIn(output, retained))).toBeOK();
+    await expect(await request.get(serveIn(input, 'shared/same.png'))).toBeOK();
+    await page.reload();
+    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(3);
+    const remaining = await page.locator('#galleryGrid img[data-original]').evaluateAll(images => images.map(image => image.dataset.original));
+    expect(remaining).toHaveLength(originals.length - 1);
+    for (const url of remaining) {
+        expect(originals).toContain(url);
+        await expect(await request.get(url)).toBeOK();
+    }
+}
+
+test('duplicate cleanup cancels safely and deletes only the selected file after a retry', async ({ page, request }) => {
+    const scan = await openDuplicateScan(page, request);
+    const { output, candidates } = scan;
+    const selected = await candidates.first().getAttribute('data-image-path');
+    const retained = await candidates.last().getAttribute('data-image-path');
+    await candidates.first().check();
+    let deletes = 0;
+    page.on('request', request => { if (request.url().endsWith('/delete_duplicate_images')) deletes++; });
+    confirmNextDialog(page, false, 'permanently delete 1 duplicate image files');
+    await page.locator('#removeDuplicatesBtn').click();
+    expect(deletes).toBe(0);
+    await expect(await request.get(serveIn(output, selected))).toBeOK();
+    await page.route('**/prompt_manager/delete_duplicate_images', route => route.abort('failed'), { times: 1 });
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    await page.locator('#removeDuplicatesBtn').click();
+    await expect(page.getByText('Failed to delete duplicate images', { exact: true })).toBeVisible();
+    await expect(page.locator('#removeDuplicatesBtn')).toBeEnabled();
+    await expect(await request.get(serveIn(output, selected))).toBeOK();
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    const deleted = page.waitForResponse(response => response.url().endsWith('/delete_duplicate_images'));
+    await page.locator('#removeDuplicatesBtn').click();
+    expect((await (await deleted).json())).toMatchObject({ success: true, deleted_count: 1, failed_count: 0 });
+    await expect(page.locator('#duplicatesModal')).toBeHidden();
+    await expectOnlySelectedGone(page, request, scan, selected, retained);
+});
+
+test('deleting a duplicate whose path another gallery root also holds removes only the scanned copy', async ({ page, request }) => {
+    // The order CI saw: a bulk copy stamped first, so shared/same.png is the first Delete candidate.
+    const ciOrder = ['bulk/0000.png', 'shared/same.png', 'bulk/0001.png'];
+    const rank = image => ciOrder.indexOf(image.path.replace(/\\/g, '/'));
+    const scan = await openDuplicateScan(page, request, images => [...images].sort((a, b) => rank(a) - rank(b)));
+    const selected = await scan.candidates.first().getAttribute('data-image-path');
+    const retained = await scan.candidates.last().getAttribute('data-image-path');
+    expect(selected.replace(/\\/g, '/')).toBe('shared/same.png');
+    await scan.candidates.first().check();
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    const deleted = page.waitForResponse(response => response.url().endsWith('/delete_duplicate_images'));
+    await page.locator('#removeDuplicatesBtn').click();
+    expect((await (await deleted).json())).toMatchObject({ success: true, deleted_count: 1, failed_count: 0 });
+    await expect(page.locator('#duplicatesModal')).toBeHidden();
+    await expectOnlySelectedGone(page, request, scan, selected, retained);
+});
@@ -1,6 +1,5 @@
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {readFile,writeFile} from 'node:fs/promises';
 import {createHash} from 'node:crypto';

@@ -17,13 +16,13 @@ const marker=(page,id,anchor='10')=>recorded(page).locator(`button[data-run-id="
 const exact=async locator=>locator.evaluate(node=>node.textContent);

 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);page.historyErrors=[];page.on('pageerror',error=>page.historyErrors.push(error.message));
+    await startCoverage(page,browserName);page.historyErrors=[];page.on('pageerror',error=>page.historyErrors.push(error.message));
    const reset=await request.post('/__test__/reset',{data:{chronological_history:true}});await expect(reset).toBeOK();page.fixture=await reset.json();
 });
 test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.historyErrors).toEqual([]);});

 const command=async(request,data)=>{const response=await request.post('/__test__/history/commands',{data});await expect(response).toBeOK();return response.json();};
-const restoreSnapshot=async(page,request,bytes)=>{const response=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'history.db',mimeType:'application/octet-stream',buffer:bytes}}}));await expect(response).toBeOK();expect((await response.json()).success).toBe(true);};
+const restoreSnapshot=async(request,bytes)=>{const response=await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'history.db',mimeType:'application/octet-stream',buffer:bytes}}});await expect(response).toBeOK();expect((await response.json()).success).toBe(true);};
 const historyRead=async(request,id)=>{const response=await request.get(`/prompt_manager/library/${id}/history`);await expect(response).toBeOK();return response.json();};
 const frozenContexts=contexts=>contexts.map(({navigation,positive_prompt_id,negative_prompt_id,pair_id,...frozen})=>frozen);
 const immutableReceipts=items=>items.map(({current_candidate,...receipt})=>receipt);
@@ -63,7 +62,7 @@ for(const boundary of ['window','detail','candidate','inspection','media']) test
    await command(request,{action:'arm',boundary});const pending=request.get(target);
    try {
        await expect.poll(async()=> (await(await request.get('/__test__/history/checkpoint')).json()).entered).toBe(true);
-        await restoreSnapshot(page,request,bytes);
+        await restoreSnapshot(request,bytes);
    } finally {await command(request,{action:'release'});}
    const retired=await pending;expect(retired.status()).toBe(409);expect((await retired.json()).code).toBe('history-changed');
    for(const url of [`/prompt_manager/library/${f.detail_id}/history?limit=1&cursor=${encodeURIComponent(firstWindow.next_cursor)}`,`${base}?epoch=${epoch}`,`${base}/outputs?epoch=${epoch}`,`${base}/outputs?epoch=${epoch}&cursor=${encodeURIComponent(outputs.next_cursor)}`,media.url,media.thumbnail_url,media.inspection_url]) {
@@ -131,7 +130,7 @@ test('archive delete merge and prune preserve frozen evidence without repairing

 test('actual restore with reused numeric owner rejects stale history and offers explicit saved recovery',async({page,request})=>{
    const f=page.fixture;await open(page,f.detail_id);const original=await exact(saved(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'));
-    const source=await request.get('/__test__/history/reused-snapshot');await expect(source).toBeOK();await restoreSnapshot(page,request,await source.body());
+    const source=await request.get('/__test__/history/reused-snapshot');await expect(source).toBeOK();await restoreSnapshot(request,await source.body());
    await marker(page,f.runs.shared).click();await expect(dialog(page)).toContainText('Recorded evidence changed');await page.keyboard.press('Escape');
    await expect(page.locator('.library-parent-status')).toContainText('changed');expect(await exact(saved(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'))).toBe(original);
    await expect(recorded(page).getByRole('button',{name:'Reload recorded history',exact:true})).toBeVisible();
@@ -143,12 +142,12 @@ for(const outcome of ['success','error'])test(`delayed actual old browser ${outc
    const f=page.fixture;await open(page,f.detail_id);const snapshot=await request.get('/__test__/history/snapshot');const bytes=await snapshot.body();
    let entered,release;const started=new Promise(resolve=>{entered=resolve;}),held=new Promise(resolve=>{release=resolve;});
    await page.route(new RegExp(`/history/runs/${f.runs.shared}\\?`),async route=>{
-        if(outcome==='error')await restoreSnapshot(page,request,bytes);
+        if(outcome==='error')await restoreSnapshot(request,bytes);
        const response=await route.fetch();expect(response.status()).toBe(outcome==='success'?200:409);entered();await held;
        await route.fulfill({response}).catch(()=>{});
    });
    try {
-        await marker(page,f.runs.shared).click();await started;if(outcome==='success')await restoreSnapshot(page,request,bytes);
+        await marker(page,f.runs.shared).click();await started;if(outcome==='success')await restoreSnapshot(request,bytes);
        await page.evaluate(()=>{location.hash='#/overview';});await expect(page.locator('#workspace-main h1')).toHaveText('Overview');release();
        await page.unroute(new RegExp(`/history/runs/${f.runs.shared}\\?`));await open(page,f.detail_id);
        await expect(recorded(page).locator('button[data-run-id]')).toHaveCount(0);
@@ -259,7 +258,7 @@ test('inspection first discovers a real restore and immediately retires every su
                if(changed)window.recordedRecoveryStates.push({receipts:run.querySelectorAll('[data-receipt]').length,active:[...run.querySelectorAll('[data-send-role],[data-copy-role],[data-view-receipt]')].filter(node=>!node.disabled&&node.checkVisibility()).length});
            });observer.observe(run,{subtree:true,childList:true,attributes:true,characterData:true});
        });
-        await restoreSnapshot(page,request,await snapshot.body());
+        await restoreSnapshot(request,await snapshot.body());
    } finally {await command(request,{action:'release'});}
    const response=await inspectionRead;expect(response.status()).toBe(409);expect((await response.json()).code).toBe('history-changed');
    await expect(dialog(page).locator('.recorded-run-status')).toContainText('Recorded evidence changed');
@@ -2189,248 +2189,3 @@ test('scan for metadata opens the review dialog from Import', async ({ page, req
    await expect.poll(async () => (await (await request.get('/prompt_manager/jobs')).json()).jobs
        .map(job => [job.kind, job.state])).toEqual([['backup', 'finished']]);
 });
-
-// #392 (D135): file-manager selection beyond the concept's checkbox.
-const selectedCount = page => bulkbar(page).locator('.bulkbar > strong');
-const cardAt = (page, index) => page.locator(`article[data-image-key][data-index="${index}"]`);
-const boxAt = (page, index) => cardAt(page, index).getByRole('checkbox', { name: /^Select / });
-const checkedIndexes = page => page.locator('article[data-image-key]').evaluateAll(nodes => nodes
-    .filter(node => node.querySelector('.image-overlays input[type="checkbox"]').checked)
-    .map(node => Number(node.dataset.index)).sort((a, b) => a - b));
-const range = (from, to) => Array.from({ length: to - from + 1 }, (_, index) => from + index);
-async function bulkReset(page, request) {
-    await page.addInitScript(() => { window.IntersectionObserver = undefined; });
-    await expect(await request.post('/__test__/reset', { data: { extra_images: 200 } })).toBeOK();
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(40);
-}
-/** A touch press on `locator` the way a finger makes one: pointerdown, (held), pointerup. */
-const touchDown = locator => locator.evaluate(node => {
-    const { left, top } = node.getBoundingClientRect();
-    node.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, isPrimary: true, pointerType: 'touch', clientX: left + 5, clientY: top + 5 }));
-});
-const touchUpAndClick = locator => locator.evaluate(node => {
-    node.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, isPrimary: true, pointerType: 'touch' }));
-    // A tap's click counts one press (`detail` 1); a keyboard click (and `HTMLElement.click()`) counts none.
-    node.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, detail: 1 }));
-});
-async function touchTap(locator) {
-    await touchDown(locator);
-    await touchUpAndClick(locator);
-}
-
-test('Shift+click selects a range across an appended batch in Grid, List and Masonry', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    for (const mode of ['Grid', 'List', 'Masonry']) {
-        await page.getByRole('group', { name: 'Image layout', exact: true }).getByRole('button', { name: mode, exact: true }).click();
-        // The anchor is the last image toggled on its own (List hides the concept's checkbox: the card carries it).
-        await cardAt(page, 3).locator('.media-info h3').click({ modifiers: ['ControlOrMeta'] });
-        await expect(selectedCount(page)).toHaveText('1 selected');
-        // The range runs into the second batch (index 40 on), and backwards from the same anchor.
-        await cardAt(page, 45).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('43 selected');
-        expect(await checkedIndexes(page)).toEqual(range(3, 45));
-        await cardAt(page, 0).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('46 selected');
-        expect(await checkedIndexes(page)).toEqual(range(0, 45));
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-        if (mode !== 'List') {
-            // A Shift+click on a checkbox gives its range the box's new state: here, unchecked.
-            await boxAt(page, 3).uncheck();
-            await boxAt(page, 10).click({ modifiers: ['Shift'] });
-            await expect(boxAt(page, 10)).not.toBeChecked();
-            await expect(selectedCount(page)).toHaveText('38 selected');
-            expect(await checkedIndexes(page)).toEqual([0, 1, 2, ...range(11, 45)]);
-        }
-        await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).click();
-        await expect(bulkbar(page)).toBeEmpty();
-    }
-});
-
-test('Ctrl/Cmd+click toggles a card without opening it, and a plain click still opens the viewer', async ({ page }) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const first = cards(page).first();
-    const inspectorBefore = await details(page).innerText();
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    await cards(page).last().getByRole('button', { name: 'Inspect same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await star(first, 'same.png').click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(star(first, 'same.png')).toHaveAttribute('aria-pressed', 'false');
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    expect(await details(page).innerText()).toBe(inspectorBefore);
-    // A plain click keeps its meaning: the image opens the viewer.
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click();
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await expect(selectedCount(page)).toHaveText('1 selected');
-});
-
-test('Ctrl/Cmd+A, Select all N matching and Add tags tag every matching image on the server', async ({ page, request }) => {
-    await bulkReset(page, request);
-    // Ctrl/Cmd+A in the search box stays the field's own.
-    await search(page).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(bulkbar(page)).toBeEmpty();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    const offer = bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true });
-    await expect(offer).toBeVisible();
-    await expect(bulkbar(page).locator('.bulkbar > *').nth(1)).toHaveText('Select all 202 matching');
-    await offer.click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    await expect(offer).toHaveCount(0);
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).toHaveAttribute('aria-disabled', 'true');
-    // A later batch arrives checked.
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    await expect(boxAt(page, 70)).toBeChecked();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Unchecking one image leaves "all matching": the other loaded images stay selected.
-    await boxAt(page, 0).uncheck();
-    await expect(selectedCount(page)).toHaveText('79 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).not.toHaveAttribute('aria-disabled', 'true');
-    await cardAt(page, 1).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Add tags sends the listing filter, not 202 identities, and the server tags every match.
-    await bulkbar(page).getByRole('button', { name: 'Add tags', exact: true }).click();
-    const dialog = page.getByRole('dialog', { name: 'Tag selected images', exact: true });
-    await dialog.getByRole('textbox', { name: 'Tags, separated by commas', exact: true }).fill('picked392');
-    const started = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/jobs/image-tags');
-    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
-    expect((await started).postDataJSON()).toEqual({ mode: 'add', filter: { sort: 'newest' }, tags: ['picked392'] });
-    await expect.poll(async () => (await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&tags=picked392')).json()).total,
-        { timeout: 20000 }).toBe(202);
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Escape in the grid clears the selection.
-    await cardAt(page, 2).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(boxAt(page, 2)).not.toBeChecked();
-});
-
-test('Shift+arrow keys extend the selection from the focused card, and Escape in the bar clears it', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Shift+ArrowRight');
-    await page.keyboard.press('Shift+ArrowRight');
-    await expect(cardAt(page, 2).getByRole('button', { name: /^Open / })).toBeFocused();
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    expect(await checkedIndexes(page)).toEqual([0, 1, 2]);
-    // A plain arrow moves without selecting; Shift+End reaches the last loaded card from the same anchor.
-    await page.keyboard.press('ArrowRight');
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    await page.keyboard.press('Shift+End');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('#workspace-main h1')).toBeFocused();
-});
-
-test('a touch long-press starts selection mode, taps then toggle, and an empty selection ends it', async ({ page }, testInfo) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const [first, second] = [cards(page).first(), cards(page).last()];
-    const open = card => card.getByRole('button', { name: 'Open same.png', exact: true });
-    await touchDown(open(first));
-    // The context menu of a held press belongs to the long press.
-    expect(await open(first).evaluate(node => !node.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true })))).toBe(true);
-    // Held: the long press selects the card once its delay passed.
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await touchUpAndClick(open(first));
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    // Taps now toggle instead of opening.
-    if (testInfo.project.name === 'touch') await open(second).tap();
-    else await touchTap(open(second));
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    // A keyboard Enter keeps its meaning in touch selection mode: the image opens.
-    await open(first).focus();
-    await page.keyboard.press('Enter');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await page.keyboard.press('Escape');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(0);
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await touchTap(open(first));
-    await touchTap(open(second));
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    // The selection is empty, so touch selection mode ended: a tap opens the image again.
-    await touchTap(open(first));
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-});
-
-test('all matching sets the category through the listing filter and survives a return visit as the loaded images', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    // The offer left with its press: focus moves to the bar's first action.
-    await expect(bulkbar(page).getByRole('button', { name: 'Add tags', exact: true })).toBeFocused();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Export metadata waits for loaded images: a press does nothing.
-    const exportButton = bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true });
-    await expect(exportButton).toHaveAttribute('title', 'Export metadata reads each image in the browser, so it works on loaded images only.');
-    // No match linked (a stubbed answer): the nothing-linked sentence, and the selection stays.
-    await page.route('**/prompt_manager/bulk/category', route => route.fulfill({ json: { success: true, updated_count: 0, prompt_count: 0, skipped: 202 } }), { times: 1 });
-    const categorize = page.getByRole('dialog', { name: 'Categorize selected images', exact: true });
-    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
-    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
-    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
-    await expect(toast(page)).toHaveText("None of the selected images is linked to a saved prompt, so there is no prompt category to set.");
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // The real write: one request with the filter, every matching image's positive changes.
-    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
-    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
-    const posted = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/bulk/category');
-    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
-    expect((await posted).postDataJSON()).toEqual({ images_filter: { sort: 'newest' }, category: 'Bulk392' });
-    await expect(toast(page)).toHaveText(/^Category set on \d+ prompts?\.$/);
-    await expect(bulkbar(page)).toBeEmpty();
-    const filtered = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&category=Bulk392')).json();
-    expect(filtered.total).toBe(202);
-    // A return visit keeps "all matching" as the loaded images, and the offer shows again.
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await page.evaluate(() => { window.location.hash = '/overview'; });
-    await expect(page.locator('#workspace-main h1')).toHaveText('Overview');
-    await page.evaluate(() => { window.location.hash = '/images'; });
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true })).toBeVisible();
-    // Escape in the bar with nothing selected does nothing; with a selection it clears.
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-});
-
-test('all matching over 10,000 images says so before any dialog or request', async ({ page, request }) => {
-    await page.route(url => url.pathname === '/prompt_manager/images/output' && url.searchParams.get('limit') !== '1', async route => {
-        const response = await route.fetch();
-        const body = await response.json();
-        await route.fulfill({ response, json: { ...body, total: 20002 } });
-    });
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 20,002 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 20,002 matching selected');
-    let posted = 0;
-    page.on('request', item => { if (item.method() === 'POST') posted += 1; });
-    for (const action of ['Set category', 'Add tags', 'Auto-tag selected']) {
-        await bulkbar(page).getByRole('button', { name: action, exact: true }).click();
-        await expect(toast(page)).toHaveText('Narrow the view to at most 10,000 images.');
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-    }
-    expect(posted).toBe(0);
-});
@@ -1,7 +1,6 @@
 import {writeFile} from 'node:fs/promises';
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
 import {inventoryOf,mapConcept,diffInventory} from './library-editor-canonical-comparison.mjs';

@@ -14,7 +13,7 @@ const RATINGS=[['5','5 / 5'],['4','4 / 5'],['3','3 / 5'],['2','2 / 5'],['1','1 /
 const editorDialog=page=>page.locator('dialog.library-editor');

 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);
+    await startCoverage(page,browserName);
    const reset=await request.post('/__test__/library-editor/reset',{data:{}});await expect(reset).toBeOK();page.fixture=await reset.json();
    page.editorErrors=[];page.on('pageerror',error=>page.editorErrors.push(error.message));
    page.writes=[];page.on('request',item=>{if(item.method()!=='GET')page.writes.push({method:item.method(),url:new URL(item.url()).pathname,body:item.postDataJSON()});});
@@ -261,8 +260,7 @@ test('recovery states render inline and never replay a write',async({page,reques
    page.writes.length=0;
    dialog=await openEditor(page,{mode:'new'});await ready(dialog);
    const snapshot=await request.get('/__test__/library-editor/snapshot');await expect(snapshot).toBeOK();
-    const buffer=await snapshot.body();
-    const restore=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer}}}));
+    const restore=await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:await snapshot.body()}}});
    await expect(restore).toBeOK();page.writes.length=0;
    await field(dialog,'Title').fill('After restore');await field(dialog,'Positive prompt').fill('Restored storage prompt');await button(dialog,'Save').click();
    await expect(note(dialog)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was saved.');
@@ -590,7 +588,7 @@ test('saved refresh failure retries only reads',async({page})=>{

 test('restored storage after a confirmed save or before an archive offers an explicit Library reload',async({page,request})=>{
    const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
    await openHistory(page,f.positive_id);
    await page.route(`**/prompt_manager/library/${f.positive_id}`,async route=>{
        if(route.request().method()!=='PATCH')return route.continue();
@@ -617,7 +615,7 @@ test('restored storage after a confirmed save or before an archive offers an exp
 const DISCARDS='Leaving this dialog discards your entries.';
 test('restored storage before an Edit or Add negative save offers only the Library reload exit',async({page,request})=>{
    const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
    await openHistory(page,f.positive_id);
    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();let dialog=editorDialog(page);await ready(dialog);
    await expect(await restore()).toBeOK();
@@ -47,17 +47,6 @@ async function serverJson(request, url) {
    return response.json();
 }

-/**
- * The restore job's own end (#361): its progress stream closes when the job takes its final state, however long the
- * disk-bound publish takes (bounded by the test, not by a 5 s expect), and the job finished. The toast the page shows
- * for it is then the page's reaction alone, checked with the default timeout.
- */
-async function restoreFinished(request, id) {
-    await expect(await request.get(`/prompt_manager/jobs/${id}/events`)).toBeOK();
-    const { job } = await serverJson(request, `/prompt_manager/jobs/${id}`);
-    expect([job.kind, job.state]).toEqual(['restore', 'finished']);
-}
-
 async function openBackups(page) {
    // A fresh page each time: the drafts live for the page session (Q10), and a hash-only goto would not reload.
    if (page.url().endsWith('#/system/backups')) await page.reload();
@@ -227,7 +216,6 @@ test('Restore starts the job, opens Activity; views reload after it finishes', a
    const { job } = await (await applied).json();
    expect([job.kind, job.title, job.cancellable]).toEqual(['restore', 'Database restore', false]);
    await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    await restoreFinished(request, job.id);
    await expect(toast(page)).toHaveText(/^Database restore finished · Restored \d+ prompts?, /);
    // The library is the backup's again, and the page says so without a reload: the sidebar counts were read again.
    expect(await libraryTotal(request)).toBe(restoredTotal);
@@ -256,8 +244,7 @@ test('a finished restore shows the open page again from the restored data', asyn
    const card = page.locator('#workspace-main article.prompt-card').filter({ hasText: 'S9 prompt the restore removes' });
    await expect(card).toHaveCount(1);
    await expect(await request.post('/__test__/release')).toBeOK();
-    const { job } = await (await applied).json();
-    await restoreFinished(request, job.id);
+    await applied;
    await expect(toast(page)).toHaveText(/^Database restore finished · /);
    // The shelf was read again from the restored library, on the same route.
    await expect(card).toHaveCount(0);
@@ -395,15 +382,14 @@ test('a failed settings read leaves the policy disabled with the reason', async
    await expect(row.locator('input')).toBeDisabled();
 });

-test('the legacy Backup and Restore routes keep working and the admin page links to System', async ({ page, request }) => {
+test('the legacy admin Backup and Restore keep working', async ({ page, request }) => {
    const bytes = await backupBytes(request);
    const restored = await request.post('/prompt_manager/restore', { multipart: { database_file: {
        name: 'prompts_backup.db', mimeType: 'application/octet-stream', buffer: bytes } } });
    await expect(restored).toBeOK();
    expect((await restored.json()).success).toBe(true);
-    // #330: the admin page's Backup DB and Restore DB open System › Backup & export.
    await page.goto('/prompt_manager/admin');
-    for (const id of ['#backupBtn', '#restoreBtn']) await expect(page.locator(id)).toHaveAttribute('href', 'workspace#/system/backups');
+    await expect(page.locator('#restoreFileInput')).toHaveCount(1);
 });

 /** Start a fake running job (a metadata scan another tab started), which an exclusive restore must wait for. */
@@ -436,7 +422,6 @@ test('a refused restore reopens its review: Restore retries it, Discard releases
    await dialog(page).getByRole('button', { name: 'Restore', exact: true }).click();
    const { job } = await (await applied).json();
    await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    await restoreFinished(request, job.id);
    await expect(toast(page)).toHaveText(/^Database restore finished · /);
    expect(await stagesOf(request)).toBe(0);
 });
@@ -1,611 +0,0 @@
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-import { seedConcept } from './concept-inventory.mjs';
-
-// System › Diagnostics & logs (#249 System S12, #329) on the concept-shaped fixture, with the logger writing into this
-// server's own root (workspace_diagnostics_fixture.py): the meta-grid's live values, Run checks, the report, Inspect and
-// the test link (D110); the log viewer, statistics, downloads and runtime drafts (D109); and the reviewed rotated-log
-// cleanup (D100) and Clear all logs, which delete only inside that temporary log folder.
-const workspace = '/prompt_manager/workspace';
-const REPORT_URL = '/prompt_manager/system/diagnostics';
-const LOGS_URL = '/prompt_manager/logs';
-const CONFIG_URL = '/prompt_manager/logs/config';
-const PREVIEW_URL = '/prompt_manager/maintenance/preview';
-const APPLY_URL = '/prompt_manager/maintenance/apply';
-const TEST_LINK_URL = '/prompt_manager/diagnostics/test-link';
-const CHANGED = 'The log files changed since the review; nothing was deleted. Review again.';
-const KEY = 'sk-s12-browser-SECRET-0123456789';
-const LEVELS = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await seedConcept(request);
-    await expect(await request.post('/__test__/system/reset')).toBeOK();
-    await expect(await request.post('/__test__/integrations/reset')).toBeOK();
-    await expect(await request.post('/__test__/jobs/restart')).toBeOK();
-    await expect(await request.post('/__test__/logs/reset')).toBeOK();
-    page.systemErrors = [];
-    page.on('pageerror', error => page.systemErrors.push(error.message));
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    await request.post('/__test__/release');
-    await request.post('/__test__/jobs/restart');
-    await request.post('/__test__/logs/reset');
-    await request.post('/__test__/integrations/reset');
-    await request.post('/__test__/system/reset');
-    expect(page.systemErrors).toEqual([]);
-});
-
-const toast = page => page.locator('#workspace-toast');
-const layoutOf = page => page.locator('#workspace-main .settings-layout');
-const dialog = page => page.locator('dialog#modal[open]');
-const surfaceOf = (page, title) => layoutOf(page).locator(':scope > section.surface').filter({
-    has: page.getByRole('heading', { level: 2, name: title, exact: true }) });
-const cell = (page, term) => surfaceOf(page, 'Diagnostics').locator('.meta-grid > div').filter({
-    has: page.locator(`dt:text-is("${term}")`) }).locator('dd');
-const lines = page => page.locator('#log-lines > code');
-const operation = (page, title) => layoutOf(page).locator('.operation').filter({ has: page.locator(`h3:text-is("${title}")`) });
-const settingOf = (page, label) => layoutOf(page).locator('.setting-row').filter({ has: page.locator(`label:text-is("${label}")`) });
-const status = page => page.locator('#settings-status');
-const save = page => page.getByRole('button', { name: 'Save preferences', exact: true });
-
-async function serverJson(request, url) {
-    const response = await request.get(url);
-    await expect(response).toBeOK();
-    return response.json();
-}
-
-async function seedLogs(request, data = {}) {
-    await expect(await request.post('/__test__/logs/seed', { data })).toBeOK();
-}
-
-const names = async request => (await serverJson(request, '/__test__/logs/state')).entries.map(entry => entry.name);
-
-async function openDiagnostics(page) {
-    if (page.url().endsWith('#/system/diagnostics')) await page.reload();
-    else await page.goto(`${workspace}#/system/diagnostics`);
-    await expect(layoutOf(page).locator(':scope > section.surface')).toHaveCount(2);
-    await expect(lines(page)).not.toHaveText('Loading…');
-    await expect(cell(page, 'Database')).not.toHaveText('Loading…');
-    // The renderer line settles first: its text can move the rows below.
-    await expect(cell(page, 'Host renderers')).not.toHaveText('Loading…');
-    await expect(page.locator('#log-stats')).not.toHaveText('Loading…');
-    return layoutOf(page);
-}
-
-async function openFiles(page) {
-    const details = surfaceOf(page, 'Logs').locator('details');
-    if (!(await details.evaluate(node => node.open))) await details.locator('summary').click();
-    await expect(details.locator(':scope > p.small').first()).not.toHaveText('Loading…');
-    return details;
-}
-
-/** The levels of the viewer's lines, in order. */
-const shownLevels = async page => (await lines(page).textContent()).split('\n').filter(Boolean)
-    .map(line => line.split(/ +/)[1]);
-
-async function ended(request, id) {
-    await expect.poll(async () => (await serverJson(request, `/prompt_manager/jobs/${id}`)).job.state).not.toBe('running');
-    return (await serverJson(request, `/prompt_manager/jobs/${id}`)).job;
-}
-
-/** A second page of this origin that serves a fake ComfyUI window on the send bridge. */
-async function fakeComfyWindow(context, renderer) {
-    const host = await context.newPage();
-    await host.goto(`${workspace}#/overview`);
-    await host.evaluate(async drawn => {
-        const { createBridgeHost } = await import('/prompt_manager/js/shared/toolkit/prompt-bridge.js');
-        window.fakeHost = createBridgeHost({ namespace: '/', origin: location.origin, label: 'PromptManager — ComfyUI',
-            adapter: { listTargets: () => [{ id: '7', label: 'Prompt Manager', type: 'PromptManager', roles: ['positive'],
-                renderer: drawn }], preview() { throw new Error('unused'); }, apply() { throw new Error('unused'); } } });
-    }, renderer);
-    return host;
-}
-
-async function readBlob(download) {
-    const chunks = await (await download.createReadStream()).toArray();
-    return Buffer.concat(chunks).toString('utf8');
-}
-
-// ── Task 4: the Diagnostics surface ─────────────────────────────────────────────────────────────────────────────────
-
-test('meta-grid shows real database and source status, the pinned Viewer.js version and the host renderers',
-    async ({ page, request, context }) => {
-        const mutations = [];
-        page.on('request', item => { if (!['GET', 'HEAD', 'OPTIONS'].includes(item.method())) mutations.push(item.url()); });
-        await openDiagnostics(page);
-        const report = await serverJson(request, REPORT_URL);
-        const surface = surfaceOf(page, 'Diagnostics');
-        await expect(surface.locator(':scope > .panel-heading > h2')).toHaveText('Diagnostics');
-        await expect(surface.locator(':scope > .panel-heading > button')).toHaveText('Run checks');
-        await expect(surface.locator('.meta-grid dt')).toHaveText(['Database', 'Sources', 'Viewer.js', 'Host renderers']);
-        const images = report.checks.database.image_count;
-        await expect(cell(page, 'Database')).toHaveText(new RegExp(`^Readable · [\\d.]+ (bytes|KB|MB|GB) · ${images.toLocaleString('en-US')} images?$`));
-        // The size is the database's real size (`database_size_bytes`), never a missing key read as 0.
-        expect(report.database_info.database_size_bytes).toBeGreaterThan(0);
-        await expect(cell(page, 'Database')).not.toContainText('· 0 bytes ·');
-        const { configured, watching } = report.sources;
-        await expect(cell(page, 'Sources')).toHaveText(configured
-            ? `${configured} source${configured === 1 ? '' : 's'} · ${watching} watching`
-            : `ComfyUI output folder · ${watching ? 'watching' : 'manual scan'}`);
-        await expect(cell(page, 'Viewer.js')).toHaveText('1.15.2 · pinned vendor');
-        await expect(cell(page, 'Host renderers')).toHaveText('No ComfyUI window is open in this browser, so its renderer is not known.');
-        // A ComfyUI window with a Classic node: the line Integrations shows (D106).
-        const host = await fakeComfyWindow(context, 'classic');
-        await openDiagnostics(page);
-        await expect(cell(page, 'Host renderers')).toHaveText('Detected: Classic (1 ComfyUI window).');
-        await host.close();
-        // A refused read names the running job (D57's naming).
-        await page.route(`**${REPORT_URL}`, route => route.fulfill({ status: 409, contentType: 'application/json',
-            body: JSON.stringify({ success: false, code: 'busy', error: 'busy', running: { id: 'a'.repeat(32), title: 'Restore' } }) }));
-        await openDiagnostics(page);
-        await expect(cell(page, 'Database')).toHaveText('Busy: Restore is running.');
-        await page.unroute(`**${REPORT_URL}`);
-        await expect(await request.post('/__test__/system/fail', { data: { path: REPORT_URL, times: 1 } })).toBeOK();
-        await openDiagnostics(page);
-        await expect(cell(page, 'Sources')).toHaveText('Could not be read.');
-        expect(mutations).toEqual([]);
-    });
-
-test('Run checks opens the shared Health report', async ({ page, request }) => {
-    const before = await serverJson(request, '/__test__/system/digest');
-    await openDiagnostics(page);
-    const run = surfaceOf(page, 'Diagnostics').getByRole('button', { name: 'Run checks', exact: true });
-    await run.click();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Health report');
-    await expect(run).toHaveText('Run checks');
-    await dialog(page).getByRole('button', { name: 'Close', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    await expect(run).toBeFocused();
-    // The same report Overview reads: Overview's metric names it.
-    expect((await serverJson(request, '/prompt_manager/system/health')).report).toBeTruthy();
-    expect((await serverJson(request, '/__test__/system/digest')).rows).toEqual(before.rows);
-});
-
-test('report download goes through the api client and holds no secret or absolute path', async ({ page, request }) => {
-    const { revision } = await serverJson(request, '/prompt_manager/settings');
-    await expect(await request.post('/prompt_manager/lora/enable', { data: { enabled: false, trigger_words_enabled: false, path: '',
-        civitai_api_key: KEY, expected_revision: revision } })).toBeOK();
-    await openDiagnostics(page);
-    const reads = [];
-    page.on('request', item => { if (item.url().endsWith(REPORT_URL)) reads.push(item.url()); });
-    const download = page.waitForEvent('download');
-    await surfaceOf(page, 'Diagnostics').getByRole('button', { name: 'Download diagnostic report', exact: true }).click();
-    const file = await download;
-    expect(file.suggestedFilename()).toMatch(/^prompt-manager-diagnostics-\d{8}-\d{4}\.json$/);
-    await expect(toast(page)).toHaveText('Diagnostic report downloaded.');
-    expect(reads).toHaveLength(1);
-    const text = await readBlob(file);
-    const report = JSON.parse(text);
-    expect(report.host_renderers).toBe('No ComfyUI window is open in this browser, so its renderer is not known.');
-    expect(report.config.integrations.has_civitai_api_key).toBe(true);
-    expect(report.redacted).toBe(0);
-    expect(report.viewerjs).toBe('1.15.2');
-    expect(Object.keys(report.checks)).toEqual(['database', 'dependencies', 'comfyui_output', 'image_monitor']);
-    expect(text).not.toContain(KEY);
-    expect(text).not.toContain('pm-browser-');
-    const strings = [];
-    const walk = value => {
-        if (typeof value === 'string') strings.push(value);
-        else if (value && typeof value === 'object') Object.values(value).forEach(walk);
-    };
-    walk(report);
-    expect(strings.filter(value => /^(\/|[A-Za-z]:[\\/]|\\\\)/.test(value))).toEqual([]);
-    // A refused report names the job and saves nothing.
-    await page.route(`**${REPORT_URL}`, route => route.fulfill({ status: 409, contentType: 'application/json',
-        body: JSON.stringify({ success: false, code: 'busy', error: 'busy', running: { id: 'a'.repeat(32), title: 'Restore' } }) }));
-    let saved = false;
-    page.on('download', () => { saved = true; });
-    await surfaceOf(page, 'Diagnostics').getByRole('button', { name: 'Download diagnostic report', exact: true }).click();
-    await expect(toast(page)).toHaveText('Busy: Restore is running. Try again when it ends.');
-    await page.unroute(`**${REPORT_URL}`);
-    await page.route(`**${REPORT_URL}`, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'The diagnostic report could not be built.' }) }));
-    await surfaceOf(page, 'Diagnostics').getByRole('button', { name: 'Download diagnostic report', exact: true }).click();
-    await expect(toast(page)).toHaveText('The diagnostic report could not be downloaded. Nothing was saved to this device.');
-    expect(saved).toBe(false);
-});
-
-test('Inspect opens the Inspect a file page and writes nothing', async ({ page, request }) => {
-    const before = await serverJson(request, '/__test__/system/digest');
-    const mutations = [];
-    page.on('request', item => { if (!['GET', 'HEAD', 'OPTIONS'].includes(item.method())) mutations.push(item.url()); });
-    await openDiagnostics(page);
-    const row = operation(page, 'Image-link diagnostics');
-    await expect(row.locator('p')).toHaveText('Check a file-to-prompt association without changing it.');
-    await row.getByRole('button', { name: 'Inspect', exact: true }).click();
-    await expect(page).toHaveURL(`${workspace}#/inspect`);
-    await expect(page.locator('#workspace-main h1')).toHaveText('Inspect a file');
-    expect(mutations).toEqual([]);
-    expect(await serverJson(request, '/__test__/system/digest')).toEqual(before);
-});
-
-test('Create test link confirms first and names the prompt', async ({ page, request }) => {
-    const [prompt] = (await serverJson(request, '/prompt_manager/recent?limit=1')).results;
-    const posts = [];
-    page.on('request', item => { if (item.url().endsWith(TEST_LINK_URL)) posts.push(item.postDataJSON()); });
-    await openDiagnostics(page);
-    const row = operation(page, 'Test image link');
-    await expect(row.locator('p')).toHaveText('Write a placeholder image record to check that linking works.');
-    const create = row.getByRole('button', { name: 'Create test link…', exact: true });
-    await expect(create).not.toHaveAttribute('aria-disabled', 'true');
-    await create.click();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Create test link');
-    await expect(dialog(page).locator('#modal-body > p')).toHaveText(new RegExp('^Writes a placeholder image record '
-        + `\\(prompt_manager_test_link\\.png\\) linked to prompt #${prompt.id} “.+”\\. Maintenance › Missing-file links removes it later\\.$`));
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    expect(posts).toEqual([]);
-    await create.click();
-    await dialog(page).getByRole('button', { name: 'Create', exact: true }).click();
-    await expect(toast(page)).toHaveText(/^Test link created \(image record \d+\)\.$/);
-    expect(posts).toEqual([{ prompt_id: prompt.id }]);
-    // A failed write says nothing was changed.
-    await page.route(`**${TEST_LINK_URL}`, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'Test link failed' }) }));
-    await create.click();
-    await dialog(page).getByRole('button', { name: 'Create', exact: true }).click();
-    await expect(toast(page)).toHaveText('The test link could not be created. Nothing was changed.');
-    // With no prompt to link, the button is unavailable and says why.
-    await page.route('**/prompt_manager/recent?limit=1', route => route.fulfill({ status: 200, contentType: 'application/json',
-        body: JSON.stringify({ success: true, results: [] }) }));
-    await openDiagnostics(page);
-    await expect(operation(page, 'Test image link').locator('p'))
-        .toHaveText('Write a placeholder image record to check that linking works. Add a prompt first.');
-    await expect(operation(page, 'Test image link').getByRole('button')).toHaveAttribute('aria-disabled', 'true');
-});
-
-// ── Task 5: the log viewer, statistics and runtime settings ─────────────────────────────────────────────────────────
-
-test('level filter is minimum-level over all six choices', async ({ page, request }) => {
-    await seedLogs(request);
-    const urls = [];
-    page.on('request', item => { if (new URL(item.url()).pathname === LOGS_URL) urls.push(new URL(item.url()).search); });
-    await openDiagnostics(page);
-    const level = page.locator('#log-level');
-    await expect(level.locator('option')).toHaveText(['All levels', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']);
-    await expect(page.locator('label[for="log-level"]')).toHaveText('Level');
-    // All levels: the concept's four lines first, newest first, in its format.
-    await expect(lines(page)).toContainText('09:42:18 INFO  Scan completed: 12 enriched, 0 duplicate links\n'
-        + '09:42:18 WARNING 3 images have ambiguous prompt metadata\n09:39:04 INFO  Database backup verified\n'
-        + '09:38:52 INFO  Source monitor started: output');
-    for (const line of (await lines(page).textContent()).split('\n')) expect(line).toMatch(/^\d\d:\d\d:\d\d [A-Z]+ +\S/);
-    expect(urls.at(-1)).toBe('?limit=100');
-    for (const minimum of LEVELS) {
-        await level.selectOption(minimum);
-        await expect.poll(() => urls.at(-1)).toBe(`?limit=100&level=${minimum}`);
-        await expect(lines(page)).toContainText('CRITICAL The database could not be opened');
-        const shown = await shownLevels(page);
-        expect(shown.every(name => LEVELS.indexOf(name) >= LEVELS.indexOf(minimum)), `${minimum}: ${shown}`).toBe(true);
-        if (minimum === 'DEBUG') await expect(lines(page)).toContainText('DEBUG Thumbnail cache lookup');
-        if (minimum === 'WARNING') {
-            await expect(lines(page)).not.toContainText('Database backup verified');
-            await expect(lines(page)).toContainText('ERROR A source folder could not be read');
-        }
-    }
-    await level.selectOption('');
-    await expect.poll(() => urls.at(-1)).toBe('?limit=100');
-});
-
-test('Lines accepts 1 to 500 and sends nothing when invalid', async ({ page, request }) => {
-    await seedLogs(request, { filler: 30 });
-    const urls = [];
-    page.on('request', item => { if (new URL(item.url()).pathname === LOGS_URL) urls.push(new URL(item.url()).search); });
-    await openDiagnostics(page);
-    const limit = page.locator('#log-limit');
-    await expect(page.locator('label[for="log-limit"]')).toHaveText('Lines');
-    await expect(limit).toHaveValue('100');
-    expect(await limit.evaluate(node => [node.type, node.min, node.max, node.title]))
-        .toEqual(['number', '1', '500', 'Lines to show: a whole number from 1 to 500.']);
-    await limit.fill('20');
-    await limit.dispatchEvent('change');
-    await expect.poll(() => urls.at(-1)).toBe('?limit=20');
-    await expect.poll(async () => (await lines(page).textContent()).split('\n').length).toBe(20);
-    const sent = urls.length;
-    for (const value of ['0', '501', '2.5', '']) {
-        await limit.fill(value);
-        await limit.dispatchEvent('change');
-        await expect(limit).toHaveAttribute('aria-invalid', 'true');
-    }
-    // A Level change while Lines is invalid sends nothing either.
-    await page.locator('#log-level').selectOption('WARNING');
-    await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
-    expect(urls.length).toBe(sent);
-    await limit.fill('500');
-    await limit.dispatchEvent('change');
-    await expect(limit).not.toHaveAttribute('aria-invalid');
-    await expect.poll(() => urls.at(-1)).toBe('?limit=500&level=WARNING');
-});
-
-test('logs refresh handles empty, error and stale answers', async ({ page, request }) => {
-    await seedLogs(request);
-    await openDiagnostics(page);
-    const level = page.locator('#log-level');
-    const refresh = surfaceOf(page, 'Logs').getByRole('button', { name: 'Refresh', exact: true });
-    // Empty: nothing at this level once the buffer is cleared.
-    await expect(await request.post('/__test__/logs/reset')).toBeOK();
-    await level.selectOption('CRITICAL');
-    await expect(lines(page)).toHaveText('No log entries at this level.');
-    // Error.
-    await page.route(`**${LOGS_URL}?*`, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'boom', logs: [] }) }));
-    await refresh.click();
-    await expect(lines(page)).toHaveText('The log could not be read.');
-    await page.unroute(`**${LOGS_URL}?*`);
-    // Stale: an older answer that arrives after a newer request never paints.
-    await seedLogs(request);
-    await expect(await request.post('/__test__/hold', { data: { path: LOGS_URL } })).toBeOK();
-    await level.selectOption('DEBUG');
-    await expect.poll(async () => (await serverJson(request, '/__test__/hold')).held[LOGS_URL] ?? 0).toBe(1);
-    await level.selectOption('ERROR');
-    await expect.poll(async () => (await serverJson(request, '/__test__/hold')).held[LOGS_URL] ?? 0).toBe(2);
-    await expect(await request.post('/__test__/release')).toBeOK();
-    await expect(lines(page)).toContainText('CRITICAL The database could not be opened');
-    await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
-    expect((await shownLevels(page)).every(name => ['ERROR', 'CRITICAL'].includes(name))).toBe(true);
-});
-
-test('log statistics show entries, errors, warnings, files and size', async ({ page, request }) => {
-    await seedLogs(request, { rotated: [2048, 1024], other: true, link: true, active: 512 });
-    await openDiagnostics(page);
-    const stats = page.getByRole('status', { name: 'Log statistics', exact: true });
-    await expect(stats).toHaveAttribute('id', 'log-stats');
-    const text = await stats.textContent();
-    const match = /^([\d,]+) entr(?:y|ies) in memory · (\d+) errors? · (\d+) warnings? · (\d+) files? · (.+) on disk$/.exec(text);
-    expect(match, text).not.toBeNull();
-    const [, entries, errors, warnings, files, size] = match;
-    expect(Number(entries.replace(/,/g, ''))).toBeGreaterThanOrEqual(7);
-    expect(Number(errors)).toBeGreaterThanOrEqual(2);
-    expect(Number(warnings)).toBeGreaterThanOrEqual(1);
-    // The active log, two rotated copies and the .bak; the link is not counted (Rule R).
-    expect(Number(files)).toBe(4);
-    expect(size).toMatch(/^[\d.]+ (bytes|KB|MB)$/);
-});
-
-test('Download log saves the active log', async ({ page, request }) => {
-    await seedLogs(request, { active: 300 });
-    await openDiagnostics(page);
-    const download = page.waitForEvent('download');
-    await surfaceOf(page, 'Logs').getByRole('button', { name: 'Download log', exact: true }).click();
-    const file = await download;
-    expect(file.suggestedFilename()).toBe('prompt_manager.log');
-    expect((await readBlob(file)).length).toBeGreaterThanOrEqual(300);
-    await page.route('**/prompt_manager/logs/download/**', route => route.fulfill({ status: 404, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'Log file not found' }) }));
-    await surfaceOf(page, 'Logs').getByRole('button', { name: 'Download log', exact: true }).click();
-    await expect(toast(page)).toHaveText('The log could not be downloaded.');
-});
-
-test('runtime level (including CRITICAL) and console logging save and say they apply until the server restarts',
-    async ({ page, request }) => {
-        const posts = [];
-        page.on('request', item => { if (item.method() === 'POST' && item.url().endsWith(CONFIG_URL)) posts.push(item.postDataJSON()); });
-        await openDiagnostics(page);
-        const level = settingOf(page, 'Runtime log level');
-        await expect(level.locator('p')).toHaveText('How much the server writes to the log. Applied until the server restarts.');
-        await expect(level.locator('option')).toHaveText(['INFO', 'WARNING', 'DEBUG', 'ERROR', 'CRITICAL']);
-        await expect(level.locator('select')).toHaveValue('INFO');
-        const consoleRow = settingOf(page, 'Console logging');
-        await expect(consoleRow.locator('p')).toHaveText('Print Prompt Manager’s warnings and errors in the ComfyUI console '
-            + '(everything at DEBUG). Applied until the server restarts.');
-        const toggle = consoleRow.locator('input[type="checkbox"]');
-        await expect(toggle).toBeChecked();
-        await level.locator('select').selectOption('CRITICAL');
-        await toggle.uncheck();
-        await expect(status(page)).toHaveText('Unsaved changes.');
-        await save(page).click();
-        await expect(status(page)).toHaveText('Applied until the server restarts.');
-        expect(posts).toEqual([{ level: 'CRITICAL', console_logging: false }]);
-        const { config } = await serverJson(request, CONFIG_URL);
-        expect([config.level, config.console_logging]).toEqual(['CRITICAL', false]);
-        // Read again on a fresh page: the server's values.
-        await openDiagnostics(page);
-        await expect(settingOf(page, 'Runtime log level').locator('select')).toHaveValue('CRITICAL');
-        await expect(settingOf(page, 'Console logging').locator('input[type="checkbox"]')).not.toBeChecked();
-        // Only the changed key is sent.
-        await settingOf(page, 'Runtime log level').locator('select').selectOption('DEBUG');
-        await save(page).click();
-        await expect(status(page)).toHaveText('Applied until the server restarts.');
-        expect(posts.at(-1)).toEqual({ level: 'DEBUG' });
-    });
-
-test('a refused runtime value is marked invalid', async ({ page }) => {
-    await page.route(`**${CONFIG_URL}`, route => (route.request().method() === 'POST'
-        ? route.fulfill({ status: 400, contentType: 'application/json', body: JSON.stringify({ success: false, error: 'Invalid log level' }) })
-        : route.continue()));
-    await openDiagnostics(page);
-    const select = settingOf(page, 'Runtime log level').locator('select');
-    await select.selectOption('WARNING');
-    await save(page).click();
-    await expect(status(page)).toHaveText('Some changes were not saved. Review the highlighted settings.');
-    await expect(select).toHaveAttribute('aria-invalid', 'true');
-    await expect(settingOf(page, 'Console logging').locator('input[type="checkbox"]')).not.toHaveAttribute('aria-invalid');
-    // The draft stays: an edit clears the mark.
-    await expect(select).toHaveValue('WARNING');
-    await select.selectOption('ERROR');
-    await expect(select).not.toHaveAttribute('aria-invalid');
-});
-
-test('runtime values that cannot be read stay disabled and say so', async ({ page }) => {
-    await page.route(`**${CONFIG_URL}`, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'boom' }) }));
-    await openDiagnostics(page);
-    for (const label of ['Runtime log level', 'Console logging']) {
-        const row = settingOf(page, label);
-        await expect(row.locator('p.small')).toHaveText('The current value could not be read.');
-        await expect(row.locator('select, input[type="checkbox"]')).toBeDisabled();
-    }
-});
-
-// ── Task 6: log files, the reviewed cleanup and Clear all logs ─────────────────────────────────────────────────────
-
-const LOG_FOLDER = { rotated: [3000, 2048, 1024], other: true, link: true, active: 100 };
-const LINKS = process.platform === 'win32' ? 0 : 1;
-
-test('Review log cleanup lists only rotated copies and keeps the rest', async ({ page, request }) => {
-    await seedLogs(request, LOG_FOLDER);
-    const before = await names(request);
-    const previews = [];
-    page.on('request', item => { if (item.url().endsWith(PREVIEW_URL)) previews.push(item.postDataJSON()); });
-    await openDiagnostics(page);
-    const details = await openFiles(page);
-    await expect(details.locator(':scope > p.small').first()).toHaveText(/^prompt_manager\.log · [\d.]+ (bytes|KB) · rotated copies: 3$/);
-    await details.getByRole('button', { name: 'Review log cleanup', exact: true }).click();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Review maintenance plan');
-    await expect(dialog(page).locator('#modal-body > h3')).toHaveText('Rotated log copies');
-    expect(previews).toEqual([{ operation: 'rotated_logs', options: {} }]);
-    const grid = await dialog(page).locator('dl.meta-grid > div').evaluateAll(items => items.map(item =>
-        [item.querySelector('dt').textContent, item.querySelector('dd').textContent]));
-    expect(grid.map(([term]) => term)).toEqual(['Scope', 'Protected', 'Backup', 'Media on disk']);
-    expect(grid[0][1]).toMatch(/^3 rotated log copies · 5\.9 KB$/);
-    expect(grid[1][1]).toBe(['Kept: the active log', ...(LINKS ? ['Kept: 1 link'] : []), 'Kept: 1 other file'].join(' · '));
-    expect(grid[2][1]).toBe('Not needed: no library record changes');
-    expect(grid[3][1]).toBe('Deletes only the listed log files. No image, video or library record changes.');
-    await expect(dialog(page).locator('details > summary')).toHaveText('Listed files (3)');
-    await expect(dialog(page).locator('details pre')).toHaveText(/^prompt_manager\.log\.1 · 2\.9 KB · .+\nprompt_manager\.log\.2 · 2\.0 KB · .+\nprompt_manager\.log\.3 · 1\.0 KB · .+$/);
-    // No D55 backup box: nothing in the library changes.
-    await expect(dialog(page).locator('.notice')).toHaveCount(0);
-    await expect(dialog(page).getByRole('button', { name: 'Back up now' })).toHaveCount(0);
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    expect(await names(request)).toEqual(before);
-});
-
-test('Apply deletes exactly the listed files and Activity lists them', async ({ page, request }) => {
-    await seedLogs(request, LOG_FOLDER);
-    await openDiagnostics(page);
-    const details = await openFiles(page);
-    await details.getByRole('button', { name: 'Review log cleanup', exact: true }).click();
-    await dialog(page).getByRole('button', { name: 'Apply reviewed operation', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    await expect(page).toHaveURL(/#\/activity\/[0-9a-f]{32}$/);
-    const job = await ended(request, page.url().split('/').pop());
-    expect([job.kind, job.state, job.title, job.counters.changed]).toEqual(['maintenance', 'finished', 'Rotated log copies', 3]);
-    await expect(toast(page)).toHaveText(/Rotated log copies (started|finished · 3 changed)/);
-    const main = page.locator('#workspace-main');
-    await expect(main.locator('h1')).toHaveText('Rotated log copies');
-    for (const name of ['prompt_manager.log.1', 'prompt_manager.log.2', 'prompt_manager.log.3']) await expect(main).toContainText(name);
-    // Only those three are gone: the active log, the user's .bak and the link are kept.
-    expect(await names(request)).toEqual(['prompt_manager.log', ...(LINKS ? ['prompt_manager.log.4'] : []), 'prompt_manager.log.bak']);
-});
-
-test('a rollover after the review deletes nothing and Activity offers Review again', async ({ page, request }) => {
-    await seedLogs(request, LOG_FOLDER);
-    await openDiagnostics(page);
-    const details = await openFiles(page);
-    await details.getByRole('button', { name: 'Review log cleanup', exact: true }).click();
-    await expect(dialog(page).locator('#modal-body > h3')).toHaveText('Rotated log copies');
-    await expect(await request.post('/__test__/logs/rotate')).toBeOK();
-    const rolled = await serverJson(request, '/__test__/logs/state');
-    await dialog(page).getByRole('button', { name: 'Apply reviewed operation', exact: true }).click();
-    await expect(page).toHaveURL(/#\/activity\/[0-9a-f]{32}$/);
-    const job = await ended(request, page.url().split('/').pop());
-    expect([job.state, job.scope.failure]).toEqual(['failed', 'plan-changed']);
-    await expect(page.locator('#workspace-main')).toContainText(CHANGED);
-    expect((await serverJson(request, '/__test__/logs/state')).entries.map(entry => entry.name))
-        .toEqual(rolled.entries.map(entry => entry.name));
-    const previews = [];
-    page.on('request', item => { if (item.url().endsWith(PREVIEW_URL)) previews.push(item.postDataJSON()); });
-    await page.locator('#workspace-main').getByRole('button', { name: 'Review again', exact: true }).click();
-    await expect(dialog(page).locator('#modal-body > h3')).toHaveText('Rotated log copies');
-    expect(previews).toEqual([{ operation: 'rotated_logs', options: {} }]);
-});
-
-test('Clear all logs states both counts, confirms first and reads everything again', async ({ page, request }) => {
-    await seedLogs(request, LOG_FOLDER);
-    const truncates = [];
-    page.on('request', item => { if (item.url().endsWith('/prompt_manager/logs/truncate')) truncates.push(item.postDataJSON()); });
-    await openDiagnostics(page);
-    await expect(lines(page)).toContainText('Database backup verified');
-    const details = await openFiles(page);
-    const clearRow = operation(page, 'Clear all logs');
-    await expect(clearRow.locator('p')).toHaveText('Empty the active log and delete its rotated copies.');
-    const clear = clearRow.getByRole('button', { name: 'Clear all logs…', exact: true });
-    await expect(clear).toHaveClass(/\bdanger\b/);
-    await clear.click();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Clear all logs');
-    await expect(dialog(page).locator('#modal-body > p')).toHaveText('Empties prompt_manager.log, deletes 3 rotated copies (5.9 KB) '
-        + 'and clears the lines shown here. The other files in the log folder are kept. This cannot be undone.');
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    expect(truncates).toEqual([]);
-    await clear.click();
-    await dialog(page).getByRole('button', { name: 'Clear', exact: true }).click();
-    await expect(toast(page)).toHaveText('Logs cleared · 3 rotated copies deleted.');
-    expect(truncates).toHaveLength(1);
-    // #389: Clear sends back exactly the files the dialog was built from, each with its identity string.
-    expect(truncates[0].expected.map(row => row.name).sort()).toEqual(['prompt_manager.log', 'prompt_manager.log.1',
-        'prompt_manager.log.2', 'prompt_manager.log.3']);
-    for (const row of truncates[0].expected) expect(row.identity).toMatch(/^\d+:\d+:\d+$/);
-    // Read again: the viewer, the file line and the list.
-    await expect(lines(page)).not.toContainText('Database backup verified');
-    await expect(details.locator(':scope > p.small').first()).toHaveText(/rotated copies: 0$/);
-    const kept = ['prompt_manager.log', 'prompt_manager.log.bak', ...(LINKS ? ['prompt_manager.log.4'] : [])];
-    // The server lists newest first: compare as a set.
-    await expect.poll(async () => (await details.locator('.operation-list h3').allTextContents()).sort()).toEqual([...kept].sort());
-    expect(await names(request)).toEqual(['prompt_manager.log', ...(LINKS ? ['prompt_manager.log.4'] : []), 'prompt_manager.log.bak']);
-});
-
-test('Clear all logs reads the files again before it states what it deletes', async ({ page, request }) => {
-    await seedLogs(request, { rotated: [1024], active: 100 });
-    await openDiagnostics(page);
-    const details = await openFiles(page);
-    await expect(details.locator(':scope > p.small').first()).toHaveText(/rotated copies: 1$/);
-    // The log rolls over while the page stays open: Clear names what it deletes now, not the count shown.
-    await seedLogs(request, { records: false, rotated: [1024, 1024, 1024] });
-    await operation(page, 'Clear all logs').getByRole('button', { name: 'Clear all logs…', exact: true }).click();
-    await expect(dialog(page).locator('#modal-body > p')).toHaveText(/^Empties prompt_manager\.log, deletes 3 rotated copies \(3\.0 KB\) /);
-    await expect(details.locator(':scope > p.small').first()).toHaveText(/rotated copies: 3$/);
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    // A list that cannot be read gives the general sentence, never an old count.
-    await page.route('**/prompt_manager/logs/files', route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: JSON.stringify({ success: false, error: 'boom', files: [] }) }));
-    await operation(page, 'Clear all logs').getByRole('button', { name: 'Clear all logs…', exact: true }).click();
-    await expect(dialog(page).locator('#modal-body > p')).toHaveText(/^Empties prompt_manager\.log, deletes its rotated copies and clears/);
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    expect(await names(request)).toEqual(['prompt_manager.log', 'prompt_manager.log.1', 'prompt_manager.log.2', 'prompt_manager.log.3']);
-});
-
-test('a rollover while Clear all logs is open deletes nothing and says why (#389)', async ({ page, request }) => {
-    await seedLogs(request, { rotated: [1024, 1024], active: 100 });
-    await openDiagnostics(page);
-    await openFiles(page);
-    await operation(page, 'Clear all logs').getByRole('button', { name: 'Clear all logs…', exact: true }).click();
-    await expect(dialog(page).locator('#modal-body > p')).toHaveText(/^Empties prompt_manager\.log, deletes 2 rotated copies /);
-    // The log rolls over after the confirmation was built: the copies it listed are not the ones there now.
-    await expect(await request.post('/__test__/logs/rotate')).toBeOK();
-    const rolled = await names(request);
-    const answer = page.waitForResponse(response => response.url().endsWith('/prompt_manager/logs/truncate'));
-    await dialog(page).getByRole('button', { name: 'Clear', exact: true }).click();
-    expect((await answer).status()).toBe(409);
-    await expect(toast(page)).toHaveText('The log files changed since you confirmed; nothing was cleared. '
-        + 'Read the list again and clear again.');
-    expect(await names(request)).toEqual(rolled);
-});
-
-test('each listed file downloads by its returned name and a link has no Download', async ({ page, request }) => {
-    await seedLogs(request, LOG_FOLDER);
-    await openDiagnostics(page);
-    const details = await openFiles(page);
-    await expect(details.locator(':scope > p.small').nth(1))
-        .toHaveText('Rotates at 10 MB · keeps 5 rotated copies · file logging on · memory buffer 1,000 entries');
-    const list = details.locator('.operation-list');
-    expect((await list.locator('h3').allTextContents()).sort()).toEqual(['prompt_manager.log', 'prompt_manager.log.1',
-        'prompt_manager.log.2', 'prompt_manager.log.3', ...(LINKS ? ['prompt_manager.log.4'] : []), 'prompt_manager.log.bak'].sort());
-    const item = name => list.locator('.operation').filter({ has: page.locator(`h3:text-is("${name}")`) });
-    await expect(item('prompt_manager.log.1').locator('p')).toHaveText(/^2\.9 KB · \d{4}-\d\d-\d\d \d\d:\d\d · Rotated copy$/);
-    await expect(item('prompt_manager.log.bak').locator('p')).toHaveText(/^0 bytes · .+ · Other file$/);
-    if (LINKS) {
-        await expect(item('prompt_manager.log.4').locator('p')).toHaveText(/ · Link, not downloaded$/);
-        await expect(item('prompt_manager.log.4').getByRole('button')).toHaveCount(0);
-    }
-    for (const name of ['prompt_manager.log.1', 'prompt_manager.log.bak']) {
-        const download = page.waitForEvent('download');
-        await item(name).getByRole('button', { name: `Download ${name}`, exact: true }).click();
-        const file = await download;
-        expect(file.suggestedFilename()).toBe(name);
-        if (name === 'prompt_manager.log.1') expect((await readBlob(file)).length).toBe(3000);
-    }
-});
@@ -315,28 +315,22 @@ test('Preview tagging review without a selection toasts the D115 sentence', asyn
    await expect(tagDialog(page)).toHaveCount(0);
 });

-test('Tag output images reviews the images, tags each one and never a prompt (#379)', async ({ page, request }) => {
+test('Tag output images reviews the scope and starts a batch job', async ({ page, request }) => {
    const before = await serverJson(request, '/__test__/tagging/snapshot');
    await openTagging(page);
-    // The saved policy is Skip: no image is auto-tagged yet, so every listed still image is to tag.
+    // The fixture's one prompt is already tagged: under Merge it is tagged again with what its images give.
+    await page.locator('#tag-existing').selectOption('merge');
    const previewed = page.waitForResponse(item => new URL(item.url()).pathname === PREVIEW_URL);
    await reviewButton(page).click();
    const answer = await previewed;
-    expect(answer.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'skip' });
+    expect(answer.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'merge' });
    const plan = await answer.json();
-    // Four still images (two linked, a copy, an unlinked one); the video is not a target.
-    expect([plan.images, plan.already_tagged, plan.to_tag]).toEqual([4, 0, 4]);
-    expect(plan.prompts).toBeUndefined();
    await expect(dialog(page).locator('#modal-title')).toHaveText('Review tag output images');
    await expect(dialog(page).locator('#modal-body > h3')).toHaveText('Tag output images');
-    expect(await gridOf(page)).toEqual([['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Skip already tagged'],
-        ['Images', '4'], ['Already auto-tagged', '0'], ['Images to tag', 'about 4'],
-        ['Time', 'about 1 min on a processor; a graphics card can be faster.'],
-        ['Settings', `General 0.35 · Character 0.85 · up to ${plan.suggestion_limit} tags per image`],
+    expect(await gridOf(page)).toEqual([['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Merge with existing'],
+        ['Images linked', String(plan.images)], ['Prompts', String(plan.prompts)], ['Already tagged', String(plan.already_tagged)],
+        ['Prompts to tag', `up to ${plan.to_tag}`], ['Settings', 'General 0.35 · Character 0.85'],
        ['Backup', 'Create and verify before changes']]);
-    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Nothing is written until you start. The number to '
-        + 'tag is an estimate: images changed since they were tagged are tagged again, and missing files are skipped. '
-        + 'Activity reports what was tagged.');
    await expect(dialog(page).locator('#modal-body > .notice h3')).toHaveText('Back up the database first (recommended)');
    // The review wrote nothing.
    expect(await serverJson(request, '/__test__/tagging/snapshot')).toEqual(before);
@@ -344,23 +338,15 @@ test('Tag output images reviews the images, tags each one and never a prompt (#3
    const started = page.waitForResponse(item => new URL(item.url()).pathname === '/prompt_manager/jobs/autotag');
    await dialog(page).getByRole('button', { name: 'Start tagging', exact: true }).click();
    const start = await started;
-    expect(start.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'skip',
+    expect(start.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'merge',
        options: { general_threshold: 0.35, character_threshold: 0.85 } });
    const { job } = await start.json();
    await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
    await expect(page.locator('#workspace-main h1')).toHaveText('Tag output images');
    const finished = await ended(request, job.id);
    expect(finished.state).toBe('finished');
-    expect(finished.status_line).toBe('Tagged 4 images');
-    // Each image got its own tags; no prompt, pair or link row changed.
-    expect(await serverJson(request, '/__test__/tagging/snapshot')).toEqual(before);
-
-    // Under Skip every image is now auto-tagged: nothing to start.
-    await openTagging(page);
-    await reviewButton(page).click();
-    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Every output image is already auto-tagged.');
-    expect((await gridOf(page)).slice(2, 5)).toEqual([['Images', '4'], ['Already auto-tagged', '4'], ['Images to tag', 'about 0']]);
-    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel']);
+    const after = await serverJson(request, '/__test__/tagging/snapshot');
+    expect(after.prompt_tags.length).toBeGreaterThan(before.prompt_tags.length);
 });

 test('Replace after review shows only Cancel with the reason', async ({ page, request }) => {
@@ -369,13 +355,18 @@ test('Replace after review shows only Cancel with the reason', async ({ page, re
    await page.locator('#tag-existing').selectOption('replace_after_review');
    await reviewButton(page).click();
    await expect(dialog(page).locator('#modal-title')).toHaveText('Review tag output images');
-    expect((await gridOf(page)).map(([term]) => term)).toEqual(['Model', 'Existing tags', 'Images', 'Already auto-tagged',
-        'Images to tag', 'Time', 'Settings', 'Backup']);
+    expect((await gridOf(page)).map(([term]) => term)).toEqual(['Model', 'Existing tags', 'Images linked', 'Prompts', 'Already tagged',
+        'Prompts to tag', 'Settings', 'Backup']);
    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Replacing tags needs a review of each image. '
        + 'Use Preview tagging review, or choose Skip or Merge for a batch run.');
    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel']);
    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
    await expect(dialog(page)).toHaveCount(0);
+    // Under Skip the fixture's only prompt is already tagged: nothing to start either.
+    await page.locator('#tag-existing').selectOption('skip');
+    await reviewButton(page).click();
+    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Every prompt with an output image is already tagged.');
+    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel']);
    expect(await serverJson(request, '/__test__/tagging/snapshot')).toEqual(before);
    expect((await serverJson(request, '/prompt_manager/jobs')).jobs.filter(item => item.kind === 'autotag')).toEqual([]);
 });
@@ -1,7 +1,6 @@
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';
 import { seedConcept } from './concept-inventory.mjs';
-import { readCoverageTable, parseControl, CONTROL_EXEMPTIONS } from '../../tools/vendor/legacy-coverage.mjs';

 // System › Overview (#249 System S2 Task 6) on the concept-shaped real fixture: the metrics, rows, Statistics dialog and
 // Health report read the server, never sample values (D93, D95, D96). The hooks are workspace_system_fixture.py's.
@@ -413,16 +412,15 @@ test('out-of-order overview responses never repaint a newer section', async ({ p
    await nav.getByRole('button', { name: 'Appearance', exact: true }).click();
    await nav.getByRole('button', { name: 'Overview', exact: true }).click();
    await expect.poll(held).toBe(2);
-    // Diagnostics & logs is native (S12): its body is its two surfaces.
+    // Diagnostics still hands off (S12), so its body is one known panel.
    await nav.getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
-    await expect(layout.locator(':scope > section.surface')).toHaveCount(2);
    await expect(await request.post('/__test__/release')).toBeOK();
    await expect.poll(held).toBe(0);
    // Both late answers reached a section that had left: Diagnostics keeps its own body.
+    await expect(layout.locator(':scope > section.handoff')).toBeVisible();
    await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
    await expect(layout.locator('.summary-metrics')).toHaveCount(0);
-    expect(await layout.evaluate(node => [...node.children].map(child => `${child.localName}.${child.className}`)))
-        .toEqual(['section.surface', 'section.surface', 'div.save-row']);
+    expect(await layout.evaluate(node => [...node.children].map(child => child.className))).toEqual(['surface handoff', 'save-row']);
    // Back on Overview, one fresh read paints one set of metrics.
    await nav.getByRole('button', { name: 'Overview', exact: true }).click();
    await expect(layout.locator('.summary-metrics')).toHaveCount(1);
@@ -795,45 +793,3 @@ test('reset restores defaults without touching other keys', async ({ page }) =>
    expect(stored).toEqual({ gridColumns: 5, defaultLimit: 200, thumbnailPromptDismissed: 'kept', workspaceLayout: 'grid',
        videoMute: true, showImageInfo: true });
 });
-
-// TESTING.md "Legacy System capability coverage" (#249 System S12, #329): each `covered` row's native control is on its
-// System section, found by role and accessible name (a `term` by its text, a disclosure by its summary). Collapsed
-// `details` are opened first, so a control inside one counts once it is shown. tests/vendor/legacy-coverage.test.mjs
-// checks the rest of each row.
-test('every covered legacy System capability has its native control', async ({ page, request }) => {
-    // Download is offered for a model that is not on disk ("Download again" otherwise): the selected default's file is
-    // missing here.
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-swinv2'] } })).toBeOK();
-    try {
-        await findControls(page);
-    } finally {
-        await request.post('/__test__/tagging/reset', { data: {} });
-    }
-});
-
-async function findControls(page) {
-    const covered = readCoverageTable().filter(row => row.Status === 'covered')
-        .map(row => ({ capability: row.Capability, ...parseControl(row['Native control']) }));
-    // A covered row without a control is one of the recorded exemptions, never silently skipped.
-    expect(covered.filter(row => !row.section).map(row => row.capability)).toEqual(Object.keys(CONTROL_EXEMPTIONS));
-    const controls = covered.filter(row => row.section);
-    expect(controls.length).toBeGreaterThan(40);
-    const sections = [...new Set(controls.map(row => row.section))];
-    for (const section of sections) {
-        await page.goto(`${workspace}#/system/${section}`);
-        const main = page.locator('#workspace-main');
-        await expect(layoutOf(page).locator(':scope > *').first()).toBeVisible();
-        for (const details of await main.locator('details:not([open]) > summary').all()) await details.click();
-        for (const { capability, role, name, row } of controls.filter(item => item.section === section)) {
-            // A name several rows share is looked up inside the row the table names.
-            const within = row ? main.locator('.operation').filter({ has: page.locator(`h3:text-is("${row}")`) }) : main;
-            const exact = new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
-            // A `dt` (term) and a `details` disclosure (group) have no name from content: the term's text, the summary's.
-            const control = role === 'term' ? within.getByRole('term').filter({ hasText: exact })
-                : role === 'group' ? within.locator('details').filter({ has: page.locator(':scope > summary', { hasText: exact }) })
-                    .or(within.getByRole('group', { name, exact: true }))
-                    : within.getByRole(role, { name, exact: true });
-            await expect(control.first(), `${capability}: ${section} · ${role} · "${name}"${row ? ` in "${row}"` : ''}`).toBeVisible();
-        }
-    }
-}
@@ -513,41 +513,6 @@ test('search finds an image by its image tag', async ({ page, request }) => {
    await expect(card(page, UNLINKED)).toBeVisible();
 });

-// #379 CUJ 8: the Tags filter finds images by their own image tags through the tag index; no prompt carries them, and
-// selecting a match shows its prompt. A linked prompt's tag still combines with the image tags.
-test('the Tags filter finds images by image tags only, and selecting one shows its prompt (#379)', async ({ page, request }) => {
-    await saveImageTags(request, FIRST, ['beach', '1girl', 'waves']);
-    await saveImageTags(request, SECOND, ['beach', 'waves']);
-    await saveImageTags(request, UNLINKED, ['beach', '1girl', 'waves', 'gulls']);
-    await page.goto(images);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(manifest.files.length);
-    const filters = page.locator('#workspace-main search.toolbar').getByRole('button', { name: /^Filters(?: · \d+)?$/ });
-    const refine = page.getByRole('dialog', { name: 'Refine this view', exact: true });
-    const applyTags = async value => {
-        await filters.click();
-        await refine.getByLabel('Tags', { exact: true }).fill(value);
-        const listing = page.waitForRequest(item => item.url().includes('/images/output?')
-            && new URL(item.url()).searchParams.get('tags') !== null);
-        await refine.getByRole('button', { name: 'Apply filters', exact: true }).click();
-        await listing;
-    };
-    await applyTags('beach, 1girl, waves');
-    // Every listed image whose image tags hold all three; SECOND lacks 1girl.
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, UNLINKED)).toBeVisible();
-    await expect(card(page, SECOND)).toHaveCount(0);
-    // The newest match is selected; the inspector shows its linked prompt.
-    await infoButton(page, FIRST).click();
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
-    // The linked positive's own tag combines: SECOND has beach and waves itself and minimal through its prompt.
-    await applyTags(`beach, waves, ${manifest.prompt_tags[0]}`);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, SECOND)).toBeVisible();
-});
-
 // Task C4 rulings: a save re-reads the selected file's details without a loading flash, and under a Tags filter or a
 // search the loaded listing is re-read in place (scroll and selection kept while the file still matches).
 const cards = page => page.locator('.gallery-body article[data-image-key]');
@@ -1,7 +1,6 @@
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
 import {pageInventoryOf,inventoryOf,diffInventory,mapVocabularyConcept,mapVocabularyDialog} from './vocabulary-canonical-comparison.mjs';

@@ -41,7 +40,7 @@ async function expectLibrary(page,{tags='',category='',count}) {

 let manifest;
 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);manifest=await seed(request);
+    await startCoverage(page,browserName);manifest=await seed(request);
    page.vocabularyErrors=[];page.on('pageerror',error=>page.vocabularyErrors.push(error.message));
 });
 test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.vocabularyErrors).toEqual([]);});
@@ -265,8 +264,7 @@ const toast=page=>page.locator('#workspace-toast');
 const actionNames=scope=>scope.locator('.dialog-actions button').evaluateAll(nodes=>nodes.map(node=>node.textContent.trim()));
 const snapshot=async request=>{const response=await request.get('/__test__/vocabulary/snapshot');await expect(response).toBeOK();return response.json();};
 const backup=async request=>{const response=await request.get('/__test__/vocabulary/backup');await expect(response).toBeOK();return response.body();};
-// A restore the open page has not seen, so its dialog stays to report it (#413).
-const restore=async(page,request,buffer)=>expect(await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'vocabulary.db',mimeType:'application/octet-stream',buffer}}}))).toBeOK();
+const restore=async(request,buffer)=>expect(await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'vocabulary.db',mimeType:'application/octet-stream',buffer}}})).toBeOK();
 const tagNames=rows=>rows.tags.map(([,name])=>name);
 function trackWrites(page) {
    const writes=[];page.on('request',item=>{if(item.method()!=='GET')writes.push({method:item.method(),url:new URL(item.url()).pathname,body:item.postDataJSON()});});return writes;
@@ -484,7 +482,7 @@ test('conflict and restore states keep the dialog and write nothing',async({page

    const before=await snapshot(request);
    box=await openDialog(page,main(page).getByRole('button',{name:'+ Create tag',exact:true}),'Create tag');
-    await restore(page,request,saved);
+    await restore(request,saved);
    await field(box,'Tag name').fill('sunrise');await button(box,'Apply').click();
    await expect(note(box)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was changed.');
    await expect(button(box,'Apply')).toBeDisabled();
@@ -624,7 +622,7 @@ test('delete confirmation read failure, missing tag and restore keep Delete disa
    await expect(button(box,'Delete')).toBeDisabled();await expect(tagRow(page,'calm').locator('td:nth-child(2)')).toHaveText('2');
    await button(box,'Cancel').click();

-    box=await openRename(page,'mist');await restore(page,request,saved);
+    box=await openRename(page,'mist');await restore(request,saved);
    await button(box,'Delete tag…').click();
    await expect(note(box)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was changed.');
    await expect(button(box,'Delete')).toBeDisabled();expect(await actionNames(box)).toEqual(['Reload','Cancel','Delete']);
@@ -18,7 +18,7 @@ const routes = [
    ['tags', 'Tags & categories', null],
    // #249 local Inspect: the native Inspect a file page; Overview's tool card still links the legacy metadata page.
    ['inspect', 'Inspect a file', null],
-    // #249 System S2: native System; every section native since S12 (D94 retired, asserted below).
+    // #249 System S2: native System; its undelivered sections hand off per section (D94, asserted below).
    ['system', 'System', null],
    // #249 D51: SAVED VIEWS' Favorites, Images filtered to favorites.
    ['favorites', 'Favorites', null],
@@ -395,7 +395,7 @@ const SURFACE = {
    intro: { fontSize: '12px', marginTop: '7px' },
 };

-for (const width of [1600, 390]) test(`overview renders with concept surfaces and no System section hands off ${width}`, async ({ page }) => {
+for (const width of [1600, 390]) test(`overview and handoff render with concept surfaces ${width}`, async ({ page }) => {
    await page.setViewportSize({ width, height: 900 });
    await page.goto(`${workspace}#/overview`);
    const main = page.locator('#workspace-main');
@@ -412,23 +412,23 @@ for (const width of [1600, 390]) test(`overview renders with concept surfaces an
    expect(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)).toBe(true);

    await sidebarLink(page, 'System').click();
-    // Every System section is native (S12 retired D94): the last one, Diagnostics & logs, shows concept surfaces.
+    // System's Overview is native (S2 Task 6); a section not delivered yet still hands off (D94).
    await main.locator('.section-nav').getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
-    const logs = main.locator('.settings-layout > section.surface').last();
-    await expect(logs.locator(':scope > h2')).toHaveText('Logs');
-    expect(await logs.evaluate(surfaceStyle)).toMatchObject(SURFACE);
-    await expect(main.locator('.handoff')).toHaveCount(0);
+    const handoff = main.locator('section.handoff');
+    await expect(handoff).toHaveClass(/\bsurface\b/);
+    expect(await handoff.evaluate(surfaceStyle)).toMatchObject(SURFACE);
+    await expect(handoff.locator('a[href="/prompt_manager/admin"]')).toBeVisible();
    await expect(main.locator('.panel')).toHaveCount(0);
    expect(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)).toBe(true);
 });

-// #249 System S2 Task 5: the concept's renderSystem shell (app.js 698–706) at `#/system/<section>`, every section native
-// (S12 retired the D94 hand-off), and the Save row's truthful status (D92).
+// #249 System S2 Task 5: the concept's renderSystem shell (app.js 698–706) at `#/system/<section>`, every section a D94
+// hand-off until its PR, and the Save row's truthful status (D92).
 const SYSTEM_SECTION_LABELS = ['Overview', 'Appearance', 'Sources & scans', 'Integrations', 'Auto-tagging', 'Maintenance',
    'Backup & export', 'Diagnostics & logs'];
 const SYSTEM_HASHES = ['overview', 'appearance', 'sources', 'integrations', 'tagging', 'maintenance', 'backups', 'diagnostics'];

-test('System is native: the concept shell, section navigation, sections and the Save row', async ({ page }) => {
+test('System is native: the concept shell, section navigation, sections, hand-offs and the Save row', async ({ page }) => {
    const mutations = [];
    page.on('request', item => { if (!['GET', 'HEAD', 'OPTIONS'].includes(item.method())) mutations.push(item.url()); });
    await page.goto(`${workspace}#/system`);
@@ -466,8 +466,7 @@ test('System is native: the concept shell, section navigation, sections and the
        // (S4 Task 11, workspace-system-sources.spec.mjs, its update notice shown in a fresh browser), Integrations (S10
        // Task 27, workspace-system-integrations.spec.mjs), Maintenance (S7 Task 19,
        // workspace-system-maintenance.spec.mjs), Backup & export (S9 Task 24, workspace-system-backups.spec.mjs) and
-        // Auto-tagging (S11 Task 6, workspace-system-tagging.spec.mjs) and Diagnostics & logs (S12,
-        // workspace-system-diagnostics.spec.mjs): none hands off.
+        // Auto-tagging (S11 Task 6, workspace-system-tagging.spec.mjs); every other section hands off.
        if (hash === 'tagging') await expect(layout.locator('#tag-model')).toBeVisible();
        if (hash === 'overview') await expect(layout.locator(':scope > .summary-metrics')).toBeVisible();
        if (hash === 'sources') await expect(layout.locator('#source-list .operation')).toHaveCount(2);
@@ -477,9 +476,13 @@ test('System is native: the concept shell, section navigation, sections and the
                integrations: ['section.surface', 'section.surface', 'div.save-row'],
                maintenance: ['div.notice', 'section.surface', 'section.surface', 'div.save-row'],
                backups: ['div.two-col', 'section.surface', 'div.save-row'],
-                tagging: ['section.surface', 'div.save-row'],
-                diagnostics: ['section.surface', 'section.surface', 'div.save-row'] }[hash]);
-        await expect(layout.locator('.handoff')).toHaveCount(0);
+                tagging: ['section.surface', 'div.save-row'] }[hash]
+                ?? ['section.surface handoff', 'div.save-row']);
+        if (['overview', 'appearance', 'sources', 'integrations', 'tagging', 'maintenance', 'backups'].includes(hash)) continue;
+        const handoff = layout.locator('section.handoff');
+        await expect(handoff.locator('h2')).toHaveText('Your current tools are ready');
+        expect(await handoff.locator('a.workspace-link').evaluateAll(links => links.map(link => link.getAttribute('href'))))
+            .toEqual(['/prompt_manager/admin']);
        await expect(layout.locator('#settings-status')).toHaveText('No unsaved changes.');
        await expect(page.locator('aside.sidebar a[href="#/system"]')).toHaveAttribute('aria-current', 'page');
    }
@@ -16,6 +16,7 @@ import json
 import math
 import os
 from pathlib import Path
+import shutil
 import time
 from types import SimpleNamespace
 from typing import TYPE_CHECKING
@@ -33,7 +34,6 @@ from utils.execution_contexts import (
 from utils.execution_history_events import make_finish, make_start
 from utils.execution_outputs import OutputBundle, OutputReference, snapshot_output_roots
 from utils.pair_execution import EXECUTION_KEY
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -181,7 +181,6 @@ _TABLES = (
    "media_image_tags",
    "media_annotation_bytes",
    "media_annotation_files",
-    "image_categories",
    "image_prompt_pairs",
    "prompt_pair_tags",
    "prompt_pairs",
@@ -301,7 +300,8 @@ def _clear(api: PromptManagerAPI, root: Path) -> None:
        for table in _TABLES:
            conn.execute(f"DELETE FROM {table}")
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()


 def _record_run(
@@ -1,293 +0,0 @@
-"""System › Diagnostics & logs test hooks for the browser tests (#249 System S12).
-
-The logger writes into ``<server root>/logs`` (``repoint_logs``, called by
-``create_app`` before any record is written), so no test reads or deletes a
-real log folder. Every route refuses a log folder outside the server root.
-
- ``POST /__test__/logs/reset`` restores the default logging configuration,
-  empties the active log, removes every other entry of the log folder (a
-  link is removed, never followed) and clears the in-memory buffer. The
-  global ``/__test__/reset`` calls it too;
- ``POST /__test__/logs/seed`` ``{records, filler, rotated, active, link,
-  other}`` writes buffer records with fixed times (``records``: the concept's
-  four lines, then one DEBUG, ERROR and CRITICAL record, older; ``filler``
-  more INFO records older still), ``active`` bytes into the active log,
-  rotated copies ``prompt_manager.log.<n>`` of the listed sizes (fixed
-  times), on POSIX a symlink ``prompt_manager.log.<n+1>`` to a file outside
-  the folder (``link``) and a user's ``prompt_manager.log.bak`` (``other``).
-  ``{mode: "concept"}`` reproduces the concept's Logs sample (app.js 695)
-  for the comparison: the buffer holds only its four lines, the active log
-  is 1.4 MB with three rotated copies ("prompt_manager.log · 1.4 MB · rotated
-  copies: 3") and console logging is off, as the concept's toggle;
- ``POST /__test__/logs/rotate`` rolls the copies over as the handler does
-  (``.2`` → ``.3``, ``.1`` → ``.2``, a new ``.1``), so a reviewed plan no
-  longer matches;
- ``GET /__test__/logs/state`` answers the folder's entries (name, size, link)
-  and the buffer's length.
-"""
-
-import datetime
-import logging
-import os
-import shutil
-from pathlib import Path
-
-from aiohttp import web
-
-ACTIVE = "prompt_manager.log"
-SEED_DAY = datetime.datetime(2026, 10, 26)
-# The concept's four lines (app.js 695), oldest first: the viewer shows them
-# newest first.
-CONCEPT_RECORDS = (
-    ("09:38:52", logging.INFO, "Source monitor started: output"),
-    ("09:39:04", logging.INFO, "Database backup verified"),
-    ("09:42:18", logging.WARNING, "3 images have ambiguous prompt metadata"),
-    ("09:42:18", logging.INFO, "Scan completed: 12 enriched, 0 duplicate links"),
-)
-# Older than the concept's lines, so they come after them: the levels the
-# concept does not show.
-LEVEL_RECORDS = (
-    ("09:30:01", logging.DEBUG, "Thumbnail cache lookup"),
-    ("09:30:02", logging.ERROR, "A source folder could not be read"),
-    ("09:30:03", logging.CRITICAL, "The database could not be opened"),
-)
-ROTATED_TIME = datetime.datetime(2026, 10, 25, 14, 2)
-# The concept's "prompt_manager.log · 1.4 MB · rotated copies: 3": the active
-# log stays under 1.45 MB while the server writes its own lines.
-CONCEPT_ACTIVE = int(1.4 * 1024 * 1024)
-CONCEPT_ROTATED = (3072, 2048, 1024)
-MAX_SEED_BYTES = 64 * 1024 * 1024
-DEFAULT_CONFIG = {
-    "level": "INFO",
-    "max_file_size": 10 * 1024 * 1024,
-    "backup_count": 5,
-    "console_logging": True,
-    "file_logging": True,
-    "buffer_size": 1000,
-}
-
-
-def _manager():
-    from utils.logging_config import get_logger_manager
-
-    return get_logger_manager()
-
-
-def repoint_logs(root: Path) -> Path:
-    """Point the logger at ``<root>/logs`` before anything is logged.
-
-    The logger is built while ``logs_dir`` answers that folder, so its first
-    handler never opens a log file anywhere else (a node folder with a legacy
-    database would otherwise name a real log folder).
-    """
-    from utils import library_location
-
-    folder = Path(root) / "logs"
-    folder.mkdir(exist_ok=True)
-    original = library_location.logs_dir
-    library_location.logs_dir = lambda **_kwargs: str(folder)
-    try:
-        manager = _manager()
-    finally:
-        library_location.logs_dir = original
-    with manager._files_lock:
-        manager.log_dir = folder
-        manager._setup_loggers()
-    return folder
-
-
-def _require_inside(root: Path, folder: Path) -> None:
-    resolved = Path(os.path.realpath(folder))
-    if Path(os.path.realpath(root)) not in resolved.parents:
-        raise web.HTTPForbidden(text="The log folder is outside the test server root")
-
-
-def _record(time_text, level, message, index):
-    record = logging.LogRecord(
-        "prompt_manager.test", level, __file__, index, message, None, None
-    )
-    hours, minutes, seconds = (int(part) for part in time_text.split(":"))
-    moment = SEED_DAY.replace(hour=hours, minute=minutes, second=seconds)
-    # Equal times keep their order: each later record is a microsecond newer.
-    record.created = moment.timestamp() + index / 1e6
-    return record
-
-
-def _touch(path: Path, size: int, moment: datetime.datetime) -> None:
-    # A link at this name is replaced, never written through.
-    if path.is_symlink():
-        path.unlink()
-    with open(path, "wb") as handle:
-        handle.write(b"x" * size)
-    stamp = moment.timestamp()
-    os.utime(path, (stamp, stamp))
-
-
-def _append_active(manager, log_dir: Path, size: int) -> None:
-    """Grow the active log as this process's handler does (#389).
-
-    A second handle appending to the file the handler writes is what Clear
-    all logs refuses as another program writing to it, so the bytes go
-    through the handler's own stream; with file logging off, to the file.
-    """
-
-    def same(path) -> bool:
-        return os.path.normcase(os.path.realpath(path)) == os.path.normcase(
-            os.path.realpath(log_dir / ACTIVE)
-        )
-
-    for handler in manager._file_handlers():
-        stream = getattr(handler, "stream", None)
-        if stream is None or not same(handler.baseFilename):
-            continue
-        handler.acquire()
-        try:
-            stream.write("x" * size)
-            stream.flush()
-        finally:
-            handler.release()
-        return
-    with open(log_dir / ACTIVE, "ab") as handle:
-        handle.write(b"x" * size)
-
-
-def _bounded(value, name, top=MAX_SEED_BYTES):
-    if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= top:
-        raise web.HTTPBadRequest(text=f"{name} must be an integer 0..{top}")
-    return value
-
-
-def register_diagnostics_commands(app, routes, api, root: Path):
-    """Register the hooks; returns ``reset()`` for the global reset."""
-
-    def folder() -> Path:
-        path = Path(_manager().log_dir)
-        _require_inside(root, path)
-        return path
-
-    def reset() -> None:
-        manager = _manager()
-        log_dir = folder()
-        if manager.get_config() != DEFAULT_CONFIG:
-            manager.update_config(dict(DEFAULT_CONFIG))
-        with manager._files_lock:
-            held = manager._acquire_file_handlers()
-            try:
-                with os.scandir(log_dir) as entries:
-                    found = list(entries)
-                for entry in found:
-                    path = Path(entry.path)
-                    if entry.name == ACTIVE and entry.is_file(follow_symlinks=False):
-                        manager._truncate_main_log(path)
-                    elif entry.is_dir(follow_symlinks=False):
-                        shutil.rmtree(path)
-                    else:
-                        os.unlink(path)
-            finally:
-                manager._release_handlers(held)
-        with manager._buffer_lock:
-            manager._log_buffer.clear()
-
-    def seed_concept() -> None:
-        manager = _manager()
-        log_dir = folder()
-        manager.update_config({"console_logging": False})
-        with manager._buffer_lock:
-            manager._log_buffer.clear()
-        for index, (time_text, level, message) in enumerate(CONCEPT_RECORDS):
-            record = _record(time_text, level, message, index)
-            manager.add_to_buffer(record, record.getMessage())
-        _append_active(manager, log_dir, CONCEPT_ACTIVE)
-        for number, size in enumerate(CONCEPT_ROTATED, start=1):
-            moment = ROTATED_TIME - datetime.timedelta(hours=number)
-            _touch(log_dir / f"{ACTIVE}.{number}", size, moment)
-
-    def seed(data) -> None:
-        if data.get("mode") == "concept":
-            seed_concept()
-            return
-        manager = _manager()
-        log_dir = folder()
-        with_records = data.get("records", True) is not False
-        filler = _bounded(data.get("filler", 0), "filler", 900)
-        older = [
-            (f"08:{index // 60:02}:{index % 60:02}", logging.INFO, f"Filler {index}")
-            for index in range(filler)
-        ]
-        named = list(LEVEL_RECORDS) + list(CONCEPT_RECORDS) if with_records else []
-        ordered = older + named
-        for index, (time_text, level, message) in enumerate(ordered):
-            record = _record(time_text, level, message, index)
-            manager.add_to_buffer(record, record.getMessage())
-        active = _bounded(data.get("active", 0), "active")
-        if active:
-            _append_active(manager, log_dir, active)
-        rotated = data.get("rotated", [])
-        if not isinstance(rotated, list) or len(rotated) > 20:
-            raise web.HTTPBadRequest(text="rotated must be a list of sizes")
-        for number, size in enumerate(rotated, start=1):
-            moment = ROTATED_TIME - datetime.timedelta(hours=number)
-            _touch(log_dir / f"{ACTIVE}.{number}", _bounded(size, "size"), moment)
-        if data.get("link") and os.name != "nt":
-            target = Path(root) / "outside-log-target.txt"
-            target.write_bytes(b"not a log of this folder")
-            os.symlink(target, log_dir / f"{ACTIVE}.{len(rotated) + 1}")
-        if data.get("other"):
-            _touch(log_dir / f"{ACTIVE}.bak", 0, ROTATED_TIME)
-
-    def rotate() -> None:
-        manager = _manager()
-        log_dir = folder()
-        with manager._files_lock:
-            held = manager._acquire_file_handlers()
-            try:
-                for number in (2, 1):
-                    source = log_dir / f"{ACTIVE}.{number}"
-                    if source.is_file() and not source.is_symlink():
-                        os.replace(source, log_dir / f"{ACTIVE}.{number + 1}")
-                _touch(log_dir / f"{ACTIVE}.1", 4096, datetime.datetime.now())
-            finally:
-                manager._release_handlers(held)
-
-    def state():
-        manager = _manager()
-        log_dir = folder()
-        entries = []
-        with os.scandir(log_dir) as listing:
-            found = sorted(listing, key=lambda item: item.name)
-        for entry in found:
-            info = entry.stat(follow_symlinks=False)
-            entries.append(
-                {"name": entry.name, "size": info.st_size, "link": entry.is_symlink()}
-            )
-        with manager._buffer_lock:
-            buffered = len(manager._log_buffer)
-        return {"entries": entries, "buffer": buffered, "config": manager.get_config()}
-
-    async def body(request):
-        data = await request.json() if request.can_read_body else {}
-        if not isinstance(data, dict):
-            raise web.HTTPBadRequest()
-        return data
-
-    @routes.post("/__test__/logs/reset")
-    async def logs_reset(request: web.Request) -> web.Response:
-        await api._run_in_executor(reset)
-        return web.json_response({"success": True})
-
-    @routes.post("/__test__/logs/seed")
-    async def logs_seed(request: web.Request) -> web.Response:
-        data = await body(request)
-        await api._run_in_executor(seed, data)
-        return web.json_response({"success": True})
-
-    @routes.post("/__test__/logs/rotate")
-    async def logs_rotate(request: web.Request) -> web.Response:
-        await api._run_in_executor(rotate)
-        return web.json_response({"success": True})
-
-    @routes.get("/__test__/logs/state")
-    async def logs_state(request: web.Request) -> web.Response:
-        return web.json_response(await api._run_in_executor(state))
-
-    return reset
@@ -3,11 +3,11 @@
 from __future__ import annotations

 from pathlib import Path
+import shutil
 from typing import TYPE_CHECKING

 from aiohttp import web
 from PIL import Image
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -33,7 +33,6 @@ _TABLES = (
    "media_image_tags",
    "media_annotation_bytes",
    "media_annotation_files",
-    "image_categories",
    "image_prompt_pairs",
    "prompt_pair_tags",
    "prompt_pairs",
@@ -52,7 +51,8 @@ def seed_library_editor(api: PromptManagerAPI, root: Path) -> dict:
        for table in _TABLES:
            conn.execute(f"DELETE FROM {table}")
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()
    epoch = db.get_execution_epoch()
    receipt = db.create_library_recipe(
        EDITOR_POSITIVE,
@@ -52,7 +52,6 @@ from typing import TYPE_CHECKING
 from aiohttp import web
 from PIL import Image
 from PIL.PngImagePlugin import PngInfo
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -85,7 +84,6 @@ _TABLES = (
    "media_image_tags",
    "media_annotation_bytes",
    "media_annotation_files",
-    "image_categories",
    "image_prompt_pairs",
    "prompt_pair_tags",
    "prompt_pairs",
@@ -227,7 +225,8 @@ def seed_review(
            conn.execute(f"DELETE FROM {table}")
    api.close_annotation_captures()
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()
    shutil.rmtree(root / "temp" / "review", ignore_errors=True)
    output = root / "output"
    files = []
@@ -35,8 +35,7 @@ read. These per-server hooks only change what a System test needs on top:
  previews for Convert outdated;
 - ``POST /__test__/system/jxl-encoder`` ``{available}`` (#317) makes the
  server read as having (``cjxl``) or lacking a JPEG XL encoder without
-  probing, whatever the host has installed (#371: ``false`` stands in for the
-  detector itself); reset restores the thumbnail settings and the real detection.
+  probing; reset restores the thumbnail settings and the real detection.

 - ``POST /__test__/system/duplicate-prompts`` (S7) adds two prompts whose
  text differs only in case and spacing (a duplicate prompt text group);
@@ -119,11 +118,6 @@ def register_system_commands(app, routes, api, root: Path):
    }
    from py.api import thumbnail_encode

-    real_detect = thumbnail_encode._detect
-
-    def _no_encoder():
-        return None
-
    monitor = getattr(image_monitor, "_monitor_instance", None)
    failures: dict[str, int] = {}

@@ -153,7 +147,6 @@ def register_system_commands(app, routes, api, root: Path):
        api._health_report = None
        for (owner, name), value in host_values.items():
            setattr(owner, name, value)
-        thumbnail_encode._detect = real_detect
        thumbnail_encode.reset_encoders()
        image_monitor._monitor_instance = monitor
        api.__dict__.pop("_library_resolver", None)
@@ -305,12 +298,7 @@ def register_system_commands(app, routes, api, root: Path):
        available = data.get("available")
        if not isinstance(available, bool):
            raise web.HTTPBadRequest()
-        # Test-only: the fixture, not the host, decides (#371). Without an encoder the
-        # detector itself stands in, so a re-probe (a "none found" is probed again on
-        # every settings read) cannot find the host's real encoder; with one the cached
-        # answer stands, and a failed write still probes the real detector as before.
-        # Reset restores the real detector.
-        thumbnail_encode._detect = real_detect if available else _no_encoder
+        # Test-only: stand in the cached detection (no probe).
        with thumbnail_encode._detect_lock:
            thumbnail_encode._detected = "cjxl" if available else None
        return web.json_response({"success": True})
@@ -19,7 +19,6 @@ from typing import TYPE_CHECKING
 from aiohttp import web
 from PIL import Image
 from PIL.PngImagePlugin import PngInfo
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -51,7 +50,6 @@ _TABLES = (
    "media_image_tags",
    "media_annotation_bytes",
    "media_annotation_files",
-    "image_categories",
    "image_prompt_pairs",
    "prompt_pair_tags",
    "prompt_pairs",
@@ -100,7 +98,8 @@ def seed_tagging(api: PromptManagerAPI, root: Path, extra_images: int = 0) -> di
        for table in _TABLES:
            conn.execute(f"DELETE FROM {table}")
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()
    output = root / "output"
    _png(output / FILES[0][0], (196, 140, 92))
    _png(output / FILES[1][0], (150, 110, 80))
@@ -248,22 +247,6 @@ def register_tagging_commands(
        model.unavailable = set(data["unavailable"])
        return web.json_response({"success": True})

-    @routes.post("/__test__/tagging/loaded")
-    async def loaded(request: web.Request) -> web.Response:
-        """Mark one fake model loaded (``{"model": "<key>"}``), as a batch that
-        kept it in memory leaves it; ``/autotag/models`` then reports
-        ``model_loaded``. Reset unloads it."""
-        data = await request.json() if request.can_read_body else None
-        if (
-            request.query
-            or not isinstance(data, dict)
-            or set(data) != {"model"}
-            or data["model"] not in MODELS
-        ):
-            raise web.HTTPBadRequest()
-        model.loaded = data["model"]
-        return web.json_response({"success": True})
-
    @routes.post("/__test__/tagging/download")
    async def download_mode(request: web.Request) -> web.Response:
        """Switch the model's download to a fake (never a real download).
@@ -5,13 +5,13 @@ from __future__ import annotations
 import json
 import os
 from pathlib import Path
+import shutil
 from typing import TYPE_CHECKING

 from PIL import Image, ImageDraw
 from PIL.PngImagePlugin import PngInfo

 from utils.hashing import generate_prompt_hash
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -119,7 +119,6 @@ def seed_workspace_visual(api: PromptManagerAPI, root: Path) -> None:
            "media_image_tags",
            "media_annotation_bytes",
            "media_annotation_files",
-            "image_categories",
            "image_prompt_pairs",
            "prompt_pair_tags",
            "prompt_pairs",
@@ -130,7 +129,8 @@ def seed_workspace_visual(api: PromptManagerAPI, root: Path) -> None:
        ):
            conn.execute(f"DELETE FROM {table}")
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()
    for parent_index, (positive, negatives) in enumerate(zip(_POSITIVES, _NEGATIVES)):
        category = ("Architecture", "Landscape", "Abstract")[parent_index % 3]
        tags = ["geometric", ("warm", "cool")[parent_index % 2]]
@@ -7,10 +7,10 @@ in concept order, so tag creation order and category first use match the mock.
 from __future__ import annotations

 from pathlib import Path
+import shutil
 from typing import TYPE_CHECKING

 from aiohttp import web
-from tests.browser.folder_trash import replace_folder

 if TYPE_CHECKING:
    from py.api import PromptManagerAPI
@@ -86,7 +86,6 @@ _TABLES = (
    "media_image_tags",
    "media_annotation_bytes",
    "media_annotation_files",
-    "image_categories",
    "image_prompt_pairs",
    "prompt_pair_tags",
    "prompt_pairs",
@@ -121,7 +120,8 @@ def seed_vocabulary(
        for table in _TABLES:
            conn.execute(f"DELETE FROM {table}")
    for name in ("output", "input"):
-        replace_folder(root / name)
+        shutil.rmtree(root / name)
+        (root / name).mkdir()
    epoch = db.get_execution_epoch()
    recipes = []
    for recipe in CONCEPT_RECIPES:
@@ -140,26 +140,3 @@ test('an output saved without metadata links once its recorded run names a store
        expect((await request.post('/pm_execution_fixture/metadata', { data: { disabled: false } })).ok()).toBe(true);
    }
 });
-
-// #332 on the real host: the migration ran at startup and the image category routes
-// set, list and remove an own category on a generated output.
-test('an output gets its own image category and loses it again', async ({ execution }, testInfo) => {
-    const request = execution.request;
-    const filename = await saved(request, graph({ text: `category host ${randomUUID()}`, prefix: 'pm332/category' }));
-    let image;
-    await expect.poll(async () => {
-        const listing = await (await request.get('/prompt_manager/images/output?mode=workspace&q=pm332&rescan=1')).json();
-        image = (listing.images || []).find(entry => entry.filename === filename || entry.path?.endsWith(`/${filename}`));
-        return Boolean(image);
-    }, { timeout: 20000, message: `${filename} is listed by Images` }).toBe(true);
-    const items = [{ root_index: image.root_index, root_scope: image.root_scope, path: image.path }];
-    const value = `PM332 host ${testInfo.project.name}`;
-    const set = await request.put('/prompt_manager/images/category', { data: { items, category: value } });
-    expect(set.status()).toBe(200);
-    expect(await set.json()).toEqual({ success: true, category: value, updated: 1, unchanged: 0, not_found: 0 });
-    expect((await (await request.get('/prompt_manager/images/categories')).json()).categories).toContain(value);
-    const cleared = await request.delete('/prompt_manager/images/category', { data: { items } });
-    expect(cleared.status()).toBe(200);
-    expect(await cleared.json()).toEqual({ success: true, cleared: 1 });
-    expect((await (await request.get('/prompt_manager/images/categories')).json()).categories).not.toContain(value);
-});
@@ -1,16 +0,0 @@
-"""Hang guards for waits on disk-bound work (tests only).
-
-A test that waits for a job or handoff whose work is file and SQLite I/O
-(a safety backup with fsync, a restore, hashing and unlinking files) waits
-on that state; the ceiling below only ends a real hang. Hosted Windows
-runners stall disk I/O for tens of seconds at a time: a restore took over
-10 s (merge queue, #382), and on PR #405 every test setup in a 50 s window
-took up to 9 s against 0.1-0.6 s around it while the test bodies stayed
-fast, so a one-file duplicate cleanup missed a 10 s bound (#409).
-
-The ceiling is per wait and stays under the suite's 120 s per-test hang
-watchdog. A test with several such waits in a row can reach the watchdog
-first; either way a real hang fails, the watchdog with every thread's stack.
-"""
-
-DISK_BOUND_SECONDS = 90
@@ -113,19 +113,3 @@ by their own suites. The expectations start as the observed baseline. A change
 that alters an outcome edits the vector in the same commit.
 `tests/js/legacy-metadata-characterization.test.js` pins what
 the legacy viewers show on the same files.
-
-# Legacy contract snapshot
-
-`legacy_contract_snapshot.json` records what the legacy admin and gallery pages
-talk to while System S13 (#330) moves their tools to native System: every
-registered route as `"<METHOD> <path>"` (`routes`) and the key paths of
-`GET /prompt_manager/settings` to depth 2 (`settings_keys`; list items give the
-union of their keys as `name[].key`). `tests/test_legacy_contract_snapshot.py`
-compares a temp-database API against it. Record it again only for an intended
-change, and say why in the PR body:
-
-```sh
-PM_RECORD_LEGACY_SNAPSHOT=1 python3 -m unittest tests.test_legacy_contract_snapshot
-```
-
-Cutover (#334) removes the test and this fixture.
@@ -1,203 +0,0 @@
-{
-  "routes": [
-    "DELETE /prompt_manager/delete/{prompt_id}",
-    "DELETE /prompt_manager/image-annotations/capture/{token}",
-    "DELETE /prompt_manager/images/category",
-    "DELETE /prompt_manager/images/favorite",
-    "DELETE /prompt_manager/images/{image_id}",
-    "DELETE /prompt_manager/pairs/{pair_id}",
-    "DELETE /prompt_manager/prompts/{prompt_id}/tags",
-    "DELETE /prompt_manager/restore/preview/{token}",
-    "DELETE /prompt_manager/saved-views/{view_id}",
-    "DELETE /prompt_manager/tags/{tag_name}",
-    "GET /prompt_manager/admin",
-    "GET /prompt_manager/autotag/models",
-    "GET /prompt_manager/backup",
-    "GET /prompt_manager/backup/status",
-    "GET /prompt_manager/categories",
-    "GET /prompt_manager/diagnostics",
-    "GET /prompt_manager/export",
-    "GET /prompt_manager/gallery",
-    "GET /prompt_manager/gallery.html",
-    "GET /prompt_manager/gallery/subfolders",
-    "GET /prompt_manager/history/runs/{run_id}",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/inspection",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/media",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/thumbnail",
-    "GET /prompt_manager/history/runs/{run_id}/outputs",
-    "GET /prompt_manager/image-annotations/capture/{token}",
-    "GET /prompt_manager/images/all",
-    "GET /prompt_manager/images/categories",
-    "GET /prompt_manager/images/inspect/{image_path}",
-    "GET /prompt_manager/images/output",
-    "GET /prompt_manager/images/prompt/{image_path}",
-    "GET /prompt_manager/images/recent",
-    "GET /prompt_manager/images/search",
-    "GET /prompt_manager/images/serve/{filepath}",
-    "GET /prompt_manager/images/thumbnails/plan",
-    "GET /prompt_manager/images/thumbnails/status",
-    "GET /prompt_manager/images/{image_id}/file",
-    "GET /prompt_manager/jobs",
-    "GET /prompt_manager/jobs/{job_id}",
-    "GET /prompt_manager/jobs/{job_id}/events",
-    "GET /prompt_manager/jobs/{job_id}/report",
-    "GET /prompt_manager/js/{filepath}",
-    "GET /prompt_manager/lib/{filepath}",
-    "GET /prompt_manager/library",
-    "GET /prompt_manager/library/export",
-    "GET /prompt_manager/library/options",
-    "GET /prompt_manager/library/{positive_id}",
-    "GET /prompt_manager/library/{positive_id}/history",
-    "GET /prompt_manager/library/{positive_id}/history/pairs/{pair_id}/newest",
-    "GET /prompt_manager/library/{positive_id}/images",
-    "GET /prompt_manager/logs",
-    "GET /prompt_manager/logs/config",
-    "GET /prompt_manager/logs/download/{filename}",
-    "GET /prompt_manager/logs/files",
-    "GET /prompt_manager/logs/stats",
-    "GET /prompt_manager/lora/detect",
-    "GET /prompt_manager/lora/status",
-    "GET /prompt_manager/lora/trigger-words",
-    "GET /prompt_manager/maintenance/duplicates/{job_id}",
-    "GET /prompt_manager/pairs",
-    "GET /prompt_manager/pairs/export",
-    "GET /prompt_manager/pairs/{pair_id}",
-    "GET /prompt_manager/prompts/{prompt_id}/images",
-    "GET /prompt_manager/recent",
-    "GET /prompt_manager/review/events",
-    "GET /prompt_manager/review/items",
-    "GET /prompt_manager/review/items/{item_id}",
-    "GET /prompt_manager/saved-views",
-    "GET /prompt_manager/scan/status",
-    "GET /prompt_manager/scan_duplicates",
-    "GET /prompt_manager/scan_duplicates/status",
-    "GET /prompt_manager/scan_output_dir",
-    "GET /prompt_manager/search",
-    "GET /prompt_manager/settings",
-    "GET /prompt_manager/stats",
-    "GET /prompt_manager/subfolders",
-    "GET /prompt_manager/system/diagnostics",
-    "GET /prompt_manager/system/health",
-    "GET /prompt_manager/system/library",
-    "GET /prompt_manager/system/overview",
-    "GET /prompt_manager/system/statistics",
-    "GET /prompt_manager/tags",
-    "GET /prompt_manager/tags/filter",
-    "GET /prompt_manager/tags/stats",
-    "GET /prompt_manager/tags/suggest",
-    "GET /prompt_manager/tags/{tag_name}/prompts",
-    "GET /prompt_manager/test",
-    "GET /prompt_manager/vocabulary/categories",
-    "GET /prompt_manager/vocabulary/tags",
-    "GET /prompt_manager/vocabulary/tags/{tag_id}/impact",
-    "GET /prompt_manager/web",
-    "GET /prompt_manager/workspace",
-    "PATCH /prompt_manager/library/{positive_id}",
-    "PATCH /prompt_manager/pairs/{pair_id}",
-    "PATCH /prompt_manager/saved-views/{view_id}",
-    "PATCH /prompt_manager/vocabulary/tags/{tag_id}",
-    "POST /prompt_manager/autotag/apply",
-    "POST /prompt_manager/autotag/batch/preview",
-    "POST /prompt_manager/autotag/download/{model_type}",
-    "POST /prompt_manager/autotag/single",
-    "POST /prompt_manager/autotag/start",
-    "POST /prompt_manager/autotag/unload",
-    "POST /prompt_manager/bulk/category",
-    "POST /prompt_manager/bulk/delete",
-    "POST /prompt_manager/bulk/tags",
-    "POST /prompt_manager/cleanup",
-    "POST /prompt_manager/delete_duplicate_images",
-    "POST /prompt_manager/diagnostics/test-link",
-    "POST /prompt_manager/gallery/rescan",
-    "POST /prompt_manager/image-annotations/observe",
-    "POST /prompt_manager/image-annotations/suggest",
-    "POST /prompt_manager/images/clear-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails/progress",
-    "POST /prompt_manager/images/link",
-    "POST /prompt_manager/images/reveal",
-    "POST /prompt_manager/jobs/autotag",
-    "POST /prompt_manager/jobs/duplicates",
-    "POST /prompt_manager/jobs/image-tags",
-    "POST /prompt_manager/jobs/model-download",
-    "POST /prompt_manager/jobs/scan",
-    "POST /prompt_manager/jobs/thumbnails",
-    "POST /prompt_manager/jobs/{job_id}/cancel",
-    "POST /prompt_manager/library",
-    "POST /prompt_manager/library/{positive_id}/variants",
-    "POST /prompt_manager/logs/config",
-    "POST /prompt_manager/logs/truncate",
-    "POST /prompt_manager/lora/enable",
-    "POST /prompt_manager/lora/import/apply",
-    "POST /prompt_manager/lora/import/preview",
-    "POST /prompt_manager/lora/refresh-cache",
-    "POST /prompt_manager/lora/scan",
-    "POST /prompt_manager/maintenance",
-    "POST /prompt_manager/maintenance/apply",
-    "POST /prompt_manager/maintenance/preview",
-    "POST /prompt_manager/pairs",
-    "POST /prompt_manager/prompts/tags",
-    "POST /prompt_manager/prompts/{prompt_id}/tags",
-    "POST /prompt_manager/restore",
-    "POST /prompt_manager/restore/apply",
-    "POST /prompt_manager/restore/preview",
-    "POST /prompt_manager/review/items/{item_id}/decision",
-    "POST /prompt_manager/save",
-    "POST /prompt_manager/saved-views",
-    "POST /prompt_manager/scan",
-    "POST /prompt_manager/scan/cancel",
-    "POST /prompt_manager/scan_duplicates/stream",
-    "POST /prompt_manager/settings",
-    "POST /prompt_manager/settings/validate-source",
-    "POST /prompt_manager/system/health",
-    "POST /prompt_manager/system/library/keep",
-    "POST /prompt_manager/system/library/move",
-    "POST /prompt_manager/tags/merge",
-    "POST /prompt_manager/vocabulary/categories/apply",
-    "POST /prompt_manager/vocabulary/categories/preview",
-    "POST /prompt_manager/vocabulary/tags",
-    "POST /prompt_manager/vocabulary/tags/{tag_id}/delete",
-    "PUT /prompt_manager/image-annotations/tags",
-    "PUT /prompt_manager/images/category",
-    "PUT /prompt_manager/images/favorite",
-    "PUT /prompt_manager/prompts/{prompt_id}",
-    "PUT /prompt_manager/prompts/{prompt_id}/rating",
-    "PUT /prompt_manager/tags/{tag_name}"
-  ],
-  "settings_keys": [
-    "monitor",
-    "monitor.observer_alive",
-    "monitor.present",
-    "monitor.scheduled",
-    "revision",
-    "settings",
-    "settings.autotag_character_threshold",
-    "settings.autotag_existing",
-    "settings.autotag_general_threshold",
-    "settings.autotag_model_type",
-    "settings.autotag_suggestion_limit",
-    "settings.autotag_template",
-    "settings.cpu_count",
-    "settings.gallery_root_path",
-    "settings.gallery_root_paths",
-    "settings.infinite_scroll",
-    "settings.monitored_directories",
-    "settings.monitoring_enabled",
-    "settings.result_timeout",
-    "settings.safety_backup",
-    "settings.thumbnail_edge",
-    "settings.thumbnail_format",
-    "settings.thumbnail_quality",
-    "settings.webui_display_mode",
-    "settings.worker_threads",
-    "sources",
-    "sources.auto_detected",
-    "sources.configured",
-    "sources.effective",
-    "success",
-    "thumbnail_encoders",
-    "thumbnail_encoders.jpeg",
-    "thumbnail_encoders.jxl",
-    "thumbnail_encoders.webp"
-  ]
-}
@@ -36,48 +36,33 @@ function fixture() {
    const reply = (index, data) => requests[index].resolve({ json: async () => data });
    return { manager, requests, reply, notifications };
 }
-const SHA = 'a'.repeat(64);
-test('gallery review retains root identity and applies the tags to the image by its sha256 (#379)', async () => {
+test('gallery review retains root identity and applies tags with the returned prompt ID', async () => {
    const { manager, requests, reply } = fixture();
    const load = manager.loadNextReviewImage();
    assert.equal(requests[0].body.root_index, 1);
-    assert.equal(requests[0].body.existing, 'merge');
-    reply(0, { success: true, prompt_id: 42, tags: ['smile'], sha256: SHA, image_tags: [] });
-    await load;
-    manager.loadNextReviewImage = () => {};
-    const apply = manager.applyReviewTags();
-    assert.equal(requests[1].url, '/prompt_manager/autotag/apply');
-    assert.deepEqual(requests[1].body, ImageHelpers.autotagApplyBody(
-        { id: 'digest', path: 'same.png', root_index: 1 }, SHA, ['smile']));
-    assert.equal('prompt_id' in requests[1].body, false);
-    reply(1, { success: true });
-    await apply;
-});
-test('an unlinked image applies to the image like a linked one', async () => {
-    const { manager, requests, reply } = fixture();
-    const load = manager.loadNextReviewImage();
-    reply(0, { success: true, prompt_id: null, tags: ['smile'], sha256: SHA, image_tags: [] });
-    await load;
-    manager.loadNextReviewImage = () => {};
-    const apply = manager.applyReviewTags();
-    assert.equal(requests[1].body.sha256, SHA);
-    assert.deepEqual(requests[1].body.tags, ['smile']);
-    reply(1, { success: true });
-    await apply;
-});
-test('an answer without a captured sha256 never sends an apply', async () => {
-    const { manager, requests, reply } = fixture();
-    const load = manager.loadNextReviewImage();
    reply(0, { success: true, prompt_id: 42, tags: ['smile'] });
    await load;
    manager.loadNextReviewImage = () => {};
-    await manager.applyReviewTags();
-    assert.equal(requests.filter(r => r.url === '/prompt_manager/autotag/apply').length, 0);
+    const apply = manager.applyReviewTags();
+    assert.deepEqual(requests[1].body, { prompt_id: 42, tags: ['smile'] });
+    reply(1, { success: true });
+    await apply;
+});
+test('unlinked images do not submit an invalid apply request or advance', async () => {
+    const { manager, requests, reply } = fixture();
+    const load = manager.loadNextReviewImage();
+    reply(0, { success: true, prompt_id: null, tags: ['smile'] });
+    await load;
+    const apply = manager.applyReviewTags();
+    if (requests[1]) reply(1, { success: false, error: "Unexpected apply" });
+    await apply;
+    assert.equal(requests.length, 1);
+    assert.equal(manager.autoTagState.reviewIndex, 0);
 });
 test('a failed apply keeps the current image available for retry', async () => {
    const { manager, requests, reply } = fixture();
    const load = manager.loadNextReviewImage();
-    reply(0, { success: true, prompt_id: 42, tags: ['smile'], sha256: SHA, image_tags: [] });
+    reply(0, { success: true, prompt_id: 42, tags: ['smile'] });
    await load;
    const apply = manager.applyReviewTags();
    reply(1, { success: false, error: 'Try again' });
@@ -76,101 +76,35 @@ test("the workspace keys have their own defaults and validation", () => {
    assert.equal(normalizeGallerySettings({ defaultViewMode: "masonry" }).defaultViewMode, "grid");
 });

-// #330 S13: the legacy gallery's Page options edit only the page-only keys (PAGE_OPTION_KEYS); System › Appearance owns the rest, so a Save
-// or a Reset from the legacy page keeps every other stored key.
-function legacyGallery(stored, controls, extra = {}) {
+test("a legacy gallery Save keeps the workspace keys and every other stored key", () => {
    const fs = require("node:fs");
    const path = require("node:path");
    const vm = require("node:vm");
    const settings = require("../../web/js/gallery-settings.js");
-    const storage = new Map([["gallerySettings", JSON.stringify(stored)]]);
+    const storage = new Map([["gallerySettings", JSON.stringify({ workspaceLayout: "masonry", workspaceDensity: "compact", someOtherTool: 1 })]]);
+    const controls = {
+        lazyLoadingToggle: { checked: true }, imageQualitySelect: { value: "high" }, defaultViewModeSelect: { value: "list" },
+        defaultLimitSelect: { value: "200" }, gridColumnsSelect: { value: "6" }, showImageInfoToggle: { checked: false },
+        autoLoadMetadataToggle: { checked: true }, cacheMetadataToggle: { checked: true }, showFilePathsToggle: { checked: false },
+        sidebarCollapsedByDefaultToggle: { checked: true }, infiniteScrollToggle: { checked: false }, debugModeToggle: { checked: false },
+        apiTimeoutInput: { value: "30" }, checkThumbnailsAtStartup: { checked: true }, videoAutoplayToggle: { checked: true },
+        videoMuteToggle: { checked: false }, videoLoopToggle: { checked: true },
+    };
    const context = vm.createContext({
        document: { addEventListener() {}, getElementById: id => controls[id] },
        window: {}, console: { debug() {}, warn() {}, error() {} }, GallerySettings: settings,
-        localStorage: { getItem: key => storage.get(key) ?? null, setItem: (key, value) => storage.set(key, value),
-            removeItem: key => storage.delete(key) },
-        ...extra,
+        localStorage: { getItem: key => storage.get(key) ?? null, setItem: (key, value) => storage.set(key, value) },
    });
    const file = path.join(__dirname, "../../web/js/gallery.js");
    const Manager = vm.runInContext(`${fs.readFileSync(file, "utf8")}\nGalleryManager;`, context, { filename: file });
    const manager = Object.create(Manager.prototype);
-    const calls = [];
-    Object.assign(manager, { showNotification: (message, type) => calls.push([type, message]), hideSettings() {},
-        applySettings: applied => calls.push(["apply", applied.lazyLoading]) });
-    return { manager, storage, calls, saved: () => JSON.parse(storage.get("gallerySettings")) };
-}
-
-const PAGE_OPTION_CONTROLS = () => ({
-    checkThumbnailsAtStartup: { checked: false }, lazyLoadingToggle: { checked: false },
-    defaultLimitSelect: { value: "200" },
-    gridColumnsSelect: { value: "6" }, infiniteScrollToggle: { checked: true }, debugModeToggle: { checked: true },
-    apiTimeoutInput: { value: "45" },
-});
-
-test("a legacy gallery Save keeps the workspace keys and every other stored key", () => {
-    const { manager, saved } = legacyGallery({ workspaceLayout: "masonry", workspaceDensity: "compact", someOtherTool: 1,
-        imageQuality: "high", showImageInfo: false, videoMute: false, thumbnailPromptDismissed: "sig", defaultViewMode: "list" },
-        PAGE_OPTION_CONTROLS());
+    Object.assign(manager, { showNotification() {}, hideSettings() {}, applySettings() {} });
    manager.saveSettings();
-    const result = saved();
-    assert.equal(result.workspaceLayout, "masonry");
-    assert.equal(result.workspaceDensity, "compact");
-    assert.equal(result.someOtherTool, 1);
-    assert.equal(result.imageQuality, "high");
-    assert.equal(result.showImageInfo, false);
-    assert.equal(result.videoMute, false);
-    assert.equal(result.thumbnailPromptDismissed, "sig");
-    // Page options no longer edit the default view (S13 G5), so a stored one stays.
-    assert.equal(result.defaultViewMode, "list");
-    // The page-only keys come from the dialog.
-    assert.equal(result.lazyLoading, false);
-    assert.equal(result.debugMode, true);
-    assert.equal(result.checkThumbnailsAtStartup, false);
-    assert.equal(result.defaultLimit, 200);
-    assert.equal(result.gridColumns, 6);
-    assert.equal(result.infiniteScroll, true);
-    assert.equal(result.apiTimeout, 45);
-});
-
-test("a legacy gallery Reset restores only the page options and keeps every other stored key", () => {
-    const controls = PAGE_OPTION_CONTROLS();
-    const { manager, saved, calls } = legacyGallery({ workspaceLayout: "masonry", imageQuality: "high", videoMute: false,
-        thumbnailPromptDismissed: "sig", thumbnailsGenerated: true, lazyLoading: false, debugMode: true, defaultLimit: 200,
-        gridColumns: 6, infiniteScroll: true, apiTimeout: 45, checkThumbnailsAtStartup: false, defaultViewMode: "list" }, controls,
-    { confirm: message => (calls.push(["confirm", message]), true) });
-    manager.resetSettings();
-    const result = saved();
-    const { DEFAULT_SETTINGS } = require("../../web/js/gallery-settings.js");
-    for (const key of ["checkThumbnailsAtStartup", "lazyLoading", "defaultLimit", "gridColumns",
-        "infiniteScroll", "debugMode", "apiTimeout"]) {
-        assert.equal(result[key], DEFAULT_SETTINGS[key], key);
-    }
-    // The default view is not a page option (S13 G5): Reset keeps a stored one.
-    assert.equal(result.defaultViewMode, "list");
-    assert.equal(result.workspaceLayout, "masonry");
-    assert.equal(result.imageQuality, "high");
-    assert.equal(result.videoMute, false);
-    assert.equal(result.thumbnailPromptDismissed, "sig");
-    assert.equal(result.thumbnailsGenerated, true);
-    // The dialog shows the defaults again and the page applies them.
-    assert.equal(controls.lazyLoadingToggle.checked, DEFAULT_SETTINGS.lazyLoading);
-    assert.equal(controls.apiTimeoutInput.value, DEFAULT_SETTINGS.apiTimeout);
-    assert.deepEqual(calls, [["confirm", "Reset these page options to their defaults?"], ["apply", DEFAULT_SETTINGS.lazyLoading],
-        ["success", "Page options reset to defaults"]]);
-});
-
-test("Page options no longer hold the default view; System › Appearance's Default layout is the one control", () => {
-    const { manager } = legacyGallery({}, {});
-    assert.deepEqual([...manager.constructor.PAGE_OPTION_KEYS], ["checkThumbnailsAtStartup", "lazyLoading", "defaultLimit",
-        "gridColumns", "infiniteScroll", "debugMode", "apiTimeout"]);
-});
-
-test("a viewer mute or loop click remembers only that key and never reads the Page options dialog", () => {
-    const { manager, saved, calls } = legacyGallery({ defaultLimit: 200, lazyLoading: false, videoMute: true }, {});
-    manager.storeSetting("videoMute", false);
-    const result = saved();
-    assert.equal(result.videoMute, false);
-    assert.equal(result.defaultLimit, 200);
-    assert.equal(result.lazyLoading, false);
-    assert.deepEqual(calls, []);
+    const saved = JSON.parse(storage.get("gallerySettings"));
+    assert.equal(saved.workspaceLayout, "masonry");
+    assert.equal(saved.workspaceDensity, "compact");
+    assert.equal(saved.someOtherTool, 1);
+    assert.equal(saved.defaultViewMode, "list");
+    assert.equal(saved.showImageInfo, false);
+    assert.equal(saved.videoMute, false);
 });
@@ -112,12 +112,11 @@ test('saving gallery settings retains the remembered thumbnail dismissal', () =>
 });

 // #249 System S5: the stream's work is now an Activity job that outlives the page's connection, so the gallery's
-// Cancel asks the server to stop the job. Since #330 the startup dialog is the gallery's only thumbnail stream (System
-// › Sources & scans generates the rest). The stream's first frame, `job {id, started}`, names the job; the gallery
+// Cancel asks the server to stop the job. The stream's first frame, `job {id, started}`, names the job; the gallery
 // cancels by that id, only a job this stream started, and a Cancel before the id waits for it (review I1).
 const JOB = 'b'.repeat(32);

-function streamFixture({ postFails = false } = {}) {
+function streamFixture({ modal = false, postFails = false } = {}) {
    const posts = [];
    const warnings = [];
    const gets = [];
@@ -147,20 +146,18 @@ function streamFixture({ postFails = false } = {}) {
                return { success: true };
            } } });
    const emit = (type, data) => (listeners[type] || []).forEach(handler => handler({ data: JSON.stringify(data) }));
-    // The dialog's Cancel runs the handler and from then on reads as cancelled, as the startup dialog does.
-    let cancelled = false;
    const ui = { addStatusMessage() {}, progressText: element(), progressPercent: element(), progressBar: element(),
-        progressDetails: element(), progressETA: element(), isCancelled: () => cancelled,
-        onCancel: handler => { ui.cancel = () => { cancelled = true; handler(); }; } };
-    const result = manager.generateThumbnailsWithProgressInModal(ui);
+        progressDetails: element(), progressETA: element(), isCancelled: () => false,
+        onCancel: handler => { ui.cancel = handler; } };
+    const result = modal ? manager.generateThumbnailsWithProgressInModal(ui)
+        : manager.generateThumbnailsWithProgress({ quality: 'medium' });
    const outcome = result.then(value => ({ value }), error => ({ error: error.message }));
-    const cancel = () => ui.cancel();
+    const cancel = () => (modal ? ui.cancel() : elements.cancelThumbnailsBtn.click());
    const settle = () => new Promise(resolve => setImmediate(resolve));
    return { emit, source, posts, gets, warnings, outcome, cancel, settle };
 }

 const cancelUrl = id => `/prompt_manager/jobs/${id}/cancel`;
-const CANCELLED = 'Thumbnail generation cancelled; previews already written are kept';

 test('Cancel before the job id arrives cancels that job once it does', async () => {
    const f = streamFixture();
@@ -168,8 +165,8 @@ test('Cancel before the job id arrives cancels that job once it does', async ()
    await f.settle();
    assert.deepEqual(f.posts, []);
    assert.equal(f.source.closed, 0); // kept open until the stream names its job
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
-    // The job frame is the stream's first (the dialog closes the stream on any later frame once cancelled).
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
+    f.emit('status', { phase: 'scanning', message: 'Scanning…' });
    f.emit('job', { id: JOB, started: true });
    await f.settle();
    assert.equal(JSON.stringify(f.posts), JSON.stringify([[cancelUrl(JOB), {}]]));
@@ -188,7 +185,7 @@ test('Cancel after the id cancels it at once, and a double Cancel posts once', a
    await f.settle();
    assert.equal(JSON.stringify(f.posts), JSON.stringify([[cancelUrl(JOB), {}]]));
    assert.equal(f.source.closed, 1);
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
    assert.deepEqual(f.gets, []);
 });

@@ -219,11 +216,11 @@ test('a cancel post that fails is reported, not thrown', async () => {
    await f.settle();
    assert.equal(f.posts.length, 1);
    assert.equal(f.warnings.length, 1);
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
 });

 test('the startup dialog cancels its own job by id too', async () => {
-    const f = streamFixture();
+    const f = streamFixture({ modal: true });
    f.cancel();
    await f.settle();
    assert.deepEqual(f.posts, []);
@@ -5,8 +5,6 @@ const {
    formatImageCaption,
    workflowDocumentHtml,
    autotagSingleBody,
-    autotagApplyBody,
-    autotagCompleteMessage,
    fallbackImageSource,
 } = require("../../web/js/image-helpers.js");

@@ -123,27 +121,3 @@ test('metadata lookup preserves encoded filename characters and works behind a p
    assert.equal(metadataLookupUrl('/prompt_manager/images/serve/a.png?v=123'), '/prompt_manager/images/prompt/a.png');
    assert.equal(metadataLookupUrl('/elsewhere/a.png'), null);
 });
-
-test("autotagSingleBody asks to skip auto-tagged images only when told (#379)", () => {
-    assert.equal(autotagSingleBody({ id: 1 }, WD14).existing, "merge");
-    assert.equal(autotagSingleBody({ id: 1 }, { ...WD14, existing: "skip" }).existing, "skip");
-    assert.equal(autotagSingleBody({ id: 1 }, { ...WD14, existing: "odd" }).existing, "merge");
-});
-
-test("autotagApplyBody names the image, its bytes and the tags, never a prompt (#379)", () => {
-    const sha = "a".repeat(64);
-    assert.deepEqual(autotagApplyBody({ id: 4, prompt_id: 7 }, sha, ["bird"]), { image_id: 4, sha256: sha, tags: ["bird"] });
-    assert.deepEqual(autotagApplyBody({ id: "digest", path: "sub/a.png", root_index: 1 }, sha, []),
-        { path: "sub/a.png", root_index: 1, sha256: sha, tags: [] });
-    assert.deepEqual(autotagApplyBody({ id: 2 }, undefined, null), { image_id: 2, sha256: "", tags: [] });
-    const tags = ["x"];
-    autotagApplyBody({ id: 1 }, sha, tags).tags.push("y");
-    assert.deepEqual(tags, ["x"]);
-});
-
-test("autotagCompleteMessage counts images (#379)", () => {
-    assert.equal(autotagCompleteMessage(2), "Auto tagging complete! Tagged 2 images.");
-    assert.equal(autotagCompleteMessage(1), "Auto tagging complete! Tagged 1 image.");
-    assert.equal(autotagCompleteMessage(0), "Auto tagging complete! Tagged 0 images.");
-    assert.equal(autotagCompleteMessage(undefined), "Auto tagging complete! Tagged 0 images.");
-});
@@ -65,12 +65,109 @@ function load(file, className, fetchUrl, extra = {}, dom = elements()) {

 const BUSY = 'Scan for metadata already running';

+test('gallery cache clear reports a refused server clear and never claims success', async () => {
+    const calls = [];
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async url => {
+        calls.push(url);
+        return jsonResponse(409, { success: false, error: BUSY });
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+    dom.getElementById('thumbnailStatus').textContent = 'Generated';
+
+    await page.clearCache();
+
+    assert.deepEqual(calls, ['/prompt_manager/images/clear-thumbnails']);
+    assert.deepEqual(notifications, [['error', `Thumbnails were not cleared: ${BUSY}`]]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Generated');
+    assert.equal(storage.get('gallerySettings'), undefined); // thumbnailsGenerated is not reset
+});
+
+test('gallery cache clear says what it cleared and keeps preferences and other data (#222)', async () => {
+    const calls = [];
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async url => {
+        calls.push(url);
+        return jsonResponse(200, { success: true, cleared_count: 3 });
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+
+    await page.clearCache();
+
+    // The server's thumbnails are cleared by their own explicit call; nothing Prompt Manager owns is cached in this
+    // browser, so no browser entry is removed and the toast says exactly that.
+    assert.deepEqual(calls, ['/prompt_manager/images/clear-thumbnails']);
+    assert.deepEqual(notifications, [['success',
+        "Thumbnails cleared; original images untouched. Nothing of Prompt Manager's is cached in this browser."]]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Not generated');
+    assert.equal(JSON.parse(storage.get('gallerySettings')).thumbnailsGenerated, false);
+    assert.equal(storage.get('userData'), 'keep');
+    assert.equal(storage.get('pm_cached'), '1');
+    assert.equal(storage.get('pm_workspace_theme'), 'light');
+    assert.equal(storage.get('pm_update_notice_dismissed'), '3.3.0');
+});
+
+test("gallery cache clear never deletes another tool's gallery or thumbnail caches (#222)", async () => {
+    const names = new Set(['comfy-gallery', 'thumbnail-cache']);
+    const caches = { keys: async () => [...names], delete: async name => names.delete(name) };
+    const { page, notifications } = load('gallery.js', 'GalleryManager',
+        async () => jsonResponse(200, { success: true }), { caches, window: { caches } });
+    page.getSettings = () => ({});
+
+    await page.clearCache();
+
+    assert.deepEqual([...names], ['comfy-gallery', 'thumbnail-cache']);
+    assert.equal(notifications.at(-1)[0], 'success');
+});
+
+test('gallery cache clear reports a lost server clear instead of success', async () => {
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async () => {
+        throw new TypeError('Failed to fetch');
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+    dom.getElementById('thumbnailStatus').textContent = 'Generated';
+
+    await page.clearCache();
+
+    assert.deepEqual(notifications, [['error', 'Thumbnails were not cleared: the server could not be reached.']]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Generated');
+    assert.equal(storage.get('gallerySettings'), undefined);
+});
+
+test('gallery cache clear says so when browser storage is denied', async () => {
+    const denied = { get length() { throw new Error('SecurityError'); }, key() { throw new Error('SecurityError'); },
+        getItem() { throw new Error('SecurityError'); }, setItem() { throw new Error('SecurityError'); },
+        removeItem() { throw new Error('SecurityError'); } };
+    const { page, notifications } = load('gallery.js', 'GalleryManager',
+        async () => jsonResponse(200, { success: true }), { localStorage: denied });
+    page.getSettings = () => ({});
+
+    await page.clearCache();
+
+    assert.deepEqual(notifications, [['warning',
+        'Thumbnails cleared; original images untouched. This browser refused access to its storage, so nothing there was cleared.']]);
+});
+
+test('admin LoRA import shows a refusal frame and closes its modal', async () => {
+    const { page, dom, timers, notifications } = load('admin.js', 'PromptAdmin',
+        async () => sseResponse([{ type: 'error', status: BUSY, progress: 0, message: BUSY }]));
+    page.saveLoraSettings = async () => true;
+    page.loadStatistics = () => assert.fail('a refused import must not reload statistics');
+
+    await page.runLoraImport();
+
+    assert.equal(dom.nodes.loraImportStatus.textContent, `Error: ${BUSY}`);
+    assert.deepEqual(notifications.filter(([type]) => type === 'error'), [['error', `LoRA import failed: ${BUSY}`]]);
+    assert.equal(timers.length, 1);
+    timers[0]();
+    assert.deepEqual(notifications.at(-1), ['hide', 'loraImportModal']);
+});
+
 test('admin settings save shows why config.json refused it', async () => {
    const message = 'config.json cannot be read, so nothing was saved. Fix or remove the file, then save again.';
    const { page, notifications } = load('admin.js', 'PromptAdmin',
        async () => jsonResponse(409, { success: false, persisted: false, code: 'config-unreadable', error: message }));
    page.settings = {};
-    page.setInfiniteScroll = () => assert.fail('nothing changes after a refusal');
+    page._collectScanPaths = () => [];
+    page.saveLoraSettings = async () => assert.fail('nothing else is saved after a refusal');

    await page.saveSettings();

@@ -81,30 +178,27 @@ test('admin settings save keeps its plain message when the reply has no reason',
    const { page, notifications } = load('admin.js', 'PromptAdmin', async () => ({ ok: false, status: 500,
        json: async () => { throw new SyntaxError('not json'); } }));
    page.settings = {};
+    page._collectScanPaths = () => [];

    await page.saveSettings();

    assert.deepEqual(notifications, [['error', 'Failed to save settings']]);
 });

-// #330 S13-9: the admin page's reduced Page options save sends only the list's scroll default, so a stale legacy form
-// can no longer overwrite scan folders or other settings edited in System.
-test('admin Page options save posts only infinite_scroll', async () => {
-    const sent = [];
-    const { page, dom, notifications } = load('admin.js', 'PromptAdmin', async (url, init) => {
-        sent.push([url, init.method, JSON.parse(init.body)]);
-        return jsonResponse(200, { success: true, restart_required: true });
-    });
-    page.settings = { infiniteScroll: false };
-    const scrolled = [];
-    page.setInfiniteScroll = (on, options) => scrolled.push([on, { ...options }]);
-    dom.getElementById('infiniteScrollDefault').checked = true;
+test('admin maintenance names the job that refused it', async () => {
+    const { page, dom, notifications } = load('admin.js', 'PromptAdmin',
+        async () => jsonResponse(409, { success: false, error: BUSY }), {
+            escapeHtml: text => String(text),
+            document: { readyState: 'loading', addEventListener() {}, getElementById: id => dom.getElementById(id),
+                querySelectorAll: selector => (selector === '.maintenance-option:checked' ? [{ id: 'vacuum' }] : []) },
+        });

-    await page.saveSettings();
+    await page.runMaintenance();

-    assert.deepEqual(sent, [['/prompt_manager/settings', 'POST', { infinite_scroll: true }]]);
-    assert.deepEqual(scrolled, [[true, { session: false }]]);
-    assert.equal(page.settings.infiniteScroll, true);
-    assert.deepEqual(notifications, [['success', 'Page options saved'], ['hide', 'settingsModal']]);
+    const results = dom.nodes.maintenanceResults.innerHTML;
+    assert.match(results, /Maintenance Failed/);
+    assert.match(results, new RegExp(BUSY));
+    assert.doesNotMatch(results, /HTTP 409/);
+    assert.deepEqual(notifications, [['error', '❌ Maintenance failed']]);
+    assert.equal(dom.nodes.runMaintenanceBtn.disabled, false);
 });
-
@@ -97,30 +97,6 @@ test("connect reports a non-2xx response through onerror and never onmessage", a
    assert.equal(source.readyState, source.CLOSED);
 });

-test("a non-2xx JSON answer's error sentence reaches onerror as serverMessage", async () => {
-    let error = null;
-    const fetchImpl = async () => new Response(
-        JSON.stringify({ success: false, error: "Auto-tagging is already running" }),
-        { status: 409, headers: { "Content-Type": "application/json" } },
-    );
-    const source = connect("/x", { fetchImpl });
-    source.onerror = (err) => { error = err; };
-    await until(() => error !== null);
-    assert.match(error.message, /409/);
-    assert.equal(error.status, 409);
-    assert.equal(error.serverMessage, "Auto-tagging is already running");
-});
-
-test("a non-2xx answer without a JSON error has no serverMessage", async () => {
-    let error = null;
-    const fetchImpl = async () => new Response("nope", { status: 500 });
-    const source = connect("/x", { fetchImpl });
-    source.onerror = (err) => { error = err; };
-    await until(() => error !== null);
-    assert.equal(error.status, 500);
-    assert.equal(error.serverMessage, undefined);
-});
-
 test("connect reports a network failure through onerror", async () => {
    let error = null;
    const source = connect("/x", { fetchImpl: async () => { throw new TypeError("Failed to fetch"); } });
@@ -185,26 +185,6 @@ test('legacy fill applies to local records', async () => {
    assert.notEqual(zeroed.prompts.positive.text, '');
 });

-test('a branch named by recorded run history shows the Recorded run badge', async () => {
-    // #386: the server labels sides whose save node recorded history named; Execution recorded stays stronger.
-    const base = await localRecord(new File([fs.readFileSync(new URL('f09.png', PARITY))], 'f09.png'));
-    const recorded = {...base, prompts:{positive:{...base.prompts.positive, source:'recorded-run'}, negative:{...base.prompts.negative, source:'recorded-run'}}};
-    let view = renderFull(recorded);
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Recorded run']);
-        assert.ok(view.texts(n => n.tagName === 'p').includes('Prompt evidence: recorded run'));
-    } finally { view.done(); }
-    view = renderFull({...recorded, prompts:{...recorded.prompts, negative:{...recorded.prompts.negative, source:'execution'}}});
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Execution recorded']);
-    } finally { view.done(); }
-    // A recorded branch whose negative left out a run-time part is still inferred from the workflow.
-    view = renderFull({...recorded, prompts:{...recorded.prompts, negative:{...recorded.prompts.negative, source:'runtime-parts-omitted'}}});
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Workflow inferred']);
-    } finally { view.done(); }
-});
-
 // #249 PR C Task C3 (D88): one chip row, the file's current image tags first, then D21's linked tags not already shown.
 function tagged(imageTags, library = {status:'linked', tags:['Minimal', 'warm_light', 'editorial'], tags_scope:'positive'}) {
    return {...record(), imageTags, library};
@@ -383,32 +363,3 @@ test('the D117 wrap rule targets only the settings summary button', async () =>
    assert.deepEqual(rules.map(line => line.trim()), ['.ca-tools #viewer-details .settings-summary { white-space: normal; /* D117 */ }']);
    assert.doesNotMatch(css, /#viewer-details > div > button/);
 });
-
-test('category chip names its origin and shows an own category for any link status (#332)', async () => {
-    const base = await localRecord(localPng('a.png'));
-    const chipTexts = record => {
-        const {f, done} = renderFull(record);
-        try {
-            return f.walk(f.container, n => /(^| )chip( |$)/.test(n.className ?? '')).map(n => n.textContent);
-        } finally { done(); }
-    };
-    const cases = [
-        [{status:'none', category:'Scans', category_scope:'image'}, 'Image category: Scans'],
-        [{status:'ambiguous', category:'Scans', category_scope:'image'}, 'Image category: Scans'],
-        [{status:'linked', category:'Portraits', category_scope:'image'}, 'Image category: Portraits'],
-        [{status:'linked', category:'Landscapes', category_scope:'positive'}, 'Positive prompt category: Landscapes'],
-        [{status:'linked', category:'Recipes', category_scope:'pair'}, 'Recipe category: Recipes'],
-    ];
-    for (const [library, text] of cases) {
-        const chips = chipTexts({...base, library:{...base.library, tags:[], tags_scope:null, ...library}});
-        assert.ok(chips.includes(text), `${JSON.stringify(library)} -> ${chips}`);
-    }
-    for (const library of [
-        {status:'none', category:'Inherited', category_scope:'positive'},
-        {status:'linked', category:null, category_scope:null},
-        {status:'none', category:null, category_scope:null},
-    ]) {
-        const chips = chipTexts({...base, library:{...base.library, tags:[], tags_scope:null, ...library}});
-        assert.equal(chips.some(chip => /category: /.test(chip)), false, JSON.stringify(library));
-    }
-});
@@ -1,110 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const source = import('../../web/js/workspace/images-multiselect.mjs');
-
-const KEYS = Object.freeze(['0:a', '0:b', '0:c', '0:d', '1:e']);
-
-test('a range runs from the anchor to the target in display order, either way', async () => {
-    const { rangeKeys } = await source;
-    assert.deepEqual(rangeKeys(KEYS, '0:b', '0:d'), ['0:b', '0:c', '0:d']);
-    assert.deepEqual(rangeKeys(KEYS, '1:e', '0:c'), ['0:c', '0:d', '1:e']);
-    assert.deepEqual(rangeKeys(KEYS, '0:c', '0:c'), ['0:c']);
-});
-
-test('a range without a listed anchor is the target alone, and an unlisted target is empty', async () => {
-    const { rangeKeys } = await source;
-    assert.deepEqual(rangeKeys(KEYS, null, '0:c'), ['0:c']);
-    assert.deepEqual(rangeKeys(KEYS, '9:gone', '0:c'), ['0:c']);
-    assert.deepEqual(rangeKeys(KEYS, '0:a', '9:gone'), []);
-});
-
-test('applying keys adds or removes them and keeps the same frozen set when nothing changes', async () => {
-    const { applyKeys } = await source;
-    const start = Object.freeze(new Set(['0:a']));
-    const added = applyKeys(start, ['0:b', '0:c'], true);
-    assert.deepEqual([...added], ['0:a', '0:b', '0:c']);
-    assert.ok(Object.isFrozen(added));
-    assert.deepEqual([...start], ['0:a']);
-    const removed = applyKeys(added, ['0:a', '0:b'], false);
-    assert.deepEqual([...removed], ['0:c']);
-    assert.equal(applyKeys(removed, ['0:c'], true), removed);
-    assert.equal(applyKeys(removed, ['0:a'], false), removed);
-});
-
-test('every listed key is checked only when each one is in the set', async () => {
-    const { everyChecked } = await source;
-    assert.equal(everyChecked(new Set(KEYS), KEYS), true);
-    assert.equal(everyChecked(new Set(KEYS.slice(1)), KEYS), false);
-    assert.equal(everyChecked(new Set(['x', ...KEYS.slice(1)]), KEYS), false);
-    assert.equal(everyChecked(new Set(), []), false);
-});
-
-test('the select-all-matching offer needs every loaded image checked and more to load', async () => {
-    const { offersAllMatching } = await source;
-    const all = new Set(KEYS);
-    assert.equal(offersAllMatching(all, KEYS, { total: 9, hasMore: true }), true);
-    assert.equal(offersAllMatching(all, KEYS, { total: 5, hasMore: false }), false);
-    assert.equal(offersAllMatching(new Set(KEYS.slice(1)), KEYS, { total: 9, hasMore: true }), false);
-    assert.equal(offersAllMatching(new Set(), [], { total: 9, hasMore: true }), false);
-});
-
-test('the counts read "N selected" and "All N matching selected", grouped', async () => {
-    const { matchingLabel, matchingOffer } = await source;
-    assert.equal(matchingLabel(12345), 'All 12,345 matching selected');
-    assert.equal(matchingOffer(12345), 'Select all 12,345 matching');
-});
-
-function fakeTimers() {
-    const timers = new Map();
-    let next = 1;
-    return {
-        set: (callback, delay) => { timers.set(next, { callback, delay }); return next++; },
-        clear: id => timers.delete(id),
-        fire: () => { for (const [id, { callback }] of [...timers]) { timers.delete(id); callback(); } },
-        pending: () => timers.size,
-        delays: () => [...timers.values()].map(timer => timer.delay),
-    };
-}
-
-test('a held press fires once after the delay and swallows the click that follows', async () => {
-    const { createLongPress, LONG_PRESS_MS } = await source;
-    const timers = fakeTimers(), fired = [];
-    const press = createLongPress({ onLongPress: target => fired.push(target), setTimer: timers.set, clearTimer: timers.clear });
-    press.down(10, 10, 'card-a');
-    assert.deepEqual(timers.delays(), [LONG_PRESS_MS]);
-    assert.equal(LONG_PRESS_MS, 500);
-    press.move(14, 13);
-    timers.fire();
-    assert.deepEqual(fired, ['card-a']);
-    press.up();
-    assert.equal(press.consumeClick(), true);
-    assert.equal(press.consumeClick(), false);
-});
-
-test('moving past the slop, lifting early or cancelling never fires', async () => {
-    const { createLongPress, LONG_PRESS_SLOP } = await source;
-    assert.equal(LONG_PRESS_SLOP, 10);
-    const timers = fakeTimers(), fired = [];
-    const press = createLongPress({ onLongPress: target => fired.push(target), setTimer: timers.set, clearTimer: timers.clear });
-    press.down(0, 0, 'a'); press.move(0, 11);
-    assert.equal(timers.pending(), 0);
-    press.down(0, 0, 'b'); press.up();
-    assert.equal(timers.pending(), 0);
-    press.down(0, 0, 'c');
-    assert.equal(press.pending(), true);
-    press.cancel();
-    assert.equal(press.pending(), false);
-    assert.equal(timers.pending(), 0);
-    press.move(0, 0); press.up(); press.cancel();
-    assert.deepEqual(fired, []);
-    assert.equal(press.consumeClick(), false);
-    // A new press drops a long press whose click never came.
-    press.down(0, 0, 'd'); timers.fire();
-    press.down(0, 0, 'e');
-    assert.equal(press.consumeClick(), false);
-    timers.fire();
-    assert.deepEqual(fired, ['d', 'e']);
-    // A cancel (a mouse press on a hybrid device) forgets a fired press whose click never came.
-    press.cancel();
-    assert.equal(press.consumeClick(), false);
-});
@@ -234,23 +234,6 @@ test('the count line reads N of M images and K positive prompts only when known'
    assert.equal(countLine({loaded:1200,total:3400,positiveCount:0}),'1,200 of 3,400 images · 0 positive prompts');
 });

-test('the count line reads as loading, never as an empty result, until a first page answers (#391)', async () => {
-    const {countLine,createImageStream}=await source;
-    assert.equal(countLine({loaded:0,total:0,positiveCount:null,loading:true,error:null}),'Loading images…');
-    // A failed first page and a settled empty one say what the server said; a later page keeps the loaded count.
-    assert.equal(countLine({loaded:0,total:0,positiveCount:null,loading:false,error:new Error('x')}),'0 of 0 images');
-    assert.equal(countLine({loaded:0,total:0,positiveCount:0,loading:false,error:null}),'0 of 0 images · 0 positive prompts');
-    assert.equal(countLine({loaded:40,total:102,positiveCount:2,loading:true,error:null}),'40 of 102 images · 2 positive prompts');
-    // While a reset's first page is in flight the line reads as loading (the cleared state before it is replaced in
-    // the same task, so it is never painted).
-    let answer;const lines=[];
-    const stream=createImageStream({api:{get:()=>new Promise(resolve=>{answer=resolve;})},onChange:state=>lines.push(countLine(state))});
-    const loading=stream.reset({tags:['cinematic']});
-    assert.equal(lines.at(-1),'Loading images…');
-    answer({images:[{path:'a.png',root_index:0}],total:1,has_more:false,next_cursor:null,positive_count:1});await loading;
-    assert.equal(lines.at(-1),'1 of 1 image · 1 positive prompt');
-});
-
 test('the caption date names the newest result day under Newest first only', async () => {
    const {captionDate}=await source;
    const now=new Date(2026,9,17,15,0);
@@ -511,11 +494,3 @@ test('defaults apply to a new visit but not to the current view or a saved view'
    assert.deepEqual(initialImagesView({}), { layout: 'grid', density: 'comfortable' });
    assert.deepEqual(initialImagesView({ preferences: {} }), { layout: 'grid', density: 'comfortable' });
 });
-
-test('listingFilter is the listing query as an object, without paging (#392)', async () => {
-    const { listingFilter } = await source;
-    assert.deepEqual(listingFilter({q:'cat', root:'1', subfolder:'a/b', category:'Animals', tags:[' x ','y'], media:'video', sort:'oldest', favorites:true}),
-        {q:'cat', root:'1', subfolder:'a/b', category:'Animals', tags:'x,y', media:'video', sort:'oldest', favorites:'1'});
-    assert.deepEqual(listingFilter({root:'all', q:'', tags:[], media:'all'}), {sort:'newest'});
-    assert.throws(() => listingFilter({sort:'sideways'}), TypeError);
-});
@@ -196,29 +196,3 @@ test('a preset starts the Tag image dialog on the chosen model and options', asy
    assert.throws(() => createImageTaggingController({ api, target, preset: { model: 'gguf', options: { instructions: '' } } }), TypeError);
    assert.throws(() => createImageTaggingController({ api, target, preset: { model: 'gguf', options: { nope: 1 } } }), TypeError);
 });
-
-test('all matching sends the listing filter instead of targets, up to 10,000 images (#392)', async () => {
-    const { openAddTags, openAutoTag, MAX_FILTER_IMAGES, TOO_MANY_MATCHING } = module();
-    assert.equal(MAX_FILTER_IMAGES, 10000);
-    assert.equal(TOO_MANY_MATCHING, 'Narrow the view to at most 10,000 images.');
-    const toasts = [], posted = [], tagged = [];
-    let ended = null;
-    const store = { start: async (kind, body) => { posted.push([kind, body]); return { job: { id: JOB_ID, state: 'running' } }; },
-        find: () => ended, subscribe: () => () => {} };
-    const filter = { q: 'cat', sort: 'newest' };
-    // The loaded images can be more than 500: the filter, not the identities, is sent.
-    const loaded = Array.from({ length: 600 }, (_, index) => image(`bulk/${index}.png`));
-    let dialog = null;
-    openAddTags({ scope: pageScope(), store, images: loaded, filter, count: 1234, notify: text => toasts.push(text),
-        onTagged: keys => tagged.push(keys.size), openInput: args => { dialog = args; } });
-    assert.ok(dialog, 'the Add tags dialog opens');
-    ended = { id: JOB_ID, state: 'finished', counters: { tagged: 3 } };
-    await dialog.onApply('sunset');
-    assert.deepEqual(posted, [['image-tags', { mode: 'add', filter, tags: ['sunset'] }]]);
-    // The loaded files are read again when the job tagged any.
-    assert.deepEqual(tagged, [600]);
-    openAddTags({ scope: pageScope(), store, images: loaded, filter, count: 10001, notify: text => toasts.push(text),
-        openInput: () => assert.fail('no dialog over the cap') });
-    openAutoTag({ api: {}, scope: pageScope(), store, images: loaded, filter, count: 10001, notify: text => toasts.push(text) });
-    assert.deepEqual(toasts, [TOO_MANY_MATCHING, TOO_MANY_MATCHING]);
-});
@@ -278,7 +278,6 @@ test('record rejects root path media and invalid versioned fields with retryable
        data => { data.resolution.sampler_id = {}; },
        data => { data.library.tags_scope = 'recipe'; },
        data => { data.library.category_scope = 'recipe'; },
-        data => { data.library.tags_scope = 'image'; },
        data => { delete data.library.category_scope; },
        data => { delete data.library.tags_scope; },
    ]) {
@@ -943,14 +942,3 @@ test("names the server quotes (parentheses, '!*') still match their original and
    assert.equal(record.download.url, entry.url);
    assert.deepEqual(record.preview, { url: entry.thumbnail_url });
 });
-
-test('record accepts an image\'s own category on any link status (#332)', () => {
-    const toRecord = contract('toInspectionRecord');
-    for (const status of ['linked', 'none', 'ambiguous', 'unavailable']) {
-        const data = envelope();
-        Object.assign(data.library, { status, category: 'Scans', category_scope: 'image' });
-        const record = toRecord(data, image(), extractGenerationFacts);
-        assert.equal(record.library.category, 'Scans');
-        assert.equal(record.library.category_scope, 'image');
-    }
-});
@@ -23,7 +23,7 @@ test('tags is a native route titled Tags; only unbuilt routes hand off to legacy
        assert.equal(routeTitle(route), route.label);
    }
    assert.equal(routeTitle(resolveRoute('#/library/7')), 'Prompt library');
-    // System is native from S2 (#249 System), and every section of it from S12 (D94 retired), not the route.
+    // System is native from S2 (#249 System): its undelivered sections hand off per section (D94), not the route.
    for (const id of ['images', 'library', 'tags', 'inspect', 'overview', 'activity', 'review', 'system']) assert.equal(isHandoff(resolveRoute(`#/${id}`)), false, id);
 });

@@ -1,215 +0,0 @@
-// System › Diagnostics & logs (#249 System S12, #329): the concept's two surfaces (app.js 694–695) with live values: the
-// meta-grid texts, the report's name and merge (D110), the log viewer's lines, Lines validation, statistics, retention
-// and file rows, and the Clear all logs copy (D109).
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const diagnostics = import('../../web/js/workspace/system-diagnostics.mjs');
-
-const CONCEPT = fs.readFileSync(path.join(__dirname, '../../docs/concepts/workspace/app.js'), 'utf8');
-const SOURCE = fs.readFileSync(path.join(__dirname, '../../web/js/workspace/system-diagnostics.mjs'), 'utf8');
-const SYSTEM = fs.readFileSync(path.join(__dirname, '../../web/js/workspace/system.mjs'), 'utf8');
-
-const REPORT = {
-    checks: { database: { status: 'ok', prompt_count: 4210, has_images_table: true, image_count: 19956 } },
-    database_info: { database_path: 'user/__promptmanager/prompts.db', database_size_bytes: 1717986918 },
-    sources: { configured: 2, effective: 2, watching: 2, unavailable: 0 },
-    viewerjs: '1.15.2',
-};
-
-test('the section keeps the concept surfaces, terms, rows and labels; no sample copy ships', () => {
-    const start = CONCEPT.indexOf('case "diagnostics":');
-    const body = CONCEPT.slice(start, CONCEPT.indexOf('break;', start));
-    const terms = [...body.matchAll(/<dt>([^<]+)<\/dt>/g)].map(([, term]) => term);
-    assert.deepEqual(terms, ['Database', 'Sources', 'Viewer.js', 'Host renderers']);
-    for (const text of ["'Diagnostics'", "'Logs'", "'Run checks'", "'Refresh'", "'Level'", "'Log files & retention'",
-        "'Review log cleanup'", "'Runtime log level'", "'Console logging'", "'Image-link diagnostics'"]) {
-        assert.ok(SOURCE.includes(text), text);
-    }
-    for (const id of ['runtime-level', 'console-log']) assert.ok(body.includes(`setting("${id}"`) && SOURCE.includes(`id: '${id}'`), id);
-    assert.ok(SOURCE.includes("'toolbar spaced-16'") && body.includes('class="toolbar spaced-16"'));
-    // Prototype copy is never shipped.
-    for (const sample of ['sample', 'Sample']) assert.ok(!SOURCE.includes(`'${sample}`) && !/Download sample|Inspect sample/.test(SOURCE), sample);
-});
-
-test('D94 is retired: Diagnostics & logs is a delivered section and nothing hands off', () => {
-    assert.ok(SYSTEM.includes('diagnostics: mountDiagnostics'));
-    assert.ok(!SYSTEM.includes('SECTION_HANDOFFS'));
-    assert.ok(!SYSTEM.includes('handoff('));
-    assert.ok(!SYSTEM.includes('NOT_DELIVERED'));
-});
-
-test('database text covers readable, not readable, busy and loading', async () => {
-    const { databaseText, LOADING, UNREADABLE } = await diagnostics;
-    assert.equal(databaseText({ report: REPORT }), 'Readable · 1.6 GB · 19,956 images');
-    assert.equal(databaseText({ report: { ...REPORT, checks: { database: { status: 'ok', image_count: 1 } },
-        database_info: { database_size_bytes: 2048 } } }), 'Readable · 2.0 KB · 1 image');
-    assert.equal(databaseText({ report: { checks: { database: { status: 'error', message: 'Database error: locked' } } } }),
-        'Not readable: Database error: locked');
-    assert.equal(databaseText({ loading: true }), LOADING);
-    assert.equal(LOADING, 'Loading…');
-    assert.equal(databaseText({ error: { code: 'busy', running: { id: 'j1', title: 'Restore' } } }), 'Busy: Restore is running.');
-    assert.equal(databaseText({ error: { code: 'busy' } }), 'Busy: another job is running.');
-    assert.equal(databaseText({ error: new Error('offline') }), UNREADABLE);
-    assert.equal(UNREADABLE, 'Could not be read.');
-});
-
-test('sources text follows the precedence table', async () => {
-    const { sourcesText } = await diagnostics;
-    const of = sources => sourcesText({ report: { sources } });
-    assert.equal(of({ configured: 0, effective: 1, watching: 1, unavailable: 0 }), 'ComfyUI output folder · watching');
-    assert.equal(of({ configured: 0, effective: 1, watching: 0, unavailable: 0 }), 'ComfyUI output folder · manual scan');
-    // Unavailable wins over watching.
-    assert.equal(of({ configured: 3, effective: 2, watching: 2, unavailable: 1 }), '3 sources · 1 not available');
-    assert.equal(of({ configured: 2, effective: 2, watching: 2, unavailable: 0 }), '2 sources · 2 watching');
-    assert.equal(of({ configured: 1, effective: 1, watching: 0, unavailable: 0 }), '1 source · 0 watching');
-    assert.equal(of(undefined), 'ComfyUI output folder · manual scan');
-});
-
-test('Viewer.js reads the pinned vendor version', async () => {
-    const { viewerText } = await diagnostics;
-    assert.equal(viewerText({ report: REPORT }), '1.15.2 · pinned vendor');
-    assert.equal(viewerText({ report: {} }), 'unknown · pinned vendor');
-});
-
-test('report filename uses local time', async () => {
-    const { reportFilename } = await diagnostics;
-    assert.equal(reportFilename(new Date(2026, 9, 6, 7, 5)), 'prompt-manager-diagnostics-20261006-0705.json');
-    assert.equal(reportFilename(new Date(2026, 11, 31, 23, 59)), 'prompt-manager-diagnostics-20261231-2359.json');
-});
-
-test('merged report adds only host_renderers', async () => {
-    const { mergeReport } = await diagnostics;
-    const merged = mergeReport(REPORT, 'Detected: Classic (1 ComfyUI window).');
-    assert.deepEqual(Object.keys(merged).sort(), [...Object.keys(REPORT), 'host_renderers'].sort());
-    assert.equal(merged.host_renderers, 'Detected: Classic (1 ComfyUI window).');
-    assert.equal(mergeReport(REPORT, null).host_renderers, null);
-    assert.equal(mergeReport(REPORT, undefined).host_renderers, null);
-    // The server's fields are not changed.
-    assert.equal(merged.sources, REPORT.sources);
-});
-
-test('sizes read as the server labels them (1 KB = 1024 bytes)', async () => {
-    const { sizeText } = await diagnostics;
-    assert.equal(sizeText(0), '0 bytes');
-    assert.equal(sizeText(1), '1 byte');
-    assert.equal(sizeText(1000), '1,000 bytes');
-    assert.equal(sizeText(2048), '2.0 KB');
-    assert.equal(sizeText(10 * 2 ** 20), '10.0 MB');
-    assert.equal(sizeText(1717986918), '1.6 GB');
-    assert.equal(sizeText(undefined), '0 bytes');
-});
-
-test("log line uses the concept's format", async () => {
-    const { logLine } = await diagnostics;
-    assert.equal(logLine({ timestamp: '2026-10-26T09:42:18.123456', level: 'INFO', message: 'Database backup verified' }),
-        '09:42:18 INFO  Database backup verified');
-    assert.equal(logLine({ timestamp: '2026-10-26T09:42:18', level: 'WARNING', message: '3 images have ambiguous prompt metadata' }),
-        '09:42:18 WARNING 3 images have ambiguous prompt metadata');
-    assert.match(logLine({ timestamp: '2026-10-26T09:42:18', level: 'ERROR', message: 'x' }), /^\d\d:\d\d:\d\d [A-Z]+ +\S/);
-    // The concept's sample lines read the same way.
-    assert.ok(CONCEPT.includes('09:42:18 INFO  Scan completed'));
-});
-
-test('Lines accepts whole numbers 1 to 500 only', async () => {
-    const { validLimit, logsUrl } = await diagnostics;
-    for (const [value, expected] of [['1', 1], ['500', 500], [' 20 ', 20], ['100', 100]]) assert.equal(validLimit(value), expected, value);
-    for (const value of ['0', '501', '2.5', '', ' ', '-1', '1e2', 'abc', undefined]) assert.equal(validLimit(value), null, String(value));
-    assert.equal(logsUrl('', 20), '/prompt_manager/logs?limit=20');
-    assert.equal(logsUrl('WARNING', 20), '/prompt_manager/logs?limit=20&level=WARNING');
-});
-
-test('the level filter offers all six minimum levels; the runtime level adds CRITICAL after the concept four', async () => {
-    const { LEVEL_OPTIONS, RUNTIME_LEVELS } = await diagnostics;
-    assert.deepEqual(LEVEL_OPTIONS.map(([, label]) => label), ['All levels', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']);
-    assert.equal(LEVEL_OPTIONS[0][0], '');
-    assert.deepEqual(RUNTIME_LEVELS, ['INFO', 'WARNING', 'DEBUG', 'ERROR', 'CRITICAL']);
-    assert.ok(CONCEPT.includes('["INFO", "WARNING", "DEBUG", "ERROR"]'));
-});
-
-test('statistics text uses singular forms for one', async () => {
-    const { statsText } = await diagnostics;
-    assert.equal(statsText({ buffer_count: 1000, level_counts: { INFO: 980, WARNING: 12, ERROR: 2, CRITICAL: 1 },
-        log_files_count: 5, total_log_size: 43201024 }), '1,000 entries in memory · 3 errors · 12 warnings · 5 files · 41.2 MB on disk');
-    assert.equal(statsText({ buffer_count: 1, level_counts: { WARNING: 1, CRITICAL: 1 }, log_files_count: 1, total_log_size: 1 }),
-        '1 entry in memory · 1 error · 1 warning · 1 file · 1 byte on disk');
-    assert.equal(statsText({}), '0 entries in memory · 0 errors · 0 warnings · 0 files · 0 bytes on disk');
-});
-
-test('retention, file line and file rows read the server values', async () => {
-    const { retentionText, fileLine, fileDetail } = await diagnostics;
-    assert.equal(retentionText({ max_file_size: 10485760, backup_count: 5, file_logging: true, buffer_size: 1000 }),
-        'Rotates at 10 MB · keeps 5 rotated copies · file logging on · memory buffer 1,000 entries');
-    assert.equal(retentionText({ max_file_size: 1572864, backup_count: 1, file_logging: false, buffer_size: 1 }),
-        'Rotates at 1.5 MB · keeps 1 rotated copy · file logging off · memory buffer 1 entry');
-    const files = [
-        { filename: 'prompt_manager.log', kind: 'active', size: 1468006, modified: '2026-10-26T09:42:18' },
-        { filename: 'prompt_manager.log.1', kind: 'rotated', size: 10485760, modified: '2026-10-25T14:02:00' },
-        { filename: 'prompt_manager.log.4', kind: 'link', size: 20, modified: '2026-10-25T14:02:00' },
-        { filename: 'prompt_manager.log.bak', kind: 'other', size: 0, modified: '2026-10-24T08:00:00' },
-    ];
-    assert.equal(fileLine(files), 'prompt_manager.log · 1.4 MB · rotated copies: 1');
-    assert.equal(fileLine([]), 'prompt_manager.log · not written yet · rotated copies: 0');
-    assert.equal(fileDetail(files[1]), '10.0 MB · 2026-10-25 14:02 · Rotated copy');
-    assert.equal(fileDetail(files[2]), '20 bytes · 2026-10-25 14:02 · Link, not downloaded');
-    assert.equal(fileDetail(files[3]), '0 bytes · 2026-10-24 08:00 · Other file');
-    assert.equal(fileDetail(files[0]), '1.4 MB · 2026-10-26 09:42 · Active log');
-});
-
-test('Clear all logs states both counts and its toast says what was done', async () => {
-    const { clearSentence, clearToast } = await diagnostics;
-    const rotated = size => ({ kind: 'rotated', size });
-    const files = [{ kind: 'active', size: 10 }, rotated(10 * 2 ** 20), rotated(10 * 2 ** 20), rotated(8.4 * 2 ** 20), { kind: 'other', size: 5 }];
-    assert.equal(clearSentence(files), 'Empties prompt_manager.log, deletes 3 rotated copies (28.4 MB) and clears the lines shown '
-        + 'here. The other files in the log folder are kept. This cannot be undone.');
-    assert.equal(clearSentence([{ kind: 'active', size: 1 }]), 'Empties prompt_manager.log and clears the lines shown here. '
-        + 'The other files in the log folder are kept. This cannot be undone.');
-    assert.match(clearSentence(null), /^Empties prompt_manager.log, deletes its rotated copies and clears/);
-    assert.equal(clearToast({ truncated: ['prompt_manager.log', 'prompt_manager.log.1', 'prompt_manager.log.2', 'prompt_manager.log.3'],
-        errors: [] }), 'Logs cleared · 3 rotated copies deleted.');
-    assert.equal(clearToast({ truncated: ['prompt_manager.log', 'prompt_manager.log.1', 'prompt_manager.log.2'],
-        errors: ['Failed to truncate prompt_manager.log.3: in use'] }), 'Logs cleared · 2 rotated copies deleted · 1 could not be deleted.');
-    assert.equal(clearToast({ truncated: ['prompt_manager.log', 'prompt_manager.log.1'], errors: [] }), 'Logs cleared · 1 rotated copy deleted.');
-    assert.equal(clearToast(undefined), 'Logs cleared · 0 rotated copies deleted.');
-});
-
-test('Clear all logs sends back exactly the files its confirmation showed (#389)', async () => {
-    const { clearBody, clearFailureText, COPY } = await diagnostics;
-    const files = [
-        { filename: 'prompt_manager.log', kind: 'active', identity: '10:1761000000123456789:9007199254740993' },
-        { filename: 'prompt_manager.log.1', kind: 'rotated', identity: '20:1761000000123456789:42' },
-        { filename: 'prompt_manager.log.4', kind: 'link', identity: '5:1:7' },
-        { filename: 'prompt_manager.log.bak', kind: 'other', identity: '1:1:8' },
-        { filename: 'prompt_manager.log.2', kind: 'rotated' },
-    ];
-    // Identities stay strings: mtime_ns and large inodes are not exact JS numbers.
-    assert.deepEqual(clearBody(files), { expected: [
-        { name: 'prompt_manager.log', identity: '10:1761000000123456789:9007199254740993' },
-        { name: 'prompt_manager.log.1', identity: '20:1761000000123456789:42' },
-    ] });
-    assert.deepEqual(clearBody([]), { expected: [] });
-    assert.deepEqual(clearBody(null), {});
-    const refused = Object.assign(new Error('The log files changed since you confirmed; nothing was cleared.'), { status: 409 });
-    assert.equal(clearFailureText(refused), refused.message);
-    assert.equal(clearFailureText(Object.assign(new Error('boom'), { status: 500 })), COPY.clearFailed);
-    assert.equal(clearFailureText(undefined), COPY.clearFailed);
-});
-
-test('the test-link dialog names the prompt and how Missing-file links removes the record', async () => {
-    const { testLinkSentence, promptName } = await diagnostics;
-    assert.equal(testLinkSentence({ id: 812, text: 'Misty harbor' }), 'Writes a placeholder image record '
-        + '(prompt_manager_test_link.png) linked to prompt #812 “Misty harbor”. Maintenance › Missing-file links removes it later.');
-    assert.equal(promptName({ text: '  a\n  b ' }), 'a b');
-    assert.equal(promptName({ text: 'x'.repeat(80) }).length, 60);
-});
-
-test('runtime values and body map config.level to runtime_level and back', async () => {
-    const { runtimeValues, runtimeBody } = await diagnostics;
-    assert.deepEqual(runtimeValues({ level: 'INFO', console_logging: true, max_file_size: 1 }), { runtime_level: 'INFO', console_logging: true });
-    assert.deepEqual(runtimeBody({ runtime_level: 'CRITICAL' }), { level: 'CRITICAL' });
-    assert.deepEqual(runtimeBody({ console_logging: false }), { console_logging: false });
-    assert.deepEqual(runtimeBody({ runtime_level: 'DEBUG', console_logging: true }), { level: 'DEBUG', console_logging: true });
-    assert.deepEqual(runtimeBody({}), {});
-});
@@ -169,44 +169,3 @@ test('a plan with nothing to do offers no Apply (S7 live test)', async () => {
    assert.equal(hasWork({ ...PLAN, scope: {} }), true);
    assert.equal(NOTHING_TO_APPLY, 'There is nothing to apply; nothing was changed.');
 });
-
-// S12 (#329): the rotated-log cleanup plan changes no library record: its Backup reads "Not needed", the review shows no
-// D55 backup box, and its details are files.
-const LOG_PLAN = { operation: 'rotated_logs', token: 't', expires_at: '2026-10-26T23:15:00',
-    scope: { count: 3, label: '3 rotated log copies · 28.4 MB' },
-    protected: { count: 3, reasons: ['Kept: the active log', 'Kept: 1 link', 'Kept: 1 other file'] },
-    backup: { policy: 'none', destination_label: null, expected_bytes: null },
-    media: { deletes_files: true, label: 'Deletes only the listed log files. No image, video or library record changes.' },
-    details: [{ label: 'prompt_manager.log.1', detail: '10.0 MB · 2026-10-25 14:02' }] };
-
-test('a plan without a database change reads Not needed and shows no backup box', async () => {
-    const { planGrid, backupText, backupBox, BACKUP_COPY, OPERATION_TITLES } = await review;
-    assert.equal(backupText({ policy: 'none' }), 'Not needed: no library record changes');
-    assert.deepEqual(planGrid(LOG_PLAN), [
-        ['Scope', '3 rotated log copies · 28.4 MB'],
-        ['Protected', 'Kept: the active log · Kept: 1 link · Kept: 1 other file'],
-        ['Backup', 'Not needed: no library record changes'],
-        ['Media on disk', 'Deletes only the listed log files. No image, video or library record changes.'],
-    ]);
-    const onBackup = () => {};
-    assert.equal(backupBox(LOG_PLAN, onBackup), null);
-    // Every database plan keeps its D55 box.
-    assert.deepEqual(backupBox({ ...LOG_PLAN, operation: 'optimize', backup: { policy: 'required' } }, onBackup), { copy: BACKUP_COPY, onBackup });
-    assert.deepEqual(backupBox({ operation: 'missing_links' }, onBackup), { copy: BACKUP_COPY, onBackup });
-    // Its title heads the dialog and lets Activity offer Review again.
-    assert.equal(OPERATION_TITLES.rotated_logs, 'Rotated log copies');
-});
-
-test('rotated_logs details read Listed files', async () => {
-    const { detailsSummary, detailLines } = await review;
-    assert.equal(detailsSummary(LOG_PLAN, 3), 'Listed files (3)');
-    assert.equal(detailsSummary({ ...LOG_PLAN, scope: { count: 60 } }, 50), 'Listed files (50 of 60)');
-    assert.equal(detailsSummary({ operation: 'missing_links', scope: { count: 2 } }, 2), 'Listed records (2)');
-    assert.deepEqual(detailLines(LOG_PLAN), ['prompt_manager.log.1 · 10.0 MB · 2026-10-25 14:02']);
-});
-
-test('a rotated-log cleanup the log overtook offers Review again (S12)', async () => {
-    const { reviewAgainOf } = await jobView;
-    assert.deepEqual(reviewAgainOf({ kind: 'maintenance', state: 'failed', scope: { operation: 'rotated_logs', failure: 'plan-changed' } }),
-        { operation: 'rotated_logs' });
-});
@@ -420,12 +420,3 @@ test('a partial host save keeps what saved, adopts its revision and fails only t
    assert.equal((await drafts.save()).host, 'failed');
    assert.equal(drafts.statusText(), SETTINGS_STATUS.partial);
 });
-
-// S12 (#329): System's runtime domain is the running server's log level and console setting (`/logs/config`).
-test('runtime adapter maps config.level to runtime_level and back', async () => {
-    const { runtimeValues, runtimeBody } = await import('../../web/js/workspace/system-diagnostics.mjs');
-    assert.deepEqual(runtimeValues({ level: 'WARNING', console_logging: false, backup_count: 5 }),
-        { runtime_level: 'WARNING', console_logging: false });
-    assert.deepEqual(runtimeBody({ runtime_level: 'WARNING' }), { level: 'WARNING' });
-    assert.deepEqual(runtimeBody({ runtime_level: 'CRITICAL', console_logging: true }), { level: 'CRITICAL', console_logging: true });
-});
@@ -360,23 +360,19 @@ test('Preview tagging review opens the Tag image dialog with the section’s val
    } finally { scope.dispose(); dom.restore(); }
 });

-const PLAN = { images: 3, already_tagged: 1, to_tag: 2, estimate_seconds: 3.2, estimate_device: 'cpu', suggestion_limit: 10,
+const PLAN = { images: 3, prompts: 2, already_tagged: 1, to_tag: 1,
    model: { type: 'wd14-swinv2', label: 'WD14 SwinV2', size_label: '~400 MB', downloaded: true }, existing: 'skip',
    review_required: false, backup: { policy: 'on' }, disk: { free_bytes: 10 * 2 ** 30, required_bytes: 2 ** 20, sufficient: true } };

-test('the batch review grid, body and Cancel-only reasons (D134, #379, CUJ 4–5)', async () => {
-    const { batchGrid, batchBody, batchCloseNote, existingLabel, REPLACE_NOTE, NOTHING_TO_TAG, NO_IMAGES } = await tagging;
+test('the batch review grid, body and Cancel-only reasons (D134, CUJ 4–5)', async () => {
+    const { batchGrid, batchBody, batchCloseNote, existingLabel, REPLACE_NOTE, NOTHING_TO_TAG, NO_LINKED_IMAGES } = await tagging;
    assert.deepEqual(batchGrid(PLAN, HOST), [['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Skip already tagged'],
-        ['Images', '3'], ['Already auto-tagged', '1'], ['Images to tag', 'about 2'],
-        ['Time', 'about 1 min on a processor; a graphics card can be faster.'],
-        ['Settings', 'General 0.35 · Character 0.85 · up to 10 tags per image'], ['Backup', 'Create and verify before changes']]);
+        ['Images linked', '3'], ['Prompts', '2'], ['Already tagged', '1'], ['Prompts to tag', 'up to 1'],
+        ['Settings', 'General 0.35 · Character 0.85'], ['Backup', 'Create and verify before changes']]);
    const llm = { ...HOST, autotag_model_type: 'gguf' };
-    assert.deepEqual(batchGrid({ ...PLAN, model: { type: 'gguf' }, backup: { policy: 'off' }, estimate_seconds: null,
-        estimate_device: null, suggestion_limit: 4 }, llm).slice(-3),
-    [['Time', 'Language-model engines take longer per image. Activity shows the time left once tagging starts.'],
-        ['Settings', 'Template of 27 characters · up to 4 tags per image'], ['Backup', 'No safety backup (the policy is off)']]);
+    assert.deepEqual(batchGrid({ ...PLAN, model: { type: 'gguf' }, backup: { policy: 'off' } }, llm).slice(-2),
+        [['Settings', 'Template of 27 characters'], ['Backup', 'No safety backup (the policy is off)']]);
    assert.equal(batchGrid({}, HOST)[2][1], '0');
-    assert.equal(batchGrid({}, HOST)[6][1], 'General 0.35 · Character 0.85');
    assert.equal(existingLabel('odd'), 'odd');
    assert.deepEqual(batchBody(HOST), { model_type: 'wd14-swinv2', existing: 'skip',
        options: { general_threshold: 0.35, character_threshold: 0.85 } });
@@ -389,31 +385,9 @@ test('the batch review grid, body and Cancel-only reasons (D134, #379, CUJ 4–5
    assert.equal(batchCloseNote({ ...PLAN, model: { ...PLAN.model, downloaded: false } }), 'WD14 SwinV2 is not downloaded. Download it first.');
    assert.equal(batchCloseNote({ ...PLAN, disk: { free_bytes: 2 ** 20, required_bytes: 2 ** 21, sufficient: false } }),
        'Not enough free disk space: the safety backup needs about 2.0 MB and 1.0 MB is free. Nothing is written until there is room.');
-    assert.equal(batchCloseNote({ ...PLAN, images: 0, to_tag: 0 }), NO_IMAGES);
-    assert.equal(batchCloseNote({ ...PLAN, images: undefined }), NO_IMAGES);
-    assert.equal(NO_IMAGES, 'The output folders contain no images to tag.');
+    assert.equal(batchCloseNote({ ...PLAN, prompts: 0, to_tag: 0 }), NO_LINKED_IMAGES);
    assert.equal(batchCloseNote({ ...PLAN, to_tag: 0 }), NOTHING_TO_TAG);
-    assert.equal(NOTHING_TO_TAG, 'Every output image is already auto-tagged.');
-});
-
-test('the review Time row (DEC11, #379): minutes, hours and the engine it runs on', async () => {
-    const { durationText, timeText, TIME_UNKNOWN } = await tagging;
-    assert.equal(durationText(1), 'about 1 min');
-    assert.equal(durationText(0), 'about 1 min');
-    assert.equal(durationText(89), 'about 89 min');
-    assert.equal(durationText(90), 'about 1 h 30 min');
-    assert.equal(durationText(120), 'about 2 h');
-    assert.equal(durationText(631), 'about 10 h 31 min');
-    assert.equal(durationText(Number.NaN), 'about 1 min');
-    // 23,645 images at 1.6 s on a processor (the design's CUJ 1).
-    assert.equal(timeText({ estimate_seconds: 37832, estimate_device: 'cpu' }),
-        'about 10 h 31 min on a processor; a graphics card can be faster.');
-    assert.equal(timeText({ estimate_seconds: 59, estimate_device: 'gpu' }), 'about 1 min on the graphics card.');
-    assert.equal(timeText({ estimate_seconds: 0, estimate_device: 'cpu' }), 'about 1 min on a processor; a graphics card can be faster.');
-    for (const plan of [{ estimate_seconds: null }, {}, { estimate_seconds: -1 }, { estimate_seconds: Infinity }, null]) {
-        assert.equal(timeText(plan), TIME_UNKNOWN);
-    }
-    assert.equal(TIME_UNKNOWN, 'Language-model engines take longer per image. Activity shows the time left once tagging starts.');
+    assert.equal(NOTHING_TO_TAG, 'Every prompt with an output image is already tagged.');
 });

 test('showBatchPlan opens the review with the backup box, or the Cancel-only review', async () => {
@@ -1,24 +0,0 @@
-"""A temp SQLite database in a folder no other test process shares (#346).
-
-``PromptManagerAPI`` sweeps its database's folder at startup for the stages,
-uploads and safety-backup copies an interrupted restore or backup left. A
-fixture database directly in the system temp folder made every other test
-process that started an API (another worktree's suite, a pre-push hook) delete
-this process's in-flight restore files, and left safety backups behind there.
-"""
-
-import tempfile
-
-
-def private_temp_db(case):
-    """Return a closed ``NamedTemporaryFile`` handle for an empty ``.db`` file.
-
-    The file lives in a new folder that ``case`` removes at cleanup, after its
-    own teardown has closed and unlinked the database (cleanups run after
-    ``tearDown``), together with anything a restore or backup left next to it.
-    """
-    folder = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
-    case.addCleanup(folder.cleanup)
-    handle = tempfile.NamedTemporaryFile(delete=False, suffix=".db", dir=folder.name)
-    handle.close()
-    return handle
@@ -35,8 +35,6 @@ REVIEW_TABLES = (
    "media_review_items",
    "media_review_metadata",
 )
-# The auto-tag marks (#379) cite annotation bytes too; an old backup lacks them.
-CITING_TABLES = REVIEW_TABLES + ("media_image_autotags",)
 # The exact DDL the plan pins; the module must produce precisely these objects.
 DDL = {
    METADATA: (
@@ -216,7 +214,7 @@ class AnnotationSchemaTests(unittest.TestCase):
        """
        with closing(sqlite3.connect(path)) as raw, raw:
            raw.execute("PRAGMA foreign_keys=OFF")
-            for table in CITING_TABLES + tuple(reversed(TABLES)):
+            for table in REVIEW_TABLES + tuple(reversed(TABLES)):
                raw.execute(f"DROP TABLE {table}")

    def test_fresh_install_and_reopen_is_idempotent(self):
@@ -430,9 +430,7 @@ class ReplaceImageTagsTests(AnnotationTestCase):
            self.assertTrue(
                self.db.refresh_image_fingerprint(loc, DIGEST_A, SIZE, MTIME + 1)
            )
-            self.assertEqual(
-                self.db.image_tag_locators(self.db.image_tag_ids(["img"], "")), {loc}
-            )
+            list(self.db.iter_image_tag_records())
        self.assertEqual(self.db.get_prompt_by_id(prompt)["tags"], ["prompt-tag"])


@@ -553,162 +551,14 @@ class CurrentImageTagsTests(AnnotationTestCase):
        self.assertEqual(current, {locators[0]: ["z", "y"], locators[502]: ["x"]})
        lookups = [s for s in statements if "media_annotation_files" in s]
        self.assertEqual(len(lookups), 2)
-        # The tag search finds every record's file by tag id, and the empty
-        # set's file never.
        self.assertEqual(
-            self.db.image_tag_locators(self.db.image_tag_ids(["z", "x"], "")),
-            {locators[0], locators[502]},
+            list(self.db.iter_image_tag_records()),
+            [
+                (locators[0], SIZE, MTIME, ["z", "y"]),
+                (locators[250], SIZE, MTIME + 1, []),
+                (locators[502], SIZE, MTIME + 2, ["x"]),
+            ],
        )
-        self.assertEqual(
-            self.db.current_image_tags({locators[250]: (SIZE, MTIME + 1)}),
-            {locators[250]: []},
-        )
-
-    def test_tag_locators_cover_more_ids_than_one_chunk(self):
-        # A broad text search can match more than 500 names: every id's file
-        # comes back across the chunks.
-        locators = [self.locator(f"t{i:04}.png") for i in range(503)]
-        for i, loc in enumerate(locators):
-            self.replace(loc, tags=[f"name_{i:04}"])
-        ids = self.db.image_tag_ids([], "name_")
-        self.assertEqual(len(ids), 503)
-        self.assertEqual(self.db.image_tag_locators(ids), set(locators))
-
-
-class AutotagMarkTests(AnnotationTestCase):
-    """The auto-tagged mark (#379): per byte record, written with the tags."""
-
-    def marked(self):
-        conn = self.db.model.get_connection()
-        return sorted(
-            row[0] for row in conn.execute("SELECT * FROM media_image_autotags")
-        )
-
-    def byte_id(self, loc, digest=DIGEST_A):
-        conn = self.db.model.get_connection()
-        return conn.execute(
-            "SELECT b.id FROM media_annotation_bytes b JOIN media_annotation_files f "
-            "ON f.id=b.file_id WHERE f.locator=? AND b.sha256=?",
-            (loc, digest),
-        ).fetchone()[0]
-
-    def test_hand_tags_never_mark(self):
-        loc = self.locator("a.png")
-        self.replace(loc, tags=["keeper"])
-        self.add(loc, tags=["more"])
-        self.assertEqual(self.marked(), [])
-        self.assertEqual(self.db.autotag_state({loc: (SIZE, MTIME)}), {loc: False})
-        self.assertEqual(self.db.autotagged_locators(), set())
-
-    def test_model_union_marks_including_replayed_and_empty_results(self):
-        loc = self.locator("a.png")
-        receipt = self.add(loc, tags=["bird"], mark_autotagged=True)
-        self.assertEqual((receipt["added"], receipt["replayed"]), (1, False))
-        self.assertEqual(self.marked(), [self.byte_id(loc)])
-        # A replayed union and an empty result still mark (idempotently).
-        other = self.locator("b.png")
-        self.replace(other, DIGEST_B, ["keeper"])
-        replayed = self.add(other, DIGEST_B, ["KEEPER"], mark_autotagged=True)
-        self.assertTrue(replayed["replayed"])
-        empty = self.locator("c.png")
-        nothing = self.add(empty, tags=[], mark_autotagged=True)
-        self.assertEqual((nothing["tags"], nothing["added"]), ([], 0))
-        self.add(empty, tags=[], mark_autotagged=True)
-        self.assertEqual(
-            self.marked(),
-            sorted(
-                [self.byte_id(loc), self.byte_id(other, DIGEST_B), self.byte_id(empty)]
-            ),
-        )
-        self.assertEqual(
-            self.db.autotag_state(
-                {loc: (SIZE, MTIME), other: (SIZE, MTIME), empty: (SIZE, MTIME)}
-            ),
-            {loc: True, other: True, empty: True},
-        )
-        self.schema_clean()
-
-    def test_empty_union_without_mark_is_refused(self):
-        with self.assertRaises(ValueError):
-            self.add(self.locator("a.png"), tags=[])
-        self.assertEqual(self.counts()["media_annotation_files"], 0)
-
-    def test_tag_limit_union_writes_no_tag_and_no_mark(self):
-        loc = self.locator("a.png")
-        self.replace(loc, tags=[f"t{i}" for i in range(100)])
-        before = self.rows(*ANNOTATION_TABLES, "tags")
-        with self.assertRaises(AnnotationCommandError) as ctx:
-            self.add(loc, tags=["one more"], mark_autotagged=True)
-        self.assertEqual(ctx.exception.code, "tag-limit")
-        self.assertEqual(self.rows(*ANNOTATION_TABLES, "tags"), before)
-        self.assertEqual(self.marked(), [])
-
-    def test_replace_marks_on_saved_and_replayed_receipts_not_on_conflict(self):
-        loc = self.locator("a.png")
-        saved = self.replace(loc, tags=["a"], mark_autotagged=True)
-        self.assertFalse(saved["replayed"])
-        self.assertEqual(self.marked(), [self.byte_id(loc)])
-        other = self.locator("b.png")
-        self.replace(other, DIGEST_B, ["x"])
-        replayed = self.replace(
-            other, DIGEST_B, ["x"], revision=1, mark_autotagged=True
-        )
-        self.assertTrue(replayed["replayed"])
-        third = self.locator("c.png")
-        self.replace(third, tags=["y"])
-        with self.assertRaises(AnnotationCommandError):
-            self.replace(third, tags=["z"], revision=5, mark_autotagged=True)
-        self.assertEqual(
-            self.marked(), sorted([self.byte_id(loc), self.byte_id(other, DIGEST_B)])
-        )
-
-    def test_mark_follows_the_bytes_not_the_file(self):
-        loc = self.locator("a.png")
-        self.add(loc, tags=["bird"], mark_autotagged=True)
-        # The file's bytes changed: the new record is current and unmarked.
-        self.replace(loc, DIGEST_B, ["hand"], mtime_ns=MTIME + 1)
-        self.assertEqual(self.db.autotag_state({loc: (SIZE, MTIME + 1)}), {loc: False})
-        self.assertEqual(self.db.autotag_state({loc: (SIZE, MTIME)}), {loc: True})
-        # The review's estimate counts any marked record of the locator.
-        self.assertEqual(self.db.autotagged_locators(), {loc})
-        missing = self.locator("none.png")
-        self.assertEqual(self.db.autotag_state({missing: (1, 1)}), {missing: False})
-
-    def test_state_and_tags_choose_the_same_current_record(self):
-        loc = self.locator("a.png")
-        # Two records with the same verified fingerprint: the newest wins.
-        self.replace(loc, DIGEST_A, ["old bytes"])
-        with patch.object(
-            annotations_module, "utc_now_iso", return_value="2099-01-01T00:00:00"
-        ):
-            self.add(loc, DIGEST_B, ["new bytes"], mark_autotagged=True)
-        stats = {loc: (SIZE, MTIME)}
-        self.assertEqual(self.db.current_image_tags(stats), {loc: ["new bytes"]})
-        self.assertEqual(self.db.autotag_state(stats), {loc: True})
-        with patch.object(
-            annotations_module, "utc_now_iso", return_value="2199-01-01T00:00:00"
-        ):
-            self.add(loc, DIGEST_A, ["older bytes again"])
-        self.assertEqual(
-            self.db.current_image_tags(stats), {loc: ["old bytes", "older bytes again"]}
-        )
-        self.assertEqual(self.db.autotag_state(stats), {loc: False})
-
-    def test_marks_never_touch_prompt_rows(self):
-        conn = self.db.model.get_connection()
-        prompt_id = self.db.save_prompt("a beach", tags=["beach"])
-        before = [
-            [tuple(row) for row in conn.execute(f"SELECT * FROM {table} ORDER BY 1")]
-            for table in ("prompts", "prompt_tags")
-        ]
-        self.add(self.locator("a.png"), tags=["bird"], mark_autotagged=True)
-        self.replace(self.locator("b.png"), DIGEST_B, ["waves"], mark_autotagged=True)
-        after = [
-            [tuple(row) for row in conn.execute(f"SELECT * FROM {table} ORDER BY 1")]
-            for table in ("prompts", "prompt_tags")
-        ]
-        self.assertIsNotNone(prompt_id)
-        self.assertEqual(after, before)


 class AnnotationIsolationTests(AnnotationTestCase):
@@ -8,6 +8,7 @@ without requiring a full ComfyUI server.
 import json
 import os
 import sys
+import tempfile
 import unittest

 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -17,7 +18,6 @@ from aiohttp.test_utils import AioHTTPTestCase

 from database.operations import PromptDatabase
 from py.api import PromptManagerAPI
-from tests.private_temp import private_temp_db
 from utils.hashing import generate_prompt_hash


@@ -25,7 +25,8 @@ class APITestCase(AioHTTPTestCase):
    """Base class that stands up a test aiohttp app with PromptManager routes."""

    async def get_application(self):
-        self._temp_db = private_temp_db(self)
+        self._temp_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")
+        self._temp_db.close()

        app = web.Application()
        routes = web.RouteTableDef()
@@ -846,14 +846,6 @@ class TestSettingsReadMonitorThroughModule(AdminAPITestCase):
        self.assertEqual(data["settings"]["gallery_root_paths"], ["output"])


-def _wired_prompt(text):
-    """A sampler-less graph whose one encoder feeds a guider (#252)."""
-    return {
-        "1": {"class_type": "CLIPTextEncode", "inputs": {"text": text}},
-        "2": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}},
-    }
-
-
 def _raise(*args, **kwargs):
    raise RuntimeError("boom")

@@ -2194,7 +2186,11 @@ class TestOutputScanInternals(AdminAPITestCase):

    def test_ingest_outcomes(self):
        f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a cat"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
+            )
+        }
        self.assertIsNone(self.api._ingest_scanned_file(f, {}))
        self.assertIsNone(self.api._ingest_scanned_file(f, {"prompt": "{}"}))
        self.assertEqual(
@@ -2206,19 +2202,31 @@ class TestOutputScanInternals(AdminAPITestCase):

    def test_ingest_link_failures_are_tolerated(self):
        f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a dog"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a dog"}}}
+            )
+        }
        self.api.db.link_image_to_prompt = _raise
        self.assertEqual(self.api._ingest_scanned_file(f, meta), "added")
        self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")

    def test_ingest_save_failure_counts_as_found(self):
        f = Path("gen.png")
-        meta = {"prompt": json.dumps(_wired_prompt("a bird"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a bird"}}}
+            )
+        }
        self.api.db.save_prompt = lambda *a, **k: None
        self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")

    def test_batch_counts_and_per_file_errors(self):
-        meta = {"prompt": json.dumps(_wired_prompt("a fish"))}
+        meta = {
+            "prompt": json.dumps(
+                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a fish"}}}
+            )
+        }
        self.api.db.get_prompt_by_hash = _raise
        counts = self.api._ingest_scan_batch_sync(
            [(Path("a.png"), meta), (Path("b.png"), {})]
@@ -2907,7 +2915,7 @@ class TestScanReadsVideos(AdminAPITestCase):
        shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg not installed"
    )
    async def test_scan_adds_prompts_found_in_videos(self):
-        graph = _wired_prompt("a cat")
+        graph = {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
        _write_mp4(
            self.output_dir / "clip.mp4", json.dumps({"prompt": json.dumps(graph)})
        )
@@ -363,20 +363,23 @@ class TestModelGate(SuggestTestCase):
        prompt_id = self._save_prompt("batch prompt")
        self.api.db.link_image_to_prompt(prompt_id, str(self.output_dir / "sub/a.png"))
        started, proceed = threading.Event(), threading.Event()
-        # The legacy batch is the autotag job (#379): it suggests per image.
-        self.tagger.block = (started, proceed)
+
+        def slow_generate(image_path, **kwargs):
+            started.set()
+            proceed.wait(WAIT)
+            return ["batch"]
+
+        self.tagger.generate_tags = slow_generate
        batch = asyncio.ensure_future(
            self.client.post("/prompt_manager/autotag/start?model_type=wd14-vit")
        )
        try:
            await asyncio.get_running_loop().run_in_executor(None, started.wait, WAIT)
-            calls = len(self.tagger.calls)
            status, body = await self.suggest(self.suggest_body(observed, "gguf"))
            self.assertEqual((status, body["code"]), (409, "model-busy"))
-            self.assertEqual(len(self.tagger.calls), calls)
+            self.assertEqual(self.tagger.calls, [])
            self.assertEqual(self.tagger.loaded, "wd14-vit")  # not swapped
        finally:
-            self.tagger.block = None
            proceed.set()
            response = await batch
            await response.read()
@@ -5,7 +5,6 @@ no network request is made.
 """

 import asyncio
-import hashlib
 import json
 import os
 import shutil
@@ -35,8 +34,6 @@ from aiohttp.test_utils import AioHTTPTestCase

 from database.operations import PromptDatabase
 from py.api import PromptManagerAPI
-from tests.private_temp import private_temp_db
-from py.api.autotag_routes import MODEL_BUSY_ERROR
 from py.api.jobs import JobBusy
 from utils.hashing import generate_prompt_hash

@@ -73,7 +70,6 @@ class FakeAutotagService:
        self.status_calls = 0
        self.status_threads = []
        self.status_paths = {}
-        self.suggest_calls = 0

    def get_models_status(self):
        self.status_calls += 1
@@ -119,32 +115,14 @@ class FakeAutotagService:
            raise self.generate_error
        return list(self.tags)

-    def generate_tag_suggestions(
-        self,
-        image_path,
-        *,
-        limit,
-        prompt=None,
-        general_threshold=None,
-        character_threshold=None,
-    ):
-        """The suggestion entry point (#379): the fixed tags, at most ``limit``."""
-        self.suggest_calls += 1
-        tags = self.generate_tags(
-            image_path,
-            prompt=prompt,
-            general_threshold=general_threshold,
-            character_threshold=character_threshold,
-        )
-        return [(name, None) for name in tags[:limit]]
-

 class AutotagAPITestCase(AioHTTPTestCase):
    """Stands up the PromptManager routes with a temp DB, temp output dir and a
    fake engine."""

    async def get_application(self):
-        self._temp_db = private_temp_db(self)
+        self._temp_db = tempfile.NamedTemporaryFile(delete=False, suffix=".db")
+        self._temp_db.close()
        self.tmp_root = Path(tempfile.mkdtemp())
        self.output_dir = self.tmp_root / "output"
        self.output_dir.mkdir()
@@ -197,17 +175,8 @@ class AutotagAPITestCase(AioHTTPTestCase):
        )

    def _make_image(self, directory, name="img.png"):
-        """A small, valid image (the legacy review captures and probes it)."""
-        from PIL import Image
-
        path = directory / name
-        path.parent.mkdir(parents=True, exist_ok=True)
-        shade = sum(name.encode()) % 256
-        fmt = {".jpg": "JPEG", ".jpeg": "JPEG", ".webp": "WEBP"}.get(
-            path.suffix.lower(), "PNG"
-        )
-        with Image.new("RGB", (4, 4), (shade, 64, 128)) as image:
-            image.save(path, fmt)
+        path.write_bytes(b"\x89PNG\r\n\x1a\n")
        return path

    def _link_image(self, prompt_id, path):
@@ -247,9 +216,10 @@ class TestAutotagSingleContainment(AutotagAPITestCase):
        self.assertEqual(data["tags"], ["1girl", "smile"])
        self.assertEqual(data["prompt_id"], prompt_id)
        self.assertEqual(len(self.service.generate_calls), 1)
-        # #379: the model reads a private capture of the image, never the file.
-        self.assertNotIn(str(self.output_dir), self.service.generate_calls[0][0])
-        self.assertEqual(data["sha256"], hashlib.sha256(image.read_bytes()).hexdigest())
+        self.assertEqual(
+            os.path.realpath(self.service.generate_calls[0][0]),
+            os.path.realpath(str(image)),
+        )

    async def test_path_inside_output_dir_is_tagged(self):
        image = self._make_image(self.output_dir)
@@ -479,6 +449,238 @@ class TestAutotagSideEffectRoutesArePostOnly(AutotagAPITestCase):
        self.assertTrue((await resp.json())["success"])


+class TestAutotagBatch(AutotagAPITestCase):
+    """Batch tagging over the DB image list with SSE progress reporting."""
+
+    def _seed(self):
+        """Three prompts: A (one image), B (two images), C (missing file)."""
+        a = self._save_prompt("prompt a")
+        b = self._save_prompt("prompt b")
+        c = self._save_prompt("prompt c")
+        self._link_image(a, self._make_image(self.output_dir, "a1.png"))
+        self._link_image(b, self._make_image(self.output_dir, "b1.png"))
+        self._link_image(b, self._make_image(self.output_dir, "b2.png"))
+        self._link_image(c, self.output_dir / "missing.png")
+        return a, b, c
+
+    async def _start(self, query="model_type=gguf", body=None):
+        if body is None:
+            resp = await self.client.request(
+                "POST", f"/prompt_manager/autotag/start?{query}"
+            )
+        else:
+            resp = await self._post_json(f"/prompt_manager/autotag/start?{query}", body)
+        return resp, self._sse_events(await resp.text())
+
+    async def test_batch_tags_each_prompt_once_and_reports_counts(self):
+        a, b, c = self._seed()
+
+        resp, events = await self._start()
+
+        self.assertEqual(resp.status, 200)
+        done = events[-1]
+        self.assertEqual(done["type"], "complete")
+        self.assertEqual(done["processed"], 2)
+        self.assertEqual(done["tagged"], 2)
+        self.assertEqual(done["skipped"], 2)
+        self.assertEqual(done["errors"], 0)
+        self.assertEqual(len(self.service.generate_calls), 2)
+        self.assertEqual(self.api.db.get_prompt_by_id(a)["tags"], ["1girl", "smile"])
+        self.assertEqual(self.api.db.get_prompt_by_id(b)["tags"], ["1girl", "smile"])
+        self.assertEqual(self.api.db.get_prompt_by_id(c)["tags"], [])
+        progress = [e for e in events if e["type"] == "progress"]
+        self.assertTrue(all(0 <= e["progress"] <= 100 for e in progress))
+        self.assertTrue(any("processed" in e for e in progress))
+
+    async def test_rows_outside_output_dirs_are_skipped_and_counted(self):
+        inside = self._save_prompt("inside")
+        outside = self._save_prompt("outside")
+        self._link_image(inside, self._make_image(self.output_dir, "in.png"))
+        secret = self._make_image(self.secret_dir, "password.png")
+        self._link_image(outside, secret)
+
+        _, events = await self._start()
+
+        done = events[-1]
+        self.assertEqual(done["type"], "complete")
+        self.assertEqual(done["processed"], 1)
+        self.assertEqual(done["tagged"], 1)
+        self.assertEqual(done["skipped"], 1)
+        self.assertEqual(done["skipped_outside_roots"], 1)
+        self.assertEqual(len(self.service.generate_calls), 1)
+        self.assertEqual(
+            os.path.realpath(self.service.generate_calls[0][0]),
+            os.path.realpath(str(self.output_dir / "in.png")),
+        )
+        self.assertEqual(self.api.db.get_prompt_by_id(outside)["tags"], [])
+        progress = [e for e in events if e["type"] == "progress" and "skipped" in e]
+        self.assertTrue(progress)
+        self.assertTrue(all("skipped_outside_roots" in e for e in progress))
+        body = json.dumps(events)
+        self.assertNotIn(str(self.secret_dir), body)
+
+    async def test_second_start_while_running_is_409(self):
+        self._seed()
+        started = threading.Event()
+        release = threading.Event()
+
+        def slow_generate(image_path, **kwargs):
+            started.set()
+            release.wait(5)
+            return ["slow"]
+
+        self.service.generate_tags = slow_generate
+        first = asyncio.ensure_future(self._start())
+        try:
+            await asyncio.get_event_loop().run_in_executor(None, started.wait, 5)
+            self.assertTrue(started.is_set())
+
+            resp = await self.client.request(
+                "POST", "/prompt_manager/autotag/start?model_type=gguf"
+            )
+
+            self.assertEqual(resp.status, 409)
+            self.assertEqual(
+                await resp.json(),
+                {"success": False, "error": "Auto-tagging is already running"},
+            )
+        finally:
+            release.set()
+            resp1, events = await first
+        self.assertEqual(resp1.status, 200)
+        self.assertEqual(events[-1]["type"], "complete")
+
+    async def test_lock_is_released_after_a_run(self):
+        self._seed()
+
+        resp1, _ = await self._start()
+        resp2, events = await self._start()
+
+        self.assertEqual(resp1.status, 200)
+        self.assertEqual(resp2.status, 200)
+        self.assertEqual(events[-1]["type"], "complete")
+
+    async def test_lock_is_released_when_the_run_fails(self):
+        self._seed()
+        self.service.load_error = RuntimeError("no model")
+
+        _, events = await self._start()
+        self.assertEqual(events[-1]["type"], "error")
+
+        self.service.load_error = None
+        resp, events = await self._start()
+        self.assertEqual(resp.status, 200)
+        self.assertEqual(events[-1]["type"], "complete")
+
+    async def test_already_tagged_prompts_are_skipped_unless_asked(self):
+        p = self._save_prompt("tagged", tags=["cat"])
+        self._link_image(p, self._make_image(self.output_dir, "t.png"))
+
+        _, events = await self._start("model_type=gguf&skip_tagged=true")
+        self.assertEqual(events[-1]["skipped"], 1)
+        self.assertEqual(self.service.generate_calls, [])
+
+        _, events = await self._start("model_type=gguf&skip_tagged=false")
+        self.assertEqual(events[-1]["tagged"], 1)
+        self.assertEqual(
+            self.api.db.get_prompt_by_id(p)["tags"], ["cat", "1girl", "smile"]
+        )
+
+    async def test_prompt_already_holding_the_tags_counts_as_skipped(self):
+        p = self._save_prompt("same", tags=["1girl", "smile"])
+        self._link_image(p, self._make_image(self.output_dir, "s.png"))
+
+        _, events = await self._start("model_type=gguf&skip_tagged=false")
+
+        self.assertEqual(events[-1]["skipped"], 1)
+        self.assertEqual(events[-1]["tagged"], 0)
+
+    async def test_generation_errors_are_counted_and_do_not_abort(self):
+        self._seed()
+        self.service.generate_error = RuntimeError("boom")
+
+        _, events = await self._start()
+
+        self.assertEqual(events[-1]["type"], "complete")
+        # a1, b1 and b2 each fail: a failed prompt is retried on its next image
+        self.assertEqual(events[-1]["errors"], 3)
+        self.assertEqual(events[-1]["tagged"], 0)
+
+    async def test_json_body_parameters_are_accepted(self):
+        self._seed()
+
+        _, events = await self._start(
+            "", {"model_type": "wd14-vit", "general_threshold": 0.5, "prompt": "p"}
+        )
+
+        self.assertEqual(events[-1]["type"], "complete")
+        self.assertEqual(self.service.load_calls, [("wd14-vit", True)])
+        self.assertEqual(self.service.generate_calls[0][2], 0.5)
+        self.assertEqual(self.service.custom_prompt, "p")
+
+    async def test_keep_in_memory_false_unloads_after_batch(self):
+        self._seed()
+
+        _, events = await self._start("model_type=gguf&keep_in_memory=false")
+
+        self.assertEqual(events[-1]["model_loaded"], False)
+        self.assertEqual(self.service.unload_calls, 1)
+
+    async def test_model_not_downloaded_is_an_error_event(self):
+        self.service.downloaded = False
+
+        _, events = await self._start()
+
+        self.assertEqual(events[-1]["type"], "error")
+        self.assertEqual(self.service.load_calls, [])
+
+    async def test_load_failure_is_an_error_event_without_details(self):
+        self.service.load_error = RuntimeError("/srv/models/secret.gguf is corrupt")
+
+        _, events = await self._start()
+
+        self.assertEqual(events[-1]["type"], "error")
+        self.assertNotIn("/srv/models", events[-1]["message"])
+
+    async def test_non_numeric_threshold_is_400(self):
+        resp = await self.client.request(
+            "POST", "/prompt_manager/autotag/start?general_threshold=abc"
+        )
+        self.assertEqual(resp.status, 400)
+
+    async def test_invalid_json_body_is_400(self):
+        resp = await self.client.request(
+            "POST",
+            "/prompt_manager/autotag/start",
+            data="{not json",
+            headers={"Content-Type": "application/json"},
+        )
+        self.assertEqual(resp.status, 400)
+
+    async def test_client_disconnect_stops_the_batch_and_unloads(self):
+        self._seed()
+        real_write = web.StreamResponse.write
+        state = {"writes": 0}
+
+        async def flaky_write(response, data):
+            state["writes"] += 1
+            if b"Processing " in data:
+                raise ConnectionResetError("Cannot write to closing transport")
+            return await real_write(response, data)
+
+        with patch.object(web.StreamResponse, "write", flaky_write):
+            try:
+                resp = await self.client.request(
+                    "POST", "/prompt_manager/autotag/start?keep_in_memory=false"
+                )
+                await resp.read()
+            except Exception:
+                pass
+
+        self.assertEqual(len(self.service.generate_calls), 1)
+        self.assertEqual(self.service.unload_calls, 1)
+
+
 class TestAutotagModelsAndDownloadErrors(AutotagAPITestCase):

    async def test_models_error_is_500(self):
@@ -632,15 +834,7 @@ class TestAutotagSingleEdgeCases(AutotagAPITestCase):

        self.assertEqual(resp.status, 200)
        self.assertEqual(self.service.load_calls, [("wd14-vit", True)])
-        # #379: the request's prompt is for this call only.
-        self.assertEqual(self.service.custom_prompt, "")
-        resp = await self._post_json(
-            "/prompt_manager/autotag/single",
-            {"path": str(image), "model_type": "gguf", "prompt": "terse"},
-        )
-        self.assertEqual(resp.status, 200)
-        self.assertEqual(self.service.generate_calls[-1][1], "terse")
-        self.assertEqual(self.service.custom_prompt, "")
+        self.assertEqual(self.service.custom_prompt, "terse")

    async def test_image_id_without_stored_path_is_404(self):
        prompt_id = self._save_prompt()
@@ -656,6 +850,64 @@ class TestAutotagSingleEdgeCases(AutotagAPITestCase):
        self.assertEqual(resp.status, 404)


+class TestApplyAutotag(AutotagAPITestCase):
+
+    async def test_missing_prompt_id_is_400(self):
+        resp = await self._post_json("/prompt_manager/autotag/apply", {"tags": ["a"]})
+        self.assertEqual(resp.status, 400)
+
+    async def test_no_tags_is_a_noop(self):
+        resp = await self._post_json("/prompt_manager/autotag/apply", {"prompt_id": 1})
+        data = await resp.json()
+        self.assertTrue(data["success"])
+        self.assertEqual(data["message"], "No tags to apply")
+
+    async def test_unknown_prompt_is_404(self):
+        resp = await self._post_json(
+            "/prompt_manager/autotag/apply", {"prompt_id": 999, "tags": ["a"]}
+        )
+        self.assertEqual(resp.status, 404)
+
+    async def test_tags_are_merged_without_duplicates(self):
+        prompt_id = self._save_prompt(tags=["cat"])
+
+        resp = await self._post_json(
+            "/prompt_manager/autotag/apply",
+            {"prompt_id": prompt_id, "tags": ["cat", "dog"]},
+        )
+
+        data = await resp.json()
+        self.assertEqual(data["added_tags"], ["dog"])
+        self.assertEqual(data["total_tags"], 2)
+        self.assertEqual(
+            self.api.db.get_prompt_by_id(prompt_id)["tags"], ["cat", "dog"]
+        )
+
+    async def test_string_tags_from_db_are_split(self):
+        prompt_id = self._save_prompt()
+        with patch.object(
+            self.api.db,
+            "get_prompt_by_id",
+            return_value={"id": prompt_id, "tags": "cat, dog"},
+        ):
+            resp = await self._post_json(
+                "/prompt_manager/autotag/apply",
+                {"prompt_id": prompt_id, "tags": ["dog", "owl"]},
+            )
+        data = await resp.json()
+        self.assertEqual(data["added_tags"], ["owl"])
+        self.assertEqual(data["total_tags"], 3)
+
+    async def test_db_error_is_500(self):
+        with patch.object(
+            self.api.db, "get_prompt_by_id", side_effect=RuntimeError("db")
+        ):
+            resp = await self._post_json(
+                "/prompt_manager/autotag/apply", {"prompt_id": 1, "tags": ["a"]}
+            )
+        self.assertEqual(resp.status, 500)
+
+
 class TestAutotagErrorBodiesHideServerPaths(AutotagAPITestCase):
    """Every autotag handler reports exceptions through the shared public helper."""

@@ -680,12 +932,9 @@ class TestAutotagErrorBodiesHideServerPaths(AutotagAPITestCase):
        await self._assert_hidden(resp)

    async def test_apply_error(self):
-        image = self._make_image(self.output_dir)
-        digest = hashlib.sha256(image.read_bytes()).hexdigest()
-        with patch.object(self.api.db, "add_image_tags", side_effect=self._locked()):
+        with patch.object(self.api.db, "get_prompt_by_id", side_effect=self._locked()):
            resp = await self._post_json(
-                "/prompt_manager/autotag/apply",
-                {"path": str(image), "sha256": digest, "tags": ["a"]},
+                "/prompt_manager/autotag/apply", {"prompt_id": 1, "tags": ["a"]}
            )
        await self._assert_hidden(resp)

@@ -759,13 +1008,10 @@ class TestLegacyRoutesShareTheModelGate(AutotagAPITestCase):
                    "POST", "/prompt_manager/autotag/download/gguf"
                )
            )
-            # The legacy batch is read as a stream: one error frame (#379).
-            resp = await self.client.request(
-                "POST", "/prompt_manager/autotag/start?model_type=gguf"
-            )
-            self.assertEqual(
-                self._sse_events(await resp.text()),
-                [{"type": "error", "status": "error", "message": MODEL_BUSY_ERROR}],
+            await self._busy(
+                await self.client.request(
+                    "POST", "/prompt_manager/autotag/start?model_type=gguf"
+                )
            )
            await self._busy(
                await self.client.request("POST", "/prompt_manager/autotag/unload")
@@ -780,7 +1026,7 @@ class TestLegacyRoutesShareTheModelGate(AutotagAPITestCase):
        self.assertEqual(self.service.unload_calls, 0)
        self.assertEqual(self.service.get_loaded_model_type(), "wd14-vit")

-        # A refused start left no job behind: the next start runs.
+        # A refused start released the batch lock: the next start runs.
        resp = await self.client.request(
            "POST", "/prompt_manager/autotag/start?model_type=gguf"
        )
@@ -992,7 +1238,7 @@ if __name__ == "__main__":


 class TestGalleryReviewContract(AutotagAPITestCase):
-    async def test_root_relative_gallery_targets_generate_and_apply_to_their_image(
+    async def test_root_relative_gallery_targets_generate_and_apply_to_their_prompt(
        self,
    ):
        second = self.tmp_root / "second-output"
@@ -1009,22 +1255,16 @@ class TestGalleryReviewContract(AutotagAPITestCase):
            self.assertEqual(response.status, 200)
            data = await response.json()
            self.assertEqual(data["prompt_id"], pid)
+            self.assertEqual(
+                self.service.generate_calls[-1][0], str((root / "same.png").resolve())
+            )
            response = await self._post_json(
                "/prompt_manager/autotag/apply",
-                {
-                    "path": "same.png",
-                    "root_index": index,
-                    "sha256": data["sha256"],
-                    "tags": data["tags"],
-                },
+                {"prompt_id": data["prompt_id"], "tags": data["tags"]},
            )
            self.assertEqual(response.status, 200)
-            # The image's own tags; the prompt is never written (#379).
-            self.assertEqual(self.api.db.get_prompt_by_id(pid)["tags"], [])
-            locator = os.path.normcase(os.path.realpath(str(root / "same.png")))
            self.assertEqual(
-                self.api.db.read_image_tags(locator, data["sha256"])["tags"],
-                data["tags"],
+                set(self.api.db.get_prompt_by_id(pid)["tags"]), set(data["tags"])
            )

    async def test_gallery_unlinked_image_returns_no_prompt_id(self):
@@ -1653,15 +1893,13 @@ class TestTagOutputImagesPreview(BatchJobTestCase):
        self.assertEqual(self.service.generate_calls, [])
        self.assertEqual(self.service.load_calls, [])

-    async def test_preview_counts_listed_still_images_not_prompts(self):
+    async def test_preview_counts_skip_and_merge(self):
        self._seed()
        skip = await (await self._preview(existing="skip")).json()
-        # t, f1, f2 and m are listed; gone.png is missing, o.png is outside.
        self.assertEqual(
-            {k: skip[k] for k in ("images", "already_tagged", "to_tag")},
-            {"images": 4, "already_tagged": 0, "to_tag": 4},
+            {k: skip[k] for k in ("images", "prompts", "already_tagged", "to_tag")},
+            {"images": 6, "prompts": 5, "already_tagged": 1, "to_tag": 4},
        )
-        self.assertNotIn("prompts", skip)
        self.assertEqual(
            skip["model"],
            {
@@ -1678,7 +1916,7 @@ class TestTagOutputImagesPreview(BatchJobTestCase):
            set(skip["disk"]), {"free_bytes", "required_bytes", "sufficient"}
        )
        merge = await (await self._preview(existing="merge")).json()
-        self.assertEqual(merge["to_tag"], 4)
+        self.assertEqual(merge["to_tag"], 5)
        leaked = [s for s in _strings(skip) if _absolute(s)]
        self.assertEqual(leaked, [])

@@ -1686,7 +1924,7 @@ class TestTagOutputImagesPreview(BatchJobTestCase):
        self._seed()
        data = await (await self._preview(existing="replace_after_review")).json()
        self.assertTrue(data["review_required"])
-        self.assertEqual(data["images"], 4)
+        self.assertEqual(data["prompts"], 5)

    async def test_preview_refuses_bad_bodies(self):
        for body in (
@@ -1741,6 +1979,119 @@ class TestTagOutputImagesJob(BatchJobTestCase):
            "WD14 ViT is not downloaded. Download it in System › Auto-tagging.",
        )

+    async def test_job_writes_what_legacy_writes(self):
+        ids = self._seed()
+        await self._run_job(existing="skip")
+        native = {name: sorted(self._tags(pid)) for name, pid in ids.items()}
+        # The same library through the legacy batch, in a fresh database.
+        for name, pid in ids.items():
+            self.api.db.update_prompt_metadata(
+                pid,
+                tags=(
+                    ["existing"]
+                    if name == "tagged"
+                    else (["auto-scanned"] if name == "marked" else [])
+                ),
+            )
+        resp = await self.client.post(
+            "/prompt_manager/autotag/start?model_type=wd14-vit&skip_tagged=true"
+        )
+        self.assertEqual(self._sse_events(await resp.text())[-1]["type"], "complete")
+        legacy = {name: sorted(self._tags(pid)) for name, pid in ids.items()}
+        self.assertEqual(native, legacy)
+        self.assertEqual(native["tagged"], ["existing"])
+        self.assertEqual(native["fresh"], ["1girl", "smile"])
+
+    async def test_job_outcomes_follow_the_mapping(self):
+        ids = self._seed()
+        self.api.db.update_prompt_metadata(
+            ids["marked"], tags=["auto-scanned", "1girl", "smile"]
+        )
+
+        def details(job):
+            return {
+                group: sorted(row["detail"] for row in rows)
+                for group, rows in job.outcomes.items()
+            }
+
+        merged = await self._run_job(existing="merge")
+        self.assertEqual(merged.state, "finished")
+        self.assertEqual(
+            details(merged),
+            {
+                "tagged": ["Added 2 tags", "Added 2 tags"],
+                "unchanged": ["No new tags"],
+                "skipped": [
+                    "File not found",
+                    "Outside the output folders",
+                    "Prompt handled by another image",
+                ],
+                "errors": [],
+            },
+        )
+        self.assertEqual(merged.status_line, "Tagged 2 prompts")
+
+        skipped = await self._run_job(existing="skip")
+        self.assertEqual(details(skipped)["tagged"], [])
+        self.assertEqual(details(skipped)["skipped"].count("Prompt already tagged"), 3)
+        self.assertEqual(skipped.status_line, "Tagged 0 prompts")
+
+    async def test_tagging_errors_are_fixed_strings(self):
+        self._seed()
+        self.service.generate_error = RuntimeError("/srv/secret/model exploded")
+        job = await self._run_job(existing="merge")
+        self.assertTrue(job.outcomes["errors"])
+        self.assertEqual(
+            {r["detail"] for r in job.outcomes["errors"]}, {"Tagging failed"}
+        )
+        self.assertNotIn("/srv/secret", json.dumps(job.report()))
+
+    async def test_job_progress_is_determinate(self):
+        self._seed()
+        seen = []
+        original = self.service.generate_tags
+
+        def generate(*args, **kwargs):
+            job = self.api._jobs.active("autotag")
+            seen.append((job.processed, job.total))
+            return original(*args, **kwargs)
+
+        self.service.generate_tags = generate
+        job = await self._run_job(existing="merge")
+        self.assertEqual((job.processed, job.total, job.progress), (6, 6, 100))
+        self.assertTrue(all(total == 6 for _p, total in seen[1:]), seen)
+        self.assertTrue(job.cancellable)
+
+    async def test_job_cancel_stops_before_the_next_image_and_keeps_writes(self):
+        ids = self._seed()
+        started = threading.Event()
+        proceed = threading.Event()
+        calls = []
+
+        def slow(image_path, **kwargs):
+            calls.append(image_path)
+            started.set()
+            proceed.wait(30)
+            return ["slow"]
+
+        self.service.generate_tags = slow
+        resp = await self._start_job(existing="merge")
+        job = self.api._jobs.get((await resp.json())["job"]["id"])
+        try:
+            await asyncio.get_running_loop().run_in_executor(None, started.wait, 30)
+            cancel = await self.client.post(f"/prompt_manager/jobs/{job.id}/cancel")
+            self.assertTrue((await cancel.json())["cancellation_requested"])
+        finally:
+            proceed.set()
+        await asyncio.wait_for(asyncio.shield(job.task), 30)
+        self.assertEqual(job.state, "cancelled")
+        self.assertEqual(job.status_line, "Cancelled. Tags already added were kept.")
+        self.assertEqual(len(calls), 1)
+        tagged = [n for n, pid in ids.items() if "slow" in self._tags(pid)]
+        self.assertEqual(len(tagged), 1)
+        self.assertIsNone(model_gate.holder())
+        self.assertEqual(self.service.unload_calls, 0)
+
    async def test_job_refused_while_legacy_batch_holds(self):
        async with self.api._jobs.hold(
            "autotag", "Tag output images (legacy page)", admission="records"
@@ -1752,6 +2103,41 @@ class TestTagOutputImagesJob(BatchJobTestCase):
        self.assertEqual(data["running"]["title"], "Tag output images (legacy page)")
        self.assertIsNone(model_gate.holder())

+    async def test_legacy_refused_while_job_runs(self):
+        self._seed()
+        started, proceed = threading.Event(), threading.Event()
+
+        def slow(image_path, **kwargs):
+            started.set()
+            proceed.wait(30)
+            return ["slow"]
+
+        self.service.generate_tags = slow
+        resp = await self._start_job(existing="merge")
+        job = self.api._jobs.get((await resp.json())["job"]["id"])
+        try:
+            await asyncio.get_running_loop().run_in_executor(None, started.wait, 30)
+            self.assertTrue(model_gate.holder().startswith("autotag-job:"))
+            legacy = await self.client.post("/prompt_manager/autotag/start")
+            # Both legacy pages read a stream: the refusal is one error frame
+            # that names the running job.
+            self.assertEqual(legacy.status, 200)
+            self.assertEqual(
+                self._sse_events(await legacy.text()),
+                [
+                    {
+                        "type": "error",
+                        "status": "error",
+                        "message": "Tag output images already running",
+                    }
+                ],
+            )
+            unload = await self.client.post("/prompt_manager/autotag/unload")
+            self.assertEqual((await unload.json())["operation"], "Tag output images")
+        finally:
+            proceed.set()
+        await asyncio.wait_for(asyncio.shield(job.task), 30)
+
    async def test_job_releases_gate_when_start_is_refused(self):
        class Running:
            id = "other"
@@ -1799,7 +2185,7 @@ class TestTagOutputImagesJob(BatchJobTestCase):
            ("database folder", "the safety backup", 10, 1),
            10,
        )
-        with patch("py.api.image_tag_jobs.disk_plan", return_value=short):
+        with patch("py.api.autotag_routes.disk_plan", return_value=short):
            resp = await self._start_job()
        data = await resp.json()
        self.assertEqual(resp.status, 507)
@@ -1817,6 +2203,116 @@ class TestTagOutputImagesJob(BatchJobTestCase):
        inside = [row for row in rows if row["root_index"] == 0]
        self.assertTrue(inside)

+    async def test_native_batch_leaves_custom_prompt_unchanged(self):
+        self._seed()
+        self.service.custom_prompt = "legacy page prompt"
+        await self._run_job(existing="merge", model_type="gguf")
+        self.assertEqual(self.service.custom_prompt, "legacy page prompt")
+        prompts = {call[1] for call in self.service.generate_calls}
+        self.assertEqual(prompts, {"Tags please."})
+
+
+# The legacy batch's per-image frames over BatchJobTestCase's library, newest
+# first, with every throttle check passing (pinned from main's generator).
+GOLDEN_LEGACY_ROWS = [
+    {
+        "type": "progress",
+        "progress": 24,
+        "status": "Processing 1/6...",
+        "processed": 1,
+        "tagged": 1,
+        "skipped": 0,
+        "skipped_outside_roots": 0,
+    },
+    {
+        "type": "progress",
+        "progress": 38,
+        "status": "Skipping 2/6 (outside allowed directories)...",
+        "processed": 1,
+        "tagged": 1,
+        "skipped": 1,
+        "skipped_outside_roots": 1,
+    },
+    {
+        "type": "progress",
+        "progress": 52,
+        "status": "Skipping 3/6 (file missing)...",
+        "processed": 1,
+        "tagged": 1,
+        "skipped": 2,
+        "skipped_outside_roots": 1,
+    },
+    {
+        "type": "progress",
+        "progress": 66,
+        "status": "Processing 4/6...",
+        "processed": 2,
+        "tagged": 2,
+        "skipped": 2,
+        "skipped_outside_roots": 1,
+    },
+    {
+        "type": "progress",
+        "progress": 80,
+        "status": "Skipping 5/6 (prompt already processed)...",
+        "processed": 2,
+        "tagged": 2,
+        "skipped": 3,
+        "skipped_outside_roots": 1,
+    },
+    {
+        "type": "progress",
+        "progress": 95,
+        "status": "Skipping 6/6 (already tagged)...",
+        "processed": 2,
+        "tagged": 2,
+        "skipped": 4,
+        "skipped_outside_roots": 1,
+    },
+]
+
+
+class TestLegacyBatchFrames(BatchJobTestCase):
+
+    async def test_legacy_batch_events_unchanged(self):
+        """Golden frames of the legacy batch over the seeded library."""
+        self._seed()
+        ticks = iter(range(1000))  # every throttle check sees a second pass
+        with patch("py.api.autotag_routes._monotonic", side_effect=lambda: next(ticks)):
+            resp = await self.client.post(
+                "/prompt_manager/autotag/start?model_type=wd14-vit&skip_tagged=true"
+            )
+            frames = self._sse_events(await resp.text())  # the stream runs here
+        self.assertEqual(
+            frames,
+            [
+                {"type": "progress", "progress": 0, "status": "Loading model..."},
+                {
+                    "type": "progress",
+                    "progress": 5,
+                    "status": "Model loaded. Fetching all images from database...",
+                },
+                {
+                    "type": "progress",
+                    "progress": 10,
+                    "status": "Found 6 images. Processing...",
+                },
+                *GOLDEN_LEGACY_ROWS,
+                {
+                    "type": "complete",
+                    "progress": 100,
+                    "processed": 2,
+                    "tagged": 2,
+                    "skipped": 4,
+                    "errors": 0,
+                    "skipped_outside_roots": 1,
+                    "status": "Complete",
+                    "model_status": "Model kept in memory",
+                    "model_loaded": True,
+                },
+            ],
+        )
+

 class TestTagOutputImagesEdges(BatchJobTestCase):

@@ -1846,7 +2342,7 @@ class TestTagOutputImagesEdges(BatchJobTestCase):
    async def test_unexpected_error_fails_the_job_with_a_reason(self):
        self._seed()
        with patch.object(
-            self.api, "_autotag_prepass", side_effect=RuntimeError("/srv/x")
+            self.api.db, "autotag_batch_candidates", side_effect=[[], RuntimeError("x")]
        ):
            job = await self._run_job(existing="merge")
        self.assertEqual(job.state, "failed")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vito Sansevero	9579cd8bb6	test(inspector): cover every plain-first-stage outcome on both resolvers (#381 ) The frontend coverage gate found local-resolver-stages.mjs branches at 92.44% (< 93). Each way an earlier stage stops being a plain first stage (no latent, literal, missing or cyclic latent, a sampler-shaped node, a detailer) is now a resolver test and an anchor-first-stage-* parity vector.	2026-10-27 08:20:24 -07:00
Vito Sansevero	acdc7c3561	fix(inspector): skip only plain first stages on shared links; an unfinished prefix scan anchors nothing (#381 ) Review of the saver anchor: a same-links earlier stage is skipped only when it is not a detailer, sets no prompt override and continues no other sampler, so an earlier prompt or override behind it is never hidden. A work limit while tracing a saver prefix ends the match scan without an anchor instead of counting that saver as no match.	2026-10-27 07:24:46 -07:00
Vito Sansevero	93fbe5757c	fix(inspector): anchor on the saver that wrote the file and resolve stages on shared links (#381 ) An inspected file's name now anchors the inspection on the one saver whose filename_prefix (literal or traced) makes the file's stem <prefix>_<digits>[_]; the samplers in that saver's image ancestry are the candidates. No match, several matches or an unreadable walk anchor nothing, so the file stays "several possible prompts". In a latent walk, an earlier sampler reading the same conditioning links as the later one is the same prompt, not an unattributed stage. Python and the browser resolver behave the same; the legacy parity gate states each graph that differs from legacy on purpose.	2026-10-27 07:17:44 -07:00
Vito Sansevero	6f7ae47924	Merge remote-tracking branch 'origin/main' into fix/381-switch-nodes	2026-10-27 06:36:48 -07:00
Vito Sansevero	4f927549fd	fix(inspector): keep recorded pair text, string-only seed rule, role inputs and unique candidates (#381 ) Review of the pass-through: a walk through an unknown node never overrides a PromptManagerPair's execution record (any outcome but work-limit is unverifiable while the record is checked); the run-time seed rule reads only string outputs; a node with positive/negative inputs follows only the role of the requested slot, nothing when it is unlinked; one text offered twice is one candidate.	2026-10-27 06:36:40 -07:00
Vito Sansevero	a842a3c256	fix(inspector): pass text through unknown nodes instead of refusing them (#381 ) The inspector refused any node class missing from the semantics table, so a PromptManagerPair behind an rgthree Any Switch showed "Prompt uses a node the inspector does not support". The inspection resolver (Python and browser) now reads through unknown nodes: a text input is the text, positive/negative route by output slot, a conditioning input is followed alone, otherwise every linked input except core type inputs (pass_through.skip_inputs). PromptManager nodes are authoritative; several different texts become one candidate each ("Several prompts reach the sampler"). A seeded text node with no conditioning input is generated at run time, and a recorded PromptManager execution is not checked against text that passed through an unknown node. INSPECTION_RESOLVER_VERSION goes to 2; ingestion keeps the default profile. A legacy parity gate records every committed graph whose inspection positive matches the legacy parser's; no graph may leave it.	2026-10-27 06:28:42 -07:00