test(browser): the System reset restores every settings value, safety_backup included

The frontend coverage shard of #372 failed in workspace-system-tagging: the review read "No safety backup (the policy is off)". The backups spec saves safety_backup=false, and /__test__/system/reset restored config.json but not PromptManagerConfig.SAFETY_BACKUP (nor INFINITE_SCROLL), so a later spec on the same worker server saw the policy off. The reset now captures and restores every non-tagging value POST /settings can change.
fix(threads): a later stop waits again for a worker or observer an earlier stop left running (#302 )
2026-10-27 01:53:35 -07:00 · 2026-10-27 01:40:56 -07:00 · 2026-10-27 01:30:19 -07:00 · 2026-10-27 01:28:43 -07:00
392 changed files with 7729 additions and 53533 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:
@@ -27,20 +26,6 @@ concurrency:
 # coverage shards 7m34s/6m04s/5m22s (tests 6m38s/4m53s/4m04s), merge 54s, firefox 7m57s/5m21s (tests
 # 7m08s/4m34s), webkit 8m16s/5m03s (tests 7m26s/3m58s); a cache miss adds up to 5m to npm ci, which
 # the 20-minute limits absorb.
-# Hangs (#425): a job killed at its limit keeps no log and skips its upload steps, so each browser
-# test step has its own timeout-minutes (18) below the job's 20. At the step limit, SIGTERM makes
-# tools/vendor/running-tests-reporter.mjs print the tests still running and hand over to Playwright's
-# interrupt, which writes the blob report; the always() uploads then run.
-# Measured on main (runs 40725289094, 40719375442, 40700439399): setup before the test step <= 52s,
-# uploads <= 35s; test steps up to 14m42s (webkit shard 1/2) and 13m05s for coverage (shard 1/3:
-# 12m53s, node units and the viewer suite before 11.8m of workflows), so coverage is the tight one
-# in its 18 minutes. This holds only when the npm cache hits: a cold cache adds up to 5m to npm ci,
-# and then the job limit can still end the job before the step limit does.
-# #473: firefox/webkit shard 1/2 reached its 18-minute step limit (queue run 40866252975: webkit 622 tests
-# passed in 17m56s, 48.5 worker-minutes vs 28.0 in shard 2/2; recent shard 1/2 jobs 13.7m-18.9m, shard 2/2
-# 7.3m-12.2m), because --shard splits by test count and the slow concept specs sort into shard 1. The page
-# workflows now run in three shards per browser with the limits unchanged; the per-shard times are
-# re-measured after three green main runs.
 jobs:
  frontend-coverage:
    name: frontend coverage (shard ${{ matrix.shard }}/3)
@@ -93,7 +78,6 @@ jobs:
      - if: matrix.shard == 3
        run: npm run --prefix tools/vendor test
      - name: Page workflows with coverage, shard ${{ matrix.shard }}/3
-        timeout-minutes: 18
        run: npm run --prefix tools/vendor test:coverage:shard -- ${{ matrix.shard }}/3
      - name: Upload raw coverage
        uses: actions/upload-artifact@v7
@@ -102,7 +86,6 @@ jobs:
          path: coverage/js/raw/
          if-no-files-found: error
          retention-days: 3
-      # Traces and the blob report (test-results/blob/) of a failed, timed-out or cancelled step.
      - name: Upload Chromium and touch traces
        if: always()
        uses: actions/upload-artifact@v7
@@ -180,9 +163,7 @@ jobs:
          retention-days: 14

  browser-workflows:
-    name: page workflows (${{ matrix.browser }}, shard ${{ matrix.shard }}/3)
-    # Merge queue, main and manual runs only (#420); pull requests run the Chromium/touch coverage shards.
-    if: github.event_name != 'pull_request'
+    name: page workflows (${{ matrix.browser }}, shard ${{ matrix.shard }}/2)
    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;
@@ -199,7 +180,7 @@ jobs:
      fail-fast: false
      matrix:
        browser: [firefox, webkit]
-        shard: [1, 2, 3]
+        shard: [1, 2]
    steps:
      - uses: actions/checkout@v7
      # The image's own Python 3.12 and Node 24: setup-python/setup-node install the runner's toolcache
@@ -226,10 +207,8 @@ jobs:
          path: ~/.npm
          key: npm-${{ runner.os }}-playwright-v1.64.1-${{ hashFiles('tools/vendor/package-lock.json') }}
      - run: npm ci --prefix tools/vendor --ignore-scripts
-      - name: Page workflows in ${{ matrix.browser }}, shard ${{ matrix.shard }}/3
-        timeout-minutes: 18
-        run: npm run --prefix tools/vendor test:workflows -- --project ${{ matrix.browser }} --shard ${{ matrix.shard }}/3
-      # Traces and the blob report (test-results/blob/) of a failed, timed-out or cancelled step.
+      - name: Page workflows in ${{ matrix.browser }}, shard ${{ matrix.shard }}/2
+        run: npm run --prefix tools/vendor test:workflows -- --project ${{ matrix.browser }} --shard ${{ matrix.shard }}/2
      - name: Upload browser traces
        if: always()
        uses: actions/upload-artifact@v7
@@ -239,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()
@@ -250,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
@@ -214,7 +214,3 @@ coverage/

 # Old library files a Move library renamed (never deleted; #249 S6b)
 *.moved-to-*
-
-# Per-install key behind the workspace scopes and cursors (#430)
-workspace-scope.key
-.workspace-scope.key.*.tmp
@@ -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
@@ -312,12 +315,6 @@ Both nodes support the same metadata fields:

 Both nodes will automatically save prompts to the database and link any generated images to the prompt.

- **Save to library** (`save_to_library`, on by default; "Save to library" in the Focused, Split and Pair editors):
-  turn it off while iterating and PromptManager ignores that node's runs. The prompt is not saved, the run is not
-  counted and its images are not linked (a scan skips them too), while the node's output is unchanged. Workflows
-  saved before this switch existed load with it on. If any PromptManager node feeding a sampler's positive input
-  has it off, none of that run's images are linked, because the image cannot show which sampler produced it.
-
 ### 🖼️ Using the Output-Wide Gallery

 The comprehensive gallery system provides complete access to all your ComfyUI output:
@@ -336,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**

@@ -398,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

@@ -414,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
@@ -445,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
@@ -470,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)
@@ -502,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).
@@ -517,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

@@ -832,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.
@@ -22,21 +22,22 @@ Features:
 - Comprehensive logging and diagnostics
 """

-import atexit
-import threading
-import time
+import re
 from pathlib import Path


 def get_version():
-    """Parse version from pyproject.toml (``utils/version.py``)."""
-    from .utils.version import project_version
-
+    """Parse version from pyproject.toml"""
    try:
-        root = Path(__file__).parent
+        pyproject_path = Path(__file__).parent / "pyproject.toml"
+        if pyproject_path.exists():
+            content = pyproject_path.read_text()
+            match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                return match.group(1)
    except Exception:
-        return "unknown"
-    return project_version(root)
+        pass
+    return "unknown"


 from .prompt_manager import (  # noqa: E402
@@ -71,12 +72,6 @@ NODE_DISPLAY_NAME_MAPPINGS = {
 # are served by our own routes instead (see py/api).
 WEB_DIRECTORY = "web/comfy"

-# Parts the package teardown stops (``_stop_background_work``). Each stays None
-# when its start-up block below fails, and the teardown skips it.
-api = None
-_global_prompt_tracker = None
-_global_image_monitor = None
-
 # Add API routes (same pattern as ComfyUI_Assets)
 try:
    # Set extension URI
@@ -94,6 +89,8 @@ try:
    api.add_routes(routes)
    # Temp files of preview writes a crash interrupted (#317), off the
    # import path: the walk may cover a large thumbnails folder.
+    import threading
+
    threading.Thread(
        target=api.sweep_thumbnail_temps,
        name="PromptManagerPreviewTempSweep",
@@ -144,16 +141,29 @@ try:

    # The Needs review pass for ambiguous new outputs runs through the API's
    # capture store (the one the scan and the Tag dialog use): a linked output
-    # is never queued and its pending items leave the queue. The package
-    # teardown detaches it before that store is closed at shutdown.
-    if api is not None:
-        _global_image_monitor.set_review_recorder(api.record_review_file)
+    # is never queued and its pending items leave the queue. It stops before
+    # that store is closed at shutdown.
+    _review_api = globals().get("api")
+    if _review_api is not None:
+        _global_image_monitor.set_review_recorder(_review_api.record_review_file)
        # Every settled output's preview is queued for the API's background
        # worker (#249): the workspace never asks to generate thumbnails.
-        _global_image_monitor.set_thumbnail_queue(api.queue_capture_thumbnail)
+        _global_image_monitor.set_thumbnail_queue(_review_api.queue_capture_thumbnail)
        # Every settled output walks its Images listing again (#348): the
        # API hops from the monitor's thread onto the server's loop.
-        _global_image_monitor.set_output_listener(api.notify_output_settled)
+        _global_image_monitor.set_output_listener(_review_api.notify_output_settled)
+        _review_host = getattr(config.server_instance, "app", None)
+        if _review_host is not None and hasattr(_review_host, "on_cleanup"):
+
+            async def _stop_review_recording(
+                app, monitor=_global_image_monitor, api=_review_api
+            ):
+                monitor.set_review_recorder(None)
+                monitor.set_thumbnail_queue(None)
+                monitor.set_output_listener(None)
+                api.close_auto_thumbnails(final=True)
+
+            _review_host.on_cleanup.insert(0, _stop_review_recording)

    # Start monitoring
    _global_image_monitor.start_monitoring()
@@ -195,26 +205,6 @@ except Exception as e:
            f"Failed to register usage hook: {e}"
        )

-# A cached node counts what its last execution of the same text counted (#347).
-try:
-    from .py.config import server_instance
-    from .utils.cached_runs import register_cached_runs
-
-    register_cached_runs(server_instance, _db_factory)
-except Exception as e:
-    try:
-        from .utils.logging_config import get_logger
-
-        get_logger("prompt_manager.init").error(
-            f"Failed to register cached-run counting: {e}"
-        )
-    except Exception:
-        import logging
-
-        logging.getLogger("prompt_manager.init").error(
-            f"Failed to register cached-run counting: {e}"
-        )
-

 def _history_db_factory() -> "PromptDatabase":
    """Initialize history on its worker even if monitoring initialization failed."""
@@ -243,193 +233,6 @@ except Exception:
            "Failed to register execution history"
        )

-
-# ── Package teardown (#301, #302) ────────────────────────────────────────────
-# ComfyUI never runs aiohttp's cleanup hooks (it never calls
-# ``runner.cleanup()``), so ``atexit`` is the live host's path: Ctrl+C, and a
-# normal exit. It is registered after the history hook, so at exit (newest
-# first) it runs before the history dispose. Hosts that do run ``on_cleanup``
-# (our test servers) run it there, and the tests' package unload calls it.
-
-TEARDOWN_SECONDS = 10.0
-_clock = time.monotonic
-_background_work_lock = threading.Lock()
-_background_work_result = None
-
-
-def _teardown_step(name, stop, logger):
-    """Run one teardown step; a failure (even Ctrl+C) is logged and is False."""
-    try:
-        return bool(stop())
-    except (Exception, KeyboardInterrupt):
-        logger.error(f"Background work: stopping {name} failed", exc_info=True)
-        return False
-
-
-def _teardown_logger():
-    """PromptManager's init logger; the standard one if that cannot load."""
-    try:
-        from .utils.logging_config import get_logger
-
-        return get_logger("prompt_manager.init")
-    except Exception:
-        import logging
-
-        return logging.getLogger("prompt_manager.init")
-
-
-def _stop_background_work():
-    """Stop the image monitor, the preview worker and the prompt cleanup
-    thread against one TEARDOWN_SECONDS deadline, once.
-
-    Returns ``{"monitor", "thumbnails", "tracker"}`` booleans (True: it
-    stopped), leaving out parts that never started. Later calls return a
-    copy of the first result. A Ctrl+C inside a step is logged and the
-    step is False; one between steps is re-raised after the result (parts
-    not reached are False) is stored and the ``atexit`` entry removed.
-    """
-    global _background_work_result
-    with _background_work_lock:
-        if _background_work_result is not None:
-            return dict(_background_work_result)
-        monitor, thumbnails, tracker = (
-            _global_image_monitor,
-            api,
-            _global_prompt_tracker,
-        )
-        # A part whose global is set has started; False until its step says
-        # otherwise, so an interrupt between steps leaves an honest result.
-        started = (
-            ("monitor", monitor),
-            ("thumbnails", thumbnails),
-            ("tracker", tracker),
-        )
-        result = {name: False for name, part in started if part is not None}
-        try:
-            logger = _teardown_logger()
-            began = _clock()
-            deadline = began + TEARDOWN_SECONDS
-
-            def left(own_bound):
-                return max(0.0, min(own_bound, deadline - _clock()))
-
-            if monitor is not None:
-
-                def stop_monitor():
-                    from .utils.image_monitor import OBSERVER_JOIN_SECONDS
-
-                    # Callbacks first: an image in hand queues no preview into a
-                    # closing preview worker. The worker may have read the queue
-                    # callback already, so the API refuses new previews too (at
-                    # exit, Python 3.12+ refuses to start their worker thread).
-                    if thumbnails is not None:
-                        thumbnails.refuse_auto_thumbnails()
-                    monitor.set_review_recorder(None)
-                    monitor.set_thumbnail_queue(None)
-                    monitor.set_output_listener(None)
-                    return monitor.stop_monitoring(left(OBSERVER_JOIN_SECONDS))
-
-                result["monitor"] = _teardown_step(
-                    "the image monitor", stop_monitor, logger
-                )
-            if thumbnails is not None:
-
-                def close_previews():
-                    from .py.api.thumbnail_auto import CLOSE_WAIT_SECONDS
-
-                    return thumbnails.close_auto_thumbnails(
-                        final=True, timeout=left(CLOSE_WAIT_SECONDS)
-                    )
-
-                result["thumbnails"] = _teardown_step(
-                    "the preview worker", close_previews, logger
-                )
-            if tracker is not None:
-
-                def stop_tracker():
-                    from .utils.prompt_tracker import TRACKER_JOIN_SECONDS
-
-                    return tracker.shutdown(left(TRACKER_JOIN_SECONDS))
-
-                result["tracker"] = _teardown_step(
-                    "the prompt cleanup thread", stop_tracker, logger
-                )
-            elapsed = _clock() - began
-            failed = [name for name, ok in result.items() if not ok]
-            if failed:
-                logger.warning(
-                    f"Background work not stopped in time ({elapsed:.1f} s): "
-                    + ", ".join(failed)
-                )
-            else:
-                parts = " ".join(f"{name}=ok" for name in result)
-                logger.info(f"Background work stopped in {elapsed:.1f} s: {parts}")
-        finally:
-            _background_work_result = result
-            atexit.unregister(_stop_background_work)
-        return dict(result)
-
-
-async def _stop_background_work_on_cleanup(app):
-    """aiohttp ``on_cleanup``: no request is served then, so it runs inline."""
-    _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
-
-    _teardown_host = getattr(_teardown_server, "app", None)
-    if _teardown_host is not None and hasattr(_teardown_host, "on_cleanup"):
-        _teardown_host.on_cleanup.insert(0, _stop_background_work_on_cleanup)
-except Exception as e:
-    try:
-        from .utils.logging_config import get_logger
-
-        get_logger("prompt_manager.init").error(
-            f"Failed to register the background work teardown: {e}"
-        )
-    except Exception:
-        pass
-
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

 # Print startup message with loaded tools
@@ -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
@@ -9,12 +9,8 @@ IMMEDIATE`` transaction, so no row ever names a deleted file:
  already links the kept copy: then its saved-pair links join that record
  and it is deleted;
 - its favorite;
- its collection memberships (#331), joined onto the kept copy's as their
-  union under the same keys a favorite moves by;
 - 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.
@@ -26,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
@@ -56,15 +50,6 @@ INSERT_FAVORITE_SQL = "INSERT OR IGNORE INTO image_favorites VALUES (?, ?, ?)"
 DELETE_FAVORITE_SQL = (
    "DELETE FROM image_favorites WHERE root_key = ? AND relative_path = ?"
 )
-COPY_MEMBERSHIPS_SQL = (
-    "INSERT OR IGNORE INTO image_collection_items "
-    "(collection_id, root_key, relative_path, added_at) "
-    "SELECT collection_id, ?, ?, added_at FROM image_collection_items "
-    "WHERE root_key = ? AND relative_path = ?"
-)
-DELETE_MEMBERSHIPS_SQL = (
-    "DELETE FROM image_collection_items WHERE root_key = ? AND relative_path = ?"
-)
 COPY_BYTE_SQL = (
    f"SELECT b.id FROM {FILES_TABLE} f JOIN {BYTES_TABLE} b "  # nosec B608
    "ON b.file_id=f.id WHERE f.locator=? AND b.sha256=?"
@@ -88,12 +73,9 @@ FILE_LINK_SQL = (
    DELETE_LINK_SQL,
    FAVORITE_SQL,
    DELETE_FAVORITE_SQL,
-    COPY_MEMBERSHIPS_SQL,
-    DELETE_MEMBERSHIPS_SQL,
    COPY_BYTE_SQL,
    COPY_TAG_COUNT_SQL,
    PENDING_COUNT_SQL,
-    COPY_CATEGORY_SQL,
 )


@@ -153,17 +135,12 @@ class DuplicateCopyOperations:
        by), ``targets`` (``{removed spelling: kept spelling}``, the spelling
        a moved record takes; else ``kept_path``), ``favorites`` (``(root key,
        removed key, kept root key, kept key)`` per listed root holding the
-        file; they move its favorite and its collection memberships),
-        ``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, collections, categories}``
-        (``collections``: the memberships inserted on the kept copy;
-        ``categories``: the image categories copied to the kept copy).
+        file), ``removed_locator``,
+        ``kept_locator``, ``sha256`` and the kept copy's ``kept_size`` and
+        ``kept_mtime_ns``. Returns ``{moved, merged, favorites, tags,
+        review}``.
        """
-        counts = dict.fromkeys(
-            ("moved", "merged", "favorites", "tags", "review", "collections"), 0
-        )
+        counts = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
        kept_keys = [normalize_image_path(path) for path in move["kept"]]
        with self._pair_transaction() as conn:
            for spelled in dict.fromkeys(move["removed"]):
@@ -196,12 +173,7 @@ class DuplicateCopyOperations:
                    counts["moved"] += 1
            for favorite in move.get("favorites", ()):
                counts["favorites"] += _move_favorite(conn, *favorite)
-                counts["collections"] += _move_memberships(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():
@@ -241,12 +213,3 @@ def _move_favorite(conn, root_key, removed_key, kept_root, kept_key):
    conn.execute(INSERT_FAVORITE_SQL, (kept_root, kept_key, row[0]))
    conn.execute(DELETE_FAVORITE_SQL, (root_key, removed_key))
    return 1
-
-
-def _move_memberships(conn, root_key, removed_key, kept_root, kept_key):
-    """Copy a removed copy's memberships to the kept copy; the rows inserted."""
-    inserted = conn.execute(
-        COPY_MEMBERSHIPS_SQL, (kept_root, kept_key, root_key, removed_key)
-    ).rowcount
-    conn.execute(DELETE_MEMBERSHIPS_SQL, (root_key, removed_key))
-    return inserted
@@ -7,11 +7,6 @@ from typing import Callable, ContextManager, Iterator

 try:
    from ..utils.execution_history_events import RunFinish, encode_command
-    from ..utils.hashing import (
-        generate_prompt_hash,
-        stored_prompt_text,
-        stored_prompt_text_sql,
-    )
    from ..utils.execution_contexts import (
        CAPTURE_REASONS,
        ContextBundle,
@@ -20,11 +15,6 @@ try:
    )
 except ImportError:
    from utils.execution_history_events import RunFinish, encode_command
-    from utils.hashing import (
-        generate_prompt_hash,
-        stored_prompt_text,
-        stored_prompt_text_sql,
-    )
    from utils.execution_contexts import (
        CAPTURE_REASONS,
        ContextBundle,
@@ -144,8 +134,7 @@ def _insert_exact(

 def _role_hints(role: str) -> str:
    return (
-        f"SELECT r.{role}_prompt_id, tx.text_value, "
-        f"{stored_prompt_text_sql('tx.text_value')} "
+        f"SELECT r.{role}_prompt_id, tx.text_value "
        "FROM execution_run_contexts r "
        "JOIN execution_contexts c ON c.context_id = r.context_id "
        f"JOIN execution_prompt_snapshots s ON s.snapshot_id = c.{role}_snapshot_id "
@@ -157,78 +146,57 @@ def _role_hints(role: str) -> str:

 # Set form of the read-time prompt-hint rule in get_execution_contexts():
 # a stored role hint is live only in the current storage epoch, and only when
-# the hinted prompt is the one match of _prompt_hint: by text (the raw
-# snapshot text or its stored form, outer whitespace stripped, #438), or, only
-# when no prompt has either text, by dedup hash (case folded too, #460).
-# The hash is a fallback, so a hint #438 kept is never made ambiguous.
-# Needs register_prompt_functions (pm_prompt_hash). The hint rows are the
-# outer loop (CROSS JOIN), so each prompts lookup is by index.
+# its exact raw snapshot text matches exactly one prompt, which is the hinted
+# one (_prompt_hint). Evaluated once per statement, never per prompt row.
 # Defines the CTE ``live_hint_prompts(prompt_id)``; prefix it with WITH.
 LIVE_HINT_CTES = (
-    "stored_hints(prompt_id, raw, stored) AS ("
+    "stored_hints(prompt_id, raw) AS ("
    + _role_hints("positive")
    + " UNION "
    + _role_hints("negative")
-    + "), hint_matches(prompt_id, raw, stored, match_id) AS ("
-    "SELECT h.prompt_id, h.raw, h.stored, p.id FROM stored_hints h "
-    "CROSS JOIN prompts p ON p.text COLLATE BINARY IN (h.raw, h.stored) "
-    "UNION ALL "
-    "SELECT h.prompt_id, h.raw, h.stored, p.id FROM stored_hints h "
-    "CROSS JOIN prompts p ON p.hash = pm_prompt_hash(h.raw) "
-    "WHERE NOT EXISTS (SELECT 1 FROM prompts q "
-    "WHERE q.text COLLATE BINARY IN (h.raw, h.stored))"
+    + "), unique_hint_texts(prompt_id, raw) AS ("
+    "SELECT MIN(id), text COLLATE BINARY FROM prompts "
+    "WHERE text COLLATE BINARY IN (SELECT raw FROM stored_hints) "
+    "GROUP BY text COLLATE BINARY HAVING COUNT(*) = 1"
    "), live_hint_prompts(prompt_id) AS ("
-    "SELECT prompt_id FROM hint_matches GROUP BY prompt_id, raw, stored "
-    "HAVING COUNT(*) = 1 AND MIN(match_id) = prompt_id)"
+    "SELECT h.prompt_id FROM stored_hints h JOIN unique_hint_texts u "
+    "ON u.prompt_id = h.prompt_id AND u.raw = h.raw COLLATE BINARY)"
 )
 LIVE_HINT_PROMPT_IDS_SQL = (
    "WITH " + LIVE_HINT_CTES + " SELECT DISTINCT prompt_id FROM live_hint_prompts"
 )

-_BY_TEXT = "SELECT id FROM prompts WHERE text COLLATE BINARY IN (?,?) LIMIT 2"
-
-
-def _text_matches(conn: sqlite3.Connection, raw: str) -> list:
-    return [row[0] for row in conn.execute(_BY_TEXT, (raw, stored_prompt_text(raw)))]
-

 def _prompt_hint(conn: sqlite3.Connection, raw: str | None) -> int | None:
-    """The one prompt that stores ``raw`` (#438), else the one it counts toward.
-
-    By text first: ``raw`` or ``raw.strip()`` (the exact form keeps hints of
-    older rows that kept outer whitespace). Only when no prompt has either
-    text, by the dedup hash, which also folds case (#460).
-    """
    if raw is None:
        return None
-    matches = _text_matches(conn, raw)
-    if not matches:
-        matches = [
-            row[0]
-            for row in conn.execute(
-                "SELECT id FROM prompts WHERE hash=? LIMIT 2",
-                (generate_prompt_hash(raw),),
-            )
-        ]
-    return matches[0] if len(matches) == 1 else None
+    rows = conn.execute(
+        "SELECT id FROM prompts WHERE text=? COLLATE BINARY LIMIT 2", (raw,)
+    ).fetchall()
+    return rows[0][0] if len(rows) == 1 else None


 def _hints(
    conn: sqlite3.Connection, positive: str | None, negative: str | None
 ) -> tuple:
    pos_id, neg_id = _prompt_hint(conn, positive), _prompt_hint(conn, negative)
-    stored = None if negative is None else stored_prompt_text(negative)
    pair_id = None
-    # A known negative that names no prompt because several share its text
    negative_ambiguous = (
-        stored is not None and neg_id is None and bool(_text_matches(conn, negative))
+        negative is not None
+        and neg_id is None
+        and conn.execute(
+            "SELECT 1 FROM prompts WHERE text=? COLLATE BINARY LIMIT 1", (negative,)
+        ).fetchone()
+        is not None
    )
-    if pos_id is not None and stored is not None and not negative_ambiguous:
+    if pos_id is not None and negative is not None and not negative_ambiguous:
        rows = conn.execute(
-            "SELECT pp.id FROM prompt_pairs pp "
+            "SELECT pp.id FROM prompt_pairs pp LEFT JOIN prompts n ON "
+            "n.id=pp.negative_prompt_id "
            "WHERE pp.positive_prompt_id=? AND ((pp.negative_prompt_id IS NULL AND "
-            "?='') OR pp.negative_prompt_id=?) LIMIT 2",
-            (pos_id, stored, neg_id),
+            "?='') "
+            "OR (pp.negative_prompt_id=? AND n.text=? COLLATE BINARY)) LIMIT 2",
+            (pos_id, negative, neg_id, negative),
        ).fetchall()
        if len(rows) == 1:
            pair_id = rows[0][0]
@@ -23,10 +23,10 @@ from pathlib import PurePosixPath, PureWindowsPath
 from urllib.parse import quote

 try:
-    from ..utils.hashing import register_prompt_functions
+    from ..utils.hashing import generate_prompt_hash
    from .models import normalize_image_path
 except ImportError:
-    from utils.hashing import register_prompt_functions
+    from utils.hashing import generate_prompt_hash
    from database.models import normalize_image_path

 logger = logging.getLogger("prompt_manager.database.health")
@@ -125,8 +125,12 @@ def _foreign_keys(conn, _roots):
    )


+def _prompt_hash(text):
+    return generate_prompt_hash(text) if isinstance(text, str) else None
+
+
 def _canonical_hashes(conn, _roots):
-    register_prompt_functions(conn)  # pm_prompt_hash, shared with history (#460)
+    conn.create_function("pm_prompt_hash", 1, _prompt_hash, deterministic=True)
    return _counted(
        f"Prompt {row[0]}: the stored hash does not match its text"
        for row in conn.execute(
@@ -15,11 +15,6 @@ from .execution_history import HistoryEpochChanged
 from .execution_outputs import _capture, _REFERENCE_COLUMNS
 from .library import _ELIGIBLE

-try:
-    from ..utils.hashing import prompt_key, stored_prompt_text
-except ImportError:
-    from utils.hashing import prompt_key, stored_prompt_text
-
 RunKey = tuple[int, str, int, str]


@@ -105,43 +100,14 @@ _ORDER = (
 )
 # Stale-hint rows a newest-pair lookup inspects before it reports none.
 _PAIR_RUN_CANDIDATES = 16
-# The recorded texts of one scope, as a JSON array parameter (_scope_text_ids).
-_IN_SCOPE = "IN (SELECT value FROM json_each(?))"
 _MATCHING = (
    "SELECT DISTINCT rc.run_id FROM execution_prompt_snapshots s "
    "JOIN execution_contexts c ON c.positive_snapshot_id=s.snapshot_id "
    "JOIN execution_run_contexts rc ON rc.context_id=c.context_id "
-    f"WHERE s.raw_text_id {_IN_SCOPE}"
+    "WHERE s.raw_text_id=?"
 )


-def _scope_text_ids(conn: sqlite3.Connection, key: str) -> str:
-    """Every recorded raw text whose prompt key is ``key``, as a JSON array.
-
-    A run keeps its exact raw text, while the Library saves and counts it as
-    the prompt with its key (outer whitespace #438, case #460). The values are
-    compared, never only their digests; ``pm_prompt_key`` is Python's key.
-    """
-    return json.dumps(
-        [
-            row[0]
-            for row in conn.execute(
-                # Only snapshot raw texts: effective and affix texts are skipped
-                "SELECT t.text_id FROM (SELECT DISTINCT raw_text_id AS text_id "
-                "FROM execution_prompt_snapshots) s CROSS JOIN "
-                "execution_context_texts t WHERE t.text_id=s.text_id AND "
-                "pm_prompt_key(t.text_value)=? COLLATE BINARY",
-                (key,),
-            )
-        ]
-    )
-
-
-def _scope_text_id(raw: str | None) -> str | None:
-    """The scope digest of a raw text: that of its prompt key."""
-    return None if raw is None else content_digest("text", (prompt_key(raw),))
-
-
 def _limit(limit: int) -> None:
    if type(limit) is not int or not 1 <= limit <= 100:
        raise ValueError("History limit must be an integer from 1 to 100")
@@ -289,15 +255,8 @@ class HistoryReadOperations:
        if saved is None:
            return None
        text = saved["text"]
-        raw_id = _scope_text_id(text)
-        # A position from before #460 names the scope by the stripped text
-        # alone; it is the same scope, so a page open across the upgrade resumes.
-        legacy_id = (
-            None
-            if text is None
-            else content_digest("text", (stored_prompt_text(text),))
-        )
-        if after is not None and after.raw_text_id not in (raw_id, legacy_id):
+        raw_id = None if text is None else content_digest("text", (text,))
+        if after is not None and after.raw_text_id != raw_id:
            raise ValueError("History position text scope changed")
        group = {
            "positive_id": positive_id,
@@ -314,11 +273,18 @@ class HistoryReadOperations:
            next_position=None,
            resume_position=None,
        )
-        if raw_id is None:
+        if (
+            raw_id is None
+            or conn.execute(
+                "SELECT 1 FROM execution_context_texts WHERE text_id=? "
+                "AND text_value=? COLLATE BINARY",
+                (raw_id, text),
+            ).fetchone()
+            is None
+        ):
            return result
-        scope = _scope_text_ids(conn, prompt_key(text))
        where = f"r.run_id IN ({_MATCHING})"
-        params = [scope]
+        params = [raw_id]
        if after is not None:
            where += f" AND {_KEY}<=(?,?,?,?)"
            params.extend(after.upper)
@@ -372,9 +338,9 @@ class HistoryReadOperations:
            "LEFT JOIN execution_prompt_snapshots n "
            "ON n.snapshot_id=c.negative_snapshot_id "
            "LEFT JOIN execution_context_texts t ON t.text_id=n.raw_text_id "
-            f"WHERE rc.run_id IN ({placeholders}) AND p.raw_text_id {_IN_SCOPE} "
+            f"WHERE rc.run_id IN ({placeholders}) AND p.raw_text_id=? "
            "ORDER BY rc.anchor_id COLLATE BINARY,rc.run_id COLLATE BINARY",
-            (*by_run, scope),
+            (*by_run, raw_id),
        )
        summaries = {}
        evidence_by_context = {}
@@ -472,7 +438,6 @@ class HistoryReadOperations:
        if saved["text"] is None:
            return {"run": None}
        epoch = self.get_execution_epoch()
-        key = prompt_key(saved["text"])
        candidates = conn.execute(
            "SELECT r.run_id,rc.anchor_id,rc.context_id,"
            "c.positive_snapshot_id,c.negative_snapshot_id "
@@ -480,11 +445,10 @@ class HistoryReadOperations:
            "ON rc.run_id=r.run_id JOIN execution_contexts c "
            "ON c.context_id=rc.context_id JOIN execution_prompt_snapshots s "
            "ON s.snapshot_id=c.positive_snapshot_id "
-            f"WHERE s.raw_text_id {_IN_SCOPE} AND rc.pair_id=? "
-            "AND rc.reference_epoch=? "
+            "WHERE s.raw_text_id=? AND rc.pair_id=? AND rc.reference_epoch=? "
            f"ORDER BY {_ORDER},rc.anchor_id COLLATE BINARY LIMIT ?",
            (
-                _scope_text_ids(conn, key),
+                content_digest("text", (saved["text"],)),
                pair_id,
                epoch,
                _PAIR_RUN_CANDIDATES,
@@ -493,11 +457,7 @@ class HistoryReadOperations:
        for row in candidates:
            positive = _values(conn, row["positive_snapshot_id"])
            negative = _values(conn, row["negative_snapshot_id"])
-            if (
-                positive is None
-                or positive["raw"] is None
-                or prompt_key(positive["raw"]) != key
-            ):
+            if positive is None or positive["raw"] != saved["text"]:
                continue
            hints = _hints(conn, positive["raw"], negative["raw"] if negative else None)
            if hints[2] == pair_id:
@@ -517,9 +477,11 @@ class HistoryReadOperations:
        snapshots = {
            row["anchor_id"]: row
            for row in conn.execute(
-                "SELECT rc.anchor_id,c.positive_snapshot_id,c.negative_snapshot_id "
+                "SELECT rc.anchor_id,c.positive_snapshot_id,c.negative_snapshot_id,"
+                "p.raw_text_id AS positive_raw_text_id "
                "FROM execution_run_contexts rc JOIN execution_contexts c "
-                "ON c.context_id=rc.context_id WHERE rc.run_id=?",
+                "ON c.context_id=rc.context_id LEFT JOIN execution_prompt_snapshots p "
+                "ON p.snapshot_id=c.positive_snapshot_id WHERE rc.run_id=?",
                (run_id,),
            )
        }
@@ -529,12 +491,12 @@ class HistoryReadOperations:
            context.update(
                {
                    key: row[key]
-                    for key in ("positive_snapshot_id", "negative_snapshot_id")
-                },
-                # The history scope this context belongs to (#438)
-                positive_raw_text_id=_scope_text_id(
-                    (context["positive"] or {}).get("raw")
-                ),
+                    for key in (
+                        "positive_snapshot_id",
+                        "negative_snapshot_id",
+                        "positive_raw_text_id",
+                    )
+                }
            )
            pair = context["pair_id"]
            context["navigation"] = {
@@ -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
@@ -1,490 +0,0 @@
-"""Collections (#331): named, hand-picked groups of image files.
-
-A member names its file exactly as a favorite does (``image_favorites.py``):
-the source folder's real, case-normalized path (``root_key``) and the path
-below it (``relative_path``), both server-side only. A member whose file is
-moved, renamed or deleted outside PromptManager is kept and simply not listed;
-nothing follows a file to a new place.
-
-Names are trimmed with each run of whitespace collapsed to one space, 1 to 100
-characters without control characters; ``name_key`` (NFC of the case-folded
-NFC name) is UNIQUE, so names are unique ignoring case and Unicode form.
-
-The two tables install like ``image_favorites`` and ``saved_views``: optional
-in old backups, required once a database is current, created empty with no
-backfill. Startup checks only the structure, so a value saved under older
-rules never stops the library from opening; restore checks the values too,
-but never recomputes ``name_key`` (case tables differ between Python
-versions).
-"""
-
-import re
-import sqlite3
-import unicodedata
-from typing import Optional
-
-from .image_favorites import MAX_KEY_LENGTH
-
-COLLECTIONS_TABLE = "image_collections"
-ITEMS_TABLE = "image_collection_items"
-FILE_INDEX = "idx_image_collection_items_file"
-TABLES = (COLLECTIONS_TABLE, ITEMS_TABLE)
-MAX_NAME_LENGTH = 100
-_TIMESTAMP_BYTES = 64
-# A name key's byte bound: case folding expands a character to at most
-# three, each at most 4 UTF-8 bytes.
-_MAX_KEY_BYTES = MAX_NAME_LENGTH * 3 * 4
-_WHITESPACE = re.compile(r"\s+")
-
-_TABLE_DDL = {
-    COLLECTIONS_TABLE: (
-        f"CREATE TABLE {COLLECTIONS_TABLE} (id INTEGER PRIMARY KEY AUTOINCREMENT, "
-        "name TEXT NOT NULL, name_key TEXT NOT NULL UNIQUE, "
-        "created_at TEXT NOT NULL)"
-    ),
-    ITEMS_TABLE: (
-        f"CREATE TABLE {ITEMS_TABLE} (collection_id INTEGER NOT NULL REFERENCES "
-        f"{COLLECTIONS_TABLE}(id) ON DELETE CASCADE, root_key TEXT NOT NULL, "
-        "relative_path TEXT NOT NULL, added_at TEXT NOT NULL, "
-        "PRIMARY KEY (collection_id, root_key, relative_path))"
-    ),
-}
-_INDEX_DDL = f"CREATE INDEX {FILE_INDEX} ON {ITEMS_TABLE}(root_key, relative_path)"
-# (name, declared type, not null, default, primary key position)
-_COLUMNS = {
-    COLLECTIONS_TABLE: (
-        ("id", "INTEGER", 0, None, 1),
-        ("name", "TEXT", 1, None, 0),
-        ("name_key", "TEXT", 1, None, 0),
-        ("created_at", "TEXT", 1, None, 0),
-    ),
-    ITEMS_TABLE: (
-        ("collection_id", "INTEGER", 1, None, 1),
-        ("root_key", "TEXT", 1, None, 2),
-        ("relative_path", "TEXT", 1, None, 3),
-        ("added_at", "TEXT", 1, None, 0),
-    ),
-}
-# (column, parent table, parent column, on delete)
-_FOREIGN_KEYS = {
-    COLLECTIONS_TABLE: set(),
-    ITEMS_TABLE: {("collection_id", COLLECTIONS_TABLE, "id", "CASCADE")},
-}
-
-
-class CollectionInvalid(ValueError):
-    """A name, id or target breaks the write rules (a 400)."""
-
-
-def _has_control(text: str) -> bool:
-    """Any Unicode control character (category Cc: C0, DEL and C1)."""
-    return any(unicodedata.category(char) == "Cc" for char in text)
-
-
-def normalize_collection_name(name: object) -> str:
-    """The stored spelling of *name*: trimmed, whitespace collapsed, checked.
-
-    Raises ``CollectionInvalid`` unless the result is 1 to 100 characters
-    without control characters.
-    """
-    if not isinstance(name, str):
-        raise CollectionInvalid("Name must be a string")
-    collapsed = _WHITESPACE.sub(" ", name).strip()
-    if not 1 <= len(collapsed) <= MAX_NAME_LENGTH:
-        raise CollectionInvalid(f"Name must be 1 to {MAX_NAME_LENGTH} characters")
-    if _has_control(collapsed):
-        raise CollectionInvalid("Name contains control characters")
-    return collapsed
-
-
-def collection_name_key(name: str) -> str:
-    """The uniqueness key of a name: NFC of the case-folded NFC spelling."""
-    return unicodedata.normalize("NFC", unicodedata.normalize("NFC", name).casefold())
-
-
-def _compact(sql: str) -> str:
-    return re.sub(r"\s+", "", sql).lower()
-
-
-def _expected_catalog() -> set:
-    objects = {("table", name, _compact(sql)) for name, sql in _TABLE_DDL.items()}
-    objects.add(("index", FILE_INDEX, _compact(_INDEX_DDL)))
-    objects |= {("index", f"sqlite_autoindex_{table}_1", "") for table in TABLES}
-    return objects
-
-
-def _catalog(conn: sqlite3.Connection) -> list:
-    # sqlite_sequence (AUTOINCREMENT) is shared with other tables and ignored.
-    return conn.execute(
-        "SELECT type,name,sql FROM sqlite_master "
-        "WHERE name IN (?,?,?) OR tbl_name IN (?,?)",
-        (*TABLES, FILE_INDEX, *TABLES),
-    ).fetchall()
-
-
-def _structure_error(conn: sqlite3.Connection) -> Optional[str]:
-    for table, expected in _COLUMNS.items():
-        columns = tuple(
-            (row[1], row[2].upper(), row[3], row[4], row[5])
-            for row in conn.execute(f"PRAGMA table_info({table})")
-        )
-        if columns != expected:
-            return f"Image collections table {table} has invalid columns"
-        foreign_keys = {
-            (row[3], row[2], row[4], row[6])
-            for row in conn.execute(f"PRAGMA foreign_key_list({table})")
-        }
-        if foreign_keys != _FOREIGN_KEYS[table]:
-            return f"Image collections table {table} has invalid foreign keys"
-    return None
-
-
-def _decoded_too_long(conn, sql: str, limit: int) -> bool:
-    """Whether a byte-bounded candidate row decodes to over *limit* characters."""
-    for row in conn.execute(sql):
-        for raw in row:
-            if len(bytes(raw).decode("utf-8", "replace")) > limit:
-                return True
-    return False
-
-
-def _value_error(conn: sqlite3.Connection) -> Optional[str]:
-    # Only this module's constants are interpolated into the SQL below. Bytes
-    # bound characters from above (UTF-8 is at most 4 bytes each); the few
-    # candidates over the character bound are measured decoded in Python.
-    if conn.execute(
-        f"SELECT 1 FROM {COLLECTIONS_TABLE} WHERE "  # nosec B608
-        "typeof(id) != 'integer' OR typeof(name) != 'text' "
-        "OR typeof(name_key) != 'text' OR typeof(created_at) != 'text' "
-        f"OR length(CAST(name AS BLOB)) > {MAX_NAME_LENGTH * 4} "
-        "OR length(CAST(name_key AS BLOB)) = 0 "
-        f"OR length(CAST(name_key AS BLOB)) > {_MAX_KEY_BYTES} "
-        f"OR length(CAST(created_at AS BLOB)) > {_TIMESTAMP_BYTES} LIMIT 1"
-    ).fetchone():
-        return "Image collections contains invalid values"
-    # The key is not recomputed: Unicode case tables differ between Python
-    # versions, and a key written by another version must stay restorable.
-    # Its UNIQUE constraint keeps names distinct; writes compute it.
-    for (name,) in conn.execute(f"SELECT name FROM {COLLECTIONS_TABLE}"):  # nosec B608
-        if (
-            not 1 <= len(name) <= MAX_NAME_LENGTH
-            or _has_control(name)
-            or name != name.strip()
-        ):
-            return "Image collections contains invalid names"
-    limit = MAX_KEY_LENGTH * 4
-    if conn.execute(
-        f"SELECT 1 FROM {ITEMS_TABLE} WHERE "  # nosec B608
-        "typeof(collection_id) != 'integer' OR typeof(root_key) != 'text' "
-        "OR typeof(relative_path) != 'text' OR typeof(added_at) != 'text' "
-        f"OR length(CAST(root_key AS BLOB)) > {limit} "
-        f"OR length(CAST(relative_path AS BLOB)) > {limit} "
-        f"OR length(CAST(added_at AS BLOB)) > {_TIMESTAMP_BYTES} LIMIT 1"
-    ).fetchone() or _decoded_too_long(
-        conn,
-        f"SELECT CAST(root_key AS BLOB), CAST(relative_path AS BLOB) "  # nosec B608
-        f"FROM {ITEMS_TABLE} WHERE length(CAST(root_key AS BLOB)) > {MAX_KEY_LENGTH} "
-        f"OR length(CAST(relative_path AS BLOB)) > {MAX_KEY_LENGTH}",
-        MAX_KEY_LENGTH,
-    ):
-        return "Image collections contains invalid members"
-    if conn.execute(f"PRAGMA foreign_key_check({ITEMS_TABLE})").fetchone():
-        return "Image collections contains members of a missing collection"
-    return None
-
-
-def image_collections_schema_error(
-    conn: sqlite3.Connection,
-    *,
-    allow_missing: bool = True,
-    check_values: bool = True,
-) -> Optional[str]:
-    """Reject partial or unsupported collections schemas and invalid rows.
-
-    Reads only: nothing is ever repaired. A database without either table is
-    acceptable for backups that predate them unless ``allow_missing`` is
-    false. ``check_values=False`` (live startup) checks the structure only.
-    """
-    objects = _catalog(conn)
-    if not objects:
-        return None if allow_missing else "Missing image collections schema"
-    present = {name for kind, name, _sql in objects if kind == "table"}
-    if present != set(TABLES):
-        return "Incomplete image collections schema"
-    actual = {(kind, name, _compact(sql or "")) for kind, name, sql in objects}
-    if actual != _expected_catalog():
-        return "Image collections has an invalid schema definition"
-    error = _structure_error(conn)
-    if error or not check_values:
-        return error
-    return _value_error(conn)
-
-
-def migrate_image_collections(conn: sqlite3.Connection) -> None:
-    """Install both tables atomically; validate before and after creating them."""
-    conn.execute("SAVEPOINT image_collections_schema")
-    try:
-        error = image_collections_schema_error(conn, check_values=False)
-        if error:
-            raise sqlite3.DatabaseError(error)
-        for sql in _TABLE_DDL.values():
-            conn.execute(sql.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1))
-        conn.execute(_INDEX_DDL.replace("INDEX", "INDEX IF NOT EXISTS", 1))
-        error = image_collections_schema_error(
-            conn, allow_missing=False, check_values=False
-        )
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute("RELEASE image_collections_schema")
-    except BaseException:
-        conn.execute("ROLLBACK TO image_collections_schema")
-        conn.execute("RELEASE image_collections_schema")
-        raise
-
-
-class CollectionMissing(LookupError):
-    """No collection has the id (a 404 ``collection-not-found``)."""
-
-
-class CollectionNameTaken(ValueError):
-    """Another collection already has the name's key (a 409 ``name-taken``)."""
-
-    def __init__(self, collection_id: int):
-        super().__init__("Another collection has this name")
-        self.collection_id = collection_id
-
-
-class CollectionFilesMissing(LookupError):
-    """A new name with nothing to insert (a 404 ``files-not-found``)."""
-
-
-LIST_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} ORDER BY name_key, id"
-GET_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} WHERE id = ?"
-BY_KEY_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} WHERE name_key = ?"
-MEMBERS_SQL = (
-    f"SELECT relative_path FROM {ITEMS_TABLE} "
-    "WHERE collection_id = ? AND root_key = ?"
-)
-ROOT_MEMBERS_SQL = (
-    f"SELECT collection_id, relative_path FROM {ITEMS_TABLE} WHERE root_key = ?"
-)
-COUNTS_SQL = (
-    f"SELECT c.id, (SELECT COUNT(*) FROM {ITEMS_TABLE} i "
-    f"WHERE i.collection_id = c.id) FROM {COLLECTIONS_TABLE} c"
-)
-FILE_SQL = (
-    f"SELECT collection_id FROM {ITEMS_TABLE} "
-    "WHERE root_key = ? AND relative_path = ? ORDER BY collection_id"
-)
-# Every read, for the EXPLAIN QUERY PLAN check: none scans the items table and
-# only the two whole-list reads (LIST_SQL, COUNTS_SQL) scan the collections.
-READ_SQL = (
-    LIST_SQL,
-    GET_SQL,
-    BY_KEY_SQL,
-    MEMBERS_SQL,
-    ROOT_MEMBERS_SQL,
-    COUNTS_SQL,
-    FILE_SQL,
-)
-_INSERT_ITEM_SQL = f"INSERT OR IGNORE INTO {ITEMS_TABLE} VALUES (?, ?, ?, ?)"
-_DELETE_ITEM_SQL = (
-    f"DELETE FROM {ITEMS_TABLE} "
-    "WHERE collection_id = ? AND root_key = ? AND relative_path = ?"
-)
-
-
-def _collection_id(value: object) -> int:
-    if type(value) is not int or not 1 <= value <= 999_999_999:
-        raise CollectionInvalid("Collection id must be a positive integer")
-    return value
-
-
-def _items(items: object) -> list:
-    """Distinct ``(root key, relative key)`` pairs, in order."""
-    if not isinstance(items, (list, tuple)):
-        raise CollectionInvalid("Items must be a list")
-    found = []
-    for item in items:
-        if (
-            not isinstance(item, (list, tuple))
-            or len(item) != 2
-            or not all(
-                isinstance(part, str) and 1 <= len(part) <= MAX_KEY_LENGTH
-                for part in item
-            )
-        ):
-            raise CollectionInvalid("Each item is a root key and a relative key")
-        found.append((item[0], item[1]))
-    return list(dict.fromkeys(found))
-
-
-def _row(row) -> dict:
-    return {"id": row[0], "name": row[1]}
-
-
-class ImageCollectionOperations:
-    """PromptDatabase mixin: collections and their members.
-
-    Each write runs in its own ``BEGIN IMMEDIATE`` transaction
-    (``_pair_transaction``), so two tabs creating one name are serialized.
-    """
-
-    def list_collections(self) -> list[dict]:
-        """Every collection ``{id, name}`` in name-key order, then id."""
-        rows = self.model.get_connection().execute(LIST_SQL)
-        return [_row(row) for row in rows]
-
-    def get_collection(self, collection_id: int) -> Optional[dict]:
-        """``{id, name}`` of one collection, or None."""
-        row = (
-            self.model.get_connection()
-            .execute(GET_SQL, (_collection_id(collection_id),))
-            .fetchone()
-        )
-        return _row(row) if row else None
-
-    def collection_exists(self, collection_id: int) -> bool:
-        return self.get_collection(collection_id) is not None
-
-    def collection_members(self, collection_id: int, root_key: str) -> set[str]:
-        """The relative keys stored for one collection under one source."""
-        rows = self.model.get_connection().execute(
-            MEMBERS_SQL, (_collection_id(collection_id), root_key)
-        )
-        return {path for (path,) in rows}
-
-    def root_collection_members(self, root_key: str) -> dict[int, set[str]]:
-        """``{collection id: relative keys}`` stored under one source."""
-        found: dict[int, set[str]] = {}
-        for collection_id, path in self.model.get_connection().execute(
-            ROOT_MEMBERS_SQL, (root_key,)
-        ):
-            found.setdefault(collection_id, set()).add(path)
-        return found
-
-    def collection_count_snapshot(self, root_keys: list) -> tuple[dict, dict]:
-        """``({root key: {id: relative keys}}, {id: stored rows})`` read in
-        one read transaction, so a write between the reads cannot skew them.
-        """
-        conn = self.model.get_connection()
-        if conn.in_transaction:
-            raise RuntimeError("Collection counts require their own transaction")
-        conn.execute("BEGIN")
-        try:
-            members = {}
-            for root_key in dict.fromkeys(root_keys):
-                found: dict[int, set[str]] = {}
-                for collection_id, path in conn.execute(ROOT_MEMBERS_SQL, (root_key,)):
-                    found.setdefault(collection_id, set()).add(path)
-                members[root_key] = found
-            stored = {cid: count for cid, count in conn.execute(COUNTS_SQL)}
-        finally:
-            conn.rollback()  # it only read
-        return members, stored
-
-    def collection_counts(self) -> dict[int, int]:
-        """``{collection id: stored rows}`` for every collection."""
-        rows = self.model.get_connection().execute(COUNTS_SQL)
-        return {collection_id: count for collection_id, count in rows}
-
-    def file_collections(self, root_key: str, relative_path: str) -> list[int]:
-        """Ids of the collections holding one file."""
-        rows = self.model.get_connection().execute(FILE_SQL, (root_key, relative_path))
-        return [collection_id for (collection_id,) in rows]
-
-    def add_to_collection(
-        self, *, items: object, collection_id: object = None, name: object = None
-    ) -> dict:
-        """Add files to an existing id or a name; create the name when needed.
-
-        A name whose key exists uses that collection; otherwise a collection
-        is created only when at least one item is inserted. Returns
-        ``{collection, created, added, already}``.
-        """
-        from .models import utc_now_iso  # models imports this module's schema
-
-        if (collection_id is None) == (name is None):
-            raise CollectionInvalid("Give either a collection id or a name")
-        pairs = _items(items)
-        if name is not None:
-            spelled = normalize_collection_name(name)
-        else:
-            collection_id = _collection_id(collection_id)
-        now = utc_now_iso()
-        with self._pair_transaction() as conn:
-            created = False
-            if name is not None:
-                row = conn.execute(
-                    BY_KEY_SQL, (collection_name_key(spelled),)
-                ).fetchone()
-                if row is None:
-                    if not pairs:
-                        raise CollectionFilesMissing("Nothing to add")
-                    cursor = conn.execute(
-                        f"INSERT INTO {COLLECTIONS_TABLE} "  # nosec B608
-                        "(name, name_key, created_at) VALUES (?, ?, ?)",
-                        (spelled, collection_name_key(spelled), now),
-                    )
-                    row, created = (cursor.lastrowid, spelled), True
-            else:
-                row = conn.execute(GET_SQL, (collection_id,)).fetchone()
-                if row is None:
-                    raise CollectionMissing("No such collection")
-            collection = _row(row)
-            added = sum(
-                conn.execute(
-                    _INSERT_ITEM_SQL, (collection["id"], root, path, now)
-                ).rowcount
-                for root, path in pairs
-            )
-        return {
-            "collection": collection,
-            "created": created,
-            "added": added,
-            "already": len(pairs) - added,
-        }
-
-    def remove_from_collection(self, collection_id: object, items: object) -> dict:
-        """Remove files from one collection; ``{collection, removed}``."""
-        collection_id = _collection_id(collection_id)
-        pairs = _items(items)
-        with self._pair_transaction() as conn:
-            row = conn.execute(GET_SQL, (collection_id,)).fetchone()
-            if row is None:
-                raise CollectionMissing("No such collection")
-            removed = sum(
-                conn.execute(_DELETE_ITEM_SQL, (collection_id, root, path)).rowcount
-                for root, path in pairs
-            )
-        return {"collection": _row(row), "removed": removed}
-
-    def rename_collection(self, collection_id: object, name: object) -> dict:
-        """The renamed ``{id, name}``; a case variant of its own name is fine."""
-        collection_id = _collection_id(collection_id)
-        spelled = normalize_collection_name(name)
-        key = collection_name_key(spelled)
-        with self._pair_transaction() as conn:
-            if conn.execute(GET_SQL, (collection_id,)).fetchone() is None:
-                raise CollectionMissing("No such collection")
-            taken = conn.execute(BY_KEY_SQL, (key,)).fetchone()
-            if taken is not None and taken[0] != collection_id:
-                raise CollectionNameTaken(taken[0])
-            conn.execute(
-                f"UPDATE {COLLECTIONS_TABLE} SET name = ?, name_key = ? "  # nosec B608
-                "WHERE id = ?",
-                (spelled, key, collection_id),
-            )
-        return {"id": collection_id, "name": spelled}
-
-    def delete_collection(self, collection_id: object) -> bool:
-        """Delete one collection and its members (never a file). True."""
-        collection_id = _collection_id(collection_id)
-        with self._pair_transaction() as conn:
-            cursor = conn.execute(
-                f"DELETE FROM {COLLECTIONS_TABLE} WHERE id = ?",  # nosec B608
-                (collection_id,),
-            )
-            if cursor.rowcount == 0:
-                raise CollectionMissing("No such collection")
-        return True
@@ -5,7 +5,6 @@ import sqlite3
 from collections.abc import Iterator
 from contextlib import contextmanager

-from .library_folders import folder_condition, list_library_folders
 from .library_tokens import library_edit_token

 _ELIGIBLE = """(EXISTS(SELECT 1 FROM prompt_pairs ep WHERE ep.positive_prompt_id=p.id)
@@ -122,54 +121,7 @@ def _archive(value: str) -> str:
    return ARCHIVE_SCOPES[value]


-# How the Tags filter matches (#444): every tag (AND), any of them (OR), or
-# parents without any tag.
-TAG_MODES = ("all", "any", "untagged")
-# A parent that no tag's Browse returns (#444 "Untagged prompts"): no tag of its
-# own and no active pair carrying one. The vocabulary's untagged count uses it too.
-UNTAGGED = (
-    "NOT EXISTS(SELECT 1 FROM prompt_tags ut WHERE ut.prompt_id=p.id) "
-    "AND NOT EXISTS(SELECT 1 FROM prompt_pairs up JOIN prompt_pair_tags upt "
-    "ON upt.pair_id=up.id WHERE up.positive_prompt_id=p.id AND up.archived=0)"
-)
-
-
-def _tag_mode(tag_mode: object, tags: list[str]) -> str:
-    if not isinstance(tag_mode, str) or tag_mode not in TAG_MODES:
-        raise ValueError("tag_mode must be one of " + ", ".join(TAG_MODES))
-    if tag_mode == "untagged" and tags:
-        raise ValueError("Untagged prompts cannot also filter by tags")
-    return tag_mode
-
-
-def _tag_conditions(tags: list[str], any_tag: bool) -> tuple[list, list, list]:
-    """Parent-arm and pair-arm tag conditions and the tags' parameters."""
-    parent_exists = (
-        "EXISTS(SELECT 1 FROM prompt_tags pt JOIN tags t ON t.id=pt.tag_id "
-        "WHERE pt.prompt_id=p.id AND t.name{test})"
-    )
-    pair_exists = (
-        "EXISTS(SELECT 1 FROM prompt_pair_tags pt JOIN tags t ON t.id=pt.tag_id "
-        "WHERE pt.pair_id=pp.id AND t.name{test})"
-    )
-    if any_tag and tags:
-        # One condition per arm: the card, or one active pair, carries any tag.
-        test = " IN (" + ",".join("?" for _ in tags) + ")"
-        return [parent_exists.format(test=test)], [pair_exists.format(test=test)], tags
-    return (
-        [parent_exists.format(test="=?") for _ in tags],
-        [pair_exists.format(test="=?") for _ in tags],
-        tags,
-    )
-
-
-def _filter(
-    text: str,
-    category: str | None,
-    tags: list[str],
-    tag_mode: str = "all",
-    folder_prefixes: list[str] | None = None,
-) -> tuple[str, list]:
+def _filter(text: str, category: str | None, tags: list[str]) -> tuple[str, list]:
    if not isinstance(text, str) or len(text) > 500:
        raise ValueError("Search text must be a string of at most 500 characters")
    if category is not None and (not isinstance(category, str) or len(category) > 200):
@@ -180,8 +132,6 @@ def _filter(
        or any(not isinstance(tag, str) or not tag or len(tag) > 200 for tag in tags)
    ):
        raise ValueError("Invalid library tags")
-    mode = _tag_mode(tag_mode, tags)
-    untagged = mode == "untagged"
    parent, pair, parent_params, pair_params = [], ["pp.archived=0"], [], []
    if text:
        parent.append("(p.text LIKE ? ESCAPE '\\' OR ls.title LIKE ? ESCAPE '\\')")
@@ -196,11 +146,17 @@ def _filter(
        pair.append("pp.category=?")
        parent_params.append(category)
        pair_params.append(category)
-    parent_tags, pair_tags, tag_params = _tag_conditions(tags, mode == "any")
-    parent.extend(parent_tags)
-    pair.extend(pair_tags)
-    parent_params.extend(tag_params)
-    pair_params.extend(tag_params)
+    for tag in tags:
+        parent.append(
+            "EXISTS(SELECT 1 FROM prompt_tags pt JOIN tags t ON t.id=pt.tag_id "
+            "WHERE pt.prompt_id=p.id AND t.name=?)"
+        )
+        pair.append(
+            "EXISTS(SELECT 1 FROM prompt_pair_tags pt JOIN tags t ON t.id=pt.tag_id "
+            "WHERE pt.pair_id=pp.id AND t.name=?)"
+        )
+        parent_params.append(tag)
+        pair_params.append(tag)
    condition = (
        "("
        + (" AND ".join(parent) or "1=1")
@@ -212,17 +168,7 @@ def _filter(
        + " AND ".join(pair)
        + ")"
    )
-    if untagged:
-        # A whole-card condition: inside the parent-or-pair OR an untagged pair
-        # would let a tagged parent through.
-        condition = f"({condition}) AND {UNTAGGED}"
-    params = [*parent_params, *pair_params]
-    if folder_prefixes:
-        # A whole-card condition around both arms: images link to the parent.
-        folder, folder_params = folder_condition(folder_prefixes)
-        condition = f"({condition}) AND {folder}"
-        params.extend(folder_params)
-    return f"({_ELIGIBLE}) AND ({condition})", params
+    return f"({_ELIGIBLE}) AND ({condition})", [*parent_params, *pair_params]


 class LibraryOperations:
@@ -305,8 +251,6 @@ class LibraryOperations:
        text: str = "",
        category: str | None = None,
        tags: list[str] | None = None,
-        tag_mode: str = "all",
-        folder_prefixes: list[str] | None = None,
        sort: str = "newest",
        limit: int = 40,
        after: dict | None = None,
@@ -314,9 +258,7 @@ class LibraryOperations:
        _limit(limit)
        if sort not in _ORDERS:
            raise ValueError("Unknown library sort order")
-        where, params = _filter(
-            text, category, [] if tags is None else tags, tag_mode, folder_prefixes
-        )
+        where, params = _filter(text, category, [] if tags is None else tags)
        if after is not None:
            if (
                not isinstance(after, dict)
@@ -369,8 +311,6 @@ class LibraryOperations:
            "items": rows,
            "total": total,
            "variant_total": variant_total,
-            # Echoed so a client can tell this read applied its tag match.
-            "tag_mode": tag_mode,
            "has_more": has_more,
            "next_key": next_key,
        }
@@ -381,8 +321,6 @@ class LibraryOperations:
        text: str = "",
        category: str | None = None,
        tags: list[str] | None = None,
-        tag_mode: str = "all",
-        folder_prefixes: list[str] | None = None,
        sort: str = "newest",
        limit: int = 40,
        after: dict | None = None,
@@ -395,8 +333,6 @@ class LibraryOperations:
                text=text,
                category=category,
                tags=tags,
-                tag_mode=tag_mode,
-                folder_prefixes=folder_prefixes,
                sort=sort,
                limit=limit,
                after=after,
@@ -527,13 +463,9 @@ class LibraryOperations:
            "categories": [row["category"] for row in rows],
        }

-    def get_library_options(self, folder_roots=None) -> dict:
-        """Categories; with *folder_roots* (root spellings) also ``folders``."""
+    def get_library_options(self) -> dict:
        with self.library_snapshot() as (conn, epoch, _ceiling):
-            result = self._get_library_options(conn, epoch)
-            if folder_roots is not None:
-                result["folders"] = list_library_folders(conn, folder_roots, _ELIGIBLE)
-            return result
+            return self._get_library_options(conn, epoch)

    def get_library_previews(self, positive_ids: list[int]) -> dict[int, list[dict]]:
        """Read at most two links per parent in one bounded page query."""
@@ -21,10 +21,6 @@ _UUID = re.compile(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}")
 _TOKEN = re.compile(r"[0-9a-f]{64}")
 # Parent metadata stored on the prompt row; title lives in prompt_library_state.
 _PROMPT_COLUMNS = ("category", "rating", "notes")
-# Ids per IN (...) read: well under SQLite's oldest bound-parameter limit (999).
-_BULK_CHUNK = 500
-# The tags one prompt may carry: what the editor's save accepts (``validate_tags``).
-MAX_LIBRARY_TAGS = 20


 class LibraryCommandError(Exception):
@@ -89,13 +85,6 @@ def _validate_epoch(expected_epoch: str) -> None:
        raise ValueError("expected_epoch must be a canonical UUID")


-def _validate_bulk_ids(prompt_ids: list[int]) -> None:
-    if not isinstance(prompt_ids, list) or not prompt_ids:
-        raise ValueError("prompt_ids must be a non-empty list")
-    if any(type(pid) is not int or not 1 <= pid <= 2**63 - 1 for pid in prompt_ids):
-        raise ValueError("prompt_ids must be positive integers")
-
-
 def _validate_guards(positive_id: int, expected_epoch: str, if_match: str) -> None:
    if type(positive_id) is not int or not 1 <= positive_id <= 2**63 - 1:
        raise ValueError("Invalid positive prompt ID")
@@ -319,134 +308,3 @@ class LibraryCommandOperations:
                positive_created=False,
                pair_created=pair_created,
            )
-
-    def bulk_set_library_category(
-        self, prompt_ids: list[int], category: str, *, expected_epoch: str
-    ) -> dict:
-        """Set one category on many Library parents, all or nothing (#437).
-
-        Guarded by the storage epoch the page read. Only rows whose category
-        differs are written (their ``updated_at`` and edit token change) and
-        registered as Library parents, as the editor's PATCH does; ids
-        that are missing or are not Library parents count as not found.
-        """
-        _validate_epoch(expected_epoch)
-        _validate_bulk_ids(prompt_ids)
-        prompt_ids = list(dict.fromkeys(prompt_ids))
-        if not isinstance(category, str) or not category.strip():
-            raise ValueError("Category is required")
-        validate_category(category)
-        category = category.strip()
-        with self._pair_transaction() as conn:
-            epoch = self._library_epoch(conn, expected_epoch)
-            current = {}
-            for start in range(0, len(prompt_ids), _BULK_CHUNK):
-                chunk = prompt_ids[start : start + _BULK_CHUNK]
-                marks = ",".join("?" for _ in chunk)
-                current.update(
-                    conn.execute(
-                        f"SELECT p.id,p.category FROM prompts p "  # nosec B608
-                        f"WHERE p.id IN ({marks}) AND {_ELIGIBLE}",
-                        chunk,
-                    ).fetchall()
-                )
-            changed = [pid for pid, value in current.items() if value != category]
-            for pid in changed:
-                self._ensure_library_parent(conn, pid)
-            now = utc_now_iso()
-            conn.executemany(
-                "UPDATE prompts SET category=?,updated_at=? WHERE id=?",
-                [(category, now, pid) for pid in changed],
-            )
-            return {
-                "library_epoch": epoch,
-                "category": category,
-                "updated": len(changed),
-                "unchanged": len(current) - len(changed),
-                "not_found": len(prompt_ids) - len(current),
-            }
-
-    def bulk_add_library_tags(
-        self, prompt_ids: list[int], tags: list[str], *, expected_epoch: str
-    ) -> dict:
-        """Add tags to many Library parents, all or nothing (#442).
-
-        Names are normalized once (trim, the vocabulary name rules, casefold
-        repeats folded, at most 20). A parent is given only the names it lacks,
-        compared with ``casefold`` against its own tags; registry rows are
-        found and inserted by their exact name, and only for names some parent
-        gets. A parent whose tags would pass 20 is skipped (``over_limit``) so
-        the editor can still save it. Pair and image tags are not touched.
-        """
-        from .annotations import ImageTagLimitError, normalize_image_tags
-
-        _validate_epoch(expected_epoch)
-        _validate_bulk_ids(prompt_ids)
-        prompt_ids = list(dict.fromkeys(prompt_ids))
-        too_many = f"At most {MAX_LIBRARY_TAGS} tags can be added at once"
-        try:
-            tags = normalize_image_tags(tags)
-        except ImageTagLimitError:
-            # Its message names images; this is a prompt route.
-            raise ValueError(too_many) from None
-        if not tags:
-            raise ValueError("tags must name at least one tag")
-        if len(tags) > MAX_LIBRARY_TAGS:
-            raise ValueError(too_many)
-        with self._pair_transaction() as conn:
-            epoch = self._library_epoch(conn, expected_epoch)
-            held = self._library_parent_tags(conn, prompt_ids)
-            additions, over_limit = {}, 0
-            for pid, names in held.items():
-                present = {name.casefold() for name in names}
-                missing = [name for name in tags if name.casefold() not in present]
-                if not missing:
-                    continue
-                if len(names) + len(missing) > MAX_LIBRARY_TAGS:
-                    over_limit += 1
-                    continue
-                additions[pid] = missing
-            wanted = list(
-                dict.fromkeys(n for names in additions.values() for n in names)
-            )
-            tag_ids = self._ensure_tags(conn, wanted)
-            now = utc_now_iso()
-            for pid, names in additions.items():
-                conn.executemany(
-                    "INSERT OR IGNORE INTO prompt_tags (prompt_id, tag_id) "
-                    "VALUES (?, ?)",
-                    [(pid, tag_ids[name]) for name in names],
-                )
-                self._ensure_library_parent(conn, pid)
-                conn.execute("UPDATE prompts SET updated_at=? WHERE id=?", (now, pid))
-            return {
-                "library_epoch": epoch,
-                "tags": tags,
-                "updated": len(additions),
-                "unchanged": len(held) - len(additions) - over_limit,
-                "not_found": len(prompt_ids) - len(held),
-                "over_limit": over_limit,
-            }
-
-    def _library_parent_tags(
-        self, conn: sqlite3.Connection, prompt_ids: list[int]
-    ) -> dict[int, list[str]]:
-        """The Library parents among ``prompt_ids`` and their own tag names."""
-        held: dict[int, list[str]] = {}
-        for start in range(0, len(prompt_ids), _BULK_CHUNK):
-            chunk = prompt_ids[start : start + _BULK_CHUNK]
-            marks = ",".join("?" for _ in chunk)
-            for (pid,) in conn.execute(
-                f"SELECT p.id FROM prompts p WHERE p.id IN ({marks}) "  # nosec B608
-                f"AND {_ELIGIBLE}",
-                chunk,
-            ):
-                held[pid] = []
-            for pid, name in conn.execute(
-                "SELECT pt.prompt_id,t.name FROM prompt_tags pt "  # nosec B608
-                f"JOIN tags t ON t.id=pt.tag_id WHERE pt.prompt_id IN ({marks})",
-                chunk,
-            ):
-                if pid in held:
-                    held[pid].append(name)
-        return held
@@ -1,114 +0,0 @@
-"""Library output-folder filter (#444): folder names, root prefixes and listing.
-
-A folder is a ``/``-joined path relative to an output root, as Images' folder
-filter and the legacy ``/prompt_manager/subfolders`` name them. A parent
-matches a folder when one of its linked images (``generated_images.prompt_id``,
-the link its previews and image count read) lies in that folder or below it,
-under any spelling of any output root.
-
-Matching compares ``generated_images.file_path``, which is always
-``normcase(normpath(abspath(path)))`` (``models.normalize_image_path``), with
-prefixes built by the same normalization here, so case folding is the
-platform's own on both sides (Windows folds non-ASCII too, unlike SQLite's
-``lower()``) and the comparison is an exact ``substr`` with no wildcards.
-"""
-
-import os
-import sqlite3
-
-_MAX_FOLDER = 1024
-_MAX_PREFIXES = 64
-
-
-def normalize_folder(value: object, pathmod=os.path) -> str:
-    """The folder as ``a/b``, outer slashes dropped; empty means no filter.
-
-    ``/`` always separates. ``\\`` separates only on Windows (``ntpath``): on
-    POSIX it is an ordinary character of a folder's name, and the listing
-    (``relative_folder``) names such a folder with it, so both agree.
-    ``.``/``..``/empty segments, control characters and (on Windows) a drive
-    are refused: the value only ever names a folder below a root.
-    """
-    if not isinstance(value, str) or len(value) > _MAX_FOLDER:
-        raise ValueError(f"folder must be text of at most {_MAX_FOLDER} characters")
-    windows = pathmod.sep == "\\"
-    folder = (value.replace("\\", "/") if windows else value).strip("/")
-    if not folder:
-        return ""
-    parts = folder.split("/")
-    if (
-        any(part in ("", ".", "..") for part in parts)
-        or (windows and ":" in parts[0])
-        or any(ord(char) < 32 or ord(char) == 127 for char in folder)
-    ):
-        raise ValueError("folder must be a folder below an output root")
-    return folder
-
-
-def _base(root: object, pathmod) -> str:
-    return pathmod.normcase(pathmod.normpath(str(root)))
-
-
-def folder_prefixes(roots, folder: str, pathmod=os.path) -> list[str]:
-    """One ``file_path`` prefix per root spelling for a normalized folder."""
-    prefixes = []
-    for root in roots:
-        joined = pathmod.join(_base(root, pathmod), *folder.split("/"))
-        prefix = pathmod.normcase(pathmod.normpath(joined)) + pathmod.sep
-        if prefix not in prefixes:
-            prefixes.append(prefix)
-    if not prefixes or len(prefixes) > _MAX_PREFIXES:
-        raise ValueError("No output folder to filter by")
-    return prefixes
-
-
-def folder_condition(prefixes: list[str]) -> tuple[str, list]:
-    """A condition on alias ``p``: one linked image under any prefix."""
-    tests = " OR ".join("substr(fg.file_path,1,?)=?" for _ in prefixes)
-    params = [value for prefix in prefixes for value in (len(prefix), prefix)]
-    return (
-        "EXISTS(SELECT 1 FROM generated_images fg WHERE fg.prompt_id=p.id "
-        f"AND ({tests}))",
-        params,
-    )
-
-
-def relative_folder(image_path: str, roots, pathmod=os.path) -> str | None:
-    """The folder of *image_path* below the first root spelling holding it.
-
-    The spelling of the stored path is kept (its case on Windows); ``None``
-    for an image directly in a root or outside every root.
-    """
-    directory = pathmod.normpath(pathmod.dirname(image_path))
-    folded = pathmod.normcase(directory)
-    for root in roots:
-        base = _base(root, pathmod)
-        start = base if base.endswith(pathmod.sep) else base + pathmod.sep
-        if not folded.startswith(start):
-            continue
-        # normcase keeps the length for ordinary names; else show the folded form.
-        rest = (directory if len(directory) == len(folded) else folded)[len(start) :]
-        parts = rest.split(pathmod.sep)
-        if any(part in ("", ".", "..") for part in parts):
-            return None
-        return "/".join(parts)
-    return None
-
-
-def list_library_folders(
-    conn: sqlite3.Connection, roots, eligible: str, pathmod=os.path
-) -> list[str]:
-    """Every folder (and ancestor) holding an image of an eligible parent."""
-    folders = set()
-    for (image_path,) in conn.execute(
-        "SELECT DISTINCT g.image_path FROM generated_images g "
-        "JOIN prompts p ON p.id=g.prompt_id WHERE " + eligible
-    ):
-        if not isinstance(image_path, str) or not image_path:
-            continue
-        folder = relative_folder(image_path, roots, pathmod)
-        if folder is None:
-            continue
-        parts = folder.split("/")
-        folders.update("/".join(parts[:index]) for index in range(1, len(parts) + 1))
-    return sorted(folders, key=lambda value: (value.casefold(), value))
@@ -56,11 +56,9 @@ from .models import BUSY_TIMEOUT_SECONDS, PromptModel
 try:
    from ..utils import library_location as ll
    from ..utils.logging_config import get_logger
-    from ..utils.workspace_keys import KEY_FILE_NAME
 except ImportError:
    from utils import library_location as ll
    from utils.logging_config import get_logger
-    from utils.workspace_keys import KEY_FILE_NAME

 logger = get_logger("prompt_manager.database.library_move")

@@ -493,8 +491,7 @@ class _Move:
        sweep_move_temps(target)
        if ll.read_marker(target).get("state") == ll.MARKER_PENDING:
            # An earlier move stopped before it switched: its files are ours.
-            names = (ll.DATABASE_NAME, ll.CONFIG_NAME, KEY_FILE_NAME)
-            for name in names + self.plan.backups:
+            for name in (ll.DATABASE_NAME, ll.CONFIG_NAME) + self.plan.backups:
                _remove(os.path.join(target, name))
            for suffix in ("-wal", "-shm", "-journal"):
                _remove(os.path.join(target, ll.DATABASE_NAME + suffix))
@@ -539,7 +536,6 @@ class _Move:
                raise MoveFailed("copy-failed") from error
            _check_copies([(self.plan.config_path, temp, expected)])
            copies = copies + [(self.plan.config_path, temp, expected, ll.CONFIG_NAME)]
-        copies = copies + self._key_copy()
        self.marker = write_marker(
            target, ll.MARKER_PENDING, self.plan.db_path, self.plan.config_path
        )
@@ -560,28 +556,6 @@ class _Move:
        self.checkpoint("marked")
        return files

-    def _key_copy(self) -> list:
-        """The workspace key's verified copy (#430), or none: it is re-creatable.
-
-        Without it the moved library starts with a new key, so pages left open
-        across the restart refresh once; that never fails the move.
-        """
-        source = os.path.join(self.plan.source_dir, KEY_FILE_NAME)
-        if not os.path.isfile(source):
-            return []
-        temp = self.temp(".key")
-        try:
-            expected = _hash_copy(source, temp)
-            _check_copies([(source, temp, expected)])
-        except (OSError, MoveFailed) as error:
-            _remove(temp)
-            logger.warning(
-                f"Library move: the workspace key was not copied ({error}); "
-                "open workspace pages refresh once after the restart"
-            )
-            return []
-        return [(source, temp, expected, KEY_FILE_NAME)]
-
    def cleanup(self) -> None:
        if self.moved:
            return
@@ -44,11 +44,6 @@ from .health import BATCH_ROWS, link_states, readable_roots, readonly_uri
 from .pairs import PairDependencyError
 from .workflow_documents import documents_of_rows, release_documents

-try:
-    from ..utils.hashing import register_prompt_functions
-except ImportError:
-    from utils.hashing import register_prompt_functions
-
 MAINTENANCE_OPERATIONS = (
    "duplicate_prompts",
    "optimize",
@@ -294,7 +289,6 @@ def _read_snapshot(db_path, read):
    conn = sqlite3.connect(readonly_uri(db_path), uri=True)
    try:
        conn.row_factory = sqlite3.Row
-        register_prompt_functions(conn)  # LIVE_HINT_CTES calls them (#460)
        conn.execute("BEGIN")  # one read snapshot for the whole plan
        return read(conn)
    finally:
@@ -22,28 +22,13 @@ from .managed_connection import (
 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 .image_collections import (
-    image_collections_schema_error,
-    migrate_image_collections,
-)
 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
-
-try:
-    from ..utils.hashing import register_prompt_functions
-except ImportError:
-    from utils.hashing import register_prompt_functions
-from .image_categories import image_categories_schema_error, migrate_image_categories
 from .workflow_documents import (
    DOCUMENT_ID_COLUMNS,
    migrate_workflow_documents,
@@ -158,15 +143,12 @@ def configure_connection(conn: sqlite3.Connection) -> None:
    (common on Windows) let other writers' polling busy handlers starve past
    BUSY_TIMEOUT_SECONDS and fail with "database is locked" (#242). Without
    WAL (for example an in-memory database) SQLite's FULL default is kept.
-    It also registers the prompt-key SQL functions (register_prompt_functions).
    """
    journal_mode = conn.execute("PRAGMA journal_mode = WAL").fetchone()[0]
    conn.execute("PRAGMA foreign_keys = ON")
    conn.execute(f"PRAGMA busy_timeout = {BUSY_TIMEOUT_SECONDS * 1000}")
    if str(journal_mode).lower() == "wal":
        conn.execute("PRAGMA synchronous = NORMAL")
-    # History reads and the live-hint rule call Python's prompt key (#460)
-    register_prompt_functions(conn)


 class PromptModel:
@@ -350,22 +332,14 @@ class PromptModel:
        migrate_library_state(conn)
        migrate_image_favorites(conn)
        migrate_saved_views(conn)
-        migrate_image_collections(conn)
        # A review group without its annotation group is refused before the
        # annotation install could make it look valid (catalog only; the rows
        # are validated once, in migrate_review_state).
        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)

@@ -1171,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, collections, 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
@@ -1237,21 +1210,11 @@ 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
            )
            if views_error:
                return False, views_error
-            collections_error = image_collections_schema_error(
-                conn, allow_missing=not require_library_state
-            )
-            if collections_error:
-                return False, collections_error
            annotation_error = annotation_schema_error(
                conn, allow_missing=not require_library_state
            )
@@ -1262,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,18 +7,12 @@ 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)
 from .library import LibraryOperations, titled
 from .image_favorites import ImageFavoriteOperations
-from .image_collections import ImageCollectionOperations
 from .annotations import AnnotationOperations
 from .review import ReviewOperations
 from .review_decisions import ReviewDecisionOperations
@@ -33,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,
@@ -244,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
@@ -263,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
@@ -316,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).

@@ -347,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))
@@ -360,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")


@@ -454,7 +359,6 @@ class PromptDatabase(
    ExecutionOutputOperations,
    HistoryReadOperations,
    ImageFavoriteOperations,
-    ImageCollectionOperations,
    AnnotationOperations,
    ReviewOperations,
    ReviewDecisionOperations,
@@ -464,7 +368,6 @@ class PromptDatabase(
    DuplicateCopyOperations,
    WorkflowStorageOperations,
    CategoryImportOperations,
-    ImageCategoryOperations,
 ):
    """Database operations class for managing prompts."""

@@ -1905,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,
@@ -2638,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
@@ -2736,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:
@@ -2745,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]
@@ -2759,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]:
@@ -1,14 +1,7 @@
-"""Atomic metadata enrichment for a single known generation context.
-
-Also the helpers both ingestion store paths share (#247): the file's link
-rows and the one-prompt-per-file rule (``file_link_rows``,
-``link_conflict``) and the marks a prompt created by ingestion carries
-(``Marks``, ``mark_created``).
-"""
+"""Atomic metadata enrichment for a single known generation context."""

 import os
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict

 from .models import normalize_image_path
 from .operations import _coerce_file_info
@@ -44,85 +37,16 @@ def blank_positive(resolution: Dict[str, Any]) -> bool:
    return not (isinstance(text, str) and text.strip())


-@dataclass(frozen=True)
-class Marks:
-    """What a prompt ingestion creates carries, so it can be found and removed.
-
-    ``note`` is formatted with ``name``, the file's name.
-    """
-
-    category: str
-    tags: Tuple[str, ...]
-    note: str
-
-
-SCAN_MARKS = Marks("scanned", ("auto-scanned",), "Auto-scanned from {name}")
-RUN_MARKS = Marks("scanned", ("auto-scanned",), "Saved from a workflow run: {name}")
-
-
-def mark_created(conn: Any, db: Any, prompt_id: int, marks: Marks, name: str) -> None:
-    """Apply ``marks`` to a prompt row the caller just created on ``conn``."""
-    conn.execute(
-        "UPDATE prompts SET category = ?, notes = ? WHERE id = ?",
-        (marks.category, marks.note.format(name=name), prompt_id),
-    )
-    db._sync_prompt_tags(conn, prompt_id, list(marks.tags))
-
-
-def file_link_rows(conn: Any, image_path: str) -> List[Any]:
-    """The file's link rows, each with its prompt's hash.
-
-    Matched under the path and its resolved spelling (an output folder
-    reached through a symlink or junction), each normalized and raw;
-    deduplicated by row id.
-    """
-    rows: Dict[Any, Any] = {}
-    for spelling in dict.fromkeys((image_path, _resolved(image_path))):
-        for row in conn.execute(
-            "SELECT gi.*,p.hash AS positive_hash FROM generated_images gi "
-            "JOIN prompts p ON p.id=gi.prompt_id "
-            "WHERE gi.file_path=? OR gi.image_path=?",
-            (normalize_image_path(spelling), spelling),
-        ).fetchall():
-            rows.setdefault(row["id"], row)
-    return list(rows.values())
-
-
-def _resolved(path: str) -> str:
-    try:
-        return os.path.realpath(path)
-    except (OSError, ValueError):
-        return path
-
-
-def link_conflict(rows: List[Any], prompt_hash: str) -> bool:
-    """One prompt per file: more than one row, or a row of another prompt."""
-    return len(rows) > 1 or bool(rows and rows[0]["positive_hash"] != prompt_hash)
-
-
 def ingest_resolved_pair(
-    db: Any,
-    image_path: str,
-    metadata: Dict[str, Any],
-    resolution: Dict[str, Any],
-    *,
-    marks: Optional[Marks] = None,
+    db: Any, image_path: str, metadata: Dict[str, Any], resolution: Dict[str, Any]
 ) -> Dict[str, Any]:
-    """Store a resolved pair and link the file to it in one transaction.
-
-    With ``marks`` (ingestion from files), each pair component this call
-    creates carries them; without (the PromptManager node path) components
-    are created bare, as always.
-    """
    state = resolution.get("state", "unresolved")
    if state == "resolved" and blank_positive(resolution):
        state = "unresolved"
    if state != "resolved":
        return {"status": state, "pairs_added": 0, "links_added": 0}
    with db._pair_transaction() as conn:
-        return _ingest_resolved_pair_in(
-            conn, db, image_path, metadata, resolution, marks=marks
-        )
+        return _ingest_resolved_pair_in(conn, db, image_path, metadata, resolution)


 def _conflict() -> Dict[str, Any]:
@@ -137,7 +61,6 @@ def _ingest_resolved_pair_in(
    resolution: Dict[str, Any],
    *,
    provenance: Dict[str, Any] | None = None,
-    marks: Optional[Marks] = None,
 ) -> Dict[str, Any]:
    """``ingest_resolved_pair`` inside the caller's open ``_pair_transaction``.

@@ -146,8 +69,7 @@ def _ingest_resolved_pair_in(
    negative is a ``conflict`` and nothing is written. The caller owns the
    transaction, so its own later failure rolls the link back too.
    ``provenance`` replaces the link's default resolver provenance (Needs
-    review records the user's selection there). ``marks`` as in
-    ``ingest_resolved_pair``.
+    review records the user's selection there).
    """
    positive, negative = resolution["positive"], resolution["negative"]
    positive_text = positive.get("storage_text", positive["text"])
@@ -160,8 +82,15 @@ def _ingest_resolved_pair_in(
            "negative": negative,
        }
    encoded = dumps_strict(provenance, sort_keys=True, separators=(",", ":"))
-    images = file_link_rows(conn, image_path)
-    if link_conflict(images, generate_prompt_hash(positive_text)):
+    images = conn.execute(
+        "SELECT gi.*,p.hash AS positive_hash FROM generated_images gi "
+        "JOIN prompts p ON p.id=gi.prompt_id "
+        "WHERE gi.file_path=? OR gi.image_path=?",
+        (normalized, image_path),
+    ).fetchall()
+    if len(images) > 1 or (
+        images and images[0]["positive_hash"] != generate_prompt_hash(positive_text)
+    ):
        return _conflict()
    existing = images[0] if images else None
    if existing:
@@ -186,12 +115,7 @@ def _ingest_resolved_pair_in(
            generate_prompt_hash(negative_text) if negative_text.strip() else None,
        ),
    ).fetchone()
-    if marks is None:
-        pair_id = db._save_pair(conn, positive_text, negative_text)
-    else:
-        pair_id = _save_marked_pair(
-            conn, db, positive_text, negative_text, marks, os.path.basename(image_path)
-        )
+    pair_id = db._save_pair(conn, positive_text, negative_text)
    pair = conn.execute("SELECT * FROM prompt_pairs WHERE id=?", (pair_id,)).fetchone()
    pairs_added = int(prior_pair is None)
    file_size, width, height, image_format = _coerce_file_info(metadata)
@@ -273,26 +197,6 @@ def _ingest_resolved_pair_in(
    }


-def _save_marked_pair(
-    conn: Any,
-    db: Any,
-    positive_text: str,
-    negative_text: str,
-    marks: Marks,
-    name: str,
-) -> int:
-    """``_save_pair`` that marks each component it creates."""
-    texts = [positive_text] + ([negative_text] if negative_text.strip() else [])
-    ids = []
-    for text in texts:
-        prompt_id, created = db._pair_component_outcome(conn, text)
-        if created:
-            mark_created(conn, db, prompt_id, marks, name)
-        ids.append(prompt_id)
-    negative_id = ids[1] if len(ids) > 1 else None
-    return db._save_pair_components(conn, ids[0], negative_id)[0]
-
-
 def _document_form(conn: Any, values: Dict[str, Any]) -> Dict[str, Any]:
    """``values`` with the workflow and prompt graph texts stored once.

@@ -59,7 +59,6 @@ SUMMARY_KEYS = (
    "image_links",
    "runs",
    "saved_views",
-    "collections",
 )


@@ -145,8 +144,7 @@ def library_summary(conn: sqlite3.Connection) -> Dict[str, int]:
    ``positives`` are the Library's prompts (``library_counts``'s
    ``positive_prompts``); ``pairs`` the active saved pairs and
    ``archived_pairs`` the archived ones; ``image_links`` the indexed image
-    rows; ``runs`` the recorded executions; ``collections`` the image
-    collections (#331).
+    rows; ``runs`` the recorded executions.
    """
    from .library import _ELIGIBLE

@@ -171,7 +169,6 @@ def library_summary(conn: sqlite3.Connection) -> Dict[str, int]:
        "image_links": _count(conn, "generated_images"),
        "runs": _count(conn, "execution_runs"),
        "saved_views": _count(conn, "saved_views"),
-        "collections": _count(conn, "image_collections"),
    }


@@ -183,7 +180,6 @@ _FINGERPRINT_SQL = (
    ("prompt_pairs", "SELECT MAX(id), MAX(updated_at) FROM prompt_pairs"),
    ("execution_runs", "SELECT COUNT(*), MAX(rowid) FROM execution_runs"),
    ("saved_views", "SELECT MAX(rowid) FROM saved_views"),
-    ("image_collections", "SELECT MAX(rowid) FROM image_collections"),
 )


@@ -194,9 +190,9 @@ def live_fingerprint(conn: sqlite3.Connection):
    tables a restore replaces, or when a prompt, pair, run or saved view is
    the newest edited (counts plus the newest row and edit of each table);
    the apply refuses with ``plan-changed`` then. It does not see every
-    edit (a tag, favorite or collection membership change on an older row);
-    those are kept in the restore's safety backup. A read transaction the
-    caller already has is used and left open; one opened here is ended here.
+    edit (a tag or favorite change on an older row); those are kept in the
+    restore's safety backup. A read transaction the caller already has is
+    used and left open; one opened here is ended here.
    """
    import json

@@ -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,51 +151,13 @@ 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]:
-    """The one stored prompt every positive context of ``run_id`` names, else None."""
+def _named_prompt(db: Any, run_id: str) -> Optional[int]:
    contexts = db.get_execution_contexts(run_id).get("contexts") or []
    named = {
        context.get("positive_prompt_id")
@@ -228,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)
+            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()

@@ -33,14 +33,8 @@ MAX_TAG_LENGTH = 50
 _IMAGE_SORTS = ("newest", "oldest", "name", "name-desc", "rating")
 _LIBRARY_SORTS = ("newest", "oldest", "name", "rating")
 _MEDIA = ("all", "image", "video")
-# How a Library view's Tags match (#444): every tag, any of them, or parents
-# without tags ("untagged" never goes with tags; the listing refuses both).
-_TAG_MODES = ("all", "any", "untagged")
 _CONTROL = re.compile(r"[\x00-\x1f\x7f]")
 _SOURCE = re.compile(r"all|0|[1-9][0-9]{0,8}")
-# A collection id as the listing's ``collection`` query takes it (#331): none
-# ("") or 1 to 9 digits without a leading zero.
-_COLLECTION = re.compile(r"|[1-9][0-9]{0,8}")
 FALLBACK_NAME = "Saved view"


@@ -61,18 +55,12 @@ _STATE_FIELDS = {
        "tags": ("tags", None, ()),
        # The Favorites page's filter (#249 D51): a view saved there reopens it.
        "favorites": ("bool", None, False),
-        # A view saved on a collection page (#331 D140) reopens that
-        # collection; never together with favorites.
-        "collection": ("collection", None, ""),
    },
    "library": {
        "q": ("text", 500, ""),
        "category": ("text", 100, ""),
        "sort": ("choice", _LIBRARY_SORTS, "newest"),
        "tags": ("tags", None, ()),
-        # #444: the Tags match and the output folder (relative, "/"-joined).
-        "tag_mode": ("choice", _TAG_MODES, "all"),
-        "folder": ("text", 1024, ""),
    },
 }

@@ -137,8 +125,6 @@ def _validate_value(key: str, kind: str, limit, value: object) -> None:
        raise SavedViewInvalid(f"State '{key}' is not a supported value")
    if kind == "source" and not _SOURCE.fullmatch(value):
        raise SavedViewInvalid(f"State '{key}' must be 'all' or a source index")
-    if kind == "collection" and not _COLLECTION.fullmatch(value):
-        raise SavedViewInvalid(f"State '{key}' must be empty or a collection id")
    if kind == "text" and (len(value) > limit or _CONTROL.search(value)):
        raise SavedViewInvalid(f"State '{key}' is too long or has control characters")

@@ -156,10 +142,6 @@ def encode_state(page: object, state: object) -> str:
        )
    for key, (kind, limit, _default) in fields.items():
        _validate_value(key, kind, limit, state[key])
-    if state.get("favorites") is True and state.get("collection"):
-        raise SavedViewInvalid("A view cannot filter by favorites and a collection")
-    if state.get("tag_mode") == "untagged" and state.get("tags"):
-        raise SavedViewInvalid("A view cannot list untagged prompts and filter tags")
    encoded = json.dumps(
        {key: state[key] for key in fields}, ensure_ascii=False, separators=(",", ":")
    )
@@ -199,13 +181,6 @@ def normalize_state(page: str, raw: object) -> dict:
        except SavedViewInvalid:
            value = default
        state[key] = list(value) if kind == "tags" else value
-    # Never written by this build; a stored row with both opens the collection,
-    # as the listing does for a URL with both (#331 D140).
-    if state.get("favorites") is True and state.get("collection"):
-        state["favorites"] = False
-    # Never written by this build either: the tags win.
-    if state.get("tag_mode") == "untagged" and state.get("tags"):
-        state["tag_mode"] = "all"
    return state


@@ -1,87 +0,0 @@
-"""Link an output file to the prompt of one text, creating it when new (#247).
-
-The store step of ingestion from file metadata when the decision is a
-positive text (``utils.file_prompt``). The prompt insert and the link run in
-one ``BEGIN IMMEDIATE`` transaction: two writers never store one text twice,
-a failed link leaves no new prompt behind, and a file stays linked to one
-prompt (a file already linked to another prompt is a ``conflict``).
-"""
-
-import logging
-import os
-from typing import Any, Dict, Optional, Tuple
-
-from .pair_ingestion import Marks, file_link_rows, link_conflict, mark_created
-
-try:
-    from ..utils.hashing import generate_prompt_hash
-except ImportError:
-    from utils.hashing import generate_prompt_hash
-
-_LOGGER = logging.getLogger("prompt_manager.database.scanned_prompts")
-
-
-def store_scanned_prompt_or_raise(
-    db: Any, path: str, canonical: Dict[str, Any], text: str, marks: Marks
-) -> Tuple[str, Optional[int]]:
-    """``(status, prompt id)`` after linking ``path`` to ``text``'s prompt.
-
-    ``added`` (prompt created, carrying ``marks``), ``linked`` (stored text
-    reused), ``unchanged`` (already linked to it) or ``conflict`` (linked to
-    another prompt; nothing written, id None). Database errors are raised
-    and roll the whole store back, so a caller can run it again.
-    """
-    with db._pair_transaction() as conn:
-        rows = file_link_rows(conn, path)
-        if link_conflict(rows, generate_prompt_hash(text)):
-            return "conflict", None
-        if rows:
-            return "unchanged", rows[0]["prompt_id"]
-        prompt_id, created = db._pair_component_outcome(conn, text)
-        if created:
-            mark_created(conn, db, prompt_id, marks, os.path.basename(path))
-        db._insert_image_link(conn, prompt_id, path, canonical)
-        return ("added" if created else "linked"), prompt_id
-
-
-def store_scanned_prompt(
-    db: Any, path: str, canonical: Dict[str, Any], text: str, marks: Marks
-) -> Tuple[str, Optional[int]]:
-    """The scan's form: an error is logged and reported as ``("found", None)``.
-
-    A write that failed because Move library switched runs again on the new
-    library (``survive_library_switch``); the rerun re-checks the link rows.
-    """
-    try:
-        return db.survive_library_switch(
-            lambda: store_scanned_prompt_or_raise(db, path, canonical, text, marks)
-        )
-    except Exception as error:
-        _LOGGER.error(
-            f"Failed to store the prompt of {os.path.basename(path)}: {error}"
-        )
-        return "found", None
-
-
-def link_stored_prompt_or_raise(
-    db: Any, path: str, canonical: Dict[str, Any], prompt_id: int
-) -> Optional[str]:
-    """Link ``path`` to the stored prompt ``prompt_id`` (recorded history, #342).
-
-    ``linked``, ``unchanged`` (already linked to it), ``conflict`` (linked to
-    another prompt; nothing written) or None when the prompt is gone. One
-    ``BEGIN IMMEDIATE`` transaction; database errors are raised.
-    """
-    with db._pair_transaction() as conn:
-        rows = file_link_rows(conn, path)
-        if len(rows) > 1 or (rows and rows[0]["prompt_id"] != prompt_id):
-            return "conflict"
-        if rows:
-            return "unchanged"
-        exists = conn.execute(
-            "SELECT 1 FROM prompts WHERE id = ?", (prompt_id,)
-        ).fetchone()
-        if exists is None:
-            return None
-        db._insert_image_link(conn, prompt_id, path, canonical)
-        return "linked"
@@ -13,14 +13,12 @@ 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

-from .library import _ELIGIBLE, UNTAGGED, _escape, _limit
+from .library import _ELIGIBLE, _limit
 from .library_commands import _TOKEN, LibraryCommandError, _validate_epoch
 from .library_tokens import canonical_token
 from .models import utc_now_iso
@@ -38,7 +36,7 @@ _IMAGE_FILES = (
 )


-def _tag_rows(page: str, order: str = "page.id") -> str:
+def _tag_rows(page: str) -> str:
    """Count rows for the registry rows selected by ``page`` (id, name)."""
    # Eligible parent components carrying a tag in the page, plus the
    # positive parent of every active pair carrying it (always eligible).
@@ -57,45 +55,11 @@ def _tag_rows(page: str, order: str = "page.id") -> str:
        "COALESCE(MAX(images.n),0) AS image_count "
        "FROM page LEFT JOIN owners ON owners.tag_id=page.id "
        "LEFT JOIN images ON images.tag_id=page.id "
-        "GROUP BY page.id ORDER BY " + order
+        "GROUP BY page.id ORDER BY page.id"
    )


 _TAG_PAGE = _tag_rows("SELECT id,name FROM tags WHERE id>? ORDER BY id LIMIT ?")
-# #444 tag sorts: sort -> (key expression on tags/counted, direction). Ties and
-# "created" follow the id, so every order is total and keyset pages are exact.
-TAG_SORTS = {
-    "created": (None, "ASC"),
-    "name": ("name COLLATE NOCASE", "ASC"),
-    "name-desc": ("name COLLATE NOCASE", "DESC"),
-    "prompts": ("prompt_count", "DESC"),
-    "prompts-asc": ("prompt_count", "ASC"),
-}
-_MAX_SEARCH = 200
-_TAG_SEARCH = "name LIKE ? ESCAPE '\\'"
-# Every matching tag ranked by the prompt count its row shows (the owners rule
-# of ``_tag_rows``), then one keyset page of it with its image counts.
-_RANKED_TAG_PAGE = (
-    "WITH owners(tag_id,pid) AS ("
-    "SELECT pt.tag_id,p.id FROM prompts p "
-    "JOIN prompt_tags pt ON pt.prompt_id=p.id WHERE " + _ELIGIBLE + " "
-    "UNION SELECT ppt.tag_id,pp.positive_prompt_id FROM prompt_pairs pp "
-    "JOIN prompt_pair_tags ppt ON ppt.pair_id=pp.id WHERE pp.archived=0),"
-    "counted AS (SELECT t.id,t.name,COUNT(DISTINCT o.pid) AS prompt_count "
-    "FROM tags t LEFT JOIN owners o ON o.tag_id=t.id WHERE {search} "
-    "GROUP BY t.id),"
-    "page AS (SELECT id,name,prompt_count FROM counted WHERE {after} "
-    "ORDER BY prompt_count {direction},id LIMIT ?),"
-    "images(tag_id,n) AS (" + _IMAGE_FILES + " "
-    "WHERE mit.tag_id IN (SELECT id FROM page) GROUP BY mit.tag_id) "
-    "SELECT page.id,page.name,page.prompt_count,"
-    "COALESCE(images.n,0) AS image_count FROM page "
-    "LEFT JOIN images ON images.tag_id=page.id "
-    "ORDER BY page.prompt_count {direction},page.id"
-)
-_UNTAGGED_COUNT = (
-    "SELECT COUNT(*) FROM prompts p WHERE (" + _ELIGIBLE + ") AND " + UNTAGGED
-)
 _TAG_ONE = _tag_rows("SELECT id,name FROM tags WHERE id=?")
 # Every owner kind a tag can sit on, for the delete confirmation.
 _TAG_IMPACT = (
@@ -133,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) "
 )


@@ -167,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=?",
 )


@@ -194,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,
@@ -211,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)


@@ -244,28 +177,6 @@ def _tag_after(after: object) -> int:
    return after


-def _tag_search(search: object) -> str:
-    if not isinstance(search, str) or len(search) > _MAX_SEARCH:
-        raise ValueError(f"Tag search must be text of at most {_MAX_SEARCH} characters")
-    return search.strip()
-
-
-def _sorted_tag_after(after: object, sort: str) -> tuple | None:
-    """The ``[key, id]`` cursor of a name or prompt-count sort."""
-    if after is None:
-        return None
-    key_type = str if sort.startswith("name") else int
-    if (
-        not isinstance(after, list)
-        or len(after) != 2
-        or type(after[0]) is not key_type
-        or type(after[1]) is not int
-        or after[1] <= 0
-    ):
-        raise ValueError("Invalid vocabulary cursor")
-    return after[0], after[1]
-
-
 def _category_after(after: object) -> tuple[int, str] | None:
    if after is None:
        return None
@@ -414,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]
@@ -429,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
            ),
        }

@@ -456,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.
@@ -487,80 +395,22 @@ class VocabularyOperations:
        epoch: str,
        *,
        limit: int = 100,
-        after: object = None,
-        search: str = "",
-        sort: str = "created",
+        after: int | None = None,
    ) -> dict:
-        """One page of tags matching ``search`` (a literal, case-insensitive
-        substring) in ``sort`` order, with the untagged parents' count."""
        _limit(limit)
-        search = _tag_search(search)
-        if not isinstance(sort, str) or sort not in TAG_SORTS:
-            raise ValueError("sort must be one of " + ", ".join(TAG_SORTS))
-        where, params = "1=1", []
-        if search:
-            where, params = _TAG_SEARCH, [f"%{_escape(search)}%"]
-        total, untagged = conn.execute(
-            f"SELECT (SELECT COUNT(*) FROM tags WHERE {where}),({_UNTAGGED_COUNT})",
-            params,
-        ).fetchone()
-        rows = [
-            dict(row) for row in self._tag_page(conn, where, params, sort, after, limit)
-        ]
+        start = _tag_after(after)
+        total = conn.execute("SELECT COUNT(*) FROM tags").fetchone()[0]
+        rows = [dict(row) for row in conn.execute(_TAG_PAGE, (start, limit + 1))]
        has_more = len(rows) > limit
        rows = rows[:limit]
-        key, _direction = TAG_SORTS[sort]
-        next_key = None
-        if has_more:
-            last = rows[-1]
-            next_key = (
-                last["id"]
-                if key is None
-                else [
-                    last["prompt_count" if key == "prompt_count" else "name"],
-                    last["id"],
-                ]
-            )
        return {
            "library_epoch": epoch,
            "tags": rows,
            "total": total,
-            "untagged_count": untagged,
-            # Echoed so a client can tell this read applied its search and sort.
-            "search": search,
-            "sort": sort,
            "has_more": has_more,
-            "next_key": next_key,
+            "next_key": rows[-1]["id"] if has_more else None,
        }

-    @staticmethod
-    def _tag_page(conn, where, params, sort, after, limit):
-        key, direction = TAG_SORTS[sort]
-        if key is None:
-            page = (
-                f"SELECT id,name FROM tags WHERE {where} AND id>? ORDER BY id LIMIT ?"
-            )
-            return conn.execute(
-                _tag_rows(page), [*params, _tag_after(after), limit + 1]
-            )
-        cursor = _sorted_tag_after(after, sort)
-        operator = ">" if direction == "ASC" else "<"
-        keyset, keys = "1=1", []
-        if cursor is not None:
-            keyset = f"({key}{operator}? OR ({key}=? AND id>?))"
-            keys = [cursor[0], cursor[0], cursor[1]]
-        if key == "prompt_count":
-            sql = _RANKED_TAG_PAGE.format(
-                search=where, after=keyset, direction=direction
-            )
-            return conn.execute(sql, [*params, *keys, limit + 1])
-        page = (
-            f"SELECT id,name FROM tags WHERE {where} AND {keyset} "
-            f"ORDER BY {key} {direction},id LIMIT ?"
-        )
-        order = f"page.{key} {direction},page.id"
-        return conn.execute(_tag_rows(page, order), [*params, *keys, limit + 1])
-
    def _vocabulary_categories(
        self,
        conn: sqlite3.Connection,
@@ -572,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],
@@ -590,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,
@@ -604,18 +450,9 @@ class VocabularyOperations:
            ),
        }

-    def list_vocabulary_tags(
-        self,
-        *,
-        limit: int = 100,
-        after: object = None,
-        search: str = "",
-        sort: str = "created",
-    ):
+    def list_vocabulary_tags(self, *, limit: int = 100, after: int | None = None):
        with self.library_snapshot() as (conn, epoch, _ceiling):
-            return self._vocabulary_tags(
-                conn, epoch, limit=limit, after=after, search=search, sort=sort
-            )
+            return self._vocabulary_tags(conn, epoch, limit=limit, after=after)

    def list_vocabulary_categories(
        self, *, limit: int = 100, after: list | None = None
@@ -12,8 +12,7 @@ code. This plan proposes implementation order and acceptance gates.
 - The native Prompt Library merged in [#210](https://github.com/ComfyAssets/ComfyUI_PromptManager/pull/210) for [#208](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/208): one positive parent, saved negative variants, full selected text and a shared filtered image gallery. It does not invent chronological runs from counters or scan dates.
 - [Durable history storage](prompt-history-storage.md) records job attempts and outcomes from [#212](https://github.com/ComfyAssets/ComfyUI_PromptManager/pull/212), frozen prompt contexts from [#213](https://github.com/ComfyAssets/ComfyUI_PromptManager/pull/213), and observed run-owned output locators from [#214](https://github.com/ComfyAssets/ComfyUI_PromptManager/pull/214). Those locators do not verify file bytes or establish gallery-image associations. That association contract and the chronological execution timeline remain pending under [#209](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/209).
 - [#215](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/215) brings the shell, Images and natural-height Prompt Library presentation into the approved geometry and themes while retaining their existing operations. [#216](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/216) adds the shared current-file inspector with exact generation facts, scoped provenance, raw/download evidence and loaded-collection viewer controls, including a slideshow that pauses at native video. This delivery does not establish whole-application parity, change the default entry point or constitute a release. Recorded chronological run/context browsing continues under [#209](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/209); image tagging/review, System consolidation and remaining organization capabilities continue under #196.
- Local Inspect (#249, PRs L1–L3) replaces the `#/inspect` handoff with the concept's native "Inspect a file" page: one local image or video previews inline and opens the shared viewer and full inspector on a record read entirely in the browser, with nothing uploaded, imported or stored. The legacy metadata page (`web/metadata.html`, served at `/prompt_manager/gallery.html`) stays reachable from Overview; its capabilities map to the shared inspector, including its one-click COPY ALL summary, which is the shared inspector's "Copy settings summary" (D117, LI-4). PR L3 ([#286](https://github.com/ComfyAssets/ComfyUI_PromptManager/pull/286)) shipped that button and local roles equal to the server's resolver (`web/js/workspace/local-resolver.mjs`, TESTING.md "Local roles (#249 PR L3, decision LI-1)"). Recorded deviations D60–D66 and D117 are in [TESTING.md](../TESTING.md).
- Collections ([#331](https://github.com/ComfyAssets/ComfyUI_PromptManager/issues/331), three PRs) adds named, hand-picked groups of images, stored in the library database by file location as favorites are: a COLLECTIONS sidebar group whose rows open Images filtered to one collection (`#/collection/<id>`) with rename and delete, Add to collection and Remove from collection in the Images selection bar, a Collections… checklist in the shared inspector for the side panel and the viewer, and saved views that keep a collection. Membership survives restarts, source reordering and System › Maintenance duplicate cleanup; no file is copied, moved or changed.
+- Local Inspect (#249, PRs L1–L2) replaces the `#/inspect` handoff with the concept's native "Inspect a file" page: one local image or video previews inline and opens the shared viewer and full inspector on a record read entirely in the browser, with nothing uploaded, imported or stored. The legacy metadata page (`web/metadata.html`, served at `/prompt_manager/gallery.html`) stays reachable from Overview; its capabilities map to the shared inspector, except its one-click COPY ALL summary, whose ruled replacement ("Copy settings summary") is pending. Recorded deviations D60–D66 are in [TESTING.md](../TESTING.md). Local roles equal to the server's resolver follow in PR L3.

 ## Scope and compatibility

@@ -26,13 +26,13 @@ except ImportError:
    InputTypeDict = dict

 try:
-    from .prompt_manager_base import SAVE_TO_LIBRARY_INPUT, PromptManagerBase
+    from .prompt_manager_base import PromptManagerBase
 except ImportError:
    import os
    import sys

    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-    from prompt_manager_base import SAVE_TO_LIBRARY_INPUT, PromptManagerBase
+    from prompt_manager_base import PromptManagerBase


 class PromptManager(PromptManagerBase, ComfyNodeABC):
@@ -115,7 +115,6 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
                        )
                    },
                ),
-                "save_to_library": SAVE_TO_LIBRARY_INPUT,
            },
            "hidden": {
                # The queued graph and this node's id: used to tell the positive
@@ -153,7 +152,6 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
        append_text: str = "",
        prompt: Optional[Dict[str, Any]] = None,
        unique_id: Optional[str] = None,
-        save_to_library: bool = True,
    ) -> Tuple[Any]:
        """
        Encode the text prompt and save it to the database.
@@ -166,7 +164,6 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
            search_text: Text to search for in past prompts
            prepend_text: Text to prepend to the main prompt
            append_text: Text to append to the main prompt
-            save_to_library: Off: nothing is saved, counted or tracked (#90)

        Returns:
            Tuple containing the conditioning for the diffusion model and the final
@@ -208,9 +205,7 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
        # Save prompt to database and set execution context for gallery tracking
        prompt_id = None
        extended_tags = []
-        if not save_to_library:
-            self._skip_not_saved(prompt, unique_id)
-        elif storage_text and storage_text.strip():
+        if storage_text and storage_text.strip():
            self.logger.debug(f"Processing prompt text: {storage_text[:100]}...")

            # Add prepend/append info to tags if they exist
@@ -254,11 +249,6 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
        tokens = clip.tokenize(encoding_text)
        conditioning = clip.encode_from_tokens_scheduled(tokens)

-        self.logger.info(f"CLIP encoding completed, text: {repr(encoding_text)[:80]}")
-        result = (conditioning, encoding_text)
-        if not save_to_library:
-            return result  # #90: no metadata registration, no history text
-
        # Register with ComfyUI integration for standard metadata compatibility
        node_id = f"promptmanager_{int(time.time() * 1000)}"
        self.comfyui_integration.register_prompt(
@@ -272,15 +262,12 @@ class PromptManager(PromptManagerBase, ComfyNodeABC):
                "append_text": append_text.strip() if append_text else None,
            },
        )
+
+        self.logger.info(f"CLIP encoding completed, text: {repr(encoding_text)[:80]}")
+        result = (conditioning, encoding_text)
        record_runtime_context(
            type(self).__name__, text, prepend_text, append_text, encoding_text
        )
-        self._record_cached_item(
-            unique_id,
-            (encoding_text,),
-            storage_text,
-            fields=((text, prepend_text, append_text),),
-        )
        return result

    @classmethod
@@ -23,16 +23,9 @@ try:
    from .utils.image_monitor import get_image_monitor
    from .utils.prompt_tracker import get_prompt_tracker
    from .utils.hashing import generate_prompt_hash
-    from .utils.prompt_graph import resolve_text, run_prompt_nodes, save_setting
+    from .utils.prompt_graph import resolve_text, run_prompt_nodes
    from .utils.run_keys import executing_run_id, prompt_node_key
    from .utils.usage_tracking import PENDING_FIRST_USE
-    from .utils.cached_runs import (
-        CACHED_RUNS,
-        Role,
-        Seen,
-        own_counts,
-        stored_facts,
-    )
 except ImportError:
    import sys

@@ -42,32 +35,9 @@ except ImportError:
    from utils.image_monitor import get_image_monitor
    from utils.prompt_tracker import get_prompt_tracker
    from utils.hashing import generate_prompt_hash
-    from utils.prompt_graph import resolve_text, run_prompt_nodes, save_setting
+    from utils.prompt_graph import resolve_text, run_prompt_nodes
    from utils.run_keys import executing_run_id, prompt_node_key
    from utils.usage_tracking import PENDING_FIRST_USE
-    from utils.cached_runs import (
-        CACHED_RUNS,
-        Role,
-        Seen,
-        own_counts,
-        stored_facts,
-    )
-
-
-# The optional input every PromptManager node declares last (#90): declared
-# last so no widget value of a workflow saved before it shifts.
-SAVE_TO_LIBRARY_INPUT = (
-    "BOOLEAN",
-    {
-        "default": True,
-        "label_on": "save",
-        "label_off": "skip",
-        "tooltip": (
-            "Save this node's prompt to the library, count its runs and link its "
-            "images. Off: PromptManager ignores the run; the output is unchanged."
-        ),
-    },
-)


 class PromptManagerBase:
@@ -101,10 +71,8 @@ class PromptManagerBase:
        """Save the prompt to the SQLite database.

        Runs are normally counted by the queue hook (utils/usage_tracking.py), so a
-        save only counts one when asked to (text the hook could not see, unless
-        this job already counted the node from ComfyUI's cache) or when the hook
-        queued this prompt before it existed. The two are independent: the
-        pending catch-up is written even when ``count_run`` is False.
+        save only counts one when asked to (batch items whose text the hook could not
+        see) or when the hook queued this prompt before it existed.

        Args:
            text: The prompt text
@@ -172,9 +140,7 @@ class PromptManagerBase:
        resolved = resolve_text(prompt_graph, node_id)
        return {
            "is_run_prompt": node_id in run_prompt_nodes(prompt_graph),
-            # The hook skips a switch it cannot read (#90): the node counts
            "seen_at_queue": resolved is not None
-            and save_setting(prompt_graph, node_id) is True
            and generate_prompt_hash(resolved) == generate_prompt_hash(text),
            "known": True,
        }
@@ -201,19 +167,8 @@ class PromptManagerBase:
        batch_item = (
            role["known"] and role["is_run_prompt"] and not role["seen_at_queue"]
        )
-        counts = own_counts(
-            type(self).__name__,
-            stored_facts(text),
-            Role(
-                frozenset({"text"} if role["known"] and role["is_run_prompt"] else ())
-            ),
-            Seen(text=role["seen_at_queue"]),
-        )
        prompt_id = self._save_prompt_to_database(
-            text=text,
-            category=category,
-            tags=tags,
-            count_run=bool(counts) and not self._replayed(unique_id),
+            text=text, category=category, tags=tags, count_run=batch_item
        )
        if role["is_run_prompt"] and not prompt_id:
            # The save failed: an older entry of this key must not stand in (#342)
@@ -227,44 +182,6 @@ class PromptManagerBase:
            )
        return prompt_id

-    def _cached_runs(self) -> Any:
-        return getattr(self, "cached_runs", CACHED_RUNS)
-
-    def _replayed(self, unique_id: Any) -> bool:
-        """This job already counted the node from ComfyUI's cache (#347).
-
-        A RAM-pressure cache can free the entry after ``execution_cached``, so
-        the node executes in a job that replayed it: its own count is skipped.
-        """
-        try:
-            return unique_id is not None and self._cached_runs().replayed(unique_id)
-        except Exception as error:
-            self.logger.debug(f"Could not check the cached-run replay: {error}")
-            return False
-
-    def _record_cached_item(
-        self,
-        unique_id: Any,
-        outputs: tuple,
-        text: Any,
-        negative_text: Any = None,
-        fields: Optional[tuple] = None,
-    ) -> None:
-        """Remember this execution's outputs and stored text for cached jobs (#347).
-
-        ``fields`` are the ``(raw, prepend, append)`` texts this execution gave
-        ``record_runtime_context`` for each output, so a cached job's history
-        can record them too (#403).
-        """
-        if unique_id is None:
-            return
-        try:
-            self._cached_runs().record_item(
-                unique_id, outputs, stored_facts(text, negative_text), fields
-            )
-        except Exception as error:
-            self.logger.debug(f"Could not record the cached-run receipt: {error}")
-
    @staticmethod
    def _run_identity(prompt_graph: Any, unique_id: Any) -> Dict[str, Any]:
        """The tracker's proof that an image belongs to this execution (#342)."""
@@ -273,24 +190,6 @@ class PromptManagerBase:
            "run_id": executing_run_id(),
        }

-    def _skip_not_saved(self, prompt_graph: Any = None, unique_id: Any = None) -> None:
-        """``save_to_library`` is off: nothing is saved, counted or tracked (#90).
-
-        A literal off makes the node no run prompt (``utils.prompt_graph``), so
-        no image looks up its run key. A switch wired from a node the graph
-        cannot read keeps the node a run prompt: its run key is marked like an
-        empty editor's, so an earlier run's entry of that key never links this
-        run's images.
-        """
-        message = (
-            "Save to library is off for this node: its prompt is not saved, the "
-            "run is not counted and its images are not linked"
-        )
-        if isinstance(prompt_graph, dict) and unique_id is not None:
-            self._mark_untracked(prompt_graph, unique_id, message)
-        else:
-            self.logger.info(message)
-
    def _skip_empty_prompt(self, prompt_graph: Any, unique_id: Any) -> None:
        """The ``text`` editor is empty: save and track nothing (#342).

@@ -12,21 +12,9 @@ else:

 try:
    from .prompt_manager import IO, InputTypeDict, PromptManagerFocused
-    from .utils.cached_runs import (
-        PAIR,
-        Role,
-        Seen,
-        own_counts,
-        pair_components,
-        stored_facts,
-    )
    from .utils.hashing import generate_prompt_hash
    from .utils.pair_execution import record_pair_execution
-    from .utils.prompt_graph import (
-        intrinsic_pair_nodes,
-        run_prompt_components,
-        save_setting,
-    )
+    from .utils.prompt_graph import intrinsic_pair_nodes, run_prompt_components
    from .utils.prompt_pair_resolver import resolve_text_input
    from .utils.usage_tracking import (
        PENDING_FIRST_USE,
@@ -35,21 +23,9 @@ try:
    )
 except ImportError:
    from prompt_manager import IO, InputTypeDict, PromptManagerFocused
-    from utils.cached_runs import (
-        PAIR,
-        Role,
-        Seen,
-        own_counts,
-        pair_components,
-        stored_facts,
-    )
    from utils.hashing import generate_prompt_hash
    from utils.pair_execution import record_pair_execution
-    from utils.prompt_graph import (
-        intrinsic_pair_nodes,
-        run_prompt_components,
-        save_setting,
-    )
+    from utils.prompt_graph import intrinsic_pair_nodes, run_prompt_components
    from utils.prompt_pair_resolver import resolve_text_input
    from utils.usage_tracking import (
        PENDING_FIRST_USE,
@@ -98,13 +74,8 @@ class PromptManagerPair(PromptManagerFocused):
        prompt: Optional[Dict[str, Any]] = None,
        unique_id: Optional[str] = None,
        extra_pnginfo: Optional[Dict[str, Any]] = None,
-        save_to_library: bool = True,
    ) -> Tuple[Any, Any, str, str]:
-        """Encode both sides once; database and tracking failures never block CLIP.
-
-        With ``save_to_library`` off nothing is saved, counted, tracked or
-        recorded (#90); the four outputs are the same.
-        """
+        """Encode both sides once; database and tracking failures never block CLIP."""
        if clip is None:
            raise RuntimeError("ERROR: clip input is invalid: None")
        if not isinstance(text, str) or not isinstance(negative_text, str):
@@ -122,10 +93,6 @@ class PromptManagerPair(PromptManagerFocused):
        negative_conditioning = clip.encode_from_tokens_scheduled(
            clip.tokenize(negative_text)
        )
-        result = positive_conditioning, negative_conditioning, positive, negative_text
-        if not save_to_library:
-            self._skip_not_saved(prompt, unique_id)
-            return result
        record_pair_execution(
            extra_pnginfo,
            unique_id,
@@ -186,6 +153,7 @@ class PromptManagerPair(PromptManagerFocused):
            )
        except Exception as error:
            self.logger.warning(f"Could not register paired metadata: {error}")
+        result = positive_conditioning, negative_conditioning, positive, negative_text
        record_runtime_context(
            type(self).__name__,
            text,
@@ -197,13 +165,6 @@ class PromptManagerPair(PromptManagerFocused):
        record_runtime_context(
            type(self).__name__, negative_text, "", "", negative_text, role="negative"
        )
-        self._record_cached_item(
-            unique_id,
-            (positive, negative_text),
-            text,
-            negative_text,
-            fields=((text, prepend_text, append_text), (negative_text, "", "")),
-        )
        return result

    def _save_and_track_pair(
@@ -239,9 +200,6 @@ class PromptManagerPair(PromptManagerFocused):
        resolved_negative = (
            resolve_text_input(prompt, node_id, "negative_text") if known else None
        )
-        if known and save_setting(prompt, node_id) is not True:
-            # The hook skips a switch it cannot read (#90): the node counts
-            resolved_positive = resolved_negative = None
        positive_seen = resolved_positive is not None and generate_prompt_hash(
            resolved_positive
        ) == generate_prompt_hash(text)
@@ -251,35 +209,36 @@ class PromptManagerPair(PromptManagerFocused):
            and generate_prompt_hash(resolved_negative)
            == generate_prompt_hash(negative_text)
        )
-        negative_seen = resolved_negative is not None and generate_prompt_hash(
-            resolved_negative
-        ) == generate_prompt_hash(negative_text)
        positive_pending = getattr(self, "pending_first_use", PENDING_FIRST_USE)
        pair_pending = getattr(self, "pending_pair_first_use", PENDING_PAIR_FIRST_USE)
-        facts = stored_facts(text, negative_text)
-        role = Role(frozenset(used_fields), pair_used)
-        # Own counts are skipped when this job already counted the node from
-        # ComfyUI's cache (#347); the pending first-use catch-up never is.
-        counts = (
-            []
-            if self._replayed(unique_id)
-            else own_counts(
-                PAIR, facts, role, Seen(positive_seen, negative_seen, pair_seen)
-            )
-        )
-        component_ids = {"text": prompt_id, "negative_text": pair["negative_prompt_id"]}
-        for field, component_hash in pair_components(facts, role):
-            component_id = component_ids[field]
-            if not component_id:
+        counted = set()
+        for field, component_text, resolved_text, component_id in (
+            ("text", text, resolved_positive, prompt_id),
+            (
+                "negative_text",
+                negative_text,
+                resolved_negative,
+                pair["negative_prompt_id"],
+            ),
+        ):
+            component_hash = generate_prompt_hash(component_text)
+            if (
+                field not in used_fields
+                or not component_id
+                or component_hash in counted
+            ):
                continue
-            runs = positive_pending.consume(component_hash) + int(
-                ("prompt", component_hash) in counts
+            counted.add(component_hash)
+            seen_at_queue = (
+                resolved_text is not None
+                and generate_prompt_hash(resolved_text) == component_hash
            )
+            runs = positive_pending.consume(component_hash) + int(not seen_at_queue)
            if runs:
                self.db.record_prompt_use(component_id, times=runs)
        if pair_used:
            runs = pair_pending.consume(pair_run_key(text, negative_text)) + int(
-                ("pair", facts.positive_hash, facts.negative_hash) in counts
+                not pair_seen
            )
            if runs:
                self.db.record_prompt_pair_use(pair_id, times=runs)
@@ -26,13 +26,13 @@ except ImportError:
    InputTypeDict = dict

 try:
-    from .prompt_manager_base import SAVE_TO_LIBRARY_INPUT, PromptManagerBase
+    from .prompt_manager_base import PromptManagerBase
 except ImportError:
    import os
    import sys

    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-    from prompt_manager_base import SAVE_TO_LIBRARY_INPUT, PromptManagerBase
+    from prompt_manager_base import PromptManagerBase


 class PromptManagerText(PromptManagerBase, ComfyNodeABC):
@@ -115,7 +115,6 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
                        ),
                    },
                ),
-                "save_to_library": SAVE_TO_LIBRARY_INPUT,
            },
            "hidden": {
                # The queued graph and this node's id: used to tell the positive
@@ -150,7 +149,6 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
        append_text: str = "",
        prompt: Optional[Dict[str, Any]] = None,
        unique_id: Optional[str] = None,
-        save_to_library: bool = True,
    ) -> Tuple[str]:
        """
        Process the text prompt and save it to the database.
@@ -162,7 +160,6 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
            search_text: Text to search for in past prompts
            prepend_text: Text to prepend to the main prompt
            append_text: Text to append to the main prompt
-            save_to_library: Off: nothing is saved, counted or tracked (#90)

        Returns:
            Tuple containing the final processed text string
@@ -187,9 +184,7 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
        # Save prompt to database and set execution context for gallery tracking
        prompt_id = None
        extended_tags = []
-        if not save_to_library:
-            self._skip_not_saved(prompt, unique_id)
-        elif storage_text and storage_text.strip():
+        if storage_text and storage_text.strip():
            self.logger.debug(f"Processing prompt text: {storage_text[:100]}...")

            # Add prepend/append info to tags if they exist
@@ -225,11 +220,6 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
        else:
            self._skip_empty_prompt(prompt, unique_id)

-        self.logger.debug(f"Text processing completed: {final_text[:100]}...")
-        result = (final_text,)
-        if not save_to_library:
-            return result  # #90: no metadata registration, no history text
-
        # Register with ComfyUI integration for standard metadata compatibility
        node_id = f"promptmanagertext_{int(time.time() * 1000)}"
        self.comfyui_integration.register_prompt(
@@ -243,15 +233,12 @@ class PromptManagerText(PromptManagerBase, ComfyNodeABC):
                "append_text": append_text.strip() if append_text else None,
            },
        )
+
+        self.logger.debug(f"Text processing completed: {final_text[:100]}...")
+        result = (final_text,)
        record_runtime_context(
            type(self).__name__, text, prepend_text, append_text, final_text
        )
-        self._record_cached_item(
-            unique_id,
-            (final_text,),
-            storage_text,
-            fields=((text, prepend_text, append_text),),
-        )
        return result

    @classmethod
@@ -5,8 +5,6 @@ Split into domain-specific mixins for maintainability:
 - ImageRoutesMixin: gallery, thumbnails, image serving and linking
 - AdminRoutesMixin: duplicates, stats, settings, diagnostics, maintenance, backup, scan
 - LoggingRoutesMixin: log management endpoints
- LogCleanupMixin: the reviewed rotated-log cleanup (a maintenance plan)
- DiagnosticsReportMixin: the shareable diagnostic report, without secrets or paths
 - AutotagRoutesMixin: auto-tagging model management and tagging
 - JobRoutesMixin: the session job registry behind Activity (py/api/jobs.py)
 - ImageTagJobsMixin: bulk Add tags / Auto-tag as image-tags jobs
@@ -40,7 +38,6 @@ from aiohttp import web
 from PIL import Image

 from .prompts import PromptRoutesMixin
-from .revalidation import revalidated_response
 from .pairs import PairRoutesMixin
 from .library import LibraryRoutesMixin
 from .vocabulary import VocabularyRoutesMixin
@@ -49,7 +46,6 @@ from .review import ReviewRoutesMixin
 from .review_recording import ReviewRecordingMixin
 from .review_events import ReviewEventsMixin
 from .saved_views import SavedViewRoutesMixin
-from .collections import CollectionRoutesMixin
 from .history import HistoryRoutesMixin
 from .images import ImageRoutesMixin
 from .gallery_listing import WALK_STOPPED, RootListing, WalkOutcome
@@ -69,17 +65,12 @@ from .duplicate_files import DuplicateFilesMixin
 from .maintenance_plans import PlanStore
 from .jobs import JobRegistry
 from .logging_routes import LoggingRoutesMixin
-from .log_cleanup import LogCleanupMixin
-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
-from .source_rescope import SourceRescopeMixin

 try:
    from ...database.operations import PromptDatabase
-    from ...utils.file_prompt import parse_comfyui_prompt
    from ...utils.logging_config import get_logger
    from ...utils.video_metadata import is_video_path, read_video_metadata
 except ImportError:
@@ -89,7 +80,6 @@ except ImportError:
        0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
    )
    from database.operations import PromptDatabase
-    from utils.file_prompt import parse_comfyui_prompt
    from utils.logging_config import get_logger
    from utils.video_metadata import is_video_path, read_video_metadata

@@ -301,10 +291,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"
@@ -320,7 +306,6 @@ class PromptManagerAPI(
    ReviewRecordingMixin,
    ReviewEventsMixin,
    SavedViewRoutesMixin,
-    CollectionRoutesMixin,
    HistoryRoutesMixin,
    PromptRoutesMixin,
    ImageRoutesMixin,
@@ -338,13 +323,9 @@ class PromptManagerAPI(
    WorkflowStorageRoutesMixin,
    DuplicateFilesMixin,
    LoggingRoutesMixin,
-    LogCleanupMixin,
-    DiagnosticsReportMixin,
    AutotagRoutesMixin,
    LoraIntegrationMixin,
    LoraImportRoutesMixin,
-    ImageCategoryRoutesMixin,
-    SourceRescopeMixin,
 ):
    """REST API handler for PromptManager operations and web interface.

@@ -372,9 +353,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
@@ -654,39 +632,35 @@ class PromptManagerAPI(

        @routes.get("/prompt_manager/workspace")
        async def serve_workspace_ui(request: web.Request) -> web.Response:
-            return self._serve_html_page(request, "workspace.html", "Workspace")
+            return self._serve_html_page("workspace.html", "Workspace")

        @routes.get("/prompt_manager/web")
        async def serve_web_ui(request):
-            return self._serve_html_page(request, "index.html", "Web UI", cache=False)
+            return self._serve_html_page("index.html", "Web UI", cache=False)

        @routes.get("/prompt_manager/gallery.html")
        async def serve_gallery_ui(request):
-            return self._serve_html_page(request, "metadata.html", "Gallery")
+            return self._serve_html_page("metadata.html", "Gallery")

        @routes.get("/prompt_manager/admin")
        async def serve_admin_ui(request):
-            return self._serve_html_page(request, "admin.html", "Admin UI")
+            return self._serve_html_page("admin.html", "Admin UI")

        @routes.get("/prompt_manager/gallery")
        async def serve_gallery_admin_ui(request):
-            return self._serve_html_page(request, "gallery.html", "Gallery")
+            return self._serve_html_page("gallery.html", "Gallery")

        # ── Static file serving ───────────────────────────────────────

        @routes.get("/prompt_manager/lib/{filepath:.*}")
        async def serve_lib_static(request):
            """Serve static library files (JS, CSS) from web/lib directory."""
-            return self._serve_static_file(
-                request, "lib", request.match_info.get("filepath")
-            )
+            return self._serve_static_file("lib", request.match_info.get("filepath"))

        @routes.get("/prompt_manager/js/{filepath:.*}")
        async def serve_js_static(request):
            """Serve static JavaScript files from web/js directory."""
-            return self._serve_static_file(
-                request, "js", request.match_info.get("filepath")
-            )
+            return self._serve_static_file("js", request.match_info.get("filepath"))

        # ── Register domain-specific routes from mixins ───────────────

@@ -697,7 +671,6 @@ class PromptManagerAPI(
        self._register_review_routes(routes)
        self._register_review_event_routes(routes)
        self._register_saved_view_routes(routes)
-        self._register_collection_routes(routes)
        self._register_history_routes(routes)
        self._register_prompt_routes(routes)
        self._register_image_routes(routes)
@@ -705,7 +678,6 @@ class PromptManagerAPI(
        self._register_settings_routes(routes)
        self._register_job_routes(routes)
        self._register_system_routes(routes)
-        self._register_diagnostics_report_routes(routes)
        self._register_library_location_routes(routes)
        self._register_maintenance_routes(routes)
        self._register_backup_restore_routes(routes)
@@ -714,8 +686,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)
-        self._register_rescope_routes(routes)

        # Register gzip compression middleware (once)
        global _gzip_registered
@@ -731,11 +701,8 @@ class PromptManagerAPI(

        self.logger.info("All routes registered with decorator pattern")

-    def _serve_static_file(self, request, subdir, filepath):
-        """Serve ``web/<subdir>/<filepath>``; 403 outside it, 404 when missing.
-
-        A served file is revalidated on every reuse (#478, ``revalidation``).
-        """
+    def _serve_static_file(self, subdir, filepath):
+        """Serve ``web/<subdir>/<filepath>``; 403 outside it, 404 when missing."""
        root = os.path.join(_get_project_root(), "web", subdir)
        exact = STATIC_EXACT_FILES.get((subdir, filepath))
        # An exact file passes the same containment check, its extension only.
@@ -750,13 +717,10 @@ class PromptManagerAPI(
            return web.Response(text="Not Found", status=404)
        with open(file_path, "rb") as f:
            content = f.read()
-        return revalidated_response(request, content, content_type)
+        return web.Response(body=content, content_type=content_type)

-    def _serve_html_page(self, request, filename, title, cache=True):
-        """Serve ``web/<filename>``; 404 when missing, 500 when unreadable.
-
-        A served page is revalidated on every reuse (#478, ``revalidation``).
-        """
+    def _serve_html_page(self, filename, title, cache=True):
+        """Serve ``web/<filename>``; 404 when missing, 500 when unreadable."""
        html_path = os.path.join(_get_project_root(), "web", filename)
        try:
            if cache and html_path in self._html_cache:
@@ -773,9 +737,7 @@ class PromptManagerAPI(
                    content_type="text/html",
                    status=404,
                )
-            return revalidated_response(
-                request, content.encode("utf-8"), "text/html", charset="utf-8"
-            )
+            return web.Response(text=content, content_type="text/html", charset="utf-8")
        except Exception:
            self.logger.exception(f"Failed to load {title}")
            return web.Response(
@@ -1049,4 +1011,278 @@ class PromptManagerAPI(

    def _parse_comfyui_prompt(self, metadata):
        """Parse ComfyUI and A1111 prompt data from metadata."""
-        return parse_comfyui_prompt(metadata)
+        result = {
+            "prompt": None,
+            "workflow": None,
+            "parameters": {},
+            "positive_prompt": None,
+            "negative_prompt": None,
+        }
+
+        # Check for A1111/Forge style parameters first.
+        # The chunk is one block: a possibly multi-line positive prompt, then a
+        # "Negative prompt:" section, then a trailing "Steps: ..." settings line.
+        # Taking lines[0] as the positive prompt truncates any multi-line prompt
+        # to one line, so split on the settings line instead.
+        if "parameters" in metadata:
+            import re as _re
+
+            params = metadata["parameters"]
+            body = params
+            settings = ""
+            _sm = _re.search(r"\nSteps:\s", body)
+            if _sm:
+                settings = body[_sm.start() + 1 :].strip()
+                body = body[: _sm.start()]
+            negative = None
+            _nm = _re.search(r"(?im)^\s*negative prompt:\s*", body)
+            if _nm:
+                negative = body[_nm.end() :].strip()
+                body = body[: _nm.start()]
+            elif body.lower().lstrip().startswith("negative prompt:"):
+                negative = body.lower().lstrip()[len("negative prompt:") :].strip()
+                body = ""
+            result["positive_prompt"] = body.strip() or None
+            if negative:
+                result["negative_prompt"] = negative
+            # Store raw parameters too
+            result["parameters"]["parameters"] = params
+            if settings:
+                for _f in ("Steps", "Sampler", "Schedule type", "CFG scale", "Seed"):
+                    _fm = _re.search(
+                        r"(?i)(?:^|,\s*)" + _re.escape(_f) + r":\s*([^,]+)", settings
+                    )
+                    if _fm:
+                        result["parameters"][_f.lower().replace(" ", "_")] = _fm.group(
+                            1
+                        ).strip()
+
+        # If no A1111 format found, proceed with ComfyUI parsing
+        if result["positive_prompt"] is None:
+            # Check for direct prompt field
+            if "prompt" in metadata:
+                try:
+                    prompt_data = json.loads(metadata["prompt"])
+                    result["prompt"] = prompt_data
+                except json.JSONDecodeError:
+                    result["prompt"] = metadata["prompt"]
+
+            # Check for workflow
+            if "workflow" in metadata:
+                try:
+                    workflow_data = json.loads(metadata["workflow"])
+                    result["workflow"] = workflow_data
+                except json.JSONDecodeError:
+                    result["workflow"] = metadata["workflow"]
+
+            # Check for other common ComfyUI fields
+            common_fields = [
+                "positive",
+                "negative",
+                "steps",
+                "cfg",
+                "sampler",
+                "scheduler",
+                "seed",
+            ]
+            for field in common_fields:
+                if field in metadata:
+                    try:
+                        result["parameters"][field] = json.loads(metadata[field])
+                    except json.JSONDecodeError:
+                        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
@@ -35,56 +35,43 @@ 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 SCAN_MARKS, ingest_resolved_pair
+    from ...database.pair_ingestion import blank_positive, ingest_resolved_pair
    from ...database.run_attribution import (
-        RecordedOutput,
        host_output_directory,
-        named_prompt,
-        recorded_runs,
+        stored_run_prompt,
+        stored_run_prompts,
    )
-    from ...database.scanned_prompts import (
-        link_stored_prompt_or_raise,
-        store_scanned_prompt,
-    )
-    from ...utils.file_prompt import (
-        NEVER,
-        NOT_SAVED,
-        NOT_SAVED_WIRED,
-        PAIR,
-        Policy,
-        decide_file_prompt,
+    from ...utils.generation_params import (
+        PLACEHOLDERS,
+        GenerationParamsError,
+        extract_generation_params,
+        parse_page_json,
    )
+    from ...utils.prompt_pair_resolver import resolve_prompt_pair
+    from ...utils.review_capture import reviewable
 except ImportError:
-    from database.pair_ingestion import SCAN_MARKS, ingest_resolved_pair
+    from database.pair_ingestion import blank_positive, ingest_resolved_pair
    from database.run_attribution import (
-        RecordedOutput,
        host_output_directory,
-        named_prompt,
-        recorded_runs,
+        stored_run_prompt,
+        stored_run_prompts,
    )
-    from database.scanned_prompts import (
-        link_stored_prompt_or_raise,
-        store_scanned_prompt,
-    )
-    from utils.file_prompt import (
-        NEVER,
-        NOT_SAVED,
-        NOT_SAVED_WIRED,
-        PAIR,
-        Policy,
-        decide_file_prompt,
+    from utils.generation_params import (
+        PLACEHOLDERS,
+        GenerationParamsError,
+        extract_generation_params,
+        parse_page_json,
    )
+    from utils.prompt_pair_resolver import resolve_prompt_pair
+    from utils.review_capture import reviewable


 try:
    from ...database.library import display_title
+    from ...utils.hashing import generate_prompt_hash
 except ImportError:
    from database.library import display_title
+    from utils.hashing import generate_prompt_hash

 IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff")
 VIDEO_EXTENSIONS = (".mp4", ".avi", ".mov", ".mkv", ".webm", ".m4v", ".wmv")
@@ -131,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
@@ -264,15 +250,10 @@ SCAN_DETAILS = {
    "skipped": "Skipped · already linked",
    "ambiguous": "Needs review: more than one prompt could match",
    "unresolved": "Needs review: the prompt could not be traced in the workflow",
-    "conflict": "Kept: already linked to a different prompt",
+    "conflict": "Needs review: already linked to a different prompt",
    "failed": "Error: the prompt could not be stored",
    "error": "Error: the file could not be processed (see the server log)",
    "found": "Metadata found, but no prompt text to store",
-    "not_saved": "Skipped · its PromptManager node does not save to the library",
-    "not_saved_wired": (
-        "Skipped · its Save to library switch is wired from another node, so only "
-        "the run itself can link it"
-    ),
    None: "No prompt metadata in the file",
 }

@@ -331,6 +312,22 @@ def _file_size(path):
        return None


+def _with_file_size(canonical, media_file):
+    """Record the file's size in ``file_info`` unless the metadata carries one.
+
+    Stored as ``generated_images.file_size``; the "new" scan scope skips a known
+    file only while its size is unchanged.
+    """
+    info = canonical.get("file_info")
+    info = dict(info) if isinstance(info, dict) else {}
+    if info.get("size") is None:
+        size = _file_size(media_file)
+        if size is not None:
+            info["size"] = size
+    if info:
+        canonical["file_info"] = info
+
+
 def _scan_roots(output_dirs):
    """(absolute root, public label, listing index), the most specific first.

@@ -492,29 +489,9 @@ def _diagnose_dependencies():
    }


-def legacy_checks(db_path, public_path=None):
-    """The four checks of ``GET /diagnostics`` (blocking).
-
-    Shared with the diagnostic report (``py/api/diagnostics_report.py``),
-    which passes its own ``public_path`` so a folder outside ComfyUI is never
-    named.
-    """
-    from ..config import GalleryConfig
-
-    return {
-        "database": _diagnose_database(db_path),
-        "dependencies": _diagnose_dependencies(),
-        "comfyui_output": _diagnose_output_dirs(
-            GalleryConfig.MONITORING_DIRECTORIES, public_path
-        ),
-        "image_monitor": _diagnose_image_monitor(public_path),
-    }
-
-
-def _diagnose_output_dirs(configured_dirs, public_path=None):
+def _diagnose_output_dirs(configured_dirs):
    """Configured gallery roots, ComfyUI's output dir, or relative fallbacks."""
    _public_path, _ = _public_helpers()
-    _public_path = public_path or _public_path
    candidates = list(configured_dirs)
    try:
        import folder_paths
@@ -548,10 +525,9 @@ def _diagnose_output_dirs(configured_dirs, public_path=None):
    }


-def _diagnose_image_monitor(public_path=None):
+def _diagnose_image_monitor():
    """Status of the running image monitor, with public directory names."""
    _public_path, _public_error = _public_helpers()
-    _public_path = public_path or _public_path
    try:
        monitor = _current_image_monitor()
        if monitor is None:
@@ -586,56 +562,18 @@ class _BatchHistory:
    """A scan batch's recorded-history lookup, made on the first file needing it.

    Most files link through their metadata and never ask; the first one that
-    does triggers one ``recorded_runs`` pass for the whole batch, from which
-    both the stored prompt (``get``) and the recorded saver (``recorded``)
-    of every file are read. A failure is logged and names nothing.
+    does triggers one lookup for the whole batch (``_recorded_runs_for``).
    """

    def __init__(self, api, media_files):
        self._api = api
-        self._files = [str(path) for path in media_files]
-        self._runs = None
-        self._prompts = {}
-
-    def _found(self):
-        if self._runs is None:
-            try:
-                self._runs = recorded_runs(
-                    self._api.db, self._files, host_output_directory(), None
-                )
-            except Exception:
-                self._api.logger.warning(
-                    "History attribution failed for a scan batch", exc_info=True
-                )
-                self._runs = {}
-        return self._runs
+        self._files = media_files
+        self._found = None

    def get(self, path):
-        """The stored prompt id history attributes to ``path``, else None."""
-        found = self._found().get(path)
-        if found is None:
-            return None
-        run_id = found[0]
-        if run_id not in self._prompts:
-            try:
-                self._prompts[run_id] = named_prompt(self._api.db, run_id)
-            except Exception:
-                self._api.logger.warning(
-                    "History attribution failed for a scan batch", exc_info=True
-                )
-                self._prompts[run_id] = None
-        return self._prompts[run_id]
-
-    def recorded(self, path):
-        """``RecordedOutput(saver, {})`` for an attributed file, else None.
-
-        ``saver`` is set only when the run reported the file from one node.
-        """
-        found = self._found().get(path)
-        if found is None:
-            return None
-        nodes = found[1]
-        return RecordedOutput(next(iter(nodes)) if len(nodes) == 1 else None, {})
+        if self._found is None:
+            self._found = self._api._recorded_runs_for(self._files)
+        return self._found.get(path)


 class AdminRoutesMixin:
@@ -1117,7 +1055,16 @@ class AdminRoutesMixin:
    async def run_diagnostics(self, request):
        """Run comprehensive system diagnostics and health checks."""
        try:
-            results = legacy_checks(self.db.model.db_path)
+            from ..config import GalleryConfig
+
+            results = {
+                "database": _diagnose_database(self.db.model.db_path),
+                "dependencies": _diagnose_dependencies(),
+                "comfyui_output": _diagnose_output_dirs(
+                    GalleryConfig.MONITORING_DIRECTORIES
+                ),
+                "image_monitor": _diagnose_image_monitor(),
+            }
            return web.json_response({"success": True, "diagnostics": results})

        except Exception as e:
@@ -1671,14 +1618,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).
@@ -1700,6 +1640,24 @@ class AdminRoutesMixin:
                note(media_file, status)
        return counts

+    @staticmethod
+    def _graph_prompt_text(metadata):
+        """The positive prompt the browser parser traces from the graphs, or None.
+
+        Records parse as the legacy pages parsed them (NaN reads as null).
+        """
+        records = {}
+        for key in ("prompt", "workflow"):
+            value = metadata.get(key)
+            records[key] = parse_page_json(value) if isinstance(value, str) else value
+        try:
+            positive = extract_generation_params(records)["positivePrompt"]
+        except GenerationParamsError:
+            return None
+        if not isinstance(positive, str) or positive == PLACEHOLDERS["positivePrompt"]:
+            return None
+        return positive.strip() or None
+
    def _ingest_scanned_file(
        self,
        media_file,
@@ -1710,81 +1668,111 @@ class AdminRoutesMixin:
        records=None,
        history=None,
    ):
-        """Store the prompt the shared per-file decision names (#247).
+        """Enrich exact pairs; retain legacy positive-only import for absent pairs.

-        ``utils.file_prompt.decide_file_prompt`` (scan policy) decides; this
-        stores the result. Returns the file's scan status, or None without
-        prompt metadata. With ``detailed``, a stored or linked file returns a
-        dict instead: its ``status``, the prompt's display ``title`` and, for
-        a resolved pair, the pair counts. When the resolver finds the file
-        ambiguous (whether or not a later step then links it) and
-        ``ambiguous`` is a list, ``media_file`` is appended to it; only a file
-        that then returns ``"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)
-        goes to ``untraced`` instead and returns ``"unresolved"`` when nothing
-        links it. The parsed records of either ambiguous file go to
-        ``records["canonical"]`` when ``records`` is a dict. ``history`` is
-        the batch's lazy recorded-history lookup.
+        Returns the file's scan status, or None without prompt metadata. With
+        ``detailed``, a stored or linked file returns a dict instead: its
+        ``status``, the prompt's display ``title`` and, for a resolved pair,
+        the pair counts. When the resolver finds the file ambiguous (whether
+        or not the browser parser then links it) and ``ambiguous`` is a list,
+        ``media_file`` is appended to it; only a file that then returns
+        ``"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``;
+        its parsed records go to ``records["canonical"]`` when ``records`` is
+        a dict.
        """
-        path = str(media_file)
-        if history is None:  # one file: history is still asked once
-            history = _BatchHistory(self, [media_file])
-        decision = decide_file_prompt(
-            metadata,
-            file_name=Path(path).name,
-            file_size=functools.partial(_file_size, media_file),
-            in_output=False,  # only the monitor policy reads it
-            lookup=functools.partial(history.recorded, path),
-            policy=Policy.SCAN,
-        )
-        if decision.kind in (NOT_SAVED, NOT_SAVED_WIRED):
-            # Save to library off (#90): no write, recorded-run fallback or
-            # Needs review item
-            return decision.kind
-        self._note_review(media_file, decision, ambiguous, untraced, records)
-        if decision.kind == NEVER:
-            if decision.try_recorded_run:
-                linked = self._link_recorded_run(
-                    media_file, decision.canonical, detailed, history
-                )
-                if linked is not None:
-                    return linked
-            return decision.unlinked_status
-        if decision.kind == PAIR:
-            # A rerun after a library move re-checks the link rows.
-            result = self.db.survive_library_switch(
-                lambda: ingest_resolved_pair(
-                    self.db,
-                    path,
-                    decision.canonical,
-                    decision.resolution,
-                    marks=SCAN_MARKS,
-                )
-            )
-            if not detailed:
-                return result["status"]
-            title_text = decision.resolution["positive"]["text"]
-            return {**result, "title": self._scan_title(media_file, title_text)}
-        status, _prompt_id = store_scanned_prompt(
-            self.db, path, decision.canonical, decision.text, SCAN_MARKS
-        )
-        if not detailed or status not in SCAN_TITLED_DETAILS:
-            return status
-        return {"status": status, "title": self._scan_title(media_file, decision.text)}
-
-    @staticmethod
-    def _note_review(media_file, decision, ambiguous, untraced, records):
-        """Hand an ambiguous file to the batch's Needs review lists."""
-        if decision.review == "untraced":
+        if not metadata:
+            # No prompt metadata (--disable-metadata, bare savers): only the
+            # recorded run can say which prompt made it (#342)
+            return self._link_recorded_run(media_file, {}, detailed, history)
+        canonical = dict(metadata)
+        for key in ("prompt", "workflow"):
+            if isinstance(canonical.get(key), str):
+                try:
+                    canonical[key] = json.loads(canonical[key])
+                except (ValueError, TypeError):
+                    # Preserve malformed metadata for conservative resolver rejection.
+                    pass
+        if not canonical.get("prompt") and not canonical.get("parameters"):
+            return self._link_recorded_run(media_file, canonical, detailed, history)
+        _with_file_size(canonical, media_file)
+        resolution = resolve_prompt_pair(canonical)
+        if blank_positive(resolution):
+            # Only prepend/append text: no stored prompt can own it (#342)
+            resolution = {**resolution, "state": "unresolved"}
+        # Ambiguous without a choice: unresolved unless something links it.
+        unchoosable = resolution["state"] == "ambiguous" and not reviewable(resolution)
+        if unchoosable:
            if untraced is not None:
                untraced.append(media_file)
            if records is not None:
-                records["canonical"] = decision.canonical
-        elif decision.review == "ambiguous" and ambiguous is not None:
+                records["canonical"] = canonical
+        elif resolution["state"] == "ambiguous" and ambiguous is not None:
            ambiguous.append(media_file)
-            if records is not None:
-                records["canonical"] = decision.canonical
+        if resolution["state"] == "resolved":
+            result = ingest_resolved_pair(
+                self.db, str(media_file), canonical, resolution
+            )
+            if not detailed:
+                return result["status"]
+            return {
+                **result,
+                "title": self._scan_title(media_file, resolution["positive"]["text"]),
+            }
+        if canonical.get("prompt") and resolution["state"] in (
+            "ambiguous",
+            "unresolved",
+        ):
+            # The resolver could not decide: link the prompt the inspector and the
+            # legacy pages show for this file (the browser parser, in Python).
+            # Graphs without a recognized sampler keep the legacy extractor below.
+            prompt_text = self._graph_prompt_text(metadata)
+            if not prompt_text:
+                linked = self._link_recorded_run(
+                    media_file, canonical, detailed, history
+                )
+                if linked is not None:
+                    return linked
+                return "unresolved" if unchoosable else resolution["state"]
+        elif resolution["state"] == "ambiguous":
+            return "unresolved" if unchoosable else "ambiguous"
+        elif resolution["state"] == "unresolved" and not isinstance(
+            canonical.get("parameters"), str
+        ):
+            return resolution["state"]
+        else:
+            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()
+
+        status = self._store_scanned_prompt(media_file, canonical, prompt_text)
+        if not detailed or status not in SCAN_TITLED_DETAILS:
+            return status
+        return {"status": status, "title": self._scan_title(media_file, prompt_text)}
+
+    def _recorded_runs_for(self, media_files):
+        """``{path: prompt id or None}`` from recorded history for a scan batch.
+
+        One output lookup per chunk of names (``stored_run_prompts``), so a
+        batch never queries history once per file. An empty dict on failure.
+        """
+        try:
+            return stored_run_prompts(
+                self.db, [str(path) for path in media_files], host_output_directory()
+            )
+        except Exception:
+            self.logger.warning(
+                "History attribution failed for a scan batch", exc_info=True
+            )
+            return {}

    def _link_recorded_run(self, media_file, canonical, detailed=False, history=None):
        """Link a file recorded history attributes to one stored prompt (#342).
@@ -1793,25 +1781,31 @@ class AdminRoutesMixin:
        ``{"status", "title"}``), or None when history names no single stored
        prompt for the file (``database.run_attribution``). Never creates a
        prompt. Works without any prompt metadata in the file. ``history`` is
-        the batch's lookup (``_BatchHistory``). A file already linked to
-        another prompt is a ``conflict``: one prompt per file.
+        the batch's precomputed lookup; without it the file is looked up alone.
        """
-        if history is None:
-            history = _BatchHistory(self, [media_file])
-        prompt_id = history.get(str(media_file))
+        if history is not None:
+            prompt_id = history.get(str(media_file))
+        else:
+            try:
+                prompt_id = stored_run_prompt(
+                    self.db, str(media_file), host_output_directory()
+                )
+            except Exception:
+                self.logger.warning(
+                    f"History attribution failed for {media_file.name}",
+                    exc_info=True,
+                )
+                return None
        if prompt_id is None:
            return None
        try:
-            status = self.db.survive_library_switch(
-                lambda: link_stored_prompt_or_raise(
-                    self.db, str(media_file), canonical, prompt_id
-                )
+            image_id = self.db.link_image_to_prompt(
+                prompt_id, str(media_file), metadata=canonical
            )
        except Exception as e:
            self.logger.error(f"Failed to link {media_file.name} from history: {e}")
            return "found"
-        if status is None:
-            return None
+        status = "linked" if image_id else "unchanged"
        if not detailed or status not in SCAN_TITLED_DETAILS:
            return status
        prompt = self.db.get_prompt_by_id(prompt_id) or {}
@@ -1831,3 +1825,35 @@ class AdminRoutesMixin:
        except Exception:
            self.logger.warning("Scan row title could not be read; using its text")
        return display_title((), text)
+
+    def _store_scanned_prompt(self, media_file, canonical, prompt_text):
+        """Link ``media_file`` to ``prompt_text``'s prompt, saving it when new."""
+        prompt_hash = generate_prompt_hash(prompt_text)
+        existing = self.db.get_prompt_by_hash(prompt_hash)
+        if existing:
+            try:
+                image_id = self.db.link_image_to_prompt(
+                    existing["id"], str(media_file), metadata=canonical
+                )
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to link {media_file.name} to existing prompt: {e}"
+                )
+                return "found"
+            return "linked" if image_id else "unchanged"
+
+        prompt_id = self.db.save_prompt(
+            prompt_text,
+            "scanned",
+            ["auto-scanned"],
+            None,
+            f"Auto-scanned from {media_file.name}",
+            prompt_hash,
+        )
+        if not prompt_id:
+            return "found"
+        try:
+            self.db.link_image_to_prompt(prompt_id, str(media_file), metadata=canonical)
+        except Exception as e:
+            self.logger.error(f"Failed to link {media_file.name} to new prompt: {e}")
+        return "added"
@@ -86,23 +86,6 @@ def unavailable_message(model_name: str) -> str:
    return f"{model_name} is not downloaded. {UNAVAILABLE_HINT}"


-def model_refusal(status: dict, model_type: str, model_name: str):
-    """Why *model_type* cannot run, from ``get_models_status()``, else None.
-
-    Not downloaded first (``unavailable_message``), then a backend package
-    that cannot be imported (#424). Both are a 409 ``model-unavailable``.
-    """
-    entry = status.get(model_type) or {}
-    if not entry.get("downloaded"):
-        return unavailable_message(model_name)
-    missing = entry.get("missing_packages") or []
-    if missing:
-        from ..autotag import missing_packages_message
-
-        return missing_packages_message(model_type, [str(name) for name in missing])
-    return None
-
-
 def run_suggestions(service, capture_path: str, model_type: str, options: dict):
    """Blocking: load (or swap to) *model_type*, then suggest for the capture.

@@ -21,18 +21,13 @@ from aiohttp import web
 from .annotation_suggest import (
    SUGGEST_FIELDS,
    OptionError,
-    model_refusal,
    run_suggestions,
    suggestion_rows,
+    unavailable_message,
    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:
@@ -595,7 +604,7 @@ class AnnotationRoutesMixin:
        it, including a legacy batch), never downloads (``model-unavailable``)
        and never writes.
        """
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
+        from ..autotag import MODELS, get_autotag_service
        from ..config import MAX_SUGGESTION_LIMIT, AutotagConfig

        data, error = await self._annotation_body(request, SUGGEST_FIELDS)
@@ -633,10 +642,9 @@ class AnnotationRoutesMixin:
                return error
            service = get_autotag_service()
            status = await self._run_in_executor(service.get_models_status)
-            name = MODELS.get(model_type, {}).get("name", model_type)
-            refusal = model_refusal(status, model_type, name)
-            if refusal is not None:
-                return _coded("model-unavailable", refusal)
+            if not status.get(model_type, {}).get("downloaded"):
+                name = MODELS.get(model_type, {}).get("name", model_type)
+                return _coded("model-unavailable", unavailable_message(name))
            owner = model_gate.new_owner("image-annotations")
            if not model_gate.try_acquire(owner):
                return model_busy_response()
@@ -655,9 +663,6 @@ class AnnotationRoutesMixin:
                    options,
                    on_skipped=functools.partial(store.release_use, token),
                )
-            except MissingBackendPackages as exc:
-                # A package gone since the status read (load_model logged it).
-                return _coded("model-unavailable", str(exc))
            except Exception:
                self.logger.exception("Tag suggestion failed")
                return _error(
@@ -670,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."""

@@ -1,350 +0,0 @@
-"""Collections (#331): named, hand-picked groups of images.
-
-Routes under ``/prompt_manager/collections``. A file is named by its listing
-identity ``{root_index, root_scope, path}`` (``media_target.py``) and stored
-under the favorites' keys (``_favorite_root_key``, ``_favorite_relative_key``),
-which never leave the server. A stale scope (the sources were reordered) is a
-409 ``source-changed`` before anything is written. Responses are
-``{"success": bool, ...}``; an unexpected failure is a logged 500 with a
-generic message, never the exception text.
-"""
-
-import hmac
-import re
-from functools import wraps
-from typing import Callable
-
-from aiohttp import web
-
-from .images import (
-    _favorite_relative_key,
-    _favorite_root_key,
-    _forbidden,
-    _json_body_or_error,
-    collection_not_found,
-)
-from .media_target import media_target
-from .prompts import bad_request
-
-try:
-    from ...database.image_collections import (
-        CollectionFilesMissing,
-        CollectionInvalid,
-        CollectionMissing,
-        CollectionNameTaken,
-        normalize_collection_name,
-    )
-    from ...database.image_favorites import MAX_KEY_LENGTH
-except ImportError:
-    from database.image_collections import (
-        CollectionFilesMissing,
-        CollectionInvalid,
-        CollectionMissing,
-        CollectionNameTaken,
-        normalize_collection_name,
-    )
-    from database.image_favorites import MAX_KEY_LENGTH
-
-BASE = "/prompt_manager/collections"
-# The most files one add or remove names (the bulk tagging cap, MC12).
-MAX_ITEMS = 500
-MAX_ID = 999_999_999
-_PATH_ID = re.compile(r"[1-9][0-9]{0,8}")
-_ROOT_INDEX = re.compile(r"[0-9]{1,9}")
-_ADD_TARGETS = (frozenset({"collection_id", "items"}), frozenset({"name", "items"}))
-_REMOVE_FIELDS = frozenset({"collection_id", "items"})
-_RENAME_FIELDS = frozenset({"name"})
-_MEDIA_MESSAGE = "Only media files can be added to a collection"
-READ_FAILED = "Collections could not be read."
-CHANGE_FAILED = "The collection could not be changed."
-SOURCES_CHANGED = "The sources changed. Refresh the images and try again."
-FILES_NOT_FOUND = (
-    "None of the selected images could be found. Refresh the images and try again."
-)
-NAME_TAKEN = "Another collection already has this name."
-
-
-class _Refused(Exception):
-    """A request refused before any write; carries its response."""
-
-    def __init__(self, response: web.Response):
-        super().__init__(response.status)
-        self.response = response
-
-
-def _coded(status: int, code: str, message: str, **extra) -> web.Response:
-    return web.json_response(
-        {"success": False, "code": code, "error": message, **extra},
-        status=status,
-        headers={"Cache-Control": "no-store"},
-    )
-
-
-def _collection_response(failure: str) -> Callable:
-    """Map the database's refusals to their status; anything else to a 500."""
-
-    def decorate(handler: Callable) -> Callable:
-        @wraps(handler)
-        async def wrapped(self, request: web.Request) -> web.Response:
-            try:
-                return await handler(self, request)
-            except _Refused as refused:
-                return refused.response
-            except CollectionInvalid as exc:
-                return bad_request(str(exc))
-            except CollectionMissing:
-                return collection_not_found()
-            except CollectionFilesMissing:
-                return _coded(404, "files-not-found", FILES_NOT_FOUND)
-            except CollectionNameTaken as exc:
-                return _coded(
-                    409, "name-taken", NAME_TAKEN, collection_id=exc.collection_id
-                )
-            except Exception:
-                self.logger.exception("Collection request failed")
-                return web.json_response(
-                    {"success": False, "error": failure}, status=500
-                )
-
-        return wrapped
-
-    return decorate
-
-
-def _path_id(request: web.Request) -> int:
-    raw = request.match_info["collection_id"]
-    if not raw.isascii() or _PATH_ID.fullmatch(raw) is None:
-        raise _Refused(bad_request("Invalid collection id"))
-    return int(raw)
-
-
-def _body_id(value: object) -> int:
-    if type(value) is not int or not 1 <= value <= MAX_ID:
-        raise _Refused(bad_request("Invalid collection id"))
-    return value
-
-
-async def _body(request: web.Request, allowed: tuple) -> dict:
-    data, error = await _json_body_or_error(request)
-    if error is not None:
-        raise _Refused(error)
-    if frozenset(data) not in allowed:
-        names = " or ".join(", ".join(sorted(fields)) for fields in allowed)
-        raise _Refused(bad_request(f"Request must contain exactly {names}"))
-    return data
-
-
-class CollectionRoutesMixin:
-    """Mixin providing the collection routes (#331)."""
-
-    def _register_collection_routes(self, routes: web.RouteTableDef) -> None:
-        # The fixed paths go first: "/items" must never match "/{collection_id}".
-        routes.get(BASE)(self.list_collections)
-        routes.post(BASE + "/items")(self.add_collection_items)
-        routes.delete(BASE + "/items")(self.remove_collection_items)
-        routes.get(BASE + "/membership")(self.collection_membership)
-        routes.patch(BASE + "/{collection_id}")(self.rename_collection)
-        routes.delete(BASE + "/{collection_id}")(self.delete_collection)
-
-    # -- reads -------------------------------------------------------------
-
-    @_collection_response(READ_FAILED)
-    async def list_collections(self, request: web.Request) -> web.Response:
-        """Every collection with its listed ``count`` and its ``missing`` rows.
-
-        ``count`` is the members listed under every configured source (one
-        primary-key range read per source, matched against its cached
-        listing); ``missing`` the stored rows beyond it. When a scan or a read
-        fails both are null for every collection and the names still return.
-        """
-        collections = await self._run_in_executor(self.db.list_collections)
-        counts = None
-        if collections:
-            try:
-                counts = await self._collection_counts()
-            except Exception:
-                self.logger.warning(
-                    "Collection counts could not be read", exc_info=True
-                )
-        rows = []
-        for collection in collections:
-            listed, stored = (None, None) if counts is None else counts
-            count = None if listed is None else listed.get(collection["id"], 0)
-            stored_rows = None if stored is None else stored.get(collection["id"], 0)
-            rows.append(
-                {
-                    **collection,
-                    "count": count,
-                    # Clamped: never below zero, whatever the snapshot saw.
-                    "missing": None if count is None else max(0, stored_rows - count),
-                }
-            )
-        return web.json_response({"success": True, "collections": rows})
-
-    async def _collection_counts(self) -> tuple[dict, dict]:
-        """``({id: listed members}, {id: stored rows})`` over every source.
-
-        The scans come from the gallery cache; the root keys (realpath), the
-        listings and one read snapshot of every member and stored count run
-        in the executor, so a write between two reads cannot skew them.
-        """
-        roots = list(self._get_all_output_dirs())
-        root_keys = await self._run_in_executor(
-            lambda: [_favorite_root_key(root) for root in roots]
-        )
-        distinct = {}  # one folder configured twice counts once
-        for root, root_key in zip(roots, root_keys):
-            distinct.setdefault(root_key, root)
-        scans = {
-            root_key: await self._get_gallery_files(root)
-            for root_key, root in distinct.items()
-        }
-        return await self._run_in_executor(self._count_members, distinct, scans)
-
-    def _count_members(self, roots: dict, scans: dict) -> tuple[dict, dict]:
-        """Blocking: match one snapshot's members against each listing."""
-        members, stored = self.db.collection_count_snapshot(list(roots))
-        listed: dict[int, int] = {}
-        for root_key, root in roots.items():
-            listing = self._favorite_listing(root, scans[root_key])
-            for collection_id, keys in members.get(root_key, {}).items():
-                found = sum(1 for key in keys if key in listing)
-                listed[collection_id] = listed.get(collection_id, 0) + found
-        return listed, stored
-
-    @_collection_response(READ_FAILED)
-    async def collection_membership(self, request: web.Request) -> web.Response:
-        """GET ``?root_index&root_scope&path``: the ids holding that file."""
-        query = request.query
-        if len(query) != 3 or set(query) != {"root_index", "root_scope", "path"}:
-            # len() counts a repeated key (?path=a&path=b) twice.
-            return bad_request("Query must name root_index, root_scope and path once")
-        raw_index = query["root_index"]
-        if not raw_index.isascii() or _ROOT_INDEX.fullmatch(raw_index) is None:
-            return bad_request("Invalid gallery root")
-        roots = list(self._get_all_output_dirs())
-        target = {
-            "root_index": int(raw_index),
-            "root_scope": query["root_scope"],
-            "path": query["path"],
-        }
-        root_key, key = await self._run_in_executor(
-            self._collection_key, target, roots, {}
-        )
-        ids = await self._run_in_executor(self.db.file_collections, root_key, key)
-        return web.json_response({"success": True, "collection_ids": ids})
-
-    # -- writes ------------------------------------------------------------
-
-    @_collection_response(CHANGE_FAILED)
-    async def add_collection_items(self, request: web.Request) -> web.Response:
-        """POST ``{collection_id | name, items}``: add the listed files.
-
-        Only files the source's listing holds are added; the rest count in
-        ``not_found``. A new name with nothing to add creates nothing (404
-        ``files-not-found``).
-        """
-        data = await _body(request, _ADD_TARGETS)
-        target = {}
-        if "name" in data:
-            target["name"] = normalize_collection_name(data["name"])
-        else:
-            target["collection_id"] = _body_id(data["collection_id"])
-        roots = list(self._get_all_output_dirs())
-        keys = await self._run_in_executor(self._collection_items, data["items"], roots)
-        found, not_found = [], 0
-        listings = {}
-        for index, root_key, key in keys:
-            if index not in listings:
-                root = roots[index]
-                files = await self._get_gallery_files(root)
-                listings[index] = await self._run_in_executor(
-                    self._favorite_listing, root, files
-                )
-            if key in listings[index]:
-                found.append((root_key, key))
-            else:
-                not_found += 1
-        result = await self._run_in_executor(
-            lambda: self.db.add_to_collection(items=found, **target)
-        )
-        return web.json_response({"success": True, **result, "not_found": not_found})
-
-    @_collection_response(CHANGE_FAILED)
-    async def remove_collection_items(self, request: web.Request) -> web.Response:
-        """DELETE ``{collection_id, items}``: listed or not, every named file."""
-        data = await _body(request, (_REMOVE_FIELDS,))
-        collection_id = _body_id(data["collection_id"])
-        roots = list(self._get_all_output_dirs())
-        keys = await self._run_in_executor(self._collection_items, data["items"], roots)
-        result = await self._run_in_executor(
-            self.db.remove_from_collection,
-            collection_id,
-            [(root_key, key) for _index, root_key, key in keys],
-        )
-        return web.json_response({"success": True, **result})
-
-    @_collection_response(CHANGE_FAILED)
-    async def rename_collection(self, request: web.Request) -> web.Response:
-        """PATCH ``{name}``: a case variant of its own name is allowed."""
-        collection_id = _path_id(request)
-        data = await _body(request, (_RENAME_FIELDS,))
-        name = normalize_collection_name(data["name"])
-        collection = await self._run_in_executor(
-            self.db.rename_collection, collection_id, name
-        )
-        return web.json_response({"success": True, "collection": collection})
-
-    @_collection_response(CHANGE_FAILED)
-    async def delete_collection(self, request: web.Request) -> web.Response:
-        """DELETE: the collection and its members; files are never touched."""
-        collection_id = _path_id(request)
-        await self._run_in_executor(self.db.delete_collection, collection_id)
-        return web.json_response({"success": True, "deleted": True})
-
-    # -- request steps -----------------------------------------------------
-
-    def _collection_items(self, items: object, roots: list) -> list[tuple]:
-        """``(index, root key, relative key)`` per distinct file, in order.
-
-        Blocking (realpath per root, once per request): run in the executor.
-        Every item is checked before anything is written: 400 for a malformed
-        shape, 403 for an unsafe path, 409 for a stale scope. Two spellings
-        that fold to one key (Windows) count once.
-        """
-        if not isinstance(items, list) or not 1 <= len(items) <= MAX_ITEMS:
-            raise _Refused(bad_request(f"items must list 1 to {MAX_ITEMS} images"))
-        keys, sources = {}, {}
-        for item in items:
-            index = item.get("root_index") if isinstance(item, dict) else None
-            root_key, key = self._collection_key(item, roots, sources)
-            keys.setdefault((root_key, key), index)
-        return [(index, root_key, key) for (root_key, key), index in keys.items()]
-
-    def _collection_key(
-        self, item: object, roots: list, sources: dict
-    ) -> tuple[str, str]:
-        """The stored keys of one target, or raise its refusal (blocking).
-
-        *sources* caches ``{index: (scope, root key)}`` for one request, so
-        each root's realpath runs once however many items name it.
-        """
-        target, error = media_target(item, media_message=_MEDIA_MESSAGE)
-        if error is not None:
-            raise _Refused(error)
-        index, scope, relative = target
-        if index >= len(roots):
-            raise _Refused(_coded(409, "source-changed", SOURCES_CHANGED))
-        if index not in sources:
-            sources[index] = (
-                self._gallery_root_scope(roots[index], index),
-                _favorite_root_key(roots[index]),
-            )
-        current, root_key = sources[index]
-        if not hmac.compare_digest(scope, current):
-            raise _Refused(_coded(409, "source-changed", SOURCES_CHANGED))
-        key = _favorite_relative_key(relative)
-        if max(len(root_key), len(key)) > MAX_KEY_LENGTH:
-            # A stored key past the schema bound would fail the next restore.
-            raise _Refused(_forbidden("Path is too long to add to a collection"))
-        return root_key, key
@@ -1,291 +0,0 @@
-"""The shareable diagnostic report (#329 System S12).
-
-``GET /prompt_manager/system/diagnostics`` answers a report built on the
-server from an explicit list of fields: the project and Viewer.js versions,
-Python and the platform, the four checks of the legacy ``GET /diagnostics``
-(one helper, ``admin.legacy_checks``), the database's public info, source
-counts, the log configuration and statistics, the last health summary and
-the configuration keys that only ``config.json`` holds. It never copies
-``PromptManagerConfig.get_config()``: no path leaf is listed, and the CivitAI
-key is reported only as ``has_civitai_api_key``.
-
-Every path in the report goes through ``report_path``: relative to the
-closest public anchor that is not a filesystem root, else ``"outside
-ComfyUI"``, never a basename that could be a user name. As a backstop,
-``scrub`` replaces any string that still looks like an absolute path, holds
-the saved key or the home folder (with or without its root), and counts each
-replacement in ``redacted`` (0 for a correct builder).
-
-The report opens the database, so it takes a registry lease: it is refused
-(409 ``busy``) while an ``exclusive`` job (a restore) runs, and a restore
-waits for it. It is built off the event loop.
-"""
-
-import datetime
-import json
-import ntpath
-import os
-import platform
-import posixpath
-import re
-from pathlib import Path, PurePosixPath, PureWindowsPath
-
-from aiohttp import web
-
-from . import admin as _admin
-from .job_routes import busy_response
-from .jobs import JobBusy
-from .system import health_summary
-
-try:
-    from ...utils.version import project_version
-except ImportError:  # loaded as the top-level ``py`` package (tests)
-    from utils.version import project_version
-
-DIAGNOSTICS_LEASE = "Diagnostics"
-_ROOT = Path(__file__).resolve().parents[2]
-VIEWERJS_PROVENANCE = str(_ROOT / "web" / "lib" / "viewerjs" / "provenance.json")
-OUTSIDE = "outside ComfyUI"
-REMOVED = "[removed]"
-# The CivitAI key is searched for only when it is long enough to be a key.
-MIN_KEY_LENGTH = 8
-_WINDOWS_ABSOLUTE = re.compile(r"^[A-Za-z]:[\\/]")
-
-
-def anchored_path(canonical, anchors, home, pathmod=os.path):
-    """``canonical`` relative to the closest usable anchor, else ``outside ComfyUI``.
-
-    All three are already canonical (``normcase``) in ``pathmod``'s spelling.
-    A filesystem root is never usable, nor is a strict ancestor of ``home``
-    (``/home``, ``C:\\Users``), whose relative paths would start with a user
-    name; so a path inside the home folder needs an anchor at or below it.
-    """
-    flavor = PureWindowsPath if pathmod is ntpath else PurePosixPath
-    target = flavor(canonical)
-    home_path = flavor(home) if home else None
-    usable = []
-    for anchor in map(flavor, anchors):
-        if anchor.parent == anchor:
-            continue
-        if home_path is not None and home_path != anchor:
-            if home_path.is_relative_to(anchor):
-                continue
-        if target.is_relative_to(anchor):
-            usable.append(anchor)
-    if not usable:
-        return OUTSIDE
-    anchor = max(usable, key=lambda a: len(a.parts))
-    return target.relative_to(anchor).as_posix() or "."
-
-
-def _canonical(path):
-    return os.path.normcase(os.path.realpath(str(path)))
-
-
-def report_path(path):
-    """``path`` relative to a public anchor (POSIX style), else ``outside ComfyUI``."""
-    if not path:
-        return ""
-    from ..config import GalleryConfig
-
-    try:
-        canonical = _canonical(path)
-        anchors = [_canonical(anchor) for anchor in GalleryConfig.path_anchors()]
-        home = os.path.expanduser("~")
-        home = _canonical(home) if home and home != "~" else None
-    except (OSError, ValueError):
-        return OUTSIDE
-    return anchored_path(canonical, anchors, home)
-
-
-def _looks_absolute(text):
-    return (
-        posixpath.isabs(text)
-        or ntpath.isabs(text)
-        or _WINDOWS_ABSOLUTE.match(text) is not None
-        or text.startswith("\\\\")
-    )
-
-
-# The home folder is matched only as whole path parts, never inside a word.
-_PART = r"(?<![\w.-]){}(?![\w.-])"
-MIN_HOME_NAME = 3
-
-
-def _home_patterns():
-    """``(pattern, paths_only)`` for the home folder: in full, rootless, its name.
-
-    Accepted residual risk: only this process's own home folder is known, so
-    another user's home (an output folder under /home/<them> while ComfyUI
-    runs as a service account) can still be named by a report path.
-    """
-    home = os.path.expanduser("~")
-    if not home or home == "~" or len(home) < 4 or home in ("/", "\\"):
-        return ()
-    spellings = {home, home.replace("\\", "/")}
-    relative = os.path.splitdrive(home)[1].strip("\\/")
-    for spelling in (relative, relative.replace("\\", "/")):
-        if "/" in spelling or "\\" in spelling:
-            spellings.add(spelling)
-    patterns = [
-        (re.compile(_PART.format(re.escape(spelling)), re.IGNORECASE), False)
-        for spelling in spellings
-    ]
-    name = re.split(r"[\\/]", relative)[-1] if relative else ""
-    if len(name) >= MIN_HOME_NAME:
-        # The bare name only inside a path ("info/x"), not a word ("INFO").
-        patterns.append(
-            (re.compile(_PART.format(re.escape(name)), re.IGNORECASE), True)
-        )
-    return tuple(patterns)
-
-
-def scrub(report, key):
-    """``report`` with leaked paths and the key replaced, counted in ``redacted``."""
-    key = key if isinstance(key, str) and len(key) >= MIN_KEY_LENGTH else None
-    homes = _home_patterns()
-    count = 0
-
-    def clean(value):
-        nonlocal count
-        if isinstance(value, str):
-            if (
-                _looks_absolute(value)
-                or (key and key in value)
-                or any(
-                    pattern.search(value)
-                    for pattern, paths_only in homes
-                    if not paths_only or "/" in value or "\\" in value
-                )
-            ):
-                count += 1
-                return REMOVED
-            return value
-        if isinstance(value, dict):
-            return {name: clean(item) for name, item in value.items()}
-        if isinstance(value, (list, tuple)):
-            return [clean(item) for item in value]
-        return value
-
-    cleaned = clean(report)
-    cleaned["redacted"] = int(cleaned.get("redacted") or 0) + count
-    return cleaned
-
-
-def viewerjs_version(path=None):
-    """The pinned Viewer.js version from its provenance file, or ``unknown``."""
-    try:
-        with open(path or VIEWERJS_PROVENANCE, encoding="utf-8") as handle:
-            version = json.load(handle).get("version")
-    except (OSError, ValueError, AttributeError):
-        return "unknown"
-    return version if isinstance(version, str) and version else "unknown"
-
-
-def public_config():
-    """The configuration keys only ``config.json`` holds, from an explicit list."""
-    from ..config import GalleryConfig, IntegrationConfig, PromptManagerConfig
-
-    return {
-        "database": {
-            "enable_duplicate_detection": (
-                PromptManagerConfig.ENABLE_DUPLICATE_DETECTION
-            ),
-            "enable_auto_save": PromptManagerConfig.ENABLE_AUTO_SAVE,
-        },
-        "web_ui": {
-            "result_timeout": PromptManagerConfig.RESULT_TIMEOUT,
-            "show_test_button": PromptManagerConfig.SHOW_TEST_BUTTON,
-            "webui_display_mode": PromptManagerConfig.WEBUI_DISPLAY_MODE,
-            "infinite_scroll": PromptManagerConfig.INFINITE_SCROLL,
-        },
-        "performance": {
-            "max_search_results": PromptManagerConfig.MAX_SEARCH_RESULTS,
-            "enable_fuzzy_search": PromptManagerConfig.ENABLE_FUZZY_SEARCH,
-            "auto_backup_interval": PromptManagerConfig.AUTO_BACKUP_INTERVAL,
-            "worker_threads": PromptManagerConfig.WORKER_THREADS,
-        },
-        "gallery": {
-            "processing_delay": GalleryConfig.PROCESSING_DELAY,
-            "prompt_timeout": GalleryConfig.PROMPT_TIMEOUT,
-            "cleanup_interval": GalleryConfig.CLEANUP_INTERVAL,
-            "auto_cleanup_missing_files": GalleryConfig.AUTO_CLEANUP_MISSING_FILES,
-            "max_image_age_days": GalleryConfig.MAX_IMAGE_AGE_DAYS,
-            "max_concurrent_processing": GalleryConfig.MAX_CONCURRENT_PROCESSING,
-            "metadata_extraction_timeout": GalleryConfig.METADATA_EXTRACTION_TIMEOUT,
-            # config.json gallery.monitoring.save_foreign_runs (#247)
-            "save_foreign_runs": GalleryConfig.SAVE_FOREIGN_RUNS,
-        },
-        "integrations": {
-            "lora_manager_enabled": bool(IntegrationConfig.LORA_MANAGER_ENABLED),
-            "has_civitai_api_key": bool(IntegrationConfig.CIVITAI_API_KEY),
-        },
-    }
-
-
-def _source_counts(sources):
-    configured = sources.get("configured") or []
-    effective = sources.get("effective") or []
-    return {
-        "configured": len(configured),
-        "effective": len(effective),
-        "watching": sum(1 for row in effective if row.get("watch") == "watching"),
-        "unavailable": sum(1 for row in configured if row.get("valid") is False),
-    }
-
-
-class DiagnosticsReportMixin:
-    """Mixin providing ``GET /prompt_manager/system/diagnostics``."""
-
-    def _register_diagnostics_report_routes(self, routes):
-        @routes.get("/prompt_manager/system/diagnostics")
-        async def diagnostics_report_route(request):
-            return await self.get_diagnostics_report(request)
-
-    async def get_diagnostics_report(self, request):
-        """The report, built off the loop under a lease (409 ``busy`` in a restore)."""
-        from ..config import IntegrationConfig
-
-        try:
-            async with self._jobs.lease(DIAGNOSTICS_LEASE):
-                report = await self._run_in_executor(self.build_report)
-        except JobBusy as busy:
-            return busy_response(busy)
-        except Exception:
-            self.logger.exception("The diagnostic report could not be built")
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": None,
-                    "error": "The diagnostic report could not be built.",
-                },
-                status=500,
-            )
-        report = scrub(report, IntegrationConfig.CIVITAI_API_KEY)
-        return web.json_response(report, headers={"Cache-Control": "no-store"})
-
-    def build_report(self):
-        """The report's fields (blocking: reads the database and the log folder)."""
-        db = self.db
-        manager = self._get_logger_manager()
-        stats = dict(manager.get_log_stats())
-        stats["log_directory"] = report_path(stats.get("log_directory"))
-        info = dict(db.model.get_database_info() or {})
-        if "database_path" in info:
-            info["database_path"] = report_path(info["database_path"])
-        sources, _monitor = self._source_status()
-        return {
-            "success": True,
-            "generated_at": datetime.datetime.now().replace(microsecond=0).isoformat(),
-            "version": project_version(_ROOT),
-            "python": platform.python_version(),
-            "platform": {"system": platform.system(), "release": platform.release()},
-            "viewerjs": viewerjs_version(VIEWERJS_PROVENANCE),
-            "checks": _admin.legacy_checks(db.model.db_path, report_path),
-            "database_info": info,
-            "sources": _source_counts(sources),
-            "logging": {"config": dict(manager.get_config()), "stats": stats},
-            "health": health_summary(self._current_health_report()),
-            "config": public_config(),
-            "redacted": 0,
-        }
@@ -588,10 +588,7 @@ class DuplicateFilesMixin:
        job.update(total=len(targets), status_line="Removing duplicate files")
        spellings = await self._run_in_executor(self._source_spellings)
        removed, failure, keepers = 0, None, {}
-        totals = dict.fromkeys(
-            ("moved", "merged", "favorites", "tags", "review", "collections"), 0
-        )
-        totals["categories"] = 0  # image categories kept on the kept copies (#332)
+        totals = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
        for done, target in enumerate(targets, start=1):
            if failure is not None:
                self._record_target(job, "kept", target, NOT_ATTEMPTED)
@@ -634,18 +631,10 @@ class DuplicateFilesMixin:
            job.log_line(
                f"Moved {_plural(totals['favorites'], 'favorite')} to the kept copies"
            )
-        if totals["collections"]:
-            job.log_line(
-                f"Moved {_plural(totals['collections'], 'collection membership')} "
-                "to the kept copies"
-            )
        if totals["tags"]:
            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))
@@ -104,8 +95,7 @@ def copy_move(target, kept_stat, spellings):

    A record found under a folder spelling moves to the kept copy under
    the same spelling when that folder holds it too, else to its real
-    path. Its favorite and its collection memberships move under every
-    listed root holding the file.
+    path. Its favorite moves under every listed root holding the file.
    """
    removed = spellings.of(target["abs"])
    kept = spellings.of(target["keeper_abs"])
@@ -135,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
@@ -27,17 +26,11 @@ from .history_current import (
    resolve_current_candidate,
    snapshot_current_output_scope,
 )
-from .inspection_service import (
-    CurrentFileChanged,
-    image_tags_reader,
-    inspect_current_file,
-)
-from .images import image_category_key
+from .inspection_service import CurrentFileChanged, inspect_current_file

 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,
@@ -45,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,
@@ -61,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
@@ -691,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:
@@ -741,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)
@@ -749,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:
@@ -771,27 +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,
-                        ),
-                        # The file's own image tags, keyed as the Tag dialog
-                        # keys them: the normcased realpath (#457).
-                        image_tags=image_tags_reader(
-                            db,
-                            str(resolved.canonical_target),
-                            self.logger,
-                            close=True,
-                        ),
-                        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

@@ -42,7 +32,7 @@ from .. import model_gate
 from .admin import _plural, _time_left
 from .annotation_suggest import (
    OptionError,
-    model_refusal,
+    unavailable_message,
    validate_options,
 )
 from .annotations import (
@@ -55,26 +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,
-    CollectionMissing,
-    ListingSourceChanged,
-    collection_not_found,
-    _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:
@@ -101,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
@@ -119,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": "!"}
@@ -139,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)

@@ -181,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:
@@ -195,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:
@@ -245,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):
@@ -306,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:
@@ -400,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."""

@@ -435,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")
@@ -470,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"]
-        message = model_refusal(status, model_type, label)
-        if message is not None:
-            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 CollectionMissing:
-            return None, collection_not_found()
-        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:
@@ -740,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:
@@ -783,20 +363,20 @@ 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

    async def _prepare_tagging_model(self, job, spec: _Spec, owner):
        """The loaded service, or None (logged) when the job cannot run."""
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
+        from ..autotag import MODELS, get_autotag_service

        service = get_autotag_service()
        status = await self._run_in_executor(service.get_models_status)
-        name = MODELS.get(spec.model_type, {}).get("name", spec.model_type)
-        message = model_refusal(status, spec.model_type, name)
-        if message is not None:
+        if not status.get(spec.model_type, {}).get("downloaded"):
+            name = MODELS.get(spec.model_type, {}).get("name", spec.model_type)
+            message = unavailable_message(name)
            job.update(status_line=message)
            job.log_line(f"! {message}")
            return None
@@ -808,11 +388,6 @@ class ImageTagJobsMixin:
                spec.model_type,
                spec.options["use_gpu"],
            )
-        except MissingBackendPackages as exc:
-            # A package gone since the status read (load_model logged it).
-            job.update(status_line=str(exc))
-            job.log_line(f"! {exc}")
-            return None
        except Exception:
            self.logger.exception("The auto-tag job could not load its model")
            job.update(status_line=INFERENCE_FAILED)
@@ -864,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
@@ -900,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":
@@ -13,13 +13,12 @@ import re
 import stat
 import subprocess  # nosec B404 - ffmpeg frames through run_encoder, fixed argv
 import sys
-import threading
 import time as _time
 import urllib.parse
 from bisect import bisect_left, bisect_right, insort
 from collections.abc import Mapping
 from pathlib import Path
-from typing import Callable, Iterable, NamedTuple
+from typing import Callable, NamedTuple

 from aiohttp import web
 from PIL import Image, UnidentifiedImageError
@@ -55,22 +54,17 @@ from .inspection_service import (
    IMAGE_EXTENSIONS as _IMAGE_EXTENSIONS,
    SERVABLE_EXTENSIONS,
    VIDEO_EXTENSIONS,
-    image_tags_reader,
    inspect_current_file,
 )

 try:
-    from ...database.image_collections import CollectionMissing
    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,
    )
@@ -83,19 +77,14 @@ try:
        reveal_executor,
        reveal_in_file_manager,
    )
-    from ...utils.workspace_keys import gallery_root_scope, workspace_keys_for
 except ImportError:
-    from database.image_collections import CollectionMissing
    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,
    )
@@ -108,7 +97,6 @@ except ImportError:
        reveal_executor,
        reveal_in_file_manager,
    )
-    from utils.workspace_keys import gallery_root_scope, workspace_keys_for


 IMAGE_EXTENSIONS = _IMAGE_EXTENSIONS
@@ -116,21 +104,6 @@ IMAGE_EXTENSIONS = _IMAGE_EXTENSIONS
 _CARD_RECORDS = ("prompt", "workflow")
 _PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
 _LISTING_FAILED = "The image list could not be filtered. Check server logs for details."
-_COLLECTION_ID = re.compile(r"[1-9][0-9]{0,8}")
-COLLECTION_NOT_FOUND = "That collection no longer exists."
-
-
-def collection_not_found() -> web.Response:
-    """The 404 a write or a listing answers for an unknown collection (#331)."""
-    return web.json_response(
-        {
-            "success": False,
-            "code": "collection-not-found",
-            "error": COLLECTION_NOT_FOUND,
-        },
-        status=404,
-        headers={"Cache-Control": "no-store"},
-    )


 def _card_header(path: Path) -> tuple:
@@ -522,8 +495,7 @@ MAX_JSON_BODY_BYTES = 1024 * 1024
 _READ_CHUNK = 64 * 1024


-# Guards the first load of an API's workspace keys (#430, _workspace_keys).
-_WORKSPACE_KEYS_LOCK = threading.Lock()
+_WORKSPACE_CURSOR_SECRET = os.urandom(32)


 def _workspace_root(query: dict, roots: list[Path]) -> int | None:
@@ -591,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:
@@ -604,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):
@@ -623,37 +600,15 @@ def _rated_key(entry: _Listed, rank: int) -> tuple:
    return (-rank, *_workspace_key(entry, "rating"))


-# Bump whenever the cursor's key tuple changes shape: a cursor now outlives a
-# restart and an upgrade (#430), so an old shape must be refused, not parsed.
-_CURSOR_VERSION = 2
-_CURSOR_STALE = "The image collection changed; refresh the gallery"
-
-
-class CursorStale(ValueError):
-    """A well-formed cursor this listing cannot verify (#430).
-
-    Another key, another root list or other filters: the page refreshes its
-    collection instead of retrying the same cursor.
-    """
-
-
-def _cursor_mac(secret: bytes, scope: str, payload: bytes) -> bytes:
-    # The listing scope (it hashes every absolute root) is bound in the MAC
-    # only, never sent: the scope is 64 hex, so the "\n" join is unambiguous.
-    return hmac.new(secret, scope.encode() + b"\n" + payload, hashlib.sha256).digest()
-
-
-def _workspace_cursor(key: tuple, scope: str, secret: bytes) -> str:
-    """The signed keyset cursor of *key*; *secret* is the API's cursor key."""
+def _workspace_cursor(key: tuple, scope: str) -> str:
    payload = json.dumps(
-        {"v": _CURSOR_VERSION, "key": key}, separators=(",", ":"), ensure_ascii=False
+        {"v": 1, "scope": scope, "key": key}, separators=(",", ":"), ensure_ascii=False
    ).encode()
-    signature = _cursor_mac(secret, scope, payload)
+    signature = hmac.new(_WORKSPACE_CURSOR_SECRET, payload, hashlib.sha256).digest()
    return base64.urlsafe_b64encode(signature + payload).decode().rstrip("=")


-def _workspace_cursor_key(token: str, scope: str, order: str, secret: bytes) -> tuple:
-    """The keyset key of *token*; CursorStale when it is not this listing's."""
+def _workspace_cursor_key(token: str, scope: str, order: str) -> tuple:
    try:
        if len(token) > 4096:
            raise ValueError()
@@ -661,14 +616,13 @@ def _workspace_cursor_key(token: str, scope: str, order: str, secret: bytes) ->
            token + "=" * (-len(token) % 4), altchars=b"-_", validate=True
        )
        signature, payload = raw[:32], raw[32:]
-        if len(signature) != 32 or not payload:
+        expected = hmac.new(_WORKSPACE_CURSOR_SECRET, payload, hashlib.sha256).digest()
+        if not hmac.compare_digest(signature, expected):
            raise ValueError()
-        if not hmac.compare_digest(signature, _cursor_mac(secret, scope, payload)):
-            raise CursorStale(_CURSOR_STALE)
        data = json.loads(payload)
        key = data["key"]
-        if data["v"] != _CURSOR_VERSION or not isinstance(key, list):
-            raise CursorStale(_CURSOR_STALE)
+        if data["v"] != 1 or data["scope"] != scope or not isinstance(key, list):
+            raise ValueError()
        types = (
            (str, str, int, (float, int))
            if order in ("name", "name-desc")
@@ -682,8 +636,6 @@ def _workspace_cursor_key(token: str, scope: str, order: str, secret: bytes) ->
        ):
            raise ValueError()
        return tuple(key)
-    except CursorStale:
-        raise
    except (ValueError, KeyError, TypeError, UnicodeError, binascii.Error):
        raise ValueError("Invalid gallery cursor; refresh the gallery") from None

@@ -854,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.

@@ -1157,9 +1062,8 @@ def _workspace_filters(query: Mapping) -> dict:
    the linked positive's text, title and tag names. ``category`` is exact,
    ``tags`` is a comma list that must all be present, ``sort=rating`` ranks by
    the linked positive, and ``favorites=1`` keeps only favorites (the
-    Favorites page, #249 D51). ``collection=<id>`` (1 to 9 digits) keeps only
-    that collection's members (#331); it wins over ``favorites`` (a page never
-    sets both). Raises ValueError for any unknown or oversized value.
+    Favorites page, #249 D51). Raises ValueError for any unknown or oversized
+    value.
    """
    text = query.get("q", "").strip()
    folded = text.casefold()
@@ -1173,10 +1077,8 @@ def _workspace_filters(query: Mapping) -> dict:
        {tag.strip() for tag in query.get("tags", "").split(",") if tag.strip()}
    )
    favorites = query.get("favorites", "0")
-    collection = query.get("collection", "")
    if (
        favorites not in ("0", "1")
-        or (collection != "" and _COLLECTION_ID.fullmatch(collection) is None)
        or len(text) > 500
        or len(folded) > 500
        or media not in ("all", "image", "video")
@@ -1199,108 +1101,41 @@ def _workspace_filters(query: Mapping) -> dict:
        "path": exact.casefold(),
        "category": category,
        "tags": tags,
-        "favorites": favorites == "1" and not collection,
-        "collection": int(collection) if collection else None,
+        "favorites": favorites == "1",
    }


-# 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",
-        # A collection page's filter (#331): bulk actions act on its members.
-        "collection",
-    }
-)
-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,
-    members: frozenset | None = 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. *members*, when given, admits only those listed paths (the
-    favorites of ``favorites=1`` or a ``collection``'s members). *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:
@@ -1311,18 +1146,12 @@ def _admitted_entries(
            continue
        if media != "all" and (media == "video") != entry.video:
            continue
-        if members is not None and entry.path not in members:
+        if favorites is not None and entry.path not in favorites:
            continue
        match = None if links is None else links.get(entry.normalized)
        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
@@ -1330,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,
-    members: 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, members, image_tags, own_categories
-    ):
        total += 1
        if match is not None:
            positives.add(match[2])
@@ -1368,27 +1174,13 @@ def _in_subfolder(rel_dir, subfolder):
 class ImageRoutesMixin:
    """Mixin providing image and gallery-related API endpoints."""

-    def _workspace_keys(self):
-        """This API's scope and cursor keys, loaded once (#430).
-
-        They derive from the secret persisted beside the database, so a restart
-        keeps every scope and cursor an open page holds. The first call reads
-        (or writes) one small file; later calls return the cached keys, which
-        a live library move or restore does not change before a restart.
-        """
-        keys = self.__dict__.get("_workspace_keys_cache")
-        if keys is None:
-            with _WORKSPACE_KEYS_LOCK:
-                keys = self.__dict__.get("_workspace_keys_cache")
-                if keys is None:
-                    db = getattr(self, "db", None)
-                    model = getattr(db, "model", None)
-                    keys = workspace_keys_for(getattr(model, "db_path", None))
-                    self.__dict__["_workspace_keys_cache"] = keys
-        return keys
-
    def _gallery_root_scope(self, root: Path, index: int) -> str:
-        return gallery_root_scope(self._workspace_keys(), str(_canonical(root)), index)
+        payload = json.dumps(
+            ["prompt-manager-gallery-root-v1", index, str(_canonical(root))],
+            separators=(",", ":"),
+            ensure_ascii=False,
+        ).encode("utf-8")
+        return hmac.new(_WORKSPACE_CURSOR_SECRET, payload, hashlib.sha256).hexdigest()

    def _gallery_scope_error(
        self, query: Mapping, roots: list[Path]
@@ -2052,8 +1844,6 @@ class ImageRoutesMixin:
            limit, _offset = parse_page_params(request.query, default_limit=100)
        except ValueError:
            return bad_request("limit and offset must be integers")
-        # #430: the first use may create the key file; never on the event loop.
-        cursor_secret = (await self._run_in_executor(self._workspace_keys)).cursor
        try:
            root_index = _workspace_root(request.query, output_dirs)
            filters = _workspace_filters(request.query)
@@ -2071,38 +1861,27 @@ class ImageRoutesMixin:
                        filters["category"],
                        filters["tags"],
                        filters["favorites"],
-                        filters["collection"],
                    ]
                ).encode()
            ).hexdigest()
            token = request.query.get("cursor")
            after = (
-                _workspace_cursor_key(token, scope, filters["order"], cursor_secret)
-                if token
-                else None
-            )
-        except CursorStale as exc:
-            return web.json_response(
-                {"success": False, "code": "cursor-stale", "error": str(exc)},
-                status=400,
-                headers={"Cache-Control": "no-store"},
+                _workspace_cursor_key(token, scope, filters["order"]) if token else None
            )
        except ValueError as exc:
            return bad_request(str(exc))

+        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
+        ]
        try:
-            if filters["collection"] is not None and not await self._run_in_executor(
-                self.db.collection_exists, filters["collection"]
-            ):
-                raise CollectionMissing("No such collection")
-            listings = await self._workspace_listings(output_dirs, root_index)
            page, total, has_more, next_cursor, positive_count = (
                await self._run_in_executor(
                    self._select_workspace_page, listings, filters, after, limit, scope
                )
            )
-        except CollectionMissing:
-            return collection_not_found()
        except Exception:
            # A filter that needs the prompt links or the image tags cannot be
            # served without them. Never echo the exception: it can carry SQL
@@ -2312,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)
@@ -2351,45 +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, members, own)``: the
-        listing in the filters' order, its keyset key, and the link, image-tag,
-        member and own-category maps _admitted_entries reads (members: a
-        collection's, else the favorites, else None). A collection deleted since
-        the route checked it raises CollectionMissing. 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",
@@ -2400,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(
@@ -2450,68 +2234,6 @@ class ImageRoutesMixin:
            def key(entry):
                return _workspace_key(entry, order)

-        return (
-            entries,
-            key,
-            links,
-            image_tags,
-            self._workspace_members(listings, filters),
-            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, members, own = self._workspace_admission(
-            listings, filters, read_links=needed or after is None
-        )
        start = 0
        if after is not None:
            if order == "name-desc":
@@ -2519,18 +2241,17 @@ 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, members, image_tags, own
+            entries, start, limit + 1, filters, links, favorites, image_tags
        )
        if not needed and after is not None:
            positive_count = _COUNT_OMITTED
        has_more = len(page) > limit
        page = page[:limit]
-        next_cursor = (
-            _workspace_cursor(key(page[-1]), scope, self._workspace_keys().cursor)
-            if has_more
-            else None
-        )
+        next_cursor = _workspace_cursor(key(page[-1]), scope) if has_more else None
        return (
            [(entry.path, entry.mtime, entry.root, entry.index) for entry in page],
            total,
@@ -2539,63 +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, members, 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, members, 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,
-        ListingSourceChanged when the filter's ``root_scope`` no longer names
-        its root (the sources were renumbered since the listing), and
-        CollectionMissing when its ``collection`` no longer exists (checked
-        before any scan and again after the members are read).
-        """
-        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)
-        if filters["collection"] is not None and not await self._run_in_executor(
-            self.db.collection_exists, filters["collection"]
-        ):
-            raise CollectionMissing("No such collection")
-        listings = await self._workspace_listings(output_dirs, 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:
@@ -2608,8 +2272,7 @@ class ImageRoutesMixin:
                )

            image_path = Path(image["image_path"])
-            lora_dirs = await self._run_in_executor(self._lora_image_dirs)
-            allowed_dirs = list(self._get_all_output_dirs()) + lora_dirs
+            allowed_dirs = list(self._get_all_output_dirs()) + self._lora_image_dirs()

            denied = _media_access_error(image_path, allowed_dirs)
            if denied is not None:
@@ -2657,10 +2320,7 @@ class ImageRoutesMixin:
        LoraManager's guarded LoRA roots, sidecar root and example-images
        root (``lora_manager_layout.media_roots``, #355) and PromptManager's
        CivitAI download cache. An unusable LoraManager layout gives the
-        default LoRA roots and the cache. The layout comes from the layout
-        cache (``lora_utils.cached_lora_manager_layout``, #362), which reloads
-        when LoraManager's settings files change; blocking, so the routes
-        call it in the executor.
+        default LoRA roots and the cache.
        """
        try:
            from ..config import IntegrationConfig
@@ -2668,18 +2328,25 @@ class ImageRoutesMixin:
            if not IntegrationConfig.LORA_MANAGER_ENABLED:
                return []
            from ..lora_utils import (
-                cached_lora_manager_layout,
                get_lora_image_cache_dir,
+                layout_for_install,
+                lora_manager_layout,
            )

-            configured = IntegrationConfig.LORA_MANAGER_PATH or ""
-            install, layout = cached_lora_manager_layout(configured)
-            if configured.strip() and install is None:
+            lora_root = IntegrationConfig.LORA_MANAGER_PATH or ""
+            if lora_root.strip():
                # A configured path comes from config.json, which can be hand
                # edited: only a LoraManager install under custom_nodes may
                # widen the serving allow-list. An empty path keeps the
                # auto-detection, which itself only scans custom_nodes.
-                return []
+                from ..lora_utils import resolve_lora_manager_path
+
+                lora_root = resolve_lora_manager_path(lora_root)
+                if not lora_root:
+                    return []
+                layout = layout_for_install(lora_root)
+            else:
+                layout = lora_manager_layout("")

            dirs = [Path(d) for d in layout.media_roots]
            # Named, not made: listing and serving never create the cache.
@@ -3776,58 +3443,25 @@ class ImageRoutesMixin:
        self._favorite_listing_cache[cache_key] = (files, listing)
        return listing

-    def _workspace_members(self, listings: list[tuple], filters: dict):
-        """The member set the filters ask for, or None (blocking)."""
-        collection = filters.get("collection")
-        if collection is not None:
-            members = self._workspace_member_paths(
-                listings,
-                lambda root_key: self.db.collection_members(collection, root_key),
-            )
-            # Checked after the reads: a collection deleted before or while
-            # they ran is a 404, never an empty page passing for it.
-            if not self.db.collection_exists(collection):
-                raise CollectionMissing("No such collection")
-            return members
-        if filters["favorites"]:
-            return self._workspace_favorite_paths(listings)
-        return None
-
    def _workspace_favorite_paths(self, listings: list[tuple]) -> frozenset:
-        """The listed paths of every favorite in the selected roots (blocking)."""
-        return self._workspace_member_paths(listings, self.db.get_root_favorites)
+        """The listed paths of every favorite in the selected roots (blocking).

-    def _workspace_member_paths(
-        self, listings: list[tuple], keys_for_source: Callable[[str], Iterable[str]]
-    ) -> frozenset:
-        """The listed paths of the stored keys of each selected root (blocking).
-
-        One read per root (``keys_for_source(root key)``: the favorites' or a
-        collection's primary-key range), matched against the root's cached
-        ``{relative key: listing spelling}``, so the work follows the members
-        rather than the files, and a key folds case exactly as it was stored
-        (Windows). A member whose file is gone matches nothing. A failed read
-        raises: an unfiltered page must never pass for the members.
+        One primary-key read per root (get_root_favorites), matched against the
+        root's cached ``{relative key: listing spelling}``, so the work follows
+        the favorites rather than the files, and a key folds case exactly as
+        the toggle stored it (Windows). A favorite whose file is gone matches
+        nothing. A failed read raises: an unfiltered page must never pass for
+        the favorites.
        """
        paths = set()
        for _index, root, files in listings:
            listing = self._favorite_listing(root, files)
-            for key in keys_for_source(_favorite_root_key(root)):
+            for key in self.db.get_root_favorites(_favorite_root_key(root)):
                listed = listing.get(key)
                if listed is not None:
                    paths.add(root / listed)
        return frozenset(paths)

-    async def _workspace_listings(
-        self, output_dirs: list[Path], root_index: int | None
-    ) -> list[tuple]:
-        """``(index, root, scan)`` of every selected root (cached scans)."""
-        return [
-            (index, root, await self._get_gallery_files(root))
-            for index, root in enumerate(output_dirs)
-            if root_index is None or index == root_index
-        ]
-
    def _workspace_favorites(self, page: list[tuple]) -> set[tuple[int, str]]:
        """``(root index, listing path)`` of the favorites among *page* entries."""
        by_root: dict[tuple[int, Path], dict[str, str]] = {}
@@ -3905,25 +3539,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
@@ -3963,22 +3589,28 @@ class ImageRoutesMixin:
            )

    def _inspection_image_tags(self, root: Path, parts: tuple) -> Callable:
-        """The inspector's ``image_tags`` reader for one rooted file (S1)."""
-        locator = os.path.normcase(os.path.join(os.path.realpath(root), *parts))
-        return image_tags_reader(self.db, locator, self.logger)
+        """The inspector's ``image_tags`` reader for one rooted file (S1).

-    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).
+        The returned function takes the inspection's own stable stat and
+        answers ``current`` only for a byte record verified at exactly that
+        ``(size, mtime_ns)``; a failed read is ``unavailable``, never an error.
        """
-        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
+        locator = os.path.normcase(os.path.join(os.path.realpath(root), *parts))
+
+        def read(size: int, mtime_ns: int) -> dict:
+            try:
+                found = self.db.current_image_tags({locator: (size, mtime_ns)})
+            except Exception:
+                self.logger.warning(
+                    "Inspection image tags could not be read", exc_info=True
+                )
+                return {"state": "unavailable", "tags": []}
+            tags = found.get(locator)
+            if tags is None:
+                return {"state": "none", "tags": []}
+            return {"state": "current", "tags": list(tags)}
+
+        return read

    def _inspection_library(self, saved: dict | None, *, unavailable: bool) -> dict:
        """The inspector's Library facts; the route sets the title afterwards."""
@@ -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 (
@@ -93,35 +93,6 @@ def _in_host_temp(path: Path) -> bool:
        return False


-def image_tags_reader(
-    db: Any, locator: str, logger: Any, *, close: bool = False
-) -> Callable[[int, int], dict]:
-    """The inspector's ``image_tags`` reader for one file *locator* (S1).
-
-    The returned function takes the inspection's own stable stat and answers
-    ``current`` only for a byte record verified at exactly that
-    ``(size, mtime_ns)``; a failed read is ``unavailable``, never an error.
-    ``close`` closes the calling thread's connection afterwards, for routes
-    that close theirs after reading (History).
-    """
-
-    def read(size: int, mtime_ns: int) -> dict:
-        try:
-            found = db.current_image_tags({locator: (size, mtime_ns)})
-        except Exception:
-            logger.warning("Inspection image tags could not be read", exc_info=True)
-            return {"state": "unavailable", "tags": []}
-        finally:
-            if close:
-                db.model.close()
-        tags = found.get(locator)
-        if tags is None:
-            return {"state": "none", "tags": []}
-        return {"state": "current", "tags": list(tags)}
-
-    return read
-
-
 def inspect_current_file(
    path: Path,
    *,
@@ -129,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):
@@ -163,15 +129,8 @@ 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).
        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
        )
    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"
@@ -21,11 +21,9 @@ from .pairs import pair_response
 try:
    from ...database.library import ARCHIVE_SCOPES
    from ...database.library_commands import LibraryCommandError
-    from ...database.library_folders import folder_prefixes, normalize_folder
 except ImportError:
    from database.library import ARCHIVE_SCOPES
    from database.library_commands import LibraryCommandError
-    from database.library_folders import folder_prefixes, normalize_folder

 _SECRET = os.urandom(32)

@@ -285,84 +283,36 @@ class LibraryRoutesMixin:
        outputs = list(self._get_all_output_dirs())
        return self._media_roots(outputs), len(outputs)

-    def _library_root_spellings(self) -> list[str]:
-        """Every spelling of each output root (#444 folder filter): the
-        validated, resolved root and each configured or detected path that
-        resolves to it, so images saved through a symlinked root match."""
-        from ..config import GalleryConfig
-
-        roots = [str(root) for root in self._get_all_output_dirs()]
-        candidates = [
-            *GalleryConfig.MONITORING_DIRECTORIES,
-            self._find_comfyui_output_dir(),
-            *self._comfyui_output_dir_list(),
-        ]
-        spellings = []
-        for root in roots:
-            for value in (root, *candidates):
-                if not value or not isinstance(value, (str, os.PathLike)):
-                    continue
-                value = str(value)
-                same = value == root or os.path.normcase(
-                    os.path.realpath(value)
-                ) == os.path.normcase(root)
-                if same and value not in spellings:
-                    spellings.append(value)
-        return spellings
-
    @pair_response
    async def get_library_options(self, request: web.Request) -> web.Response:
-        include = request.query.get("include", "")
-        if include not in ("", "folders"):
-            raise ValueError("include must be empty or 'folders'")
-        if include:
-            # Folders are read only when Refine opens (a walk of linked paths).
-            roots = await self._run_in_executor(self._library_root_spellings)
-            result = await self._run_in_executor(self.db.get_library_options, roots)
-        else:
-            result = await self._run_in_executor(self.db.get_library_options)
+        result = await self._run_in_executor(self.db.get_library_options)
        return web.json_response({"success": True, **result})

    @pair_response
    async def list_library(self, request: web.Request) -> web.Response:
-        folder = normalize_folder(request.query.get("folder", ""))
        options = {
            "text": request.query.get("text", ""),
            "category": request.query.get("category"),
            "tags": sorted(set(request.query.getall("tag", []))),
-            "tag_mode": request.query.get("tag_mode", "all"),
            "sort": request.query.get("sort", "newest"),
        }
        limit = _page_limit(request)
        cursor = request.query.get("cursor")
-        roots = (
-            await self._run_in_executor(self._library_root_spellings) if folder else []
-        )
-        prefixes = folder_prefixes(roots, folder) if folder else None

        def read() -> tuple[dict, dict]:
            with self.db.library_snapshot(include_ceiling=True) as snapshot:
                conn, epoch, ceiling = snapshot
-                # The folder and the roots it was resolved under join the scope.
                scope = _scope(
-                    {
-                        "kind": "parents",
-                        "projection": 2,
-                        "epoch": epoch,
-                        **options,
-                        **({"folder": folder, "roots": roots} if folder else {}),
-                    }
+                    {"kind": "parents", "projection": 2, "epoch": epoch, **options}
                )
                result = self.db._list_library(
                    conn,
                    epoch,
                    ceiling,
                    **options,
-                    folder_prefixes=prefixes,
                    limit=limit,
                    after=_decode(cursor, scope),
                )
-                result["folder"] = folder
                records = self.db.get_library_previews(
                    [parent["id"] for parent in result["items"]]
                )
@@ -1,207 +0,0 @@
-"""Reviewed rotated-log cleanup as a maintenance plan (#329 System S12).
-
-``POST /prompt_manager/maintenance/preview {operation: "rotated_logs",
-options: {}}`` lists the rotated copies of the active log that Rule R allows
-(``utils/logging_config.py``: ``prompt_manager.log.<n>`` regular files that
-are not links, directly in the log folder) and writes nothing. The plan keeps
-each copy's name, size, ``mtime_ns`` and inode under its token; the response
-is the maintenance ``Plan`` shape with basenames only, a ``none`` backup
-policy (no library record changes) and no ``disk`` key.
-
-``POST /prompt_manager/maintenance/apply {token}`` starts a ``maintenance``
-job titled "Rotated log copies" with admission ``read``: it may run beside a
-scan and is refused only beside another maintenance job or an ``exclusive``
-one. The job deletes exactly the reviewed copies under the logger's files
-lock and the file handler's lock, or nothing, failing ``plan-changed``, when
-any of them is missing, is no longer a rotated copy or differs in size,
-``mtime_ns`` or inode. A copy that cannot be deleted (open in another program
-on Windows) is an ``errors`` row; the others are deleted.
-"""
-
-import datetime
-import json
-
-from aiohttp import web
-
-try:
-    from ...utils.logging_config import RotatedChanged, rotated_sort_key
-except ImportError:  # loaded as the top-level ``py`` package (tests)
-    from utils.logging_config import RotatedChanged, rotated_sort_key
-
-from .jobs import MAINTENANCE_JOB_KIND
-from .maintenance_plans import ScopeTooLarge
-
-ROTATED_LOGS = "rotated_logs"
-LOG_CLEANUP_TITLE = "Rotated log copies"
-LOGS_CHANGED = (
-    "The log files changed since the review; nothing was deleted. Review again."
-)
-LOG_CLEANUP_FAILED = "The log cleanup failed."
-TOO_MANY_LOG_FILES = "Too many log files to review at once."
-LOG_CLEANUP_MEDIA = (
-    "Deletes only the listed log files. No image, video or library record changes."
-)
-_GROUPS = ("changed", "protected", "errors")
-
-
-def size_label(size):
-    """``1000 bytes``, ``2.0 KB``, ``10.0 MB`` or ``1.2 GB`` (1 KB = 1024 bytes)."""
-    size = max(0, int(size or 0))
-    if size < 1024:
-        return f"{size} {'byte' if size == 1 else 'bytes'}"
-    for unit, scale in (("KB", 2**10), ("MB", 2**20)):
-        if size < scale * 1024:
-            return f"{size / scale:.1f} {unit}"
-    return f"{size / 2**30:.1f} GB"
-
-
-def time_label(mtime_ns):
-    """The local modification time as ``YYYY-MM-DD HH:MM``."""
-    try:
-        moment = datetime.datetime.fromtimestamp(mtime_ns / 1e9)
-    except (OSError, OverflowError, ValueError):  # a time before 1970 on Windows
-        return "unknown time"
-    return moment.strftime("%Y-%m-%d %H:%M")
-
-
-def _count(count, singular, plural):
-    return f"{count} {singular if count == 1 else plural}"
-
-
-def _protected_reasons(rows):
-    """The plan's Protected reasons: what the cleanup keeps, zero counts left out."""
-    active = sum(1 for row in rows if row["kind"] == "active")
-    links = sum(1 for row in rows if row["kind"] == "link")
-    other = sum(1 for row in rows if row["kind"] == "other")
-    reasons = []
-    if active:
-        reasons.append("Kept: the active log")
-    if links:
-        reasons.append(f"Kept: {_count(links, 'link', 'links')}")
-    if other:
-        reasons.append(f"Kept: {_count(other, 'other file', 'other files')}")
-    return active + links + other, reasons
-
-
-def _scope_label(files):
-    if not files:
-        return "No rotated log copies"
-    total = sum(row["size"] for row in files)
-    return (
-        f"{_count(len(files), 'rotated log copy', 'rotated log copies')}"
-        f" · {size_label(total)}"
-    )
-
-
-class LogCleanupMixin:
-    """The ``rotated_logs`` maintenance plan and its job.
-
-    The logger manager is reached only through ``_get_logger_manager``
-    (``logging_routes.py``), so the tests can point it at a temporary folder.
-    """
-
-    async def preview_log_cleanup(self):
-        """The ``rotated_logs`` plan (runs inside the preview's lease)."""
-        from . import maintenance
-
-        manager = self._get_logger_manager()
-        try:
-            rows = await self._run_in_executor(manager.scan_log_folder)
-        except Exception:
-            self.logger.exception("Rotated log review failed")
-            return maintenance._failure("Failed to review maintenance", 500)
-        rotated = sorted(
-            (row for row in rows if row["kind"] == "rotated"),
-            key=rotated_sort_key,
-        )
-        files = [
-            {
-                "name": row["name"],
-                "size": row["size"],
-                "mtime_ns": row["mtime_ns"],
-                "ino": row["ino"],
-            }
-            for row in rotated
-        ]
-        protected, reasons = _protected_reasons(rows)
-        store = self._maintenance_plans
-        try:
-            token = store.issue(
-                ROTATED_LOGS,
-                json.dumps(files, sort_keys=True),
-                {"files": files, "protected": protected},
-                (),
-            )
-        except ScopeTooLarge:
-            return maintenance._failure(TOO_MANY_LOG_FILES, 413, "too-large")
-        plan = store.peek(token, ROTATED_LOGS)
-        return web.json_response(
-            {
-                "success": True,
-                "token": token,
-                "operation": ROTATED_LOGS,
-                "expires_at": maintenance._iso(plan.expires_at),
-                "scope": {"count": len(files), "label": _scope_label(files)},
-                "protected": {"count": protected, "reasons": reasons},
-                "backup": {
-                    "policy": "none",
-                    "destination_label": None,
-                    "expected_bytes": None,
-                },
-                "media": {"deletes_files": True, "label": LOG_CLEANUP_MEDIA},
-                "details": [
-                    {
-                        "label": row["name"],
-                        "detail": (
-                            f"{size_label(row['size'])} · {time_label(row['mtime_ns'])}"
-                        ),
-                    }
-                    for row in files
-                ],
-            },
-            headers={"Cache-Control": "no-store"},
-        )
-
-    def _start_log_cleanup(self, plan):
-        """Register the cleanup job (on the loop); raises JobBusy when refused."""
-        return self._jobs.start(
-            MAINTENANCE_JOB_KIND,
-            LOG_CLEANUP_TITLE,
-            admission="read",
-            cancellable=False,
-            scope={"operation": ROTATED_LOGS},
-            groups=_GROUPS,
-            runner=lambda job: self._run_log_cleanup(job, plan),
-        )
-
-    async def _run_log_cleanup(self, job, plan):
-        from . import maintenance
-
-        files = plan.payload["files"]
-        sizes = {row["name"]: row["size"] for row in files}
-        job.update(total=len(files), status_line="Deleting rotated log copies")
-        manager = self._get_logger_manager()
-        try:
-            result = await self._run_in_executor(manager.delete_rotated, files)
-        except RotatedChanged:
-            return maintenance._fail_job(job, "plan-changed", LOGS_CHANGED)
-        except Exception:
-            self.logger.exception("Rotated log cleanup failed")
-            return maintenance._fail_job(job, None, LOG_CLEANUP_FAILED)
-        for name in result["removed"]:
-            detail = f"Deleted · {size_label(sizes.get(name, 0))}"
-            job.record(
-                "changed", {"path": name, "detail": detail}, f"- {name} · {detail}"
-            )
-        for name, error in result["failed"]:
-            detail = self._public_error(error)
-            job.record(
-                "errors", {"path": name, "detail": detail}, f"! {name} · {detail}"
-            )
-        job.record_counted("protected", plan.payload["protected"])
-        removed, failed = len(result["removed"]), len(result["failed"])
-        line = f"Deleted {_count(removed, 'rotated log copy', 'rotated log copies')}"
-        if failed:
-            line += f", {failed} could not be deleted"
-        job.log_line(line)
-        job.update(processed=len(files), progress=100, status_line=line)
@@ -1,21 +1,9 @@
-"""Logging API routes for PromptManager.
-
-Every route that names a log file goes through Rule R (#329,
-``utils/logging_config.py``): a download is served only for a regular,
-non-link file listed directly in the log folder, and Clear deletes only
-rotated copies. File work runs off the event loop.
-"""
+"""Logging API routes for PromptManager."""

 import os
-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(
@@ -97,41 +85,6 @@ def _validate_log_config(data):
    return clean, None


-def _read_log_bytes(path):
-    """The whole file at ``path``, opened without following a link (blocking).
-
-    The file is checked again through the open handle: a regular file with
-    one name and, when ``path`` carries it, the inode it was listed with. A
-    name swapped for a link or another file after it was listed, or a hard
-    link to a file elsewhere, is refused as missing. The handle is closed
-    before this returns.
-    """
-    flags = os.O_RDONLY | getattr(os, "O_BINARY", 0) | getattr(os, "O_NOFOLLOW", 0)
-    # A FIFO swapped in after the listing must not block the executor thread.
-    flags |= getattr(os, "O_NONBLOCK", 0)
-    try:
-        fd = os.open(str(path), flags)
-    except OSError as error:
-        if getattr(os, "O_NOFOLLOW", 0) and os.path.islink(str(path)):
-            raise FileNotFoundError("Log file not found") from error
-        raise
-    listed_ino = getattr(path, "listed_ino", 0)
-    with os.fdopen(fd, "rb") as handle:
-        opened = os.fstat(handle.fileno())
-        if (
-            not stat.S_ISREG(opened.st_mode)
-            or opened.st_nlink > 1  # a hard link to a file elsewhere
-            or (listed_ino and opened.st_ino and opened.st_ino != listed_ino)
-        ):
-            raise FileNotFoundError("Log file not found")
-        return handle.read()
-
-
-def _download(logger_manager, filename):
-    """``bytes`` of a downloadable log file; FileNotFoundError otherwise."""
-    return _read_log_bytes(logger_manager.log_file_entry(filename))
-
-
 class LoggingRoutesMixin:
    """Mixin providing logging-related API endpoints."""

@@ -242,16 +195,16 @@ class LoggingRoutesMixin:
                    {"success": False, "error": "Invalid filename"}, status=400
                )

-            try:
-                file_content = await self._run_in_executor(
-                    _download, logger_manager, filename
-                )
-            except FileNotFoundError:
-                # Missing, a link, a folder or not listed: all read as absent.
+            log_file_path = logger_manager.log_dir / filename
+
+            if not log_file_path.exists():
                return web.json_response(
                    {"success": False, "error": "Log file not found"}, status=404
                )

+            with open(log_file_path, "rb") as f:
+                file_content = f.read()
+
            return web.Response(
                body=file_content,
                content_type="text/plain",
@@ -268,43 +221,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 = logger_manager.truncate_logs()

            return web.json_response(
                {
@@ -346,7 +266,7 @@ class LoggingRoutesMixin:
                return web.json_response({"success": False, "error": error}, status=400)

            logger_manager = self._get_logger_manager()
-            await self._run_in_executor(logger_manager.update_config, clean)
+            logger_manager.update_config(clean)

            return web.json_response(
                {
@@ -194,13 +194,8 @@ class LoraImportRoutesMixin:
            return False

    async def replace_lora_imports(self, db, staged, *, expected_ids, allow_empty):
-        """Swap the collection for ``staged.records`` in one transaction.
-
-        Then the image routes' layout cache is dropped (#362): the import may
-        have linked files under a folder LoraManager created after the cache
-        stored its layout (its first example-image download creates one).
-        """
-        result = await self._run_in_executor(
+        """Swap the collection for ``staged.records`` in one transaction."""
+        return await self._run_in_executor(
            lambda: db.replace_category_prompts(
                CATEGORY,
                staged.records,
@@ -208,8 +203,6 @@ class LoraImportRoutesMixin:
                allow_empty=allow_empty,
            )
        )
-        lora_utils.clear_layout_cache()
-        return result

    # ── preview ───────────────────────────────────────────────────────

@@ -2,9 +2,7 @@

 ``POST /prompt_manager/maintenance/preview {operation, options:{}}`` reviews
 one operation (``duplicate_prompts``, ``optimize``, ``unused_components`` or
-``missing_links``; ``database/maintenance.py``; ``duplicate_files``,
-``py/api/duplicate_files.py``; ``rotated_logs``, the rotated log copies,
-``py/api/log_cleanup.py``, which has its own apply job) off the event loop and
+``missing_links``; ``database/maintenance.py``) off the event loop and
 answers a ``Plan``: ``{success, token, operation, expires_at, scope:{count,
 label}, protected:{count, reasons}, backup:{policy, destination_label},
 media:{deletes_files, label}, details:[≤50 {label, detail}]}``. The preview
@@ -56,7 +54,6 @@ from aiohttp import web
 from .admin import _prune_safety_backups, _scan_location, _scan_roots
 from .job_routes import busy_response
 from .jobs import MAINTENANCE_JOB_KIND, JobBusy
-from .log_cleanup import ROTATED_LOGS
 from .maintenance_plans import PlanExpired, PlanUsed, ScopeTooLarge

 try:
@@ -86,8 +83,7 @@ MAINTENANCE_PREVIEW_LEASE = "Maintenance preview"
 DUPLICATE_PREVIEW_BODY_MAX = 1024 * 1024
 DUPLICATE_FILES = "duplicate_files"
 WORKFLOW_STORAGE = "workflow_storage"  # applied by py/api/workflow_storage.py
-# rotated_logs (#329, py/api/log_cleanup.py) reviews log files, not records.
-PREVIEW_OPERATIONS = MAINTENANCE_OPERATIONS + (DUPLICATE_FILES, ROTATED_LOGS)
+PREVIEW_OPERATIONS = MAINTENANCE_OPERATIONS + (DUPLICATE_FILES,)
 # Room left over beyond what a step writes, so a disk is never filled to 0.
 DISK_MARGIN_BYTES = 16 * 2**20
 # The concept's Maintenance row titles, which name each operation's job.
@@ -395,8 +391,6 @@ class MaintenanceRoutesMixin:
            return await self.preview_duplicate_files(options)
        if not isinstance(options, dict) or options:
            return _invalid(f"{operation} takes no options")
-        if operation == ROTATED_LOGS:
-            return await self.preview_log_cleanup()
        db = self.db
        identity = self._database_identity(db)
        try:
@@ -498,17 +492,6 @@ class MaintenanceRoutesMixin:
        if refused is not None:
            return refused
        store = self._maintenance_plans
-        if plan.operation == ROTATED_LOGS:
-            # Log files only: no database identity, backup or disk check.
-            try:
-                job = self._start_log_cleanup(plan)
-            except JobBusy as busy:
-                return busy_response(busy)  # the token stays usable
-            # Same loop turn as the peek and the start: the runner has not run.
-            store.consume(token, plan.operation, job_id=job.id)
-            return web.json_response(
-                {"success": True, "job": job.summary()}, status=202
-            )
        db = self.db
        if plan.db_identity != self._database_identity(db):
            store.discard(token)
@@ -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
@@ -8,10 +8,8 @@ import sqlite3
 from aiohttp import web

 try:
-    from ...database.library_commands import LibraryCommandError
    from ...database.pairs import PairDependencyError
 except ImportError:
-    from database.library_commands import LibraryCommandError
    from database.pairs import PairDependencyError
 from urllib.parse import quote

@@ -1130,14 +1128,7 @@ class PromptRoutesMixin:
    async def bulk_add_tags(self, request):
        """Bulk add tags to prompts."""
        try:
-            try:
-                data = await request.json()
-            except ValueError:
-                return bad_request("Invalid JSON body")
-            if not isinstance(data, dict):
-                return bad_request("Expected a JSON object")
-            if "expected_epoch" in data:
-                return await self._bulk_library_tags(data)
+            data = await request.json()
            prompt_ids = data.get("prompt_ids", [])
            new_tags = data.get("tags", [])

@@ -1187,10 +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 "expected_epoch" in data:
-                return await self._bulk_library_category(data)
            if not data.get("prompt_ids"):
                return web.json_response(
                    {"success": False, "error": "No prompt IDs provided"}, status=400
@@ -1227,118 +1214,6 @@ class PromptRoutesMixin:
                status=500,
            )

-    async def _bulk_library_tags(self, data: dict) -> web.Response:
-        """The workspace Library's fenced form (#442).
-
-        ``{prompt_ids, tags, expected_epoch}``: prompt tags only, never image tags.
-        """
-        return await self._fenced_library_write(
-            data, "tags", self.db.bulk_add_library_tags
-        )
-
-    async def _fenced_library_write(
-        self, data: dict, field: str, write
-    ) -> web.Response:
-        """One fenced Library bulk write: exact keys, checked ids, 409 on a restore."""
-        fields = {"prompt_ids", field, "expected_epoch"}
-        if set(data) != fields:
-            return bad_request(
-                "Request must contain exactly " + ", ".join(sorted(fields))
-            )
-        try:
-            prompt_ids = parse_bulk_prompt_ids(data["prompt_ids"])
-            result = await self._run_in_executor(
-                write, prompt_ids, data[field], expected_epoch=data["expected_epoch"]
-            )
-        except LibraryCommandError as exc:
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": exc.code,
-                    "library_epoch": exc.epoch,
-                    "error": "Prompt storage was restored; refresh the library",
-                },
-                status=409,
-            )
-        except ValueError as exc:
-            return bad_request(str(exc))
-        return web.json_response({"success": True, **result})
-
-    async def _bulk_library_category(self, data: dict) -> web.Response:
-        """The workspace Library's fenced form (#437).
-
-        ``{prompt_ids, category, expected_epoch}``: a non-blank category on
-        the selected Library parents, refused with 409 ``storage-changed``
-        when prompt storage was restored since the page read its epoch.
-        """
-        return await self._fenced_library_write(
-            data, "category", self.db.bulk_set_library_category
-        )
-
-    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,
-            CollectionMissing,
-            ListingSourceChanged,
-            collection_not_found,
-            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 CollectionMissing:
-            return collection_not_found()
-        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
@@ -1,47 +0,0 @@
-"""Revalidated responses for the pages and static files PromptManager serves.
-
-``Cache-Control: no-cache`` lets the browser keep a copy but makes it ask the
-server before every reuse, so a PromptManager update reaches the browser on a
-normal reload (#478). The ETag lets an unchanged file answer 304 without a
-body, which keeps that reload cheap.
-
-The tag hashes the bytes rather than the file's mtime and size: an update can
-keep both (an archive extract, a same-length edit within one clock tick), and
-the handlers read the whole file anyway. It is weak because the gzip
-middleware may send the same content in a different encoding.
-"""
-
-import hashlib
-
-from aiohttp import web
-
-REVALIDATE = "no-cache"
-
-
-def entity_tag(body: bytes) -> str:
-    """Weak ETag for ``body``."""
-    return f'W/"{hashlib.sha256(body).hexdigest()[:32]}"'
-
-
-def etag_matches(if_none_match, etag: str) -> bool:
-    """True when an If-None-Match header names ``etag`` (weak comparison)."""
-    if not if_none_match:
-        return False
-    if if_none_match.strip() == "*":
-        return True
-    opaque = etag.removeprefix("W/")
-    return any(
-        candidate.strip().removeprefix("W/") == opaque
-        for candidate in if_none_match.split(",")
-    )
-
-
-def revalidated_response(request, body: bytes, content_type: str, charset=None):
-    """200 with ``body``, or 304 when the request already holds this version."""
-    etag = entity_tag(body)
-    headers = {"Cache-Control": REVALIDATE, "ETag": etag}
-    if etag_matches(request.headers.get("If-None-Match"), etag):
-        return web.Response(status=304, headers=headers)
-    return web.Response(
-        body=body, content_type=content_type, charset=charset, headers=headers
-    )
@@ -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)
@@ -3,7 +3,7 @@
 The rule (maintainer test of #284/#288): a file is queued only when its
 final outcome is ambiguous and unlinked. The strict resolver must find it
 ``ambiguous``, the scan's legacy fallback (the browser parser,
-``graph_prompt_text``) must not link it, and no saved row may link it
+``_graph_prompt_text``) must not link it, and no saved row may link it
 already. A file the fallback links, an exact pair the ingester stored and an
 already linked file are never queued. Neither is an ambiguous file with
 nothing to choose: fewer than two of its candidates carry a prompt
@@ -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
@@ -8,8 +8,7 @@ is shared with the LoRA integration's save.
 GET also reports the image sources and the monitor (``sources.py``). A save
 that changes the sources runs as a ``source_change`` registry hold, so it is
 refused while a record-changing job (a scan) runs. ``monitoring_enabled``
-takes effect at the next restart; ``save_foreign_runs`` (#247) at once, since
-the monitor reads it for every file. ``POST /prompt_manager/settings/validate-source``
+takes effect at the next restart. ``POST /prompt_manager/settings/validate-source``
 checks one path and writes nothing.
 """

@@ -44,7 +43,6 @@ _SETTINGS_FILE_KEYS = {
    "INFINITE_SCROLL": ("web_ui", "infinite_scroll"),
    "WORKER_THREADS": ("performance", "worker_threads"),
    "MONITORING_ENABLED": ("gallery", "monitoring", "enabled"),
-    "SAVE_FOREIGN_RUNS": ("gallery", "monitoring", "save_foreign_runs"),
    "SAFETY_BACKUP": ("maintenance", "safety_backup"),
    "THUMBNAIL_FORMAT": ("thumbnails", "format"),
    "THUMBNAIL_QUALITY": ("thumbnails", "quality"),
@@ -60,7 +58,7 @@ _SETTINGS_FILE_KEYS = {
 # The thumbnail settings a running Convert outdated job fixes (#317).
 _THUMBNAIL_SETTINGS = ("THUMBNAIL_FORMAT", "THUMBNAIL_QUALITY", "THUMBNAIL_EDGE")
 # Attributes that live on GalleryConfig; the others on PromptManagerConfig.
-_GALLERY_SETTINGS = frozenset({"MONITORING_ENABLED", "SAVE_FOREIGN_RUNS"})
+_GALLERY_SETTINGS = frozenset({"MONITORING_ENABLED"})
 # Attributes that live on AutotagConfig, named without the AUTOTAG_ prefix.
 _AUTOTAG_SETTINGS = frozenset(
    name for name in _SETTINGS_FILE_KEYS if name.startswith("AUTOTAG_")
@@ -175,8 +173,8 @@ def _validate_autotag_settings(data):
        EXISTING_POLICIES,
        MAX_SUGGESTION_LIMIT,
        MODEL_TYPES,
-        validate_saved_threshold,
        validate_template,
+        validate_threshold,
    )

    updates = {}
@@ -200,7 +198,7 @@ def _validate_autotag_settings(data):
    ):
        if key in data:
            try:
-                value = validate_saved_threshold(label, data[key])
+                value = validate_threshold(label, data[key])
            except ValueError as error:
                raise ValueError(f"{error}.") from None
            updates[key.upper()] = value
@@ -266,7 +264,6 @@ class SettingsRoutesMixin:
                    "thumbnail_encoders": encoders,
                    "settings": {
                        "monitoring_enabled": GalleryConfig.MONITORING_ENABLED,
-                        "save_foreign_runs": GalleryConfig.SAVE_FOREIGN_RUNS,
                        "result_timeout": PromptManagerConfig.RESULT_TIMEOUT,
                        "webui_display_mode": PromptManagerConfig.WEBUI_DISPLAY_MODE,
                        "infinite_scroll": PromptManagerConfig.INFINITE_SCROLL,
@@ -629,10 +626,6 @@ class SettingsRoutesMixin:
            if not isinstance(data["monitoring_enabled"], bool):
                raise ValueError("monitoring_enabled must be true or false")
            updates["MONITORING_ENABLED"] = data["monitoring_enabled"]
-        if "save_foreign_runs" in data:
-            if not isinstance(data["save_foreign_runs"], bool):
-                raise ValueError("save_foreign_runs must be true or false")
-            updates["SAVE_FOREIGN_RUNS"] = data["save_foreign_runs"]
        if "safety_backup" in data:
            if not isinstance(data["safety_backup"], bool):
                raise ValueError("safety_backup must be true or false")
@@ -1,100 +0,0 @@
-"""Where a stale Images target is now (#430): ``POST /prompt_manager/images/rescope``.
-
-A page addresses a listed file as ``{root_index, root_scope, path}``. When the
-sources are renumbered its scope no longer names the root at that index, and
-every per-file action answers 409 ``source-changed``. Before it gives up, the
-page asks here. The target is mapped only when its scope is, at its old
-index, the scope of one of the current roots: the server issued that scope
-for exactly that folder, so the answer (the file's current listing
-descriptor) names nothing the page could not already address. A removed or
-replaced root, a scope of another key and a foreign scope stay refused.
-
-Only the Images roots (``_get_all_output_dirs``) are mapped; a LoRA-linked
-root's target is never re-scoped here.
-"""
-
-import hmac
-from pathlib import Path
-
-from aiohttp import web
-
-from .images import (
-    _forbidden,
-    _is_thumbnail_cache_path,
-    _json_body_or_error,
-    _media_access_error,
-)
-from .media_target import media_target
-from .prompts import bad_request
-
-# Far above any real source count; keeps the index out of huge-int territory.
-MAX_ROOT_INDEX = 4095
-SOURCE_GONE = (
-    "The source of this image changed or was removed. Refresh the image "
-    "collection to find it again."
-)
-
-
-def _coded(status: int, code: str, message: str) -> web.Response:
-    return web.json_response(
-        {"success": False, "code": code, "error": message}, status=status
-    )
-
-
-def _no_store(response: web.Response) -> web.Response:
-    response.headers["Cache-Control"] = "no-store"
-    return response
-
-
-class SourceRescopeMixin:
-    """The rescope route; composed into ``PromptManagerAPI``."""
-
-    def _register_rescope_routes(self, routes):
-        @routes.post("/prompt_manager/images/rescope")
-        async def rescope_route(request):
-            return _no_store(await self.rescope_image(request))
-
-    def _current_root_for(self, scope: str, old_index: int, roots: list) -> int | None:
-        """The index of the first current root *scope* was issued for at *old_index*."""
-        for index, root in enumerate(roots):
-            if hmac.compare_digest(scope, self._gallery_root_scope(root, old_index)):
-                return index
-        return None
-
-    def _rescope_blocking(self, scope: str, old_index: int, relative: str):
-        """The answer to one rescope (blocking: it resolves paths)."""
-        roots = list(self._get_all_output_dirs())
-        index = self._current_root_for(scope, old_index, roots)
-        if index is None:
-            return _coded(409, "source-changed", SOURCE_GONE)
-        root = Path(roots[index])
-        path = root / relative
-        denied = _media_access_error(path, [root])
-        if denied is not None:
-            return denied
-        try:
-            mtime = path.stat().st_mtime if path.is_file() else None
-        except OSError:
-            mtime = None
-        if mtime is None:
-            return _coded(404, "file-missing", "Image file not found")
-        [image] = self._format_workspace_page([(path, mtime, root, index)])
-        return web.json_response({"success": True, "image": image})
-
-    async def rescope_image(self, request) -> web.Response:
-        data, error = await _json_body_or_error(request)
-        if error is not None:
-            return error
-        if set(data) != {"target"}:
-            return bad_request("Send exactly one target")
-        target, error = media_target(data["target"])
-        if error is not None:
-            return error
-        old_index, scope, relative = target
-        if old_index > MAX_ROOT_INDEX:
-            return bad_request("Invalid gallery root")
-        if _is_thumbnail_cache_path(relative):
-            return _forbidden("Previews are not re-scoped; use the original")
-        return await self._run_in_executor(
-            self._rescope_blocking, scope, old_index, relative
-        )
@@ -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:
@@ -507,16 +488,10 @@ class AutoThumbnailer:
                f"Automatic preview failed for {src.name}", exc_info=True
            )

-    def close(self, timeout=None):
+    def close(self):
        """Stop the worker at its next file boundary (queued files are
-        dropped), kill a running ffmpeg and wait up to ``timeout`` seconds
-        (None: CLOSE_WAIT_SECONDS, read now); a worker still running after
-        that is logged.
-
-        Returns True when there was no worker or it ended; False when it is
-        still running, or when called on the worker itself (it only signals).
-        """
-        wait = CLOSE_WAIT_SECONDS if timeout is None else timeout
+        dropped), kill a running ffmpeg and wait up to CLOSE_WAIT_SECONDS;
+        a worker still running after that is logged."""
        with self._changed:
            self._closed = True
            self._queue.clear()
@@ -529,18 +504,14 @@ class AutoThumbnailer:
                process.kill()
            except OSError:
                pass
-        if worker is None:
-            return True
-        if worker is threading.current_thread():
-            return False
-        worker.join(wait)
+        if worker is None or worker is threading.current_thread():
+            return
+        worker.join(CLOSE_WAIT_SECONDS)
        if worker.is_alive():
            self._logger.warning(
                "The automatic preview worker is still running after "
-                f"{wait} s; it stops at its next file"
+                f"{CLOSE_WAIT_SECONDS} s; it stops at its next file"
            )
-            return False
-        return True

    # ── waits (tests and shutdown; never timers) ──────────────────────

@@ -638,19 +609,12 @@ class AutoThumbnailMixin:
                )
            return self._auto_thumbnailer

-    def refuse_auto_thumbnails(self):
-        """Refuse every later capture without stopping the worker yet (the
-        package teardown, before ``close_auto_thumbnails(final=True)``)."""
-        with AutoThumbnailMixin._auto_thumbnailer_lock:
-            self._auto_thumbnails_shut = True
-
-    def close_auto_thumbnails(self, final=False, timeout=None):
+    def close_auto_thumbnails(self, final=False):
        """Stop the capture worker and the view pool, and forget them.

-        Bounded by ``timeout`` (see AutoThumbnailer.close). ``final`` (the
-        package teardown) also keeps a late monitor event from starting a
-        worker again; a test reset passes False and the next use starts
-        fresh ones. Returns True when no capture worker is left running.
+        Bounded (see AutoThumbnailer.close). ``final`` (the app's cleanup)
+        also keeps a late monitor event from starting a worker again; a
+        test reset passes False and the next use starts fresh ones.
        """
        with AutoThumbnailMixin._auto_thumbnailer_lock:
            if final:
@@ -658,14 +622,12 @@ class AutoThumbnailMixin:
            thumbnailer, self._auto_thumbnailer = self._auto_thumbnailer, None
            pool, self._preview_pool_obj = self._preview_pool_obj, None
            self._preview_gate_obj = None
-        closed = True
        if thumbnailer is not None:
-            closed = thumbnailer.close(timeout)
+            thumbnailer.close()
        if pool is not None:
            pool.shutdown(wait=False, cancel_futures=True)
        if final:
            shutdown_encoders()  # kill JPEG XL / ffmpeg encoders still running
-        return closed

    def _auto_thumbnail_failures(self):
        thumbnailer = self._auto_thumbnailer
@@ -809,8 +771,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"
@@ -61,25 +61,18 @@ class VocabularyRoutesMixin:
        )

    async def _vocabulary_page(
-        self,
-        request: web.Request,
-        kind: str,
-        reader_name: str,
-        name: bool,
-        options: dict | None = None,
+        self, request: web.Request, kind: str, reader_name: str, name: bool
    ) -> web.Response:
        limit = _vocabulary_limit(request)
        cursor = request.query.get("cursor")
-        options = options or {}

        def read() -> dict:
            # The snapshot stays open while the cursor is decoded and encoded,
-            # so its epoch scope is the epoch the page was read from. A tag
-            # search or sort joins the scope: its cursor fits no other order.
+            # so its epoch scope is the epoch the page was read from.
            with self.db.library_snapshot() as (conn, epoch, _ceiling):
-                scope = _scope({"kind": kind, "epoch": epoch, **options})
+                scope = _scope({"kind": kind, "epoch": epoch})
                result = getattr(self.db, reader_name)(
-                    conn, epoch, limit=limit, after=_decode(cursor, scope), **options
+                    conn, epoch, limit=limit, after=_decode(cursor, scope)
                )
                result["next_cursor"] = _encode(
                    result.pop("next_key"), scope, name=name
@@ -91,14 +84,8 @@ class VocabularyRoutesMixin:

    @pair_response
    async def list_vocabulary_tags(self, request: web.Request) -> web.Response:
-        options = {
-            "search": request.query.get("search", "").strip(),
-            "sort": request.query.get("sort", "created"),
-        }
-        # Name keys are text: kept server side so the cursor stays small.
-        name = options["sort"].startswith("name")
        return await self._vocabulary_page(
-            request, "vocabulary-tags", "_vocabulary_tags", name, options
+            request, "vocabulary-tags", "_vocabulary_tags", False
        )

    @pair_response
@@ -7,8 +7,6 @@ Refactored from standalone_tagger.py for integration with PromptManager API.

 import errno
 import gc
-import importlib.util
-import inspect
 import os
 import sys
 from pathlib import Path
@@ -34,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."""
@@ -156,91 +106,6 @@ MODELS = {
    },
 }

-# The Python modules each backend imports when it loads, with their pip names
-# (#424). None of them is a PromptManager requirement: they are optional, and
-# llama-cpp-python needs a build for the user's GPU. Nothing is ever installed.
-BACKEND_PACKAGES: Dict[str, Tuple[Tuple[str, str], ...]] = {
-    "gguf": (("llama_cpp", "llama-cpp-python"),),
-    # The default 8-bit load needs bitsandbytes, and device_map needs accelerate.
-    "hf": (
-        ("torch", "torch"),
-        ("transformers", "transformers"),
-        ("accelerate", "accelerate"),
-        ("bitsandbytes", "bitsandbytes"),
-    ),
-    "wd14-swinv2": (("onnxruntime", "onnxruntime"),),
-    "wd14-vit": (("onnxruntime", "onnxruntime"),),
-}
-_INSTALL_NOTES = {
-    "gguf": (
-        'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python'
-    ),
-    "wd14-swinv2": "Use onnxruntime-gpu for CUDA.",
-    "wd14-vit": "Use onnxruntime-gpu for CUDA.",
-}
-_PIP_NAMES = {
-    module: pip for packages in BACKEND_PACKAGES.values() for module, pip in packages
-}
-
-
-def _importable(module: str) -> bool:
-    """Whether *module* (a top-level name) can be imported; imports nothing."""
-    if sys.modules.get(module) is not None:
-        return True
-    try:
-        return importlib.util.find_spec(module) is not None
-    except (ImportError, ValueError, OSError):
-        return False
-
-
-def missing_packages(model_type: str) -> List[str]:
-    """The pip names of the packages *model_type* needs and cannot import."""
-    return [
-        pip
-        for module, pip in BACKEND_PACKAGES.get(model_type, ())
-        if not _importable(module)
-    ]
-
-
-def package_fields(model_type: str, missing: List[str]) -> Dict[str, Any]:
-    """The status fields of *missing*: pip names, install command and note."""
-    missing = list(missing)
-    return {
-        "missing_packages": missing,
-        "install_command": "pip install " + " ".join(missing) if missing else None,
-        "install_note": _INSTALL_NOTES.get(model_type) if missing else None,
-    }
-
-
-def _joined(names: List[str]) -> str:
-    if len(names) <= 1:
-        return "".join(names)
-    return ", ".join(names[:-1]) + " and " + names[-1]
-
-
-def missing_packages_message(model_type: str, missing: List[str]) -> str:
-    """The one sentence every refusal of a model with missing packages uses."""
-    label = MODELS.get(model_type, {}).get("label", model_type)
-    fields = package_fields(model_type, missing)
-    pronoun = "it" if len(missing) == 1 else "them"
-    message = (
-        f"{label} needs {_joined(missing)}. Install {pronoun} into ComfyUI's "
-        f"Python: {fields['install_command']}."
-    )
-    if fields["install_note"]:
-        message += " " + fields["install_note"]
-    return message
-
-
-class MissingBackendPackages(RuntimeError):
-    """A model whose backend packages cannot be imported (#424)."""
-
-    def __init__(self, model_type: str, missing: List[str]):
-        self.model_type = model_type
-        self.missing = list(missing)
-        super().__init__(missing_packages_message(model_type, self.missing))
-
-
 # Default prompts
 DEFAULT_PROMPT = DEFAULT_TAG_TEMPLATE

@@ -253,10 +118,6 @@ SYSTEM_PROMPT = (
 )


-def _none(_model_type: str) -> List[str]:
-    return []
-
-
 def _load_rgb(image_path: str) -> Image.Image:
    """Decode the image as RGB and close the file before inference.

@@ -293,7 +154,6 @@ class AutoTagService:
        self,
        models_dir: Optional[Path] = None,
        model_loader: Optional[ModelLoader] = None,
-        package_probe: Optional[Callable[[str], List[str]]] = None,
    ):
        """Initialize the AutoTag service.

@@ -304,16 +164,9 @@ class AutoTagService:
                       ``(kind, backend)`` tuple used by ``generate_tags``.
                       Defaults to ``_load_model``, which imports the ML
                       backends lazily. Tests inject a fake here.
-            package_probe: Callable ``(model_type)`` returning the pip names
-                       of the backend packages that cannot be imported.
-                       Defaults to ``missing_packages`` with the default
-                       loader; an injected loader brings its own backend.
        """
        self.logger = get_logger("autotag.service")
        self._model_loader: ModelLoader = model_loader or self._load_model
-        if package_probe is None:
-            package_probe = missing_packages if model_loader is None else _none
-        self._package_probe = package_probe

        # Determine models directory
        if models_dir:
@@ -418,9 +271,6 @@ class AutoTagService:
                    # Get the actual path (local or cache)
                    model_status["model_path"] = str(self._get_hf_model_path())

-            model_status.update(
-                package_fields(model_type, self._package_probe(model_type))
-            )
            status[model_type] = model_status

        return status
@@ -547,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:
@@ -556,9 +405,13 @@ class AutoTagService:

    def _load_wd14_tagger(self, model_type: str, use_gpu: bool = True):
        """Load WD14 ONNX model and tag list."""
-        # A missing onnxruntime is refused by load_model before this runs
-        # (#424); a ModuleNotFoundError here becomes the same refusal.
-        import onnxruntime as ort
+        try:
+            import onnxruntime as ort
+        except ImportError:
+            raise RuntimeError(
+                "onnxruntime is required for WD14 models. "
+                "Install with: pip install onnxruntime (or onnxruntime-gpu for CUDA)"
+            )
        import csv

        config = MODELS[model_type]
@@ -688,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)
@@ -724,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")

@@ -742,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")

@@ -769,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")

@@ -791,7 +634,6 @@ class AutoTagService:
        Raises:
            ValueError: If model_type is invalid
            RuntimeError: If model not downloaded or loading fails
-            MissingBackendPackages: If its backend packages cannot be imported
        """
        if model_type not in MODELS:
            raise ValueError(f"Invalid model type: {model_type}")
@@ -803,11 +645,6 @@ class AutoTagService:
        status = self.get_models_status()
        if not status[model_type]["downloaded"]:
            raise RuntimeError(f"Model {model_type} not downloaded")
-        missing = status[model_type].get("missing_packages") or []
-        if missing:
-            refusal = MissingBackendPackages(model_type, missing)
-            self.logger.warning(str(refusal))
-            raise refusal

        try:
            self._tagger = self._model_loader(model_type, use_gpu)
@@ -815,17 +652,6 @@ class AutoTagService:
            self.logger.info(f"Model {model_type} loaded successfully")
            return True

-        except ModuleNotFoundError as e:
-            # A package find_spec found but that does not import (a broken
-            # install), or a dependency of one: the same refusal, no traceback.
-            self._tagger = None
-            self._current_model_type = None
-            module = (e.name or "").split(".")[0] or str(e)
-            refusal = MissingBackendPackages(
-                model_type, [_PIP_NAMES.get(module, module)]
-            )
-            self.logger.warning(str(refusal))
-            raise refusal from None
        except Exception as e:
            self.logger.error(f"Failed to load model {model_type}: {e}")
            self._tagger = None
@@ -930,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
@@ -194,8 +194,6 @@ class GalleryConfig:

    Attributes:
        MONITORING_ENABLED (bool): Enable/disable automatic image monitoring
-        SAVE_FOREIGN_RUNS (bool): The monitor stores the certain prompt of an
-            output whose workflow has no PromptManager node (#247)
        MONITORING_DIRECTORIES (List[str]): Directories to monitor for new images
        SUPPORTED_EXTENSIONS (List[str]): Image file extensions to process
        PROCESSING_DELAY (float): Delay in seconds before processing new files
@@ -212,8 +210,6 @@ class GalleryConfig:

    # Image monitoring settings
    MONITORING_ENABLED = True
-    # Read by the monitor for every file, so a save applies without a restart
-    SAVE_FOREIGN_RUNS = True
    MONITORING_DIRECTORIES = []  # Auto-detect if empty
    SUPPORTED_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp", ".gif"]
    PROCESSING_DELAY = 2.0  # Seconds to wait before processing new files
@@ -255,7 +251,6 @@ class GalleryConfig:
        return {
            "monitoring": {
                "enabled": cls.MONITORING_ENABLED,
-                "save_foreign_runs": cls.SAVE_FOREIGN_RUNS,
                "directories": cls.MONITORING_DIRECTORIES,
                "extensions": cls.SUPPORTED_EXTENSIONS,
                "processing_delay": cls.PROCESSING_DELAY,
@@ -308,14 +303,6 @@ class GalleryConfig:
                config_logger.warning(
                    "Ignoring gallery monitoring enabled: expected true or false"
                )
-        if "save_foreign_runs" in monitoring:
-            if isinstance(monitoring["save_foreign_runs"], bool):
-                cls.SAVE_FOREIGN_RUNS = monitoring["save_foreign_runs"]
-            else:
-                config_logger.warning(
-                    "Ignoring gallery monitoring save_foreign_runs: expected true "
-                    "or false"
-                )
        if "directories" in monitoring:
            directories = cls._validated_directories(monitoring["directories"])
            if directories is not None:
@@ -586,7 +573,6 @@ try:
        MAX_INSTRUCTION_CHARS,
        MODEL_TYPES,
        WD14_MODEL_TYPES,
-        validate_saved_threshold,
        validate_template,
        validate_threshold,
    )
@@ -599,7 +585,6 @@ except ImportError:
        MAX_INSTRUCTION_CHARS,
        MODEL_TYPES,
        WD14_MODEL_TYPES,
-        validate_saved_threshold,
        validate_template,
        validate_threshold,
    )
@@ -646,12 +631,12 @@ class AutotagConfig:
        "existing": ("EXISTING", _valid_existing, "skip"),
        "general_threshold": (
            "GENERAL_THRESHOLD",
-            lambda v: validate_saved_threshold("value", v),
+            lambda v: validate_threshold("value", v),
            0.35,
        ),
        "character_threshold": (
            "CHARACTER_THRESHOLD",
-            lambda v: validate_saved_threshold("value", v),
+            lambda v: validate_threshold("value", v),
            0.85,
        ),
        "template": ("TEMPLATE", validate_template, DEFAULT_TAG_TEMPLATE),
@@ -12,10 +12,9 @@ last writes to the database:
   the sidecars (``discover``). In ``alongside`` mode a sidecar beside its
   model is kept when ``<base>.safetensors`` exists; in ``centralized`` mode
   every sidecar under the sidecar root is kept when its ``file_path`` names
-   a model inside a LoRA root. ``fingerprint`` covers every scanned sidecar,
-   kept or skipped (path, size, modification time, kept or not, #362) and the
-   layout; ``preview`` adds the counts a review shows. Nothing is written
-   and nothing is requested.
+   a model inside a LoRA root. ``fingerprint`` covers the kept sidecars (path,
+   size and modification time) and the layout; ``preview`` adds the counts a
+   review shows. Nothing is written and nothing is requested.
 2. **stage**: read each sidecar and build its record. Its LoraManager preview
   and example images are linked where they are (``local_media``); only a
   LoRA without any local image downloads its CivitAI example images into the
@@ -44,10 +43,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"
@@ -72,10 +69,9 @@ def discover(lora_manager_path: Optional[str]) -> Discovery:


 def fingerprint(discovery: Discovery) -> str:
-    """What a review saw: the layout, then every scanned sidecar, kept or
-    skipped, with its path, size, modification time and whether it was kept
-    (#362). A LoraManager save that changes unrelated settings leaves it as
-    it was."""
+    """What a review saw: the layout, then each kept sidecar's path, size and
+    modification time (a LoraManager save that changes unrelated settings
+    leaves it as it was)."""
    layout = discovery.layout
    digest = hashlib.sha256()
    for value in (
@@ -91,14 +87,13 @@ def fingerprint(discovery: Discovery) -> str:
        digest.update(f"{value}\n".encode("utf-8", "surrogatepass"))
    for name in discovery.unreadable:
        digest.update(f"unreadable\0{name}\n".encode("utf-8", "surrogatepass"))
-    kept = {str(sidecar.metadata_path) for sidecar in discovery.sidecars}
-    for path in discovery.scanned_files:
-        flag = 1 if str(path) in kept else 0
+    for sidecar in discovery.sidecars:
+        path = sidecar.metadata_path
        try:
            stat = path.stat()
-            entry = f"{path}\0{stat.st_size}\0{stat.st_mtime_ns}\0{flag}\n"
+            entry = f"{path}\0{stat.st_size}\0{stat.st_mtime_ns}\n"
        except OSError:
-            entry = f"{path}\0missing\0{flag}\n"
+            entry = f"{path}\0missing\n"
        digest.update(entry.encode("utf-8", "surrogatepass"))
    return "sha256:" + digest.hexdigest()

@@ -191,15 +186,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
@@ -1,217 +0,0 @@
-"""A per-process cache of LoraManager's layout for the image hot paths (#362).
-
-Every Library list, prompt detail, inspect, reveal and serve request needs the
-LoRA allow-list (``ImagesMixin._lora_image_dirs``). Building it means finding
-the LoraManager install, reading its plugin settings file and its settings
-file, and resolving every folder. ``LayoutCache`` keeps the last result and
-reuses it while all of these hold:
-
- the key (the configured install path, stripped) and the home folder the
-  folder guard compares against are the same;
- the entry is younger than ``MAX_AGE_SECONDS`` (monotonic clock);
- the plugin settings file and the settings file have the same signature
-  (``st_mtime_ns``, ``st_size``, or ``MISSING``) as when it was stored;
- the install and every stored media root still resolve to themselves (a
-  folder swapped for a symlink reloads, so the folder guard runs again).
-
-A result is stored only when no watched file is "racy" (modified within
-``RACY_SECONDS`` of the load, git's rule for racily clean index entries),
-every watched file could be checked, the settings file was readable, and no
-``clear()`` ran during the load. What each rule covers: signatures catch a
-settings change on the next request; the racy rule catches a write during the
-load, a half-written file and coarse timestamps; the maximum age bounds the
-inputs no signature sees (``extra_model_paths.yaml``, environment, temporary
-failures); ``clear()`` makes a finished import's new folders servable at once.
-
-Hits and loads take no lock: a slow ``os.stat`` on a network share holds up
-only its own request, and two threads that miss together both load (both
-loads only read). A short lock guards the compare-and-store and the logging
-state; no file I/O runs under it. Standard library only, so it is tested
-without ComfyUI or LoraManager.
-"""
-
-import logging
-import os
-import threading
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Callable, Optional, Tuple
-
-from .lora_manager_layout import UNREADABLE, LoraManagerLayout, _canonical
-
-# A watched file modified this recently is not trusted: LoraManager writes its
-# settings in place, and FAT/exFAT store modification times in 2 s steps.
-RACY_SECONDS = 3
-# Bounds what no signature sees (unwatched inputs, temporary failures).
-MAX_AGE_SECONDS = 30
-
-# The signature of a watched file that does not exist (a valid state).
-MISSING = object()
-# ERROR_BAD_NETPATH and ERROR_BAD_NET_NAME, which Windows raises as
-# FileNotFoundError.
-_OFFLINE_SHARE_ERRORS = frozenset({53, 67})
-
-logger = logging.getLogger("prompt_manager.lora_layout_cache")
-
-
-@dataclass(frozen=True)
-class _Entry:
-    key: str
-    home: str
-    install: Optional[str]
-    layout: LoraManagerLayout
-    signatures: Tuple[Tuple[str, object], ...]
-    stored_at: float
-
-
-class _CannotValidate(Exception):
-    """A watched file could not be checked (not merely missing)."""
-
-
-class LayoutCache:
-    """At most one ``(install, layout)`` for the active LoraManager config."""
-
-    def __init__(
-        self,
-        resolve: Callable[[str], Optional[str]],
-        load: Callable[[Optional[str]], LoraManagerLayout],
-        *,
-        wall_ns: Callable[[], int] = time.time_ns,
-        monotonic: Callable[[], float] = time.monotonic,
-        stat=os.stat,
-        pathmod=os.path,
-        home: Callable[[], str] = lambda: str(Path.home()),
-    ):
-        self._resolve = resolve
-        self._load = load
-        self._wall_ns = wall_ns
-        self._monotonic = monotonic
-        self._stat = stat
-        self._pathmod = pathmod
-        self._home = home
-        self._entry: Optional[_Entry] = None
-        self._generation = 0
-        self._lock = threading.Lock()
-        # What was last logged; survives clear() so a reload of the same
-        # layout stays quiet.
-        self._logged_layout: Optional[LoraManagerLayout] = None
-        self._logged_refused: Tuple[str, ...] = ()
-
-    def get(self, configured: str) -> Tuple[Optional[str], LoraManagerLayout]:
-        """``(install, layout)`` for the configured path ("" auto-detects)."""
-        key = (configured or "").strip()
-        home = self._home()
-        entry = self._entry
-        if entry is not None and self._valid(entry, key, home):
-            return entry.install, entry.layout
-        with self._lock:
-            if entry is not None and self._entry is entry:
-                self._entry = None
-            generation = self._generation
-        install = self._resolve(key)
-        layout = self._load(install)
-        self._log_refused(layout)
-        try:
-            signatures = tuple(
-                (path, self._signature(path)) for path in self._watched(install, layout)
-            )
-        except _CannotValidate:
-            return install, layout
-        if layout.error == UNREADABLE or self._racy(signatures, self._wall_ns()):
-            return install, layout
-        stored = _Entry(key, home, install, layout, signatures, self._monotonic())
-        changed = False
-        with self._lock:
-            if self._generation == generation:
-                self._entry = stored
-                changed = layout != self._logged_layout
-                if changed:
-                    self._logged_layout = layout
-        if changed:
-            logger.info(
-                f"LoraManager layout changed: {layout.source or 'no'} settings, "
-                f"{layout.mode} storage, {len(layout.media_roots)} media folders"
-            )
-        return install, layout
-
-    def clear(self) -> None:
-        """Drop the entry; a load that started before this stores nothing."""
-        with self._lock:
-            self._entry = None
-            self._generation += 1
-
-    def _log_refused(self, layout: LoraManagerLayout) -> None:
-        """One warning per default LoRA folder newly refused by the guard."""
-        refused = tuple(layout.refused_defaults)
-        with self._lock:
-            if refused == self._logged_refused:
-                return
-            new = [folder for folder in refused if folder not in self._logged_refused]
-            self._logged_refused = refused
-        for folder in new:
-            logger.warning(
-                f"ComfyUI LoRA folder '{folder}' is neither scanned nor served: "
-                "it is a filesystem root, the home folder or a folder that "
-                "contains it"
-            )
-
-    # ── validation ──────────────────────────────────────────────────
-
-    def _valid(self, entry: _Entry, key: str, home: str) -> bool:
-        if entry.key != key or entry.home != home:
-            return False
-        if self._monotonic() - entry.stored_at >= MAX_AGE_SECONDS:
-            return False
-        try:
-            for path, signature in entry.signatures:
-                if self._signature(path) != signature:
-                    return False
-        except _CannotValidate:
-            return False
-        folders = entry.layout.media_roots
-        if entry.install is not None:
-            folders = (entry.install,) + tuple(folders)
-        for folder in folders:
-            try:
-                if _canonical(folder, self._pathmod) != folder:
-                    return False
-            except (OSError, ValueError):
-                return False
-        return True
-
-    def _watched(self, install, layout) -> Tuple[str, ...]:
-        """The plugin settings file, then the settings file, each once."""
-        if install is None:
-            return ()
-        paths = [self._pathmod.join(install, "settings.json")]
-        if layout.settings_path is not None:
-            paths.append(str(layout.settings_path))
-        watched, seen = [], set()
-        for path in paths:
-            identity = self._pathmod.normcase(self._pathmod.abspath(path))
-            if identity not in seen:
-                seen.add(identity)
-                watched.append(path)
-        return tuple(watched)
-
-    def _signature(self, path: str):
-        try:
-            result = self._stat(path)
-        except (FileNotFoundError, NotADirectoryError) as error:
-            # Windows reports an offline share as "not found": that is a
-            # temporary failure, not a missing file.
-            if getattr(error, "winerror", None) in _OFFLINE_SHARE_ERRORS:
-                raise _CannotValidate(path) from error
-            return MISSING
-        except (OSError, ValueError) as error:
-            raise _CannotValidate(path) from error
-        return (result.st_mtime_ns, result.st_size)
-
-    @staticmethod
-    def _racy(signatures, now_ns: int) -> bool:
-        threshold = now_ns - RACY_SECONDS * 10**9
-        return any(
-            signature is not MISSING and signature[0] > threshold
-            for _path, signature in signatures
-        )
@@ -12,10 +12,8 @@ server share one definition:
  plugin file, or the user config folder, in LoraManager's order), keeps only
  the seven keys the import needs, and resolves the LoRA roots, the sidecar
  root (centralized storage), the example-images root and the active
-  LoraManager library. Every folder from the settings, and each of
-  ComfyUI's default LoRA folders, passes the folder guard: it must exist and
-  must not be a filesystem root, the home folder or a folder that contains
-  it. Default folders the guard refuses are listed in ``refused_defaults``.
+  LoraManager library. Every folder from the settings passes the folder
+  guard (exists, not a filesystem root, not the home folder itself).
 - ``discover_sidecars`` finds every sidecar whose model file exists inside a
  LoRA root: beside the models in ``alongside`` mode, under the sidecar root
  (matched to its model by ``file_path``) in ``centralized`` mode.
@@ -27,7 +25,6 @@ it is testable outside ComfyUI.
 """

 import json
-import logging
 import os
 import re
 from dataclasses import dataclass, replace
@@ -101,12 +98,7 @@ NOT_OBJECT = "the settings file is not a JSON object"
 TOO_LARGE = "the settings file is larger than 5 MB"
 NO_PLATFORMDIRS = "platformdirs is not available"
 NO_SIDECAR_ROOT = "the sidecar folder does not exist"
-BAD_SIDECAR_ROOT = (
-    "the sidecar folder is a filesystem root, the home folder or a folder "
-    "that contains it"
-)
-
-logger = logging.getLogger("prompt_manager.lora_manager_layout")
+BAD_SIDECAR_ROOT = "the sidecar folder is a filesystem root or the home folder"


@dataclass(frozen=True)
@@ -122,9 +114,6 @@ class LoraManagerLayout:
    example_images_root: Optional[str]
    library: str
    media_roots: Tuple[str, ...]
-    # ComfyUI's default LoRA folders that exist but that the folder guard
-    # refused (canonical): the layout cache logs them (#362).
-    refused_defaults: Tuple[str, ...] = ()


@dataclass(frozen=True)
@@ -137,20 +126,13 @@ class Sidecar:

@dataclass(frozen=True)
 class Discovery:
-    """The sidecars kept, every metadata file seen, and those unread."""
+    """The sidecars kept, how many metadata files were seen, and those unread."""

    layout: LoraManagerLayout
    sidecars: List[Sidecar]
-    # Every ``*.metadata.json`` seen, kept or skipped: resolved, once each,
-    # sorted by ``str(path)``. The import's fingerprint covers all of them.
-    scanned_files: Tuple[Path, ...]
+    scanned: int
    unreadable: List[str]

-    @property
-    def scanned(self) -> int:
-        """How many metadata files were seen."""
-        return len(self.scanned_files)
-

 class _SettingsError(Exception):
    """The settings file cannot be used, for the reason it carries."""
@@ -333,23 +315,6 @@ def _guarded(paths, home: str) -> Tuple[str, ...]:
    return tuple(kept)


-def _refused(paths, home: str) -> Tuple[str, ...]:
-    """The folders in ``paths`` that exist but that the guard refuses."""
-    refused = []
-    for path in paths:
-        absolute = _absolute(path)
-        if not absolute or not os.path.isdir(absolute):
-            continue
-        if _guard_folder(absolute, home) is None:
-            try:
-                canonical = _canonical(absolute)
-            except (OSError, ValueError):
-                continue
-            if canonical not in refused:
-                refused.append(canonical)
-    return tuple(refused)
-
-
 def _example_images_root(
    settings: Mapping, library: str, libraries: int, home: str
 ) -> Optional[str]:
@@ -386,9 +351,7 @@ def load_layout(
    default LoRA roots, so serving and trigger words keep working.
    """
    home = str(Path.home())
-    default_list = list(default_roots())
-    defaults = _guarded(default_list, home)
-    refused_defaults = _refused(default_list, home)
+    defaults = _guarded(default_roots(), home)
    fallback = LoraManagerLayout(
        settings_path=None,
        source=None,
@@ -399,7 +362,6 @@ def load_layout(
        example_images_root=None,
        library="default",
        media_roots=defaults,
-        refused_defaults=refused_defaults,
    )
    if not lora_manager_path:
        return fallback
@@ -415,14 +377,10 @@ def load_layout(
    except _SettingsError as error:
        return replace(fallback, error=str(error))
    settings = _settings_subset(raw or {})
-    return _layout_from_settings(
-        settings, settings_path, source, defaults, home, refused_defaults
-    )
+    return _layout_from_settings(settings, settings_path, source, defaults, home)


-def _layout_from_settings(
-    settings, settings_path, source, defaults, home, refused_defaults=()
-):
+def _layout_from_settings(settings, settings_path, source, defaults, home):
    library, entry, libraries = _active_library(settings)
    lora_roots = _media_roots(
        defaults,
@@ -442,7 +400,6 @@ def _layout_from_settings(
        example_images_root=example_root,
        library=library,
        media_roots=_media_roots(lora_roots, [example_root]),
-        refused_defaults=refused_defaults,
    )
    if mode != MODE_CENTRALIZED:
        return layout
@@ -525,13 +482,13 @@ def discover_sidecars(layout: LoraManagerLayout) -> Discovery:
    cannot see every folder must not replace the collection with part of it.
    """
    if layout.error is not None:
-        return Discovery(layout, [], (), [])
+        return Discovery(layout, [], 0, [])
    if layout.mode == MODE_CENTRALIZED:
        folders = [layout.sidecar_root]
    else:
        folders = list(layout.lora_roots)
    seen = set()
-    scanned: List[Path] = []
+    scanned = 0
    unreadable: List[str] = []
    sidecars = []
    for folder in folders:
@@ -541,13 +498,12 @@ def discover_sidecars(layout: LoraManagerLayout) -> Discovery:
            if key in seen:
                continue
            seen.add(key)
-            scanned.append(resolved)
+            scanned += 1
            model = _model_for(resolved, layout, unreadable)
            if model is not None:
                sidecars.append(Sidecar(resolved, Path(os.path.realpath(model))))
    sidecars.sort(key=lambda sidecar: str(sidecar.metadata_path))
-    scanned.sort(key=str)
-    return Discovery(layout, sidecars, tuple(scanned), unreadable)
+    return Discovery(layout, sidecars, scanned, unreadable)


 # ── images ──────────────────────────────────────────────────────────
@@ -570,15 +526,8 @@ def _example_files(folder: str) -> List[str]:
 def _preview_candidates(sidecar: Sidecar, metadata: Dict) -> Iterator[str]:
    """The paths a preview is looked for at, in LoraManager's order."""
    url = metadata.get("preview_url")
-    if isinstance(url, str) and url.strip():
-        if os.path.isabs(url.strip()):
-            yield url.strip()
-        else:
-            # LoraManager writes absolute paths; it would resolve a relative
-            # one against its working directory, not the sidecar folder.
-            logger.debug(
-                "Relative preview_url skipped in %s", sidecar.metadata_path.name
-            )
+    if isinstance(url, str) and url.strip() and os.path.isabs(url.strip()):
+        yield url.strip()
    base = sidecar.metadata_path.name[: -len(METADATA_SUFFIX)]
    for suffix in PREVIEW_EXTENSIONS:
        yield str(sidecar.metadata_path.parent / f"{base}{suffix}")
@@ -30,7 +30,6 @@ except ImportError:

 from dataclasses import replace

-from .lora_layout_cache import LayoutCache
 from .lora_manager_layout import (
    MODE_ALONGSIDE,
    METADATA_SUFFIX,
@@ -296,35 +295,10 @@ def layout_for_install(install: Optional[str]) -> LoraManagerLayout:


 def lora_manager_layout(lora_manager_path: Optional[str]) -> LoraManagerLayout:
-    """Where LoraManager keeps its files (``py/lora_manager_layout.py``).
-
-    A fresh read: the import review, Start, the legacy scan and the trigger
-    word cache use it. The image hot paths use ``cached_lora_manager_layout``.
-    """
+    """Where LoraManager keeps its files (``py/lora_manager_layout.py``)."""
    return layout_for_install(lora_manager_install(lora_manager_path))


-# The image hot paths' layout cache (#362). The lambdas look the functions up
-# when called, so a test that patches them here is seen by the cache.
-_layout_cache = LayoutCache(
-    lambda path: lora_manager_install(path),
-    lambda install: layout_for_install(install),
-)
-
-
-def cached_lora_manager_layout(
-    configured: Optional[str],
-) -> Tuple[Optional[str], LoraManagerLayout]:
-    """``(install, layout)`` for the configured path, from the layout cache
-    while LoraManager's settings files are unchanged (``py/lora_layout_cache.py``)."""
-    return _layout_cache.get(configured or "")
-
-
-def clear_layout_cache() -> None:
-    """Drop the cached layout (after an import linked files in new folders)."""
-    _layout_cache.clear()
-
-
 def _get_extra_lora_paths(comfyui_root: Path) -> List[Path]:
    """Parse extra_model_paths.yaml for additional LoRA directories."""
    results = []
@@ -368,7 +342,7 @@ def read_lora_metadata(metadata_path: Path) -> Optional[Dict]:
    try:
        with open(metadata_path, "r", encoding="utf-8") as f:
            return json.load(f)
-    except (ValueError, OSError) as e:  # JSONDecodeError, UnicodeDecodeError
+    except (json.JSONDecodeError, OSError) as e:
        logger.debug(f"Failed to read {metadata_path}: {e}")
        return None

@@ -883,13 +857,11 @@ class TriggerWordCache:
        """
        try:
            new_cache = self._build(lora_manager_path)
-        except OSError as error:
+        except Exception as error:
            logger.warning(f"Trigger word cache not refreshed: {error}")
-            return self._failed()
-        except Exception:
-            # Not a disk error: keep the traceback (#362).
-            logger.exception("Trigger word cache not refreshed")
-            return self._failed()
+            with self._lock:
+                self._failed_at = time.monotonic()
+                return len(self._cache)

        with self._lock:
            self._cache = new_cache
@@ -901,12 +873,6 @@ class TriggerWordCache:
        )
        return len(new_cache)

-    def _failed(self) -> int:
-        """Keep the previous map and note when this load failed."""
-        with self._lock:
-            self._failed_at = time.monotonic()
-            return len(self._cache)
-
    @staticmethod
    def _build(lora_manager_path: str) -> Dict[str, List[str]]:
        layout = lora_manager_layout(lora_manager_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.
@@ -55,25 +39,6 @@ def validate_threshold(name: str, value: Any) -> float:
    return float(value)


-# Every page shows the thresholds in steps of 0.05 (the concept's System rows,
-# the Tag image dialogs and the legacy sliders), so a saved one must be on that
-# grid (#369). Per-request thresholds keep their own checks.
-THRESHOLD_STEP = 0.05
-_STEPS_PER_UNIT = round(1 / THRESHOLD_STEP)
-# A computed float can miss the grid by a hair: (0.1 + 0.2) * 20 is 6.000000000000001.
-_STEP_TOLERANCE = 1e-12  # in steps; refuses 0.35000000001
-
-
-def validate_saved_threshold(name: str, value: Any) -> float:
-    """A saved WD14 threshold: in [0, 1] and a multiple of ``THRESHOLD_STEP``,
-    returned exactly on the grid; else ValueError naming ``name``."""
-    value = validate_threshold(name, value)
-    steps = value * _STEPS_PER_UNIT
-    if abs(steps - round(steps)) > _STEP_TOLERANCE:
-        raise ValueError(f"{name} must be a multiple of {THRESHOLD_STEP}")
-    return round(steps) / _STEPS_PER_UNIT
-
-
 def validate_template(value: Any, name: str = "instructions") -> str:
    """Non-empty language-model instructions within the character and byte
    caps, or ValueError naming ``name``."""
@@ -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
@@ -19,7 +19,7 @@ test.beforeEach(async ({page, browserName}) => {
        await import('/extensions/promptmanager/prompt_manager.js');
        class Node {
            constructor(){
-                this.widgets=[...['text','category','tags','search_text'].map(name=>({name,value:'',inputEl:document.createElement('textarea')})),{name:'save_to_library',type:'toggle',value:true}];
+                this.widgets=['text','category','tags','search_text'].map(name=>({name,value:'',inputEl:document.createElement('textarea')}));
                this.widgets_values=[]; this.inputs=[];
            }
            addDOMWidget(name,type,element){document.body.append(element);return {element};}
@@ -36,14 +36,6 @@ test.afterEach(async ({page,browserName}) => {
    expect(page.classicErrors).toEqual([]);
 });

-test('Classic loads an older workflow with Save to library on and keeps a saved off (#90)',async({page})=>{
-    // A workflow saved before the switch held the search UI's slot ('') at the switch's index
-    const loaded=await page.evaluate(()=>{const widget=node.widgets.find(w=>w.name==='save_to_library');widget.value='';node.configure({});return widget.value;});
-    expect(loaded).toBe(true);
-    const off=await page.evaluate(()=>{const widget=node.widgets.find(w=>w.name==='save_to_library');widget.value=false;node.configure({});return [widget.value,node.serialize().widgets_values[4]];});
-    expect(off).toEqual([false,false]);
-});
-
 test('Classic keeps immediate selection, search query and metadata serialization',async({page})=>{
    await page.route('**/prompt_manager/search?**', route=>route.fulfill({json:{success:true,results:[{text:'A new portrait',category:'Portrait',tags:['film grain'],rating:5}]}}));
    await page.evaluate(()=>{node.widgets.find(w=>w.name==='search_text').value='tag:"film grain" portrait';});
@@ -1,108 +0,0 @@
-import {test,expect} from './fixtures.mjs';
-import {SIZES,THEMES,seedConceptAt,openConcept,openProduction,diffInventory,mutate} from './concept-inventory.mjs';
-
-// #331 D138: the Images selection bar's "Add to collection" dialog against the concept's own (`bulk-collection` →
-// simpleInput, app.js a1392–1398 and a1138), on the concept-shaped fixture, at 1600x1100 and 390x844 in both themes.
-// Paired screenshots are artifacts only; there are no PNG baselines.
-test.use({locale:'en-US',timezoneId:'UTC'});
-
-const CARDS='.gallery-body > .image-grid > .media-card';
-
-/**
- * Runs in the page: the open "Add selected images to collection" dialog: its title, the body's tree, the field's
- * label, input and suggestions, and the actions, with the concept's geometry and tokens.
- */
-function measureAddDialog() {
-    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 field=body.querySelector(':scope > .field');
-    const label=field?.querySelector(':scope > label');
-    const input=field?.querySelector(':scope > input');
-    const list=input?.list??null;
-    const actions=body.querySelector(':scope > .dialog-actions');
-    const rect=dialog.getBoundingClientRect();
-    return {
-        title:text(dialog.querySelector('#modal-title')),
-        tree:[...body.children].map(name),
-        field:field&&{tree:[...field.children].map(name),height:Math.round(field.getBoundingClientRect().height),
-            ...css(field,'display','flexDirection','rowGap','marginBottom')},
-        label:label&&{text:text(label),for:label.htmlFor,...css(label,'fontSize','fontWeight','color')},
-        input:input&&{id:input.id,type:input.type,value:input.value,maxLength:input.maxLength,list:input.getAttribute('list'),
-            ...css(input,'height','paddingLeft','fontSize','color','backgroundColor','borderTopColor','borderTopLeftRadius')},
-        suggestions:list&&{id:list.id,display:getComputedStyle(list).display,options:[...list.options].map(option=>option.value)},
-        actions:{tree:[...actions.children].map(name),...css(actions,'display','justifyContent','columnGap','marginTop'),
-            buttons:[...actions.children].map(button=>({text:text(button),className:button.className,
-                ...css(button,'backgroundColor','color','fontSize','paddingTop','paddingLeft','borderTopColor')}))},
-        width:Math.round(rect.width),height:Math.round(rect.height),
-    };
-}
-
-/**
- * D138: the action is "Add" (the concept's "Apply in prototype"), the field starts empty (no sample "Experiments") and
- * holds at most 100 characters, and a hidden `datalist` of the existing names (the fixture's two) follows the field:
- * the shared input dialog's suggestions list, as Set category's (#332 D140).
- */
-function mapAddDialogConcept(reference) {
-    const [cancel,apply]=reference.actions.buttons;
-    const [field,...rest]=reference.tree;
-    return {...reference,tree:[field,'datalist',...rest],
-        input:{...reference.input,value:'',maxLength:100,list:'workspace-input-suggestions'},
-        suggestions:{id:'workspace-input-suggestions',display:'none',options:['Experiments','Landscapes']},
-        actions:{...reference.actions,buttons:[cancel,{...apply,text:'Add'}]}};
-}
-
-async function openAddDialog(page,main) {
-    await page.locator(CARDS).first().locator('.image-overlays > label > input[type="checkbox"]').check();
-    await page.locator(`${main} #bulkbar`).getByRole('button',{name:'Add to collection',exact:true}).click();
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Add selected images to collection');
-    await page.mouse.move(0,0);
-    return page.evaluate(measureAddDialog);
-}
-
-async function conceptAddDialog(page,theme) {
-    await openConcept(page,'images',theme);
-    return openAddDialog(page,'#main');
-}
-
-async function productionAddDialog(page,theme) {
-    await openProduction(page,'images',theme);
-    await expect(page.locator(CARDS).first()).toBeVisible();
-    return openAddDialog(page,'#workspace-main');
-}
-
-test.beforeEach(async({page,request},testInfo)=>{testInfo.manifest=await seedConceptAt(page,request);});
-
-for(const theme of THEMES)for(const [width,height] of SIZES) {
-    test(`add to collection dialog matches the concept ${theme} ${width}x${height}`,async({page},testInfo)=>{
-        await page.setViewportSize({width,height});
-        const concept=await conceptAddDialog(page,theme);
-        await page.screenshot({path:testInfo.outputPath(`concept-add-to-collection-${theme}-${width}.png`)});
-        const production=await productionAddDialog(page,theme);
-        await page.screenshot({path:testInfo.outputPath(`production-add-to-collection-${theme}-${width}.png`)});
-        expect(concept.input.value,'the concept pre-fills its sample').toBe('Experiments');
-        expect(diffInventory(mapAddDialogConcept(concept),production)).toEqual([]);
-    });
-}
-
-test('add to collection comparison detects mutations',async({page})=>{
-    await page.setViewportSize({width:1600,height:1100});
-    const concept=await conceptAddDialog(page,'dark');
-    const expected=mapAddDialogConcept(concept);
-    const production=await productionAddDialog(page,'dark');
-    expect(diffInventory(expected,production)).toEqual([]);
-    // Unmapped, the concept differs only where D138 is recorded.
-    expect(diffInventory(concept,production).map(item=>item.path).sort()).toEqual(expect.arrayContaining(
-        ['actions.buttons.1.text','tree.1','input.list','input.maxLength','input.value']));
-    const paths=async()=>diffInventory(expected,await page.evaluate(measureAddDialog)).map(item=>item.path);
-    await page.evaluate(()=>{document.querySelector('dialog#modal[open] label[for="action-input"]').textContent='Name';});
-    expect(await paths()).toEqual(['label.text']);
-    await page.evaluate(()=>{document.querySelector('dialog#modal[open] label[for="action-input"]').textContent='Collection name';});
-    const undoStyle=await mutate(page,{css:'dialog#modal #action-input { border-color: rgb(255, 0, 0); } dialog#modal .dialog-actions { gap: 31px; }'});
-    expect(await paths()).toEqual(expect.arrayContaining(['input.borderTopColor','actions.columnGap']));
-    await undoStyle();
-    await page.evaluate(()=>document.querySelector('#workspace-input-suggestions').remove());
-    expect(await paths()).toEqual(expect.arrayContaining(['suggestions']));
-});
@@ -118,27 +118,9 @@ export async function openConcept(page,route,theme,motion='no-preference') {
    await expect(page.locator('#main #page-title')).toBeVisible();
 }

-/**
- * D157 (#451): production opens Images in Masonry when the browser has no Default layout; the concept starts at Grid.
- * A comparison (and a test of the Grid's own geometry) starts production from the concept's state, a stored Default
- * layout of Grid, once per tab and only while this browser stored nothing (a test's own settings win).
- */
-export async function startInGrid(page) {
-    if (page.conceptLayoutSeeded) return;
-    page.conceptLayoutSeeded = true;
-    await page.addInitScript(() => {
-        try {
-            if (!location.pathname.startsWith('/prompt_manager/') || sessionStorage.getItem('pm-d157-seeded')) return;
-            sessionStorage.setItem('pm-d157-seeded', '1');
-            if (localStorage.getItem('gallerySettings') === null) localStorage.setItem('gallerySettings', JSON.stringify({ workspaceLayout: 'grid' }));
-        } catch { /* A page without storage keeps the production default. */ }
-    });
-}
-
 /** Production at `#/<route>` with the D4 Theme select, once the sidebar's real counts (D27) have settled. */
 export async function openProduction(page,route,theme,motion='no-preference') {
    await page.emulateMedia({reducedMotion:motion});
-    await startInGrid(page);
    await page.goto('about:blank');await page.goto(`${PRODUCTION_URL}#/${route}`);
    await selectTheme(page,theme);
    await expect(page.locator('#workspace-main #page-title')).toBeVisible();
@@ -205,68 +187,6 @@ export async function mutate(page,{css=null,remove=[],clone=[]}={}) {
    },token);
 }

-/**
- * #332 D146: the category chip names its origin after the category, in a muted `span.chip-source` that never splits
- * (workspace.css `.chip .chip-source`). The concept's chip shows the bare name (app.js a402), so the recorded rule and
- * the span are added to the concept page at runtime and the browser lays the chip out: the first `.tags` row's
- * non-badge chip under `root`. `category` also replaces the chip's text (an own category the concept never shows).
- * Returns the undo.
- */
-export const D146_CHIP_SOURCE='.chip .chip-source { color: var(--ca-muted); white-space: nowrap; }';
-export async function withChipSource(page,root,origin,category=null) {
-    const restoreRule=await mutate(page,{css:D146_CHIP_SOURCE});
-    const token=await page.evaluate(({root,origin,category})=>{
-        const chip=document.querySelector(root)?.querySelector('.tags')?.querySelector(':scope > .chip:not(.blue)');
-        if(!chip)throw new Error(`withChipSource: no category chip under ${root}`);
-        const text=chip.textContent,source=document.createElement('span');
-        source.className='chip-source';source.textContent=` · ${origin}`;
-        if(category!==null)chip.textContent=category;
-        chip.append(source);
-        const token=`chip-source-${Math.random().toString(36).slice(2)}`;
-        (window.__chipSources??=new Map()).set(token,()=>{chip.textContent=text;});
-        return token;
-    },{root,origin,category});
-    return async()=>{
-        await page.evaluate(token=>{window.__chipSources.get(token)();window.__chipSources.delete(token);},token);
-        await restoreRule();
-    };
-}
-
-/**
- * #449 D154: the inspector's tag sections in the concept's prompt-section frame (workspace.css `.tag-section`). The concept
- * has one bare `.tags` row after its prompt blocks (app.js a402), so the recorded rule is added and that row wrapped at
- * runtime, the browser laying out what follows: `sections` lists `[className, label, name]` per section, the first
- * holding the concept's row and each further one a copy of it. Returns the undo.
- */
-export const D154_TAG_SECTION=`.tag-section { border-top: 1px solid var(--line); padding-top: 15px; margin-top: 15px; }
-.tag-section .role-label { color: var(--ca-muted); }
-.tag-section > .tags { margin-top: 0; }`;
-export const PROMPT_TAGS=[['linked-tags','Prompt tags','Prompt tags']];
-export async function withTagSections(page,root,sections=PROMPT_TAGS) {
-    const restoreRule=await mutate(page,{css:D154_TAG_SECTION});
-    const token=await page.evaluate(({root,sections})=>{
-        const container=document.querySelector(root);
-        const inner=container?.querySelector(':scope > .detail-inner')??container?.querySelector(':scope > div');
-        const row=inner&&[...inner.querySelectorAll(':scope > .tags')].find(node=>node.previousElementSibling?.matches('section.prompt-section'));
-        if(!row)throw new Error(`withTagSections: no tag row after the prompt blocks under ${root}`);
-        const anchor=row.nextSibling,parent=row.parentNode,added=[];
-        sections.forEach(([className,label,name],index)=>{
-            const section=document.createElement('section');section.className=`tag-section ${className}`;section.setAttribute('aria-label',name);
-            const heading=document.createElement('div');heading.className='prompt-heading';
-            const text=document.createElement('span');text.className='role-label';text.textContent=`${label} · ${row.children.length}`;
-            heading.append(text);section.append(heading,index?row.cloneNode(true):row);
-            parent.insertBefore(section,anchor);added.push(section);
-        });
-        const token=`tag-sections-${Math.random().toString(36).slice(2)}`;
-        (window.__tagSections??=new Map()).set(token,()=>{parent.insertBefore(row,added[0]);added.forEach(section=>section.remove());});
-        return token;
-    },{root,sections});
-    return async()=>{
-        await page.evaluate(token=>{window.__tagSections.get(token)();window.__tagSections.delete(token);},token);
-        await restoreRule();
-    };
-}
-
 /**
 * Inventory sections: {chrome, heading, toolbar, filterRow, bulkbar, caption, grid, cards, continuation, panel, library,
 * history, noPageScroll}. A section is null when its element is absent. The Images sections (toolbar … panel, #249 C7)
@@ -695,12 +615,9 @@ export function measureInspector(selector) {
            primary:node.classList.contains('ca-primary'),...box(node),...font(node),...edges(node),...layout(node),
            minHeight:style.minHeight,minWidth:style.minWidth,icon:iconOf(node)};
    }
-    // #332 D146: a category chip's visible origin (`span.chip-source`), null on every other chip.
    function chipOf(node) {
-        const source=node.querySelector(':scope > .chip-source');
        return {tag:node.tagName.toLowerCase(),className:classes(node),text:textOf(node),hidden:hiddenOf(node),...box(node),...font(node),...edges(node),
-            minHeight:getComputedStyle(node).minHeight,
-            source:when(source,()=>({text:source.textContent,...font(source),...css(source,'whiteSpace'),...box(source)}))};
+            minHeight:getComputedStyle(node).minHeight};
    }
    function rowOf(row) {
        return {...layout(row),...edges(row),...box(row),chips:[...row.children].map(chipOf)};
@@ -715,13 +632,6 @@ export function measureInspector(selector) {
            text:when(text,()=>({tag:text.tagName.toLowerCase(),className:classes(text),text:text.textContent,tabIndex:text.tabIndex,...font(text),...edges(text),
                ...css(text,'whiteSpace','overflowWrap'),...box(text),lines:px(rect(text).height/parseFloat(getComputedStyle(text).lineHeight))}))};
    }
-    function tagSectionOf(section) {
-        const heading=section.querySelector(':scope > .prompt-heading'),label=heading?.querySelector('.role-label'),row=section.querySelector(':scope > .tags');
-        return {className:classes(section),name:section.getAttribute('aria-label'),...edges(section),...box(section),
-            heading:when(heading,()=>({...layout(heading),...edges(heading),...box(heading)})),
-            label:when(label,()=>({tag:label.tagName.toLowerCase(),text:label.textContent,...font(label),...box(label)})),
-            row:when(row,rowOf)};
-    }
    function factsOf(list) {
        const style=getComputedStyle(list);
        return {...css(list,'display','columnGap','rowGap','fontSize'),...edges(list),columns:style.gridTemplateColumns.split(/\s+/).length,...box(list),
@@ -755,8 +665,6 @@ export function measureInspector(selector) {
        badges:when(rows.find(row=>parts.indexOf(row)<firstSection),rowOf),
        sections:sections.map(sectionOf),
        tags:when(rows.find(row=>parts.indexOf(row)>firstSection),rowOf),
-        // #449 D154: the labelled tag sections after the prompt blocks, each with its frame, heading, label and chip row.
-        tagSections:parts.filter(item=>item.matches('section.tag-section')).map(tagSectionOf),
        facts:when(parts.find(item=>item.matches('dl.meta-grid')),factsOf),
        // Disclosures (viewer only) by their summary and frame; their content is the D20 production facts.
        details:parts.filter(item=>item.localName==='details').map(item=>{const summary=item.querySelector(':scope > summary');
@@ -768,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,333 +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
-
-try:
-    import fcntl
-except ImportError:  # Windows: no flock, and no /dev/shm to share
-    fcntl = None
-
-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 created as <prefix>new-<owner pid>-<random>, locked, then
-# renamed to <prefix>held-<owner pid>-<random>. The pid is for people only:
-# ownership is the flock on OWNER_LOCK, which every PID namespace sees (#419).
-SCRATCH_PREFIX = "pm-reset-"
-STAGING_PREFIX = f"{SCRATCH_PREFIX}new-"
-HELD_PREFIX = f"{SCRATCH_PREFIX}held-"
-OWNER_LOCK = "owner.lock"
-
-
-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 _hold(folder: Path, *, create: bool) -> int:
-    """Take ``folder``'s owner lock without waiting; the open descriptor."""
-    flags = os.O_RDWR | (os.O_CREAT if create else 0)
-    fd = os.open(folder / OWNER_LOCK, flags, 0o600)
-    try:
-        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-    except OSError:
-        os.close(fd)
-        raise
-    return fd
-
-
-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. A live owner holds the
-    flock on the folder's owner lock; the kernel drops it when the owner
-    dies, in whatever PID namespace it ran (a container with ``--ipc=host``
-    shares /dev/shm but not the pids, #419). A folder whose lock is free is
-    removed. Folders without a lock (staging, or named before #419) cannot
-    be proven orphaned and are left alone.
-    """
-    if fcntl is None:
-        return
-    for folder in root.glob(f"{HELD_PREFIX}*"):
-        try:
-            fd = _hold(folder, create=False)
-        except OSError:
-            continue  # held by its owner, no lock to judge by, or gone
-        try:
-            shutil.rmtree(folder, ignore_errors=True)
-        finally:
-            os.close(fd)
-
-
-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._owner_lock: int | 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
-        if self._owner_lock is not None:
-            os.close(self._owner_lock)  # after the removal: never a free lock
-            self._owner_lock = 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 (
-            fcntl is not None
-            and 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:
-                held = self._held_memory_directory(root)
-                if held is not None:
-                    return held
-        self._fallback.mkdir(parents=True, exist_ok=True)
-        return self._fallback
-
-    def _held_memory_directory(self, root: Path) -> Path | None:
-        """A new folder under ``root`` that this seeder holds the lock of.
-
-        It is locked under the staging name, which no cleaner judges, and
-        only then renamed: no cleaner ever sees it held-named and unlocked.
-        """
-        staging = Path(
-            tempfile.mkdtemp(prefix=f"{STAGING_PREFIX}{os.getpid()}-", dir=root)
-        )
-        try:
-            fd = _hold(staging, create=True)
-        except OSError:
-            shutil.rmtree(staging, ignore_errors=True)
-            return None  # no locks on this filesystem: use the disk
-        held = root / (HELD_PREFIX + staging.name[len(STAGING_PREFIX) :])
-        os.rename(staging, held)
-        self._owner_lock = fd
-        return held
@@ -26,7 +26,7 @@ test.beforeEach(async({page,browserName})=>{
        window.fixtureApp={registerExtension(extension){this.extension=extension;},ui:{settings:new EventTarget()},graph:{setDirtyCanvas(){}},canvas:{}};
        await import('/extensions/promptmanager/prompt_manager.js');
        class Node {
-            constructor(){this.widgets=[...['text','category','tags','search_text'].map(name=>({name,type:'text',value:'',options:{},inputEl:document.createElement('textarea')})),{name:'save_to_library',type:'toggle',value:true,options:{}}];this.inputs=[...['clip','prepend_text','append_text'].map(name=>({name,type:name==='clip'?'CLIP':'STRING',link:null})),...['text','category','tags','search_text'].map(name=>({name,type:'STRING',link:null,widget:{name}})),{name:'save_to_library',type:'BOOLEAN',link:null,widget:{name:'save_to_library'}}];this.properties={};this.size=[550,700];}
+            constructor(){this.widgets=['text','category','tags','search_text'].map(name=>({name,type:'text',value:'',options:{},inputEl:document.createElement('textarea')}));this.inputs=[...['clip','prepend_text','append_text'].map(name=>({name,type:name==='clip'?'CLIP':'STRING',link:null})),...['text','category','tags','search_text'].map(name=>({name,type:'STRING',link:null,widget:{name}}))];this.properties={};this.size=[550,700];}
            findInputByType(type){const index=this.inputs.findIndex(input=>input.type===type&&input.link==null);return index<0?undefined:{index,slot:this.inputs[index]};}
            addWidget(type,name,value,callback,options){const widget={type,name,value,callback,options};this.widgets.push(widget);return widget;}
            addDOMWidget(name,type,element){const host=document.createElement('div');host.style.height='650px';host.className='fixture-dom-widget';host.append(element);document.body.append(host);return {element};}
@@ -41,32 +41,6 @@ test.beforeEach(async({page,browserName})=>{
 });
 test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.focusedErrors).toEqual([]);});

-test(`${variant} Save to library switch saves its value and loads older workflows on (#90)`, async ({page}) => {
-    const toggle=page.getByRole('checkbox',{name:'Save to library',exact:true});
-    await expect(toggle).toBeChecked();
-    expect(await page.evaluate(()=>node.widgets.map(widget=>widget.name))).toEqual(['text','category','tags','search_text','prepend_text','append_text','save_to_library']);
-    // The native switch is drawn in the toolbar only: the host keeps it hidden and zero-height, like the text fallbacks
-    expect(await page.evaluate(()=>{const widget=node.widgets.find(item=>item.name==='save_to_library');return {type:widget.type,hidden:widget.hidden,size:widget.computeSize()};})).toEqual({type:'hidden',hidden:true,size:[0,-4]});
-    expect(await page.evaluate(()=>node.widgets.find(item=>item.name==='text').computeSize())).toEqual([0,-4]);
-    await toggle.uncheck();
-    await expect(page.locator('.pm-focused > .pm-editor-status[role=status]')).toHaveText('Save to library is off: runs of this node are not added to the library.');
-    const saved=await page.evaluate(()=>node.serialize());
-    expect(saved.widgets_values[6]).toBe(false);
-    await page.evaluate(saved=>node.configure(saved),saved);
-    await expect(toggle).not.toBeChecked();
-    await page.getByLabel('Main prompt',{exact:true}).fill('Typed while off');
-    await expect(page.locator('.pm-focused > .pm-editor-status[role=status]')).toHaveText('Save to library is off: runs of this node are not added to the library.');
-    // A workflow saved before the switch held the editor's own slot ('') at its index
-    await page.evaluate(()=>node.configure({widgets_values:['Old text','','','','','',''],properties:{}}));
-    await expect(toggle).toBeChecked();
-    expect(await page.evaluate(()=>node.widgets.find(widget=>widget.name==='save_to_library').value)).toBe(true);
-    await toggle.check();
-    await page.getByLabel('Main prompt',{exact:true}).fill('Typed while on');
-    await expect(page.locator('.pm-focused > .pm-editor-status[role=status]')).toHaveText('Main prompt is saved when this node runs.');
-    await page.evaluate(()=>{node.inputs.find(input=>input.name==='save_to_library').link=9;node.onConnectionsChange?.();});
-    await expect(toggle).toBeDisabled();
-});
-
 test(`${variant} library autocompletes filters and searches without changing editor metadata`, async ({page}) => {
    const requests=[];
    await page.route('**/prompt_manager/categories',route=>route.fulfill({json:{success:true,categories:['Portrait']}}));
@@ -283,7 +257,7 @@ test(`${variant} restores workflow values and disclosures and protects connected
 test(`${variant} offers text as a link socket, keeps typed text while linked and through a reload (#343)`,async({page})=>{
    const sockets=()=>page.evaluate(()=>Object.fromEntries(node.inputs.map(input=>[input.name,input.widget?.name??null])));
    // The hidden text widget no longer owns the input, so the host draws it as a socket; the other widget inputs are unchanged.
-    expect(await sockets()).toEqual({clip:null,prepend_text:null,append_text:null,text:null,category:'category',tags:'tags',search_text:'search_text',save_to_library:'save_to_library'});
+    expect(await sockets()).toEqual({clip:null,prepend_text:null,append_text:null,text:null,category:'category',tags:'tags',search_text:'search_text'});
    expect(await page.evaluate(()=>node.findInputByType('STRING').slot.name)).toBe('text');
    expect(await page.evaluate(()=>node.findInputByType('CLIP').slot.name)).toBe('clip');
    const main=page.getByRole('textbox',{name:'Main prompt',exact:true});
@@ -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()
@@ -130,30 +130,24 @@ test('panel matches the concept order and copy',async({page,request})=>{
    // Linked, workflow inferred: every concept element.
    await expect(panel.locator('.panel-heading h2')).toHaveText(POSITIVE_TITLE);
    expect(await panelStructure(panel)).toEqual({outer:['img.detail-cover','div.detail-inner','div.detail-footer'],
-        inner:['div.panel-heading','p.small','div.tags','section.prompt-section.positive','section.prompt-section.negative','section.tag-section.linked-tags','dl.meta-grid']});
+        inner:['div.panel-heading','p.small','div.tags','section.prompt-section.positive','section.prompt-section.negative','div.tags','dl.meta-grid']});
    await expect(panel.locator('img.detail-cover')).toHaveAttribute('alt','');
    await expect(panel.locator('.panel-heading .chip')).toHaveText('PNG');
    await expect(panel.locator('.detail-inner > p.small')).toHaveText('complete.png');
    const badges=panel.locator('.detail-inner > .tags').first();
    await expect(badges.locator('span.chip.blue')).toHaveText('Workflow inferred');
-    // #332 MC8: the chip names where its value came from, in visible text after the category.
-    await expect(badges.locator('span.chip:not(.blue)')).toHaveText('Recipe category: Inspection · recipe');
+    await expect(badges.locator('span.chip:not(.blue)')).toHaveText('Recipe category: Inspection');
    await expect(badges.locator('span.chip:not(.blue) .ca-visually-hidden')).toHaveText('Recipe category: ');
-    // Recipe tags are not the positive tags the Images Tags filter matches, so they stay plain chips (D21 ruling); D154
-    // (#449) labels their own section after the negative prompt, named for the recipe as D146's category chip is.
-    const recipeTags=panel.getByRole('region',{name:'Recipe tags',exact:true});
-    await expect(recipeTags).toHaveClass('tag-section linked-tags');
-    await expect(recipeTags.locator('.prompt-heading .role-label')).toHaveText('Recipe tags · 2');
-    await expect(recipeTags.locator('.tags > span.chip')).toHaveText(['fixture','geometric']);
-    await expect(panel.locator('.tag-section button')).toHaveCount(0);
+    // Recipe tags are not the positive tags the Images Tags filter matches, so they stay plain chips (D21 ruling).
+    await expect(panel.locator('.detail-inner > .tags').last().locator('span.chip')).toHaveText(['fixture','geometric']);
+    await expect(panel.locator('.detail-inner > .tags button')).toHaveCount(0);
    await expect(panel.locator('.meta-grid dt')).toHaveText(['Seed','Steps','CFG','Sampler','Scheduler','Model']);
    await expect(panel.locator('.meta-grid dd')).toHaveText(['9007199254740993','28','6.5','dpmpp_2m','karras','fixture-model.safetensors']);
    const footer=panel.locator('.detail-footer');
-    // #331 D139: every listed file's footer ends with Collections… (folder icon).
-    await expect(footer.locator('button')).toHaveText(['Send to ComfyUI','Prompt history','Collections…']);
+    await expect(footer.locator('button')).toHaveText(['Send to ComfyUI','Prompt history']);
    await expect(footer.locator('button.send')).toHaveAccessibleName(`Send prompt pair to ComfyUI: ${POSITIVE_TITLE}`);
-    await expect(footer.locator('button.send svg.icon')).toHaveCount(1);await expect(footer.locator('button:not(.send) svg.icon')).toHaveCount(2);
-    await expect(panel).not.toContainText(/prompt evidence|Positive prompt tags/);
+    await expect(footer.locator('button.send svg.icon')).toHaveCount(1);await expect(footer.locator('button:not(.send) svg.icon')).toHaveCount(1);
+    await expect(panel).not.toContainText(/prompt evidence|Recipe tags|Positive prompt tags/);
    // Execution recorded and embedded parameters (D21), with the extension chip naming an unverified format.
    reads.patch=data=>{for (const role of ['positive','negative']) data.prompts[role].source='execution';};
    await selectFile(page,'explicit-empty.png');await expect(panel.locator('.panel-heading h2')).toHaveText('explicit-empty.png');
@@ -162,30 +156,27 @@ test('panel matches the concept order and copy',async({page,request})=>{
    await selectFile(page,'ambiguous.png');await expect(panel.locator('.prompt-section.positive .prompt-text')).toHaveText('embedded positive');
    await expect(panel.locator('span.chip.blue')).toHaveText('Embedded parameters');
    await expect(panel.locator('.panel-heading .chip')).toHaveText('File extension PNG');await expect(panel.locator('.panel-heading .chip .ca-visually-hidden')).toHaveText('File extension ');
-    await expect(panel.locator('.detail-footer button')).toHaveText(['Send to ComfyUI','Collections…']);
-    // Unlinked: no badge, category, tags, pair or history; the footer holds only Collections… (D139).
+    await expect(panel.locator('.detail-footer button')).toHaveText(['Send to ComfyUI']);
+    // Unlinked: no badge, category, tags, pair or history.
    reads.patch=null;await selectFile(page,'empty.png');await expect(panel.locator('.panel-heading h2')).toHaveText('empty.png');
-    await expect(panel.locator('.detail-footer button')).toHaveText(['Collections…']);
-    expect(await panelStructure(panel)).toEqual({outer:['img.detail-cover','div.detail-inner','div.detail-footer'],
+    expect(await panelStructure(panel)).toEqual({outer:['img.detail-cover','div.detail-inner'],
        inner:['div.panel-heading','p.small','section.prompt-section.positive','section.prompt-section.negative','dl.meta-grid']});
    await expect(panel.locator('.meta-grid dd')).toHaveText(Array(6).fill('Not recorded'));
    // Ambiguous saved association: the same honest absence.
    reads.patch=data=>{data.library={...data.library,status:'ambiguous',positive_id:null,pair_id:null,title:null,category:null,tags:[],category_scope:null,tags_scope:null};};
    await selectFile(page,'workflow-only.png');await expect(panel.locator('.panel-heading h2')).toHaveText('workflow-only.png');
-    await expect(panel.locator('.chip:not(.blue)')).toHaveCount(1);await expect(panel.locator('.tag-section')).toHaveCount(0);
+    await expect(panel.locator('.chip:not(.blue)')).toHaveCount(1);await expect(panel.locator('.detail-inner > .tags button')).toHaveCount(0);
    await expect(panel.getByRole('button',{name:'Prompt history',exact:true})).toHaveCount(0);
    // D39 mixed scopes: each field follows its own source, so the prefix and the tag chips can disagree.
-    const tagRow=panel.locator('.tag-section.linked-tags > .tags');
+    const tagRow=panel.locator('.detail-inner > .tags').last();
    reads.patch=data=>{data.library={...data.library,status:'linked',category:'Subject',category_scope:'pair',tags_scope:'positive',tags:['alpha','beta']};};
    await selectFile(page,'complete.png');
    await expect(panel.locator('span.chip:not(.blue) .ca-visually-hidden')).toHaveText('Recipe category: ');
    await expect(tagRow.getByRole('button')).toHaveText(['alpha','beta']);
-    await expect(panel.locator('.tag-section.linked-tags .role-label')).toHaveText('Prompt tags · 2');
    reads.patch=data=>{data.library={...data.library,status:'linked',category:'Subject',category_scope:'positive',tags_scope:'pair',tags:['alpha','beta']};};
    await selectFile(page,'workflow-only.png');
    await expect(panel.locator('span.chip:not(.blue) .ca-visually-hidden')).toHaveText('Positive prompt category: ');
    await expect(tagRow.locator('span.chip')).toHaveText(['alpha','beta']);await expect(tagRow.getByRole('button')).toHaveCount(0);
-    await expect(panel.locator('.tag-section.linked-tags .role-label')).toHaveText('Recipe tags · 2');
    // Loading and error states render in `.detail-inner` as `.small` text with the existing buttons.
    reads.patch=null;await page.unroute('**/images/inspect/**');
    await page.route('**/images/inspect/**',route=>route.fulfill({status:500,json:{success:false,error:'broken'}}));
@@ -194,53 +185,6 @@ test('panel matches the concept order and copy',async({page,request})=>{
    await expect(panel.locator('.detail-inner > button')).toHaveText(['Retry prompt details']);
 });

-// #332 CUJ 4, CUJ 5 (MC8, D146): every category chip names its origin: the image's own, the prompt's or the recipe's.
-const originChip=scope=>scope.locator('span.chip:has(> span.chip-source)');
-async function expectOrigin(scope,{prefix,category,origin}) {
-    await expect(originChip(scope)).toHaveText(`${prefix}${category} · ${origin}`);
-    await expect(originChip(scope).locator('.ca-visually-hidden')).toHaveText(prefix);
-    expect(await originChip(scope).locator('.chip-source').evaluate(node=>node.textContent)).toBe(` · ${origin}`);
-}
-async function putOwnCategory(request,paths,category) {
-    const {images}=await(await request.get('/prompt_manager/images/output?mode=workspace&subfolder=inspector&limit=40')).json();
-    const items=paths.map(path=>images.find(image=>image.root_index===0&&image.path===path)).map(({root_index,root_scope,path})=>({root_index,root_scope,path}));
-    const response=await request.put('/prompt_manager/images/category',{data:{items,category}});await expect(response).toBeOK();
-}
-
-test('the category chip names its origin in the side panel and the viewer (#332 CUJ 4, CUJ 5)',async({page,request})=>{
-    await page.setViewportSize({width:1600,height:1100});
-    await expect(await request.post('/__test__/reset',{data:{full_inspector:true}})).toBeOK();
-    // The positive's own category, set through the legacy prompt route; complete.png's recipe keeps "Inspection".
-    const list=await(await request.get('/prompt_manager/library')).json();const id=list.items.find(item=>item.text.startsWith('Inspector portrait')).id;
-    await expect(await request.post('/prompt_manager/bulk/category',{data:{prompt_ids:[id],category:'Landscapes'}})).toBeOK();
-    await page.goto('/prompt_manager/workspace#/images');const panel=inspector(page);
-    await selectFile(page,'complete.png');await expect(panel.locator('.panel-heading h2')).toHaveText(POSITIVE_TITLE);
-    await expectOrigin(panel,{prefix:'Recipe category: ',category:'Inspection',origin:'recipe'});
-    await selectFile(page,'workflow-only.png');await expect(panel.locator('.detail-inner > p.small')).toHaveText('workflow-only.png');
-    await expectOrigin(panel,{prefix:'Positive prompt category: ',category:'Landscapes',origin:'prompt'});
-    // An unlinked file shows no category until it has its own.
-    await selectFile(page,'empty.png');await expect(panel.locator('.panel-heading h2')).toHaveText('empty.png');
-    await expect(originChip(panel)).toHaveCount(0);
-    // Own categories: one overrides the prompt's on a linked file, one sits on an unlinked file.
-    await putOwnCategory(request,['inspector/workflow-only.png'],'Portraits');await putOwnCategory(request,['inspector/empty.png'],'Scans');
-    await page.reload();
-    await selectFile(page,'workflow-only.png');await expect(panel.locator('.detail-inner > p.small')).toHaveText('workflow-only.png');
-    await expectOrigin(panel,{prefix:'Image category: ',category:'Portraits',origin:'this image'});
-    await selectFile(page,'empty.png');await expect(panel.locator('.panel-heading h2')).toHaveText('empty.png');
-    await expectOrigin(panel,{prefix:'Image category: ',category:'Scans',origin:'this image'});
-    await selectFile(page,'complete.png');await expect(panel.locator('.panel-heading h2')).toHaveText(POSITIVE_TITLE);
-    await expectOrigin(panel,{prefix:'Recipe category: ',category:'Inspection',origin:'recipe'});
-    // The viewer's full details show the same chips.
-    let details=await viewerDetails(page,'workflow-only.png');
-    await expectOrigin(details,{prefix:'Image category: ',category:'Portraits',origin:'this image'});
-    await page.keyboard.press('Escape');await expect(page.locator('dialog#viewer-dialog[open]')).toHaveCount(0);
-    details=await viewerDetails(page,'complete.png');
-    await expectOrigin(details,{prefix:'Recipe category: ',category:'Inspection',origin:'recipe'});
-    await page.keyboard.press('Escape');await expect(page.locator('dialog#viewer-dialog[open]')).toHaveCount(0);
-    details=await viewerDetails(page,'empty.png');
-    await expectOrigin(details,{prefix:'Image category: ',category:'Scans',origin:'this image'});
-});
-
 test('tag chip filters Images by that tag',async({page,request})=>{
    await expect(await request.post('/__test__/reset',{data:{full_inspector:true}})).toBeOK();
    const list=await(await request.get('/prompt_manager/library')).json();const id=list.items.find(item=>item.text.startsWith('Inspector portrait')).id;
@@ -249,7 +193,7 @@ test('tag chip filters Images by that tag',async({page,request})=>{
    await page.goto('/prompt_manager/workspace#/images');await selectFile(page,'workflow-only.png');
    const panel=page.getByRole('complementary',{name:'Selected image details',exact:true});
    const listing=page.waitForRequest(item=>item.url().includes('/images/output?')&&new URL(item.url()).searchParams.has('tags'));
-    await panel.getByRole('region',{name:'Prompt tags',exact:true}).getByRole('button',{name:'geometric',exact:true}).click();
+    await panel.locator('.detail-inner > .tags').getByRole('button',{name:'geometric',exact:true}).click();
    expect(new URL((await listing).url()).searchParams.get('tags')).toBe('geometric');
    await expect(page.locator('article[data-image-key="0:inspector/workflow-only.png"]')).toBeVisible();
    await expect(page.locator('article[data-image-key="0:inspector/complete.png"]')).toBeVisible();
@@ -266,7 +210,7 @@ test('pair send and history appear only with real roles and link',async({page,re
    await expect(panel.getByRole('button',{name:'Send prompt pair to ComfyUI: explicit-empty.png',exact:true})).toBeVisible();
    await expect(panel.getByRole('button',{name:'Prompt history',exact:true})).toHaveCount(0);
    await selectFile(page,'empty.png');await expect(panel.locator('.panel-heading h2')).toHaveText('empty.png');
-    await expect(panel.locator('.detail-footer button')).toHaveText(['Collections…']);await expect(panel.getByRole('button',{name:/^Send prompt pair/})).toHaveCount(0);
+    await expect(panel.locator('.detail-footer')).toHaveCount(0);await expect(panel.getByRole('button',{name:/^Send prompt pair/})).toHaveCount(0);
 });

 test('no provenance, raw or download controls in the side panel',async({page,request})=>{
@@ -294,19 +238,19 @@ test('viewer details hold provenance, raw records and downloads',async({page,req
    await page.setViewportSize({width:1600,height:1100});const reads=await patchInspection(page);
    await fullFixture(page,request);let details=await viewerDetails(page,'complete.png');
    // The panel content without the cover, D117's Copy settings summary after the facts, then the two disclosures,
-    // then the pair send and history buttons (D20) and D139's Collections….
-    expect(await viewerStructure(details)).toEqual({outer:['div','button.send','button','button'],
-        inner:['div.panel-heading','p.small','div.tags','section.prompt-section.positive','section.prompt-section.negative','section.tag-section.linked-tags','dl.meta-grid','button.settings-summary','details','details']});
+    // then the pair send and history buttons (D20).
+    expect(await viewerStructure(details)).toEqual({outer:['div','button.send','button'],
+        inner:['div.panel-heading','p.small','div.tags','section.prompt-section.positive','section.prompt-section.negative','div.tags','dl.meta-grid','button.settings-summary','details','details']});
    await expect(details.locator(':scope > div > button')).toHaveText('Copy settings summary');
    await expect(details.locator(':scope > div > button.settings-summary')).toHaveCSS('white-space','normal');
    await expect(details.locator('.detail-cover,.detail-inner,.detail-footer')).toHaveCount(0);
    await expect(details.locator('.panel-heading h2')).toHaveText(POSITIVE_TITLE);await expect(details.locator('.panel-heading .chip')).toHaveText('PNG');
    await expect(details.locator(':scope > div > p.small')).toHaveText('complete.png');
    await expect(details.locator('span.chip.blue')).toHaveText('Workflow inferred');
-    await expect(details.getByRole('region',{name:'Recipe tags',exact:true}).locator('.tags > span.chip')).toHaveText(['fixture','geometric']);
+    await expect(details.locator(':scope > div > .tags').last().locator('span.chip')).toHaveText(['fixture','geometric']);
    await expect(details.locator('.meta-grid').first().locator('dd')).toHaveText(['9007199254740993','28','6.5','dpmpp_2m','karras','fixture-model.safetensors']);
    await expect(details.locator('summary')).toHaveText(['File & provenance','Workflow & raw metadata']);
-    await expect(details.locator(':scope > button')).toHaveText(['Send to ComfyUI','Prompt history','Collections…']);
+    await expect(details.locator(':scope > button')).toHaveText(['Send to ComfyUI','Prompt history']);
    await expect(details.locator(':scope > button.send')).toHaveAccessibleName(`Send prompt pair to ComfyUI: ${POSITIVE_TITLE}`);
    // File & provenance: the honest facts and the concept's "Prompt evidence" line; no per-fact source lines.
    const provenance=details.locator('details').first();await provenance.locator('summary').click();
@@ -317,9 +261,7 @@ test('viewer details hold provenance, raw records and downloads',async({page,req
    await expect(provenance.getByText('Prompt evidence: workflow inferred',{exact:true})).toBeVisible();
    await expect(provenance.getByText('Saved association; not verified against current file',{exact:true})).toBeVisible();
    await expect(provenance.getByRole('link',{name:'Download original',exact:true})).toBeVisible();
-    // D154 (#449) labels the recipe's tags in their own section; the other legacy labels stay gone.
-    await expect(details).not.toContainText(/Configuration evidence|Embedded parameter evidence|prompt evidence|extension/);
-    await expect(details.locator('.tag-section.linked-tags .role-label')).toHaveText('Recipe tags · 2');
+    await expect(details).not.toContainText(/Configuration evidence|Embedded parameter evidence|prompt evidence|extension|Recipe tags/);
    // Workflow & raw metadata: the concept's focusable `pre`, then the downloads with their unavailable reasons.
    const raw=details.locator('details').last();await raw.locator('summary').click();
    await expect(raw.locator('pre[tabindex="0"] > code').first()).toBeVisible();
@@ -333,10 +275,9 @@ test('viewer details hold provenance, raw records and downloads',async({page,req
    await expect(details.getByText('Prompt evidence: embedded parameters',{exact:true})).toBeVisible();
    await expect(details.locator('.panel-heading .chip')).toHaveText('File extension PNG');
    await expect(details.locator('details dl.meta-grid dd').nth(4)).toHaveText('PNG extension');await expect(details).not.toContainText('.PNG');
-    // No badge, no line; no resolved pair or link: after the details only D139's Collections….
+    // No badge, no line; no resolved pair or link, no buttons after the details.
    reads.patch=null;await page.keyboard.press('Escape');details=await viewerDetails(page,'empty.png');
-    expect((await viewerStructure(details)).outer).toEqual(['div','button']);
-    await expect(details.locator(':scope > button')).toHaveText(['Collections…']);
+    expect((await viewerStructure(details)).outer).toEqual(['div']);
    await details.getByText('File & provenance',{exact:true}).click();await expect(details).not.toContainText('Prompt evidence');
    // The history button leaves the viewer for the prompt's history.
    await page.keyboard.press('Escape');details=await viewerDetails(page,'complete.png');
@@ -475,7 +416,7 @@ test('full inspector keeps long literal content reachable on mobile',async({page

 test('embedded gallery uses the same full inspector',async({page,request})=>{
    await expect(await request.post('/__test__/reset',{data:{full_inspector:true}})).toBeOK();const list=await(await request.get('/prompt_manager/library')).json();const id=list.items.find(item=>item.text.startsWith('Inspector portrait')).id;
-    await page.goto(`/prompt_manager/workspace#/library/${id}`);await selectFile(page,'complete.png');const panel=inspector(page);await expect(panel.getByRole('heading',{name:POSITIVE_TITLE,exact:true})).toBeVisible();await expect(panel.locator('.meta-grid dt')).toHaveText(['Seed','Steps','CFG','Sampler','Scheduler','Model']);await expect(panel.getByRole('region',{name:'Recipe tags',exact:true}).locator('.tags > span.chip')).toHaveText(['fixture','geometric']);await expect(panel).not.toHaveAttribute('id','image-inspector');await openSelected(page);await expect(page.locator('#viewer-dialog .file-inspector')).toHaveCount(1);
+    await page.goto(`/prompt_manager/workspace#/library/${id}`);await selectFile(page,'complete.png');const panel=inspector(page);await expect(panel.getByRole('heading',{name:POSITIVE_TITLE,exact:true})).toBeVisible();await expect(panel.locator('.meta-grid dt')).toHaveText(['Seed','Steps','CFG','Sampler','Scheduler','Model']);await expect(panel.locator('.detail-inner > .tags').last().locator('span.chip')).toHaveText(['fixture','geometric']);await expect(panel).not.toHaveAttribute('id','image-inspector');await openSelected(page);await expect(page.locator('#viewer-dialog .file-inspector')).toHaveCount(1);
 });

 test('Prompt history to the shown route closes the viewer and re-renders it, as the concept go() does',async({page,request})=>{
@@ -558,8 +499,7 @@ test.describe('full inspector coarse pointer',()=>{
        }
        await openSelected(page);const viewer=page.locator('dialog#viewer-dialog');
        await expect(viewer.locator('.viewer-canvas img')).toBeVisible();
-        // #450 D156: the view switch is hidden at 700px and below; a shown one is measured like ×.
-        for(const target of await viewer.locator('#viewer-toolbar > :is(button,a),.dialog-header > button:visible').all()) {
+        for(const target of await viewer.locator('#viewer-toolbar > :is(button,a),.dialog-header > button').all()) {
            const box=await target.evaluate(node=>{const {width,height}=node.getBoundingClientRect();return {width,height,name:node.getAttribute('aria-label')};});
            expect(box.width,box.name).toBeGreaterThanOrEqual(80);expect(box.height,box.name).toBeGreaterThanOrEqual(80);
        }
@@ -622,11 +562,6 @@ test('viewer matches the concept shell and toolbar order',async({page,request})=
        const production=await page.evaluate(VIEWER_SHELL);
        // C8 rebuilds the details content; until then the shared file inspector marks the aside it renders into.
        production.paths=production.paths.map(path=>path.replace('aside#viewer-details.file-inspector','aside#viewer-details'));
-        // #450 D156: production's view switch sits right before × (hidden at 700px and below); the concept has none.
-        const modePaths=production.paths.filter(path=>path.includes('button#viewer-mode'));
-        expect(modePaths.map(path=>path.split(' > ').slice(2).join(' > '))).toEqual(['button#viewer-mode.icon-btn','button#viewer-mode.icon-btn > svg.icon','button#viewer-mode.icon-btn > svg.icon > path']);
-        expect(production.paths[production.paths.indexOf(modePaths[2])+1]).toBe('dialog#viewer-dialog > div.dialog-header > button#viewer-close');
-        production.paths=production.paths.filter(path=>!modePaths.includes(path));
        // #249 D34: after Next → production appends its own status lines (position, then the transform and slideshow
        // reasons), and Download stays the original-file link; every other control keeps the concept's text and order.
        const appended=production.toolbar.slice(9);
@@ -741,9 +676,6 @@ test('collection viewer uses real public transforms and resets on navigation',as
 async function slideshowFixture(page,request,preferences={videoAutoplay:false,videoMute:true,videoLoop:false}) {
    await expect(await request.post('/__test__/reset',{data:{full_inspector:true,include_video:true}})).toBeOK();
    await page.goto('/prompt_manager/workspace#/images');
-    // Install the fake clock before the fixture wraps setTimeout: the wrapped timer (which the viewer session captures)
-    // must be the fake one, so page.clock.runFor alone decides when the 3500 ms slideshow deadline fires.
-    await page.clock.install();
    await page.evaluate(async preferences=>{
        if(preferences) localStorage.setItem('gallerySettings',JSON.stringify(preferences));
        const [{createMediaViewer},{createInspectionController},{createScope},{createPromptSender}]=await Promise.all([
@@ -763,7 +695,7 @@ async function slideshowFixture(page,request,preferences={videoAutoplay:false,vi
    },preferences);
    await expect(mediaDialog(page).getByRole('button',{name:'Zoom in',exact:true})).toHaveAttribute('aria-disabled','false');
    await expect(mediaDialog(page).locator('#viewer-details > div > p.small')).toHaveText('complete.png');
-    await page.clock.pauseAt(new Date(Date.now()+1000));
+    await page.clock.install();await page.clock.pauseAt(new Date(Date.now()+1000));
 }
 const slideshowButton=page=>mediaDialog(page).locator('#viewer-toolbar').getByRole('button',{name:/^(Play|Pause|Stop) slideshow$/});
 const timerCount=page=>page.evaluate(()=>window.slideshowTimers.size);
@@ -1,7 +1,7 @@
 import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
-import {SIZES,THEMES,MOTIONS,seedConcept,openConcept,openProduction,inventoryOf,diffInventory,mutate,stripExact,measureInspector,withChipSource} from './concept-inventory.mjs';
+import {SIZES,THEMES,MOTIONS,seedConcept,openConcept,openProduction,inventoryOf,diffInventory,mutate,stripExact} from './concept-inventory.mjs';

 // Task F5 of #249: the production Prompt history (#/library/<id>) against the immutable concept's (#prompt/alpine,
 // app.js renderHistory a587–622, the dialogs a1282–1304, style.css 1059–1179 and 1546–1567), on the concept-shaped real
@@ -272,62 +272,6 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`history geomet
    } finally {await host.evaluate(()=>window.conceptHost.dispose());await host.close();}
 });

-/**
- * D145 (#332): the History media inspector (a recorded run's current file, `recorded-run.mjs`) shows the file's own
- * category with the chip rule of the Images side panel and viewer (D146). The concept has no recorded-run inspector, so
- * its chip is the concept viewer's own category chip (app.js a402, imageDetails(i, true)) with the recorded D146 origin
- * and the own category added at runtime (`withChipSource`). The chip's own place depends on what precedes it in either
- * inspector, so its box is compared by size only.
- */
-const OWN_CATEGORY='Portraits';
-const chipOnly=chip=>{const {left,top,source,...rest}=chip;return {...rest,source:source&&(({left,top,...own})=>own)(source)};};
-const categoryChipOf=async(page,root)=>(await page.evaluate(measureInspector,root)).badges.chips.find(chip=>chip.source);
-
-async function conceptViewerChip(page,theme) {
-    await openConcept(page,'images',theme);await page.mouse.move(0,0);
-    await page.locator('.gallery-body > .image-grid > .media-card').first().locator('.image-open').click();
-    await expect(page.locator('#viewer-dialog[open] #viewer-details .panel-heading h2')).toHaveText(TITLE);
-    const restore=await withChipSource(page,'#viewer-details','this image',OWN_CATEGORY);await settle(page);
-    const chip=await categoryChipOf(page,'#viewer-details');
-    await restore();
-    return chip;
-}
-
-/** Recorded run for the baseline's newest run, its one reported output opened in the viewer. */
-async function productionRunChip(page,theme,positiveId) {
-    await openProductionHistory(page,theme,'no-preference',positiveId);
-    await page.getByRole('button',{name:'Show repeat run for Quality baseline',exact:true}).click();
-    const run=page.getByRole('dialog',{name:'Recorded run',exact:true});
-    await expect(run).toBeVisible();
-    const view=run.getByRole('button',{name:'View current file',exact:true});
-    await expect(view).toBeEnabled();await view.click();
-    const details=page.locator('#viewer-dialog[open] #viewer-details');
-    await expect(details.locator('.chip-source')).toHaveText(' · this image');
-    await page.mouse.move(0,0);await settle(page);
-    return categoryChipOf(page,'#viewer-dialog[open] #viewer-details');
-}
-
-async function setOwnCategory(request,path,category) {
-    const listing=await (await request.get('/prompt_manager/images/output?mode=workspace&limit=40')).json();
-    const root_scope=listing.images.find(item=>item.root_index===0).root_scope;
-    const response=await request.put('/prompt_manager/images/category',{data:{items:[{root_index:0,root_scope,path}],category}});
-    await expect(response).toBeOK();
-}
-
-for(const [width,height] of SIZES)for(const theme of THEMES)test(`history media inspector category chip matches the concept ${width}x${height} ${theme} (D145)`,async({page,request},testInfo)=>{
-    await page.setViewportSize({width,height});
-    const {manifest}=testInfo;
-    // The baseline's newest image: the output of the run its dot opens (the fixture records one run per image).
-    const baseline=manifest.images.find(image=>image.prompt==='alpine'&&image.variant===0);
-    await setOwnCategory(request,baseline.path,OWN_CATEGORY);
-    const reference=await conceptViewerChip(page,theme);
-    const actual=await productionRunChip(page,theme,manifest.prompts[0].positive_id);
-    await captureCanonicalState(page,testInfo,`production-history-run-chip-${width}-${theme}`,'#viewer-dialog[open]');
-    expect.soft(reference,'concept chip').toMatchObject({tag:'span',className:'chip',text:`${OWN_CATEGORY} · this image`,hidden:null});
-    // D21: the hidden prefix names the scope; D146 as above.
-    expect.soft(diffInventory({...chipOnly(reference),hidden:'Image category: '},chipOnly(actual)),'chip differences after D21, D145, D146').toEqual([]);
-});
-
 // The comparison is only worth something if it notices a change (spec §7 mutation check): one CSS mutation (the variant
 // dot's width) and one DOM mutation (Compare negatives removed), each applied after an exact match.
 test('history comparison detects mutations',async({page},testInfo)=>{
@@ -30,12 +30,9 @@ function captionDay(seconds,now=new Date()) {
    return `${name} · ${date.toLocaleDateString('en-US',options)}`;
 }

-/**
- * D8 (amended by #249 PR D and #331): the selection bar's real actions only; Remove links… is left out. Add to
- * collection compares in place (D138).
- */
-const OMITTED_BULK=Object.freeze(['Remove links…']);
-const OMITTED_BULK_SELECTORS=Object.freeze(['bulk-remove'].map(action=>`#bulkbar [data-action="${action}"]`));
+/** D8 (amended by #249 PR D): the selection bar's real actions only; Add to collection and Remove links… are left out. */
+const OMITTED_BULK=Object.freeze(['Add to collection','Remove links…']);
+const OMITTED_BULK_SELECTORS=Object.freeze(['bulk-collection','bulk-remove'].map(action=>`#bulkbar [data-action="${action}"]`));
 /** D85: Auto-tag selected follows the concept's Add tags, a concept button of its own text. */
 const AUTO_TAG_CLONE=Object.freeze([{selector:'#bulkbar [data-action="bulk-tags"]',text:'Auto-tag selected'}]);

@@ -88,18 +85,15 @@ function listInfo(card,actionsWidth) {
 /** Recorded Images deviations only (spec §8); everything else in the concept inventory must equal production. */
 const nocase=(a,b)=>{const x=a.toLowerCase(),y=b.toLowerCase();return x<y?-1:x>y?1:a<b?-1:a>b?1:0;};

-export function mapImagesConcept(reference,{manifest,now=new Date(manifest.now*1000),imageCategories=[]}) {
+export function mapImagesConcept(reference,{manifest,now=new Date(manifest.now*1000)}) {
    const paths=new Map(manifest.images.map(image=>[image.filename,image.path]));
    // D14: the sort appends production's two sorts. Save view is the concept's own (saved views, #249 D16 retired).
    const toolbar={...reference.toolbar};
-    // D153 (#447): production offers no "Highest rated".
-    toolbar.items=toolbar.items.map(item=>item.id==='sort'?{...item,options:[...item.options.filter(option=>option!=='Highest rated'),'Oldest first','Name Z–A']}:item);
+    toolbar.items=toolbar.items.map(item=>item.id==='sort'?{...item,options:[...item.options,'Oldest first','Name Z–A']}:item);
    // D36: the category list is the Library's real list, sorted alphabetically (database/library.py `ORDER BY category
    // COLLATE NOCASE, category`); the concept lists its samples in prompt order (app.js 348). Only the order is mapped.
-    // D141 (#332): the list also holds the listed images' own categories (`GET /prompt_manager/images/categories`),
-    // sorted in with the Library's.
    toolbar.items=toolbar.items.map(item=>item.id==='category-filter'
-        ?{...item,options:[item.options[0],...[...item.options.slice(1),...imageCategories].sort(nocase)]}:item);
+        ?{...item,options:[item.options[0],...item.options.slice(1).sort(nocase)]}:item);
    // D29: no "Illustrative previews" sample tag.
    const filterRow=withoutItems(reference.filterRow,item=>String(item.className).includes('sample-tag'));
    filterRow.items=filterRow.items.map(item=>{
@@ -169,9 +163,9 @@ const pick=inventory=>stripExact(inventory);
 // The concept's own sample categories, in its first-appearance order (app.js 348): what D36 reorders.
 const CONCEPT_CATEGORIES=['All categories','Landscapes','Architecture','Environments','Illustration'];

-function compare(reference,actual,manifest,sections=SECTIONS,imageCategories=[]) {
+function compare(reference,actual,manifest,sections=SECTIONS) {
    const only=inventory=>Object.fromEntries(sections.map(key=>[key,inventory[key]]));
-    return diffInventory(pick(only(mapImagesConcept(reference,{manifest,imageCategories}))),pick(only(actual)));
+    return diffInventory(pick(only(mapImagesConcept(reference,{manifest}))),pick(only(actual)));
 }

 /** The comparison as a gate: throws, naming every differing path, unless production equals the mapped concept. */
@@ -292,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')))};
@@ -468,7 +461,7 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`images selecti
        'Add to collection','Export metadata','Remove links…','Clear']);
    expect.soft(diffInventory(stripExact(mapBulkbar(reference.bulkbar,0).bulkbar.bar),stripExact(removed.bar)),'bar without the omitted actions').toEqual([]);
    expect.soft(actual.bulkbar.bar.items.map(item=>item.text),'production bar').toEqual(['1 selected','Add tags','Auto-tag selected',
-        'Set category','Add to collection','Export metadata','Clear']);
+        'Set category','Export metadata','Clear']);
    expect.soft(compare(empty,emptyActual,manifest,['bulkbar','cards','panel']),'nothing checked').toEqual([]);
    expect.soft(compare(oracle,actual,manifest,['bulkbar','cards','panel']),'one card checked').toEqual([]);
    // The bar comparison notices a change to the production bar.
@@ -476,159 +469,6 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`images selecti
    expect(compare(oracle,await inventoryOf(page,'#workspace-main'),manifest,['bulkbar']).map(item=>item.path)).toContain('bulkbar.bar.paddingTop');
 });

-/**
- * #331 D137: the collection page's Edit leads the heading actions, drawn in the concept as a plain copy of its Import
- * button reading "Edit" (no icon, no action), so the browser lays out what follows it; returns an undo.
- */
-async function drawCollectionEdit(page) {
-    await page.evaluate(()=>{
-        const actions=document.querySelector('#main .heading-actions');
-        const edit=actions.querySelector('button').cloneNode(false);
-        for(const key of Object.keys(edit.dataset))delete edit.dataset[key];
-        edit.textContent='Edit';actions.prepend(edit);window.__collectionEdit=edit;
-    });
-    await settle(page);
-    return ()=>page.evaluate(()=>{window.__collectionEdit.remove();delete window.__collectionEdit;});
-}
-
-// #331 D137: `#/collection/<id>` against the concept's `#collection-landscapes` (app.js a1152–1157, a1186–1189): the
-// collection's name as the h1, "Collection" as the breadcrumb, the Images description, toolbar and filter row. The grid
-// is not compared: the concept's members come from its categories, production's from the stored collection.
-for(const [width,height] of SIZES)for(const theme of THEMES)test(`collection page heading, toolbar and filter row match the concept ${width}x${height} ${theme}`,async({page},testInfo)=>{
-    await page.setViewportSize({width,height});
-    const manifest=testInfo.manifest;
-    await openConcept(page,'collection-landscapes',theme);await page.mouse.move(0,0);await settle(page);
-    await expect(page.locator('#main #page-title')).toHaveText('Landscapes');
-    await expect(page.locator('#breadcrumb')).toHaveText('Collection');
-    const restore=await drawCollectionEdit(page);
-    const reference=await inventoryOf(page,'#main');
-    await restore();
-    await openProduction(page,`collection/${manifest.collections.Landscapes}`,theme);await page.mouse.move(0,0);
-    await expect(page.locator(CARDS)).toHaveCount(12);
-    await expect(page.locator('#workspace-main #page-title')).toHaveText('Landscapes');
-    await expect(page.locator('#workspace-breadcrumb')).toHaveText('Collection');
-    await expect(page).toHaveTitle('Collection · Prompt Manager');
-    await settle(page);
-    const actual=await inventoryOf(page,'#workspace-main');
-    expect.soft(actual.heading.actions.buttons.map(item=>item.text),'production heading actions').toEqual(['Edit','Import','New prompt']);
-    expect.soft(reference.heading.actions.buttons.map(item=>item.text),'mapped concept heading actions').toEqual(['Edit','Import','New prompt']);
-    expect.soft(compare(reference,actual,manifest,['heading','toolbar','filterRow']),'collection page').toEqual([]);
-    // The comparison notices a lost Edit.
-    await mutate(page,{remove:['#workspace-main .heading-actions > button:first-child']});
-    expect(compare(reference,await inventoryOf(page,'#workspace-main'),manifest,['heading']).length).toBeGreaterThan(0);
-});
-
-/** #332: an own category on one listed image, set through the real route (PUT /prompt_manager/images/category). */
-const IMAGE_CATEGORY='Portraits';
-async function setImageCategory(request,path,category) {
-    const listing=await (await request.get('/prompt_manager/images/output?mode=workspace&limit=40')).json();
-    const root_scope=listing.images.find(item=>item.root_index===0).root_scope;
-    const response=await request.put('/prompt_manager/images/category',{data:{items:[{root_index:0,root_scope,path}],category}});
-    await expect(response).toBeOK();
-    expect(await response.json()).toMatchObject({success:true,category,updated:1});
-}
-
-/**
- * Runs in the page: the open Set category dialog (the concept's `simpleInput`, app.js 1384-1390 and 1138): its title,
- * the body's tree, the field, the input and its suggestions (`datalist`), and the actions with every button's box,
- * all relative to the dialog, with the concept's geometry and tokens.
- */
-function measureCategoryDialog() {
-    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 origin=dialog.getBoundingClientRect();
-    const box=node=>{const rect=node.getBoundingClientRect();return {left:Math.round(rect.left-origin.left),top:Math.round(rect.top-origin.top),
-        width:Math.round(rect.width),height:Math.round(rect.height)};};
-    const body=dialog.querySelector('#modal-body');
-    const field=body.querySelector(':scope > .field');
-    const label=field?.querySelector(':scope > label'),input=field?.querySelector(':scope > input');
-    const list=body.querySelector(':scope > datalist');
-    const actions=body.querySelector(':scope > .dialog-actions');
-    return {
-        title:text(dialog.querySelector('#modal-title')),
-        tree:[...body.children].map(name),
-        field:field&&{tree:[...field.children].map(name),...css(field,'display','flexDirection','rowGap','marginBottom'),...box(field)},
-        label:label&&{text:text(label),for:label.htmlFor,...css(label,'fontSize','fontWeight','color')},
-        input:input&&{id:input.id,type:input.type,value:input.value,list:input.getAttribute('list'),
-            ...css(input,'height','paddingLeft','fontSize','color','backgroundColor','borderTopColor','borderTopLeftRadius'),...box(input)},
-        suggestions:list&&{id:list.id,shown:list.getClientRects().length>0,options:[...list.options].map(option=>option.value)},
-        actions:{tree:[...actions.children].map(name),...css(actions,'display','justifyContent','columnGap','rowGap','flexWrap','marginTop'),...box(actions),
-            buttons:[...actions.children].map(button=>({text:text(button),className:button.className,
-                ...css(button,'backgroundColor','color','fontSize','paddingTop','paddingLeft','borderTopColor','minHeight'),...box(button)}))},
-        width:Math.round(origin.width),height:Math.round(origin.height),
-    };
-}
-
-/**
- * The concept's own open dialog as production records it, changed at runtime so the browser lays it out: D140 (#332)
- * empties the field (the concept pre-fills its demo "Landscapes"), lists the toolbar's categories as the field's
- * suggestions (`datalist#workspace-input-suggestions`) and adds "Use prompt category", a plain button of the concept's
- * own Cancel, between Cancel and the primary action; D8 names the primary action "Apply" ("Apply in prototype").
- */
-async function categoryDialogAsRecorded(page,suggestions) {
-    await mutate(page,{clone:[{selector:'dialog#modal[open] .dialog-actions > button:first-child',text:'Use prompt category'}]});
-    await page.evaluate(suggestions=>{
-        const body=document.querySelector('dialog#modal[open] #modal-body');
-        const input=body.querySelector('#action-input');input.value='';input.setAttribute('list','workspace-input-suggestions');
-        const list=document.createElement('datalist');list.id='workspace-input-suggestions';
-        for(const value of suggestions){const option=document.createElement('option');option.value=value;list.append(option);}
-        body.querySelector(':scope > .field').after(list);
-        body.querySelector('.dialog-actions > .ca-primary').textContent='Apply';
-    },suggestions);
-    await settle(page);
-    return page.evaluate(measureCategoryDialog);
-}
-
-async function openCategoryDialog(page,scope) {
-    await page.locator(scope).locator(CARDS).first().locator('.image-overlays > label > input[type="checkbox"]').check();
-    await expect(page.locator('#bulkbar > .bulkbar > strong')).toHaveText('1 selected');
-    await page.locator('#bulkbar').getByRole('button',{name:'Set category',exact:true}).click();
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Categorize selected images');
-    await page.mouse.move(0,0);await settle(page);
-    return page.evaluate(measureCategoryDialog);
-}
-
-// D140 and D141 (#332): with one image's own category set, the toolbar's category options and the Set category dialog
-// against the concept's (app.js 348 and 1384-1390). The dialog is compared with the concept page itself changed at
-// runtime as recorded (`categoryDialogAsRecorded`); unmapped, it differs only in the recorded parts.
-for(const [width,height] of SIZES)for(const theme of THEMES)test(`images category options and Set category dialog match the concept ${width}x${height} ${theme}`,async({page,request},testInfo)=>{
-    await page.setViewportSize({width,height});
-    const manifest=testInfo.manifest;
-    await setImageCategory(request,manifest.images.at(-1).path,IMAGE_CATEGORY);
-    await openConceptLoaded(page,theme,'no-preference');
-    const reference=await inventoryOf(page,'#main');
-    const referenceDialog=await openCategoryDialog(page,'#main');
-    await captureCanonicalState(page,testInfo,`concept-images-category-${width}-${theme}`,'dialog#modal');
-    const suggestions=[...CONCEPT_CATEGORIES.slice(1),IMAGE_CATEGORY].sort(nocase);
-    const oracle=await categoryDialogAsRecorded(page,suggestions);
-    await page.keyboard.press('Escape');await expect(page.locator('dialog#modal[open]')).toHaveCount(0);
-
-    await openProductionLoaded(page,theme,'no-preference');
-    await expect(page.locator('#category-filter option')).toHaveText(['All categories',...suggestions]);
-    const actual=await inventoryOf(page,'#workspace-main');
-    const actualDialog=await openCategoryDialog(page,'#workspace-main');
-    await captureCanonicalState(page,testInfo,`production-images-category-${width}-${theme}`,'dialog#modal');
-    const path=testInfo.outputPath('images-category-geometry.json');
-    await writeFile(path,JSON.stringify({referenceDialog,oracle,actualDialog,reference:reference.toolbar,actual:actual.toolbar},null,2));
-    await testInfo.attach('images-category-geometry',{path,contentType:'application/json'});
-
-    // The concept itself: its sample categories and its pre-filled simpleInput with Cancel / Apply in prototype.
-    expect.soft(reference.toolbar.items.find(item=>item.id==='category-filter').options,'concept categories').toEqual(CONCEPT_CATEGORIES);
-    expect.soft(referenceDialog,'concept dialog').toMatchObject({title:'Categorize selected images',label:{text:'Category'},
-        input:{id:'action-input',value:'Landscapes',list:null},suggestions:null});
-    expect.soft(referenceDialog.actions.buttons.map(button=>button.text),'concept actions').toEqual(['Cancel','Apply in prototype']);
-    // D141: the toolbar options add the image's own category, sorted in (D36).
-    expect.soft(compare(reference,actual,manifest,['toolbar'],[IMAGE_CATEGORY]),'toolbar differences after D14, D36, D141').toEqual([]);
-    // D140 and D8: the dialog equals the concept page laid out as recorded.
-    expect.soft(diffInventory(oracle,actualDialog),'dialog differences after D8, D140').toEqual([]);
-    // Unmapped, the concept differs only in the field's value and suggestions, the body's datalist and the actions.
-    const recorded=/^(input\.(value|list)|tree\.|suggestions|actions\.)/;
-    expect.soft(diffInventory(referenceDialog,actualDialog).map(item=>item.path).filter(item=>!recorded.test(item)),'unrecorded dialog differences').toEqual([]);
-    expect.soft(actualDialog.suggestions,'suggestions').toEqual({id:'workspace-input-suggestions',shown:false,options:suggestions});
-});
-
 // The comparison is only worth something if it notices a change (spec §7 mutation check): one CSS mutation (the
 // `.media-info` padding) and one DOM mutation (the Inspect buttons removed), each applied after an exact match.
 test('images comparison detects mutations',async({page},testInfo)=>{
@@ -9,7 +9,7 @@ import { parityPng } from './local-inspect-files.mjs';
 // `#metadata` (docs/concepts/workspace/app.js renderMetadata 740–748, selection 1715–1729, style.css 709–722,
 // 1180–1194, 1543–1545, 1559–1564), at 1600x1100 and 390x844 in both themes, in three states: initial, selected (the
 // same synthetic PNG set into both `#local-file` inputs) and viewer-open. The concept is never edited: the recorded
-// differences D60–D66 and D155 (TESTING.md) are applied to its measurement, and, where they change copy, to its page before it
+// differences D60–D66 (TESTING.md) are applied to its measurement, and, where they change copy, to its page before it
 // is measured, so the browser lays the concept out with production's words. After that the diff must be empty.
 // Paired captures are artifacts only; there are no PNG baselines.
 test.use({ locale: 'en-US', timezoneId: 'UTC', reducedMotion: 'reduce' });
@@ -22,8 +22,7 @@ const COPY = {
        'Read embedded metadata in this browser. The file is not uploaded or added to your library.'],
    chooser: ['Choose an image for a local preview', 'Choose an image or video for a local preview'],
    note: ['This mock previews your file locally. Sample metadata is available with “Open sample metadata”.',
-        // D155 (#448): choosing the file opens its metadata.
-        'Your file stays in this browser. Choosing it opens its metadata.'],
+        'Your file stays in this browser. Its metadata opens with “Open file metadata”.'],
    toast: ['Local preview only. No file uploaded; sample metadata is available above.',
        'Local preview only. No file uploaded; metadata is available above.'],
 };
@@ -213,29 +212,23 @@ async function productionStates(page, theme, testInfo, tag) {
    await settle(page);
    const initial = await page.evaluate(measureInspect, '#workspace-main');
    await captureCanonicalState(page, testInfo, `production-initial-${tag}`);
-    // D155 (#448): choosing the file opens the viewer with its details at once (the concept waits for its heading
-    // action), so the viewer state is measured first; the selected page is measured after Escape, with the focus the
-    // close returned to the chooser removed (the concept's page has no focused control there).
    await page.locator('#workspace-main #local-file').setInputFiles(parityPng(FILE));
-    await expect(page.locator('dialog#viewer-dialog[open] #viewer-details .panel-heading')).toBeVisible();
-    await expect(page.locator('dialog#viewer-dialog[open] #viewer-details .meta-grid').first()).toBeVisible();
-    await page.mouse.move(0, 0);
-    await settle(page);
-    const viewer = await page.evaluate(measureViewer);
-    await captureCanonicalState(page, testInfo, `production-viewer-${tag}`);
-    await page.keyboard.press('Escape');
-    await expect(page.locator('dialog#viewer-dialog')).toHaveCount(0);
-    await page.evaluate(() => document.activeElement?.blur());
    await expect(page.locator('#workspace-main #local-preview img.local-file-preview')).toBeVisible();
    await page.locator('#workspace-main #local-preview img').evaluate(image => image.decode().catch(() => {}));
-    // D155: no toast; the opened viewer was the confirmation.
-    await expect(page.locator('#workspace-toast')).toHaveText('');
+    await expect(page.locator('#workspace-toast')).toHaveText(COPY.toast[1]);
    await expect(action).toHaveAttribute('aria-disabled', 'false');
    // D63: a readable PNG shows no status line.
    await expect(page.locator('#workspace-main #local-preview p.small')).toHaveCount(0);
    await settle(page);
    const selected = await page.evaluate(measureInspect, '#workspace-main');
    await captureCanonicalState(page, testInfo, `production-selected-${tag}`);
+    await action.click();
+    await expect(page.locator('dialog#viewer-dialog[open] #viewer-details .panel-heading')).toBeVisible();
+    await expect(page.locator('dialog#viewer-dialog[open] #viewer-details .meta-grid').first()).toBeVisible();
+    await page.mouse.move(0, 0);
+    await settle(page);
+    const viewer = await page.evaluate(measureViewer);
+    await captureCanonicalState(page, testInfo, `production-viewer-${tag}`);
    return { initial, selected, viewer };
 }

@@ -1,7 +1,7 @@
 import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
-import {SIZES,THEMES,seedConcept,openConcept,openProduction,inspectorOf,diffInventory,mutate,countCopy,saveImageTags,withChipSource,withTagSections,PROMPT_TAGS} from './concept-inventory.mjs';
+import {SIZES,THEMES,seedConcept,openConcept,openProduction,inspectorOf,diffInventory,mutate,countCopy,saveImageTags} from './concept-inventory.mjs';

 // Task D4 of #249: the Images side panel (app.js imageDetails a400–414) and the viewer's full details (imageDetails(i,
 // true)) against the immutable concept, on the concept-shaped real fixture, at 1600x1100 and 390x844 in both themes.
@@ -13,8 +13,6 @@ test.use({locale:'en-US',timezoneId:'UTC'});

 const CARDS='.gallery-body > .image-grid > .media-card';
 const TITLE='Alpine observatory';
-// D146 (#332): alpine_00001.png's recipe has no category, so its chip shows the positive's, " · prompt" (D39).
-const ORIGIN='prompt';
 const FIXTURE_IMAGES=24;
 // The concept's sticky panel never scrolls; production's scrolls inside the window above 700px (D20/D21 side panel).
 const PANEL_INSET=40;
@@ -40,23 +38,17 @@ function withFocusablePrompts(inventory) {
    return {...inventory,controls,sections:inventory.sections.map(section=>({...section,text:{...section.text,tabIndex:0}}))};
 }

-/**
- * D21: the category chip names its scope in a visually hidden prefix; here the linked positive's (D39 fallback). Its
- * visible origin (D146, #332: " · prompt") is the concept page's own chip with `span.chip-source` added at runtime
- * (`withChipSource`), so `reference.panel` and `viewerPlain` already carry it.
- */
+/** D21: the category chip names its scope in a visually hidden prefix; here the linked positive's (D39 fallback). */
 function withCategoryScope(inventory) {
    const [badge,category,...rest]=inventory.badges.chips;
    return {...inventory,badges:{...inventory.badges,chips:[badge,{...category,hidden:'Positive prompt category: '},...rest]}};
 }

 /**
- * Recorded inspector deviations only (spec §8, TESTING.md D3, D20–D22, D34, D38, D117, D139, D146 and D154, whose labelled
- * tag sections the concept page gets at runtime from `withTagSections`); everything else must
+ * Recorded inspector deviations only (spec §8, TESTING.md D3, D20–D22, D34, D38 and D117); everything else must
 * equal production. `reference.viewerPlain` is the concept's own full details
 * with its tag chips made plain (D20), D117's summary button added and, under a coarse pointer, D34's targets, all at
- * runtime: the browser lays out what follows them, as the Images spec's removed toolbar items do. D139's
- * "Collections…" is drawn after Prompt history in both the concept's panel footer and its full details.
+ * runtime: the browser lays out what follows them, as the Images spec's removed toolbar items do.
 */
 export function mapInspectorConcept(reference,{viewport}) {
    const {panel,viewerPlain,fileControls}=reference;
@@ -109,36 +101,17 @@ async function openProductionPanel(page,theme) {
    await expect(page.locator(CARDS).first()).toBeVisible();
    await expect(panelOf(page).locator('.panel-heading h2')).toHaveText(TITLE);
    await expect(panelOf(page).locator('.detail-footer')).toBeVisible();
-    await expect(panelOf(page).locator('.detail-inner > .tags')).toHaveCount(1);
-    await expect(panelOf(page).locator('.detail-inner > .tag-section.linked-tags')).toBeVisible();
+    await expect(panelOf(page).locator('.detail-inner > .tags')).toHaveCount(2);
    await settle(page);
 }

 /**
- * #331 D139: production's "Collections…" after Prompt history in `selector`'s buttons, drawn in the concept as its own
- * Prompt history button (no action) with the concept's folder icon (its Images filter chip's); returns an undo.
+ * The concept's tag chips in the open viewer as plain `span.chip`s (D20), D34's coarse targets and D117's "Copy
+ * settings summary" after the six facts (LI-4), drawn as the concept's own plain button (its "Download sample JSON",
+ * without its action); returns an undo.
 */
-async function withCollectionsButton(page,selector) {
-    await page.evaluate(selector=>{
-        const history=[...document.querySelectorAll(`${selector} > button`)].find(button=>button.textContent.includes('Prompt history'));
-        const button=history.cloneNode(false);
-        for(const key of Object.keys(button.dataset))delete button.dataset[key];
-        button.append(document.querySelector('.filter-row .chip > svg.icon').cloneNode(true),' Collections…');
-        history.after(button);(window.__collectionsButtons??=[]).push(button);
-    },selector);
-    await settle(page);
-    return async()=>{await page.evaluate(()=>{for(const button of window.__collectionsButtons??[])button.remove();delete window.__collectionsButtons;});};
-}
-
-/**
- * The concept's tag chips in the open viewer in D154's labelled sections (`sections`) as plain `span.chip`s (D20), D34's
- * coarse targets and D117's "Copy settings summary" after the six facts (LI-4), drawn as the concept's own plain button
- * (its "Download sample JSON", without its action); returns an undo.
- */
-async function plainViewerChips(page,sections) {
+async function plainViewerChips(page) {
    const restoreTargets=await mutate(page,{css:D34_COARSE_TARGETS});
-    const restoreSource=await withChipSource(page,'#viewer-details',ORIGIN);
-    const restoreSections=await withTagSections(page,'#viewer-details',sections);
    await page.evaluate(()=>{
        window.__plainChips=[...document.querySelectorAll('#viewer-details .tags > button.chip')].map(button=>{
            const span=document.createElement('span');span.className='chip';span.textContent=button.textContent;
@@ -149,12 +122,11 @@ async function plainViewerChips(page,sections) {
        summary.textContent='Copy settings summary';summary.classList.add('settings-summary');
        document.querySelector('#viewer-details > div > dl.meta-grid').after(summary);window.__summaryButton=summary;
    });
-    const restoreCollections=await withCollectionsButton(page,'#viewer-details');
+    await settle(page);
    return async()=>{
-        await restoreCollections();
        await page.evaluate(()=>{for(const [span,button] of window.__plainChips)span.replaceWith(button);delete window.__plainChips;
            window.__summaryButton.remove();delete window.__summaryButton;});
-        await restoreSections();await restoreSource();await restoreTargets();
+        await restoreTargets();
    };
 }

@@ -172,7 +144,7 @@ async function fileControlsOf(page) {
 * The first card's viewer: its full details and open "File & provenance" measured (in the concept also with plain
 * chips), then closed again. `mutation` (production) is applied once the viewer is open and undone before it closes.
 */
-async function viewerOf(page,concept,mutation=null,sections=PROMPT_TAGS) {
+async function viewerOf(page,concept,mutation=null) {
    await page.locator(CARDS).first().locator('.image-open').click();
    await expect(page.locator('#viewer-dialog[open] #viewer-details .panel-heading h2')).toHaveText(TITLE);
    await settle(page);
@@ -181,7 +153,7 @@ async function viewerOf(page,concept,mutation=null,sections=PROMPT_TAGS) {
    const {viewerDetails}=await inspectorOf(page);
    const fileControls=await fileControlsOf(page);
    let viewerPlain=null;
-    if(concept) {const restore=await plainViewerChips(page,sections);viewerPlain=(await inspectorOf(page)).viewerDetails;await restore();}
+    if(concept) {const restore=await plainViewerChips(page);viewerPlain=(await inspectorOf(page)).viewerDetails;await restore();}
    await restoreMutation?.();
    await page.keyboard.press('Escape');
    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(0);
@@ -189,18 +161,9 @@ async function viewerOf(page,concept,mutation=null,sections=PROMPT_TAGS) {
    await page.evaluate(()=>new Promise(resolve=>setTimeout(resolve,0)));await settle(page);
    return {viewerDetails,viewerPlain,fileControls};
 }
-async function inventory(page,concept=false,sections=PROMPT_TAGS) {
-    // D146: the concept panel's category chip with its visible origin; D139: Collections… after Prompt history; D154's
-    // labelled tag sections (by default the fixture's D39 positive tags under "Prompt tags"), laid out by the concept page.
-    const restoreSource=concept?await withChipSource(page,'#image-inspector',ORIGIN):null;
-    const restoreCollections=concept?await withCollectionsButton(page,'#image-inspector > .detail-footer'):null;
-    const restoreSections=concept?await withTagSections(page,'#image-inspector',sections):null;
-    if(concept)await settle(page);
+async function inventory(page,concept=false) {
    const {panel}=await inspectorOf(page);
-    await restoreSections?.();
-    await restoreCollections?.();
-    await restoreSource?.();
-    const {viewerDetails,viewerPlain,fileControls}=await viewerOf(page,concept,null,sections);
+    const {viewerDetails,viewerPlain,fileControls}=await viewerOf(page,concept);
    return concept?{panel,viewerDetails,viewerPlain,fileControls}:{panel,viewerDetails,fileControls};
 }

@@ -264,10 +227,8 @@ async function productionSendOf(page,context) {
 /** A tag chip: the collection it leaves (the count line), then the chip pressed again for the same result. */
 async function tagOf(page) {
    const before=await page.locator('#result-count').textContent();
-    // The concept's bare row, or production's linked-tags section (D154): the last chip row either way.
-    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 panelOf(page).locator('.detail-inner > .tags').last().getByRole('button',{name:'cinematic',exact:true}).click();
+    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')))};
@@ -326,13 +287,9 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`inspector pane
    expect.soft(panel.sections.map(section=>section.label.color)[0],'concept role colors').not.toBe(panel.sections[1].label.color);
    expect.soft(panel.facts,'concept facts').toMatchObject({columns:2,columnGap:'12px',rowGap:'12px',fontSize:width>700?'11px':'12px'});
    expect.soft(panel.footer,'concept footer').toMatchObject({paddingTop:'13px',paddingRight:'17px',paddingBottom:'13px',paddingLeft:'17px'});
-    // The concept's bare "Landscapes" with the D146 origin added at runtime (`withChipSource`).
-    expect.soft(panel.badges.chips.map(chip=>chip.text),'concept badges').toEqual(['Execution recorded','Landscapes · prompt']);
+    expect.soft(panel.badges.chips.map(chip=>chip.text),'concept badges').toEqual(['Execution recorded','Landscapes']);
    expect.soft(reference.viewerDetails.structure.inner.slice(-2),'concept full details').toEqual(['details','details']);

-    // D154: both documents measured the labelled section, so the comparison covers it (never two absent sections).
-    for(const [name,inventory] of [['concept panel',reference.panel],['concept viewer',reference.viewerPlain],['panel',actual.panel],['viewer',actual.viewerDetails]])
-        expect.soft(inventory.tagSections.map(section=>section.label.text),`${name} tag sections`).toEqual(['Prompt tags · 3']);
    expect.soft(diff,'differences after the recorded deviations').toEqual([]);
    // Copy: the concept's toast "Prompt copied." (or its dialog), in both documents.
    expect.soft(production.copy,'copy').toEqual(concept.copy);
@@ -362,43 +319,18 @@ test('a recipe-linked image without recipe metadata shows its positive prompt me
    await openProductionPanel(page,'dark');
    await page.locator(CARDS).nth(1).locator('[aria-label^="Inspect"]').click();
    await expect(panelOf(page).locator('.panel-heading h2')).toHaveText('Quiet geometry');
-    const badges=panelOf(page).locator('.detail-inner > .tags');
-    await expect(badges).toHaveCount(1);
-    await expect(badges.locator('.chip')).toHaveText(['Execution recorded','Positive prompt category: Architecture · prompt']);
-    await expect(badges.locator('.chip .ca-visually-hidden')).toHaveText('Positive prompt category: ');
-    // D146 (#332): the visible origin names where the value came from.
-    await expect(badges.locator('.chip .chip-source')).toHaveText(' · prompt');
-    // D154: the positive's tags, so the section is "Prompt tags", not "Recipe tags".
-    const tags=panelOf(page).getByRole('region',{name:'Prompt tags',exact:true});
-    await expect(tags.locator('.role-label')).toHaveText('Prompt tags · 3');
-    await expect(tags.locator('.tags > button.chip')).toHaveText(['minimal','warm_light','editorial']);
-    await expect(tags.locator('span.chip')).toHaveCount(0);
-    await expect(panelOf(page).locator('.detail-footer button')).toHaveText(['Send to ComfyUI','Prompt history','Collections…']);
-});
-
-// #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('.tag-section.linked-tags').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);
+    const rows=panelOf(page).locator('.detail-inner > .tags');
+    await expect(rows).toHaveCount(2);
+    await expect(rows.first().locator('.chip')).toHaveText(['Execution recorded','Positive prompt category: Architecture']);
+    await expect(rows.first().locator('.chip .ca-visually-hidden')).toHaveText('Positive prompt category: ');
+    await expect(rows.nth(1).locator('button.chip')).toHaveText(['minimal','warm_light','editorial']);
+    await expect(rows.nth(1).locator('span.chip')).toHaveCount(0);
+    await expect(panelOf(page).locator('.detail-footer button')).toHaveText(['Send to ComfyUI','Prompt history']);
 });

 // 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 them in D154's "Image tags" section (Tags filter buttons in
-// the panel, plain in the viewer) and the linked positive's equal tags in its "Prompt tags" section after it (#449),
-// and equals the concept with its row in those two sections, in both sizes.
+// 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.
 for(const [width,height] of SIZES)test(`image tags saved on the concept image keep the inspector equal to the concept ${width}x${height} (D88)`,async({page,request},testInfo)=>{
    test.setTimeout(120_000);
    const viewport={width,height};await page.setViewportSize(viewport);
@@ -406,14 +338,13 @@ for(const [width,height] of SIZES)test(`image tags saved on the concept image ke
    const names=await panelOf(page).locator('.detail-inner > .tags').last().locator('button.chip').allTextContents();
    expect(names).toEqual(['cinematic','blue_hour','architecture']);
    await captureCanonicalState(page,testInfo,`concept-image-tags-${width}`,'#image-inspector');
-    const reference=await inventory(page,true,[['image-tags','Image tags','Image tags'],...PROMPT_TAGS]);
+    const reference=await inventory(page,true);
    const {path}=testInfo.manifest.images.find(item=>item.filename==='alpine_00001.png');
    expect(await saveImageTags(request,path,names)).toEqual(names);
    const read=page.waitForResponse(item=>new URL(item.url()).pathname===`/prompt_manager/images/inspect/${path}`);
    await openProductionPanel(page,'dark');
    expect((await (await read).json()).image_tags).toEqual({state:'current',tags:names});
-    await expect(panelOf(page).locator('.tag-section.image-tags .chip')).toHaveText(names);
-    await expect(panelOf(page).locator('.tag-section.linked-tags .chip')).toHaveText(names);
+    await expect(panelOf(page).locator('.detail-inner > .tags').last().locator('.chip')).toHaveText(names);
    await captureCanonicalState(page,testInfo,`production-image-tags-${width}`,'#image-inspector');
    assertInspectorMatch(reference,await inventory(page),viewport);
 });
@@ -438,17 +369,6 @@ test('inspector comparison detects mutations',async({page})=>{
    await restoreCss();await settle(page);
    assertInspectorMatch(reference,await measure(),viewport);

-    // D154: the tag section's muted label and its row's spacing are part of the mapped concept.
-    for(const [css,path] of [['#image-inspector .tag-section .role-label { color: rgb(255, 0, 0) }',/panel\.tagSections\.0\.label\.color/],
-        ['#image-inspector .tag-section > .tags { margin-top: 12px }',/panel\.tagSections\.0\.row\.marginTop/],
-        ['#image-inspector .tag-section { border-top-width: 0 }',/panel\.tagSections\.0\.borderTopWidth/]]) {
-        const restore=await mutate(page,{css});
-        const mutated=await measure();
-        expect(()=>assertInspectorMatch(reference,mutated,viewport)).toThrow(path);
-        await restore();await settle(page);
-    }
-    assertInspectorMatch(reference,await measure(),viewport);
-
    const panel=(await inspectorOf(page)).panel;
    const viewerMutated=async mutation=>{const {viewerDetails,fileControls}=await viewerOf(page,false,mutation);return {panel,viewerDetails,fileControls};};
    const withoutActions=await viewerMutated({remove:['#viewer-details > button']});
@@ -460,19 +380,6 @@ test('inspector comparison detects mutations',async({page})=>{
    expect(()=>assertInspectorMatch(reference,withoutSummary,viewport)).toThrow(/viewerDetails\.structure\.inner/);
    assertInspectorMatch(reference,await viewerMutated(),viewport);

-    // D139: Collections… is part of the mapped concept, so losing it is a difference.
-    const restoreButton=await mutate(page,{remove:['#image-inspector > .detail-footer > button:last-child']});
-    const withoutCollections=await measure();
-    expect(()=>assertInspectorMatch(reference,withoutCollections,viewport)).toThrow(/panel\.footer/);
-    await restoreButton();await settle(page);
-
-    // D146: the visible origin is part of the mapped concept, so losing it is a difference.
-    const restoreSource=await mutate(page,{remove:['#image-inspector .chip-source']});
-    const sourceMutated=await measure();
-    expect(()=>assertInspectorMatch(reference,sourceMutated,viewport)).toThrow(/panel\.badges\.chips\.1\.source/);
-    await restoreSource();await settle(page);
-    assertInspectorMatch(reference,await measure(),viewport);
-
    await mutate(page,{remove:['#image-inspector > .detail-footer']});
    const domMutated=await measure();
    expect(()=>assertInspectorMatch(reference,domMutated,viewport)).toThrow(/panel\.footer/);
@@ -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');
-    }
-});
@@ -21,8 +21,8 @@ export function mapLibraryConcept(reference) {
    // Save view is the concept's own (saved views, #249 D16 retired).
    const toolbar={...library.toolbar};
    toolbar.items=toolbar.items.map(item=>{
-        // D14: the Library appends its Oldest first after the concept's sorts; D153 (#447) drops "Highest rated".
-        if(item.id==='sort')return {...item,options:[...item.options.filter(option=>option!=='Highest rated'),'Oldest first']};
+        // D14: the Library appends its Oldest first after the concept's three sorts.
+        if(item.id==='sort')return {...item,options:[...item.options,'Oldest first']};
        // D36: the category list is the Library's real list, sorted alphabetically; the concept lists prompt order.
        if(item.id==='category-filter')return {...item,options:[item.options[0],...item.options.slice(1).sort(nocase)]};
        return item;
@@ -30,20 +30,17 @@ export function mapLibraryConcept(reference) {
    // A shorter toolbar moves what follows it up by as much.
    const rise=library.toolbar.height-toolbar.height;
    const cards=library.cards.map((card,index)=>({...card,
-        // D148 (#437): each card leads with the concept's Images `.image-overlays` selection checkbox, placed absolutely
-        // over the art, so nothing else moves; it is compared with the concept's own overlay below.
-        children:['image-overlays',...card.children],
        // D23: "− N negative variants" uses the singular for one; that row is the concept's own, measured so (`oracle`).
        meta:card.meta.items[0]?.text===PLURAL_ONE?reference.oracle.meta[index]:card.meta,
        // D23: a long title wraps inside the title row, so the title button may shrink below its text (`min-width: 0`).
        title:{...card.title,items:card.title.items.map(item=>item.tag==='button'?{...item,minWidth:'0px'}:item)},
        // D43: tag chips come in the store's alphabetical order; the row flows again from the concept's own chips.
        tags:sortedTags(card.tags),
-        // D153 (#447): no rating stars; the concept page itself is measured without them (`dropConceptRatings`). The
-        // fixture's run_count (4) and last_used_at (its own "now", where the page's clock stands) give the concept's own
-        // "4 runs" and "Used today". The two-line clamp is
+        // D23: the stars are aria-hidden, with a visually hidden "Rated N out of 5" spoken in their place. The fixture's
+        // run_count (4) and last_used_at (its own "now", where the page's clock stands) give the concept's own "4 runs"
+        // and "Used today". The two-line clamp is
        // applied below through `clampedCards`, measured on the concept with `CLAMP_CSS` (its samples wrap at 390px).
-        footer:card.footer}));
+        footer:{...card.footer,facts:{...card.footer.facts,spoken:card.footer.facts.spoken.replace(/^(★+)/,stars=>`Rated ${stars.length} out of 5`)}}}));
    return {...reference,library:{...library,toolbar,
        // D35: the caption uses the singular for one.
        caption:{...library.caption,top:library.caption.top-rise,spans:library.caption.spans.map(span=>({...span,text:countCopy(span.text)}))},
@@ -139,20 +136,9 @@ async function sortConceptTags(page) {
    return ()=>page.evaluate(()=>{for(const [row,chips] of window.__conceptTagOrder)row.append(...chips);delete window.__conceptTagOrder;});
 }

-/**
- * D153 (#447): production draws no 1–5 rating. The concept's card footers read "★★★★★ · Used today"; the stars and
- * their separator are taken out of the concept page itself, so the footer facts are measured as production draws them.
- * Returns the concept's original footer texts.
- */
-async function dropConceptRatings(page) {
-    return page.evaluate(()=>[...document.querySelectorAll('.prompt-card .card-footer > span')].map(span=>{
-        const original=span.textContent;span.textContent=original.replace(/^★+ · /,'');return original;}));
-}
 async function openConceptLibrary(page,theme,motion) {
    await openConcept(page,'library',theme,motion);
    await expect(page.locator(CARDS)).toHaveCount(CONCEPT_PROMPTS);
-    const footers=await dropConceptRatings(page);
-    expect(footers,'the concept rates every card (D153 removes it)').toEqual(Array(CONCEPT_PROMPTS).fill().map((_,index)=>expect.stringMatching(/^★+ · \S/)));
    await page.mouse.move(0,0);await decoded(page);await settle(page);
 }
 async function openProductionLibrary(page,theme,motion) {
@@ -306,7 +292,7 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`library geomet
            expect.soft(card.meta,`${motion} concept meta`).toMatchObject({fontSize:'10px',columnGap:'9px'});
            expect.soft(card.meta.items.map(item=>item.text),`${motion} concept meta text`).toEqual(['− 3 negative variants','4 runs','4 images']);
            expect.soft(card.footer,`${motion} concept footer`).toMatchObject({paddingTop:'11px',paddingRight:'18px',paddingBottom:'11px',paddingLeft:'18px',borderTopWidth:'1px',borderTopStyle:'solid'});
-            expect.soft(card.footer.facts.text,`${motion} concept footer facts (D153: without the stars)`).toBe('Used today');
+            expect.soft(card.footer.facts.text,`${motion} concept footer facts`).toBe('★★★★★ · Used today');
            expect.soft(diffInventory(stripExact(cards.map(item=>sortedTags(item.tags))),stripExact(sorted)),`${motion} tags in alphabetical order`).toEqual([]);
            expect.soft(diffInventory(stripExact(clampedCards(reference.library)),stripExact({grid:clamped.grid,cards:clamped.cards})),`${motion} clamped cards`).toEqual([]);
            expect.soft(diff,`${motion} differences after the recorded deviations`).toEqual([]);
@@ -325,56 +311,6 @@ for(const [width,height] of SIZES)for(const theme of THEMES)test(`library geomet
    } finally {await host.evaluate(()=>window.conceptHost.dispose());await host.close();}
 });

-/**
- * D148 (#437): the selection checkbox overlay of `card` and the `.bulkbar` row inside `main`, with one item checked,
- * measured alike in the concept's Images page and production's Library: the overlay's inset in its card, the checkbox,
- * and the bar's box, tokens and the actions both bars have (Add tags, Set category, Clear; #442).
- */
-const measureSelection=(page,{card,main})=>page.evaluate(({card,main})=>{
-    const css=(node,...keys)=>{const style=getComputedStyle(node);return Object.fromEntries(keys.map(key=>[key,style[key]]));};
-    const rect=node=>node.getBoundingClientRect(),px=value=>Math.round(value*100)/100;
-    const font=node=>css(node,'fontFamily','fontSize','fontWeight','lineHeight','color');
-    const edges=node=>css(node,'paddingTop','paddingRight','paddingBottom','paddingLeft','marginBottom','borderTopWidth','borderTopStyle',
-        'borderTopColor','borderTopLeftRadius','backgroundColor');
-    const host=document.querySelector(card),overlay=host.querySelector('.image-overlays'),label=overlay.querySelector(':scope > label');
-    const input=label.querySelector('input'),root=document.querySelector(main),bar=root.querySelector('.bulkbar');
-    const shared=['Add tags','Set category','Clear'];
-    return {
-        overlay:{left:px(rect(overlay).left-rect(host).left),top:px(rect(overlay).top-rect(host).top),right:px(rect(host).right-rect(overlay).right),
-            ...css(overlay,'position','display','justifyContent','pointerEvents')},
-        label:css(label,'pointerEvents'),checkbox:{width:px(rect(input).width),height:px(rect(input).height),checked:input.checked,...css(input,'accentColor')},
-        bar:{left:px(rect(bar).left-rect(root).left),...css(bar,'display','alignItems','columnGap','rowGap','flexWrap'),...edges(bar),...font(bar),
-            count:{text:bar.querySelector(':scope > strong').textContent,...font(bar.querySelector(':scope > strong'))},
-            buttons:[...bar.querySelectorAll(':scope > button')].filter(button=>shared.includes(button.textContent.trim()))
-                .map(button=>({text:button.textContent.trim(),height:px(rect(button).height),...font(button),...edges(button)}))},
-    };
-},{card,main});
-async function conceptSelection(page,theme) {
-    await openConcept(page,'images',theme);
-    await page.locator('#image-grid .media-card').first().locator('input[data-select]').check();
-    await expect(page.locator('#bulkbar .bulkbar')).toBeVisible();await page.mouse.move(0,0);await settle(page);
-    return measureSelection(page,{card:'#image-grid .media-card',main:'#main'});
-}
-async function productionSelection(page,theme) {
-    await openProductionLibrary(page,theme,'no-preference');
-    await page.locator(CARDS).first().locator('.image-overlays input').check();
-    await expect(page.locator('#library-bulkbar .bulkbar')).toBeVisible();await page.mouse.move(0,0);await settle(page);
-    return measureSelection(page,{card:CARDS,main:'#workspace-main'});
-}
-for(const [width,height] of SIZES)for(const theme of THEMES)test(`the Library selection checkbox and bar match the concept's Images ones ${width}x${height} ${theme}`,async({page},testInfo)=>{
-    await page.setViewportSize({width,height});
-    const reference=await conceptSelection(page,theme);
-    await captureCanonicalState(page,testInfo,`concept-images-selection-${width}-${theme}`);
-    const actual=await productionSelection(page,theme);
-    await captureCanonicalState(page,testInfo,`production-library-selection-${width}-${theme}`);
-    await testInfo.attach('library-selection',{body:JSON.stringify({reference,actual},null,2),contentType:'application/json'});
-    expect(reference.bar.buttons.map(button=>button.text),'the concept bar has every Library action').toEqual(['Add tags','Set category','Clear']);
-    expect(actual).toEqual(reference);
-    // The comparison notices a moved checkbox (spec §7 mutation check).
-    await mutate(page,{css:'.prompt-card .image-overlays { inset: 20px 9px auto }'});
-    expect((await measureSelection(page,{card:CARDS,main:'#workspace-main'})).overlay.top).not.toBe(reference.overlay.top);
-});
-
 // The grid and cards at the concept's three-column breakpoint (style.css 1274–1276).
 for(const theme of THEMES)test(`library grid and cards match the concept 1800x1100 ${theme}`,async({page},testInfo)=>{
    await page.setViewportSize({width:1800,height:1100});
@@ -405,7 +341,7 @@ test('a run that crosses midnight still reads the concept fixture\'s day',async(
    const reference=await conceptInventory(page);
    await openProductionLibrary(page,'dark','no-preference');
    const actual=await inventoryOf(page,'#workspace-main');
-    expect(actual.library.cards.map(card=>card.footer.facts.text)).toEqual(Array(CONCEPT_PROMPTS).fill('Used today'));
+    expect(actual.library.cards.map(card=>card.footer.facts.text.replace(/^★+ · /,''))).toEqual(Array(CONCEPT_PROMPTS).fill('Used today'));
    expect(compare(reference,actual,{sections:['library'],library:['grid','cards','trailing']})).toEqual([]);
 });

@@ -25,10 +25,9 @@ export function inventoryOf(dialog) {
        demo:Boolean(dialog.querySelector('.demo-note')),
    };
 }
-// Documented differences only: prototype Save label, prototype demo note, data-dependent values, and D153 (#447): the
-// concept's "Rating" select is not drawn.
+// Documented differences only: prototype Save label, prototype demo note, and data-dependent values.
 export function mapConcept(reference) {
-    return {...reference,demo:false,fields:reference.fields.filter(item=>item.label!=='Rating'),actions:{...reference.actions,buttons:reference.actions.buttons.map(item=>item.text==='Save in prototype'?{...item,text:'Save'}:item)}};
+    return {...reference,demo:false,actions:{...reference.actions,buttons:reference.actions.buttons.map(item=>item.text==='Save in prototype'?{...item,text:'Save'}:item)}};
 }

 // Flatten an inventory to path->value so a comparison reports exactly which leaves differ.
@@ -17,7 +17,7 @@ test.beforeEach(async({page,browserName})=>{
        window.fixtureApp={registerExtension(extension){this.extension=extension;},ui:{settings},graph:{_nodes:[],setDirtyCanvas(){}},canvas:{},graphToPrompt:async()=>({})};
        await import('/extensions/promptmanager/prompt_manager.js');
        class Node {
-            constructor(){this.id=1;this.type='PromptManagerPair';this.widgets=[...['text','negative_text','category','tags','search_text'].map(name=>({name,type:'text',value:'',options:{},inputEl:document.createElement('textarea')})),{name:'save_to_library',type:'toggle',value:true,options:{}}];this.inputs=[...['clip','prepend_text','append_text'].map(name=>({name,type:name==='clip'?'CLIP':'STRING',link:null})),...['text','negative_text','category','tags','search_text'].map(name=>({name,type:'STRING',link:null,widget:{name}})),{name:'save_to_library',type:'BOOLEAN',link:null,widget:{name:'save_to_library'}}];this.properties={};this.size=[1100,700];}
+            constructor(){this.id=1;this.type='PromptManagerPair';this.widgets=['text','negative_text','category','tags','search_text'].map(name=>({name,type:'text',value:'',options:{},inputEl:document.createElement('textarea')}));this.inputs=[...['clip','prepend_text','append_text'].map(name=>({name,type:name==='clip'?'CLIP':'STRING',link:null})),...['text','negative_text','category','tags','search_text'].map(name=>({name,type:'STRING',link:null,widget:{name}}))];this.properties={};this.size=[1100,700];}
            findInputByType(type){const index=this.inputs.findIndex(input=>input.type===type&&input.link==null);return index<0?undefined:{index,slot:this.inputs[index]};}
            addWidget(type,name,value,callback,options){const widget={type,name,value,callback,options};this.widgets.push(widget);return widget;}
            addDOMWidget(name,type,element){const host=document.createElement('div');host.style.cssText='height:700px;width:1100px;max-width:100%';host.className='fixture-dom-widget';host.append(element);document.body.append(host);return {element};}
@@ -34,18 +34,6 @@ test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);
 async function selectPair(page){await page.getByRole('button',{name:'Recent',exact:true}).click();await page.locator('.pm-editor-result').click();}
 async function draft(page,positive='Draft positive',negative='Draft negative'){await page.getByRole('textbox',{name:'Positive prompt',exact:true}).fill(positive);await page.getByRole('textbox',{name:'Negative prompt',exact:true}).fill(negative);}

-test('paired editor Save to library switch keeps the widget order and loads older workflows on (#90)',async({page})=>{
-    await expect(page.locator('.pm-pair')).toBeVisible();
-    const toggle=page.getByRole('checkbox',{name:'Save to library',exact:true});
-    await expect(toggle).toBeChecked();
-    expect(await page.evaluate(()=>node.widgets.map(widget=>widget.name))).toEqual(['text','negative_text','category','tags','search_text','prepend_text','append_text','save_to_library']);
-    await toggle.uncheck();
-    expect(await page.evaluate(()=>node.serialize().widgets_values[7])).toBe(false);
-    await expect(page.locator('.pm-pair > .pm-editor-status[role=status]').last()).toHaveText('Save to library is off: runs of this node are not added to the library.');
-    await page.evaluate(()=>node.configure({widgets_values:['P','N','','','','','',''],properties:{}}));
-    await expect(toggle).toBeChecked();
-});
-
 test('paired editor previews both texts before explicitly replacing both',async({page})=>{
    await expect(page.locator('.pm-pair')).toBeVisible();
    await draft(page);
@@ -1,6 +1,5 @@
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import { startInGrid } from './concept-inventory.mjs';

 const workspace='/prompt_manager/workspace#/images';
 const details=page=>page.getByRole('complementary',{name:'Selected image details',exact:true});
@@ -39,9 +38,6 @@ async function chooseDestination(page) {

 test('collection viewer rejects stale source and sends only refreshed API evidence',async({page,request,context})=>{
    const host=await fakeHost(context,page);
-    // #430: the file is never found again here, so the manual Refresh is what this covers (the found-again path is
-    // workspace-stale-source.spec.mjs).
-    await page.route('**/prompt_manager/images/rescope',route=>route.fulfill({status:409,json:{success:false,code:'source-changed',error:'The source of this image changed or was removed.'}}));
    await page.addInitScript(()=>{window.copied=[];Object.defineProperty(navigator,'clipboard',{configurable:true,value:{writeText:async text=>window.copied.push(text)}});});
    try {
        const loaded=await(await request.get('/prompt_manager/images/output?mode=workspace&limit=40')).json();const stale=loaded.images.find(image=>image.root_index===0&&image.path==='shared/same.png');
@@ -253,8 +249,6 @@ test('responsive gallery defers observed size writes and still fits the new view
            });}
        };
    });
-    // The Grid's observed sizes (D157: the default layout is Masonry).
-    await startInGrid(page);
    await page.setViewportSize({width:1280,height:900});await page.goto(workspace);
    await expect(page.locator('.media-card')).toHaveCount(4);
    await page.setViewportSize({width:390,height:844});
@@ -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 (
@@ -46,13 +44,7 @@ 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.source_change_fixture import register_source_change_commands
 from tests.browser.workspace_review_fixture import register_review_commands
-from tests.browser.workspace_collections_fixture import register_collections_commands
-from tests.browser.workspace_diagnostics_fixture import (
-    register_diagnostics_commands,
-    repoint_logs,
-)

 CANONICAL_ROOT = Path(__file__).resolve().parents[2]
 CANONICAL_ASSETS = {
@@ -77,8 +69,6 @@ class TestModel:
    loaded = None
    # Models the Tag image dialog workflows mark as not downloaded.
    unavailable: set = set()
-    # Pip names per model whose backend packages "cannot be imported" (#424).
-    missing_packages: dict = {}
    # Scored names the concept comparisons answer instead of the fixed list
    # (``/__test__/tagging/suggestions``); None keeps the fixed list.
    suggestions: list | None = None
@@ -86,13 +76,10 @@ class TestModel:
    models_config: dict = {}

    def get_models_status(self) -> dict:
-        from py.autotag import package_fields
-
        return {
            name: {
                "downloaded": name not in self.unavailable,
                "loaded": self.loaded == name,
-                **package_fields(name, self.missing_packages.get(name, [])),
            }
            for name in self.models_config
        }
@@ -212,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

@@ -232,21 +217,14 @@ def create_app(root: Path) -> web.Application:
    history_commands = register_workspace_history_commands(routes, api, root)
    library_editor_commands = register_library_editor_commands(routes, api, root)
    register_vocabulary_commands(routes, api, root)
-    restore_sources = register_source_change_commands(routes, api)
-    register_tagging_commands(routes, api, root, model, on_reset=restore_sources)
+    register_tagging_commands(routes, api, root, model)
    register_review_commands(routes, api, root)
-    register_collections_commands(routes, api, root)
    reveal_stub = register_reveal_stub(routes, api, root)
    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]
@@ -260,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,
@@ -268,18 +245,15 @@ 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_collection_items",
-                "image_collections",
                "image_favorites",
                "media_review_decisions",
                "media_review_items",
                "media_image_tags",
                "media_annotation_bytes",
                "media_annotation_files",
-                "image_categories",
                "image_prompt_pairs",
                "prompt_pair_tags",
                "prompt_pairs",
@@ -290,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"),
@@ -333,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}",
@@ -364,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:
@@ -408,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.
@@ -417,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

@@ -441,11 +412,9 @@ def create_app(root: Path) -> web.Application:
    async def reset(request: web.Request) -> web.Response:
        nonlocal history_fixture
        request_holds.release()
-        restore_sources()
        # 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()
@@ -465,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})
@@ -526,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})

@@ -590,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})

@@ -666,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)
@@ -76,41 +76,13 @@ function savedNav(nav) {
    return {...nav,rows:nav.rows.map(row=>row.text==='Needs review'?{...row,count:{...row.count,text:'0'}}:row)};
 }

-/**
- * D136 (#331): the concept's COLLECTIONS rows (app.js a336–339) as production lists them, by name (DC1): the fixture's
- * "Landscapes" and "Experiments" hold the concept's 12 and 8 images, so text and counts compare as they are and each
- * place keeps the concept's row geometry. At <=950px the concept hides the nav, which would leave a phone no way to
- * open a collection: production shows it as the concept lays out every other sidebar nav there (its SAVED VIEWS nav),
- * its rows styled as that nav's rows. Text, widths and wrap gaps then follow the rows' own content.
- */
-function collectionsNav(nav,navs) {
-    const byName=[...nav.rows].sort((a,b)=>a.text<b.text?-1:a.text>b.text?1:0);
-    if(nav.shown)return {...nav,rows:byName.map((row,index)=>({...row,gapAfter:nav.rows[index].gapAfter}))};
-    const saved=navs.find(item=>item.id==='saved-nav');
-    const {id,label,rows,...frame}=saved;
-    return {...nav,...frame,id:nav.id,label:nav.label,rows:byName.map(row=>({...rows[0],text:row.text,
-        count:row.count&&rows[0].count?{...rows[0].count,text:row.count.text}:rows[0].count,
-        icon:rows[0].icon&&row.icon?{...rows[0].icon,d:row.icon.d}:row.icon,
-        width:'(content)',hugs:'(content)',gapAfter:'(content)',current:null}))};
-}
-
-/** The production collections nav at <=950px with its content-sized values replaced, as collectionsNav maps them. */
-function contentFree(navs) {
-    return navs.map(nav=>nav.id!=='collections-nav'||!nav.shown?nav:{...nav,
-        rows:nav.rows.map(row=>({...row,width:'(content)',hugs:'(content)',gapAfter:'(content)'}))});
-}
-
-/** D136: where the concept hides COLLECTIONS, the production rows' content-sized values are not compared. */
-function comparableNavs(reference,navs) {
-    return reference.chrome.navs.find(nav=>nav.id==='collections-nav')?.shown?navs:contentFree(navs);
-}
-
 /** Recorded shell deviations only (spec §8). Everything else in the concept inventory must equal production. */
 function mapShellConcept(reference) {
    const {chrome}=reference;
    const navs=chrome.navs
+        // D28: COLLECTIONS is a proposal with no persisted store, so its nav is not rendered.
+        .filter(nav=>nav.id!=='collections-nav')
        .map(nav=>{
-            if(nav.id==='collections-nav')return collectionsNav(nav,chrome.navs);
            if(nav.id==='saved-nav')return savedNav(nav);
            if(nav.id!=='system-nav')return nav;
            const system=rowNamed(nav,'System');
@@ -127,8 +99,9 @@ function mapShellConcept(reference) {
    return {...reference,chrome:{...chrome,
        // D29: no prototype suffix in the document title.
        title:chrome.title.replace(/ · Prompt Manager concept$/,' · Prompt Manager'),
-        // D49: SAVED VIEWS without its "PROPOSED" badge. D136: COLLECTIONS without it either.
-        labels:chrome.labels.map(label=>label.text.endsWith(' PROPOSED')?{...label,text:label.text.replace(/ PROPOSED$/,'')}:label),
+        // D28: no COLLECTIONS label. D49: SAVED VIEWS without its "PROPOSED" badge.
+        labels:chrome.labels.filter(label=>label.text!=='COLLECTIONS PROPOSED')
+            .map(label=>label.text==='SAVED VIEWS PROPOSED'?{...label,text:'SAVED VIEWS'}:label),
        navs,
        connection:{...chrome.connection,
            // D28: truthful copy instead of "Demo connection · Classic / Nodes 2.0".
@@ -161,9 +134,8 @@ function headingFrame(heading) {
 function compare(route,reference,actual) {
    const expected=mapShellConcept(reference);
    const heading=FULL_HEADING.has(route);
-    const chrome={...actual.chrome,navs:comparableNavs(reference,actual.chrome.navs)};
    return [
-        ...diffInventory({chrome:expected.chrome,noPageScroll:expected.noPageScroll},{chrome,noPageScroll:actual.noPageScroll}),
+        ...diffInventory({chrome:expected.chrome,noPageScroll:expected.noPageScroll},{chrome:actual.chrome,noPageScroll:actual.noPageScroll}),
        ...diffInventory(heading?expected.heading:headingFrame(expected.heading),heading?actual.heading:headingFrame(actual.heading))
            .map(item=>({...item,path:`heading.${item.path}`})),
    ];
@@ -270,7 +242,7 @@ for(const [width,height] of SIZES)test(`a saved view row matches the concept's $
    expect(reference.chrome.navs.find(nav=>nav.id==='saved-nav').rows.map(row=>row.text)).toEqual(['Favorites','Needs review','Golden hour']);
    await openProduction(page,'images','dark');
    const actual=await save('Save','#workspace-main');
-    expect(diffInventory(mapShellConcept(reference).chrome.navs,comparableNavs(reference,actual.chrome.navs))).toEqual([]);
+    expect(diffInventory(mapShellConcept(reference).chrome.navs,actual.chrome.navs)).toEqual([]);
    const referenceRows=reference.chrome.navs.find(nav=>nav.id==='saved-nav').rows;
    expect(actual.chrome.navs.find(nav=>nav.id==='saved-nav').rows.map(row=>[row.text,row.count]))
        .toEqual([['Favorites',referenceRows[0].count],['Needs review',{...referenceRows[1].count,text:'0'}],['Golden hour',null]]);
@@ -1,66 +0,0 @@
-"""Source changes under an open workspace page (#430), undone by every reset.
-
- ``POST /__test__/sources/reverse``: the image sources are listed in reverse
-  order, as System › Sources would renumber them, so every held
-  ``root_scope`` names another index and the page must re-scope its file.
- ``POST /__test__/scope-key/rotate``: the API's scope and cursor keys
-  change, as when ``workspace-scope.key`` is lost before a restart: a held
-  scope then cannot be mapped and the page offers Refresh.
-"""
-
-from __future__ import annotations
-
-import secrets
-from typing import TYPE_CHECKING, Callable
-
-from aiohttp import web
-
-from utils.workspace_keys import WorkspaceKeys
-
-if TYPE_CHECKING:
-    from py.api import PromptManagerAPI
-
-_CACHE = "_workspace_keys_cache"
-
-
-def register_source_change_commands(
-    routes: web.RouteTableDef, api: PromptManagerAPI
-) -> Callable[[], None]:
-    """Register the commands; returns the restore every reset runs."""
-    # Imported here: py.config needs the host stubs create_app installs first.
-    from py.config import GalleryConfig
-
-    saved: dict = {}
-
-    def restore() -> None:
-        if "roots" in saved:
-            GalleryConfig.MONITORING_DIRECTORIES = saved.pop("roots")
-            api.invalidate_gallery_cache(retire=True)
-        if "keys" in saved:
-            keys = saved.pop("keys")
-            if keys is None:
-                api.__dict__.pop(_CACHE, None)
-            else:
-                api.__dict__[_CACHE] = keys
-
-    @routes.post("/__test__/sources/reverse")
-    async def reverse(request: web.Request) -> web.Response:
-        if request.query or request.can_read_body:
-            raise web.HTTPBadRequest()
-        roots = list(GalleryConfig.MONITORING_DIRECTORIES)
-        saved.setdefault("roots", roots)
-        GalleryConfig.MONITORING_DIRECTORIES = roots[::-1]
-        await api._run_in_executor(api.invalidate_gallery_cache, True)
-        return web.json_response({"success": True})
-
-    @routes.post("/__test__/scope-key/rotate")
-    async def rotate(request: web.Request) -> web.Response:
-        if request.query or request.can_read_body:
-            raise web.HTTPBadRequest()
-        saved.setdefault("keys", api.__dict__.get(_CACHE))
-        api.__dict__[_CACHE] = WorkspaceKeys(
-            secrets.token_bytes(32), secrets.token_bytes(32), False
-        )
-        return web.json_response({"success": True})
-
-    return restore
@@ -162,6 +162,7 @@ async function serverJson(request, url) {
 }

 const number = value => value.toLocaleString('en-US');
+const ratingText = value => value === null ? 'Not rated' : `${number(value)} / 5`;

 /** The concept's shell and Overview with the recorded deviations applied, given the server's real overview. */
 function mapOverviewConcept(reference, overview) {
@@ -177,8 +178,8 @@ function mapOverviewConcept(reference, overview) {
        'One display configuration': row => ({ ...row, description: 'Grid and density settings are shared across views.' }),
        // D93: the real sources, not samples.
        '2 sample output sources': row => ({ ...row, title: `${number(overview.sources.effective)} output sources` }),
-        // D96: the dialog shows runs by category and library totals, not prompt, tag or date usage (D153: no ratings).
-        Statistics: row => ({ ...row, description: 'Runs by category, with library totals.' }),
+        // D96: the dialog shows runs and ratings by category and library totals, not prompt, tag or date usage.
+        Statistics: row => ({ ...row, description: 'Runs and ratings by category, with library totals.' }),
    };
    const surfaces = reference.columns.surfaces.map(surface => ({ ...surface,
        rows: surface.rows.map(row => (rows[row.title] ?? (value => value))(row)) }));
@@ -287,10 +288,7 @@ test('system comparison detects mutations', async ({ page, request }) => {
    expect(diffInventory(expected, await measure())).toEqual([]);
 });

-/**
- * D96: the concept's table, its rows the real ones; then "Library totals" in the same table markup. D153 (#447): the
- * concept's "Avg. rating" column and a "Rated images" total are not drawn.
- */
+/** D96: the concept's table, its rows the real ones; then "Library totals" in the same table markup. */
 function mapStatisticsConcept(reference, statistics) {
    const [runs] = reference.tables;
    return {
@@ -298,11 +296,10 @@ function mapStatisticsConcept(reference, statistics) {
        // No sample note (prototype copy); a second table follows the first.
        body: ['table', 'table'],
        tables: [
-            { ...runs, head: runs.head.filter(([, , text]) => text !== 'Avg. rating'),
-                rows: statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs)]) },
+            { ...runs, rows: statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs), ratingText(row.average_rating)]) },
            { caption: 'Library totals', head: [['th', 'col', 'Total'], ['th', 'col', 'Count']],
                rows: [['Prompts', number(statistics.totals.total_prompts)], ['Tags', number(statistics.totals.total_tags)],
-                    ['Images', number(statistics.totals.total_images)]] },
+                    ['Images', number(statistics.totals.total_images)], ['Rated images', number(statistics.rated_images)]] },
        ],
    };
 }
@@ -475,9 +472,9 @@ function measureAppearance(mainSelector) {
 }

 // D97: the rows Appearance adds for the legacy gallery settings, after the concept's own, as production renders them.
-// D156 (#450) moved "Collapse viewer details by default" to the Viewer surface (workspace-viewer-mode.spec.mjs).
 const ADDED_APPEARANCE_ROWS = [
    ['card-details', 'Show image details on cards', 'Show each card’s title and file details under the preview.', true],
+    ['viewer-details', 'Collapse viewer details by default', 'Open the image viewer with its details panel hidden.', false],
 ];

 /** The concept's Appearance with the recorded deviations applied, given the server's real settings. */
@@ -488,11 +485,10 @@ function mapAppearanceConcept(reference, settings) {
        control: { ...toggleRow.control, id, checked } }));
    return {
        ...reference,
-        // D156: the Viewer surface, then (#317) the server's thumbnail settings in their own surface ("Thumbnails",
-        // README: retained in Appearance).
-        layout: [reference.layout[0], 'section.surface', 'section.surface', ...reference.layout.slice(1)],
-        // D97: one added toggle (D156 moved the other) and the "Reset display defaults" operation close the surface.
-        surface: { ...reference.surface, tree: [...reference.surface.tree, 'div.setting-row', 'div.operation'] },
+        // #317: the server's thumbnail settings follow in their own surface ("Thumbnails", README: retained in Appearance).
+        layout: [reference.layout[0], 'section.surface', ...reference.layout.slice(1)],
+        // D97: two added toggles and the "Reset display defaults" operation close the surface.
+        surface: { ...reference.surface, tree: [...reference.surface.tree, 'div.setting-row', 'div.setting-row', 'div.operation'] },
        rows: [...reference.rows.map(row => row.control?.id === 'timeout'
            // The node search timeout is the server's real `result_timeout`, not the concept's sample 30.
            ? { ...row, control: { ...row.control, value: String(settings.result_timeout) } } : row), ...added],
@@ -539,7 +535,7 @@ test('appearance comparison detects mutations', async ({ page, request }) => {
    // Unmapped, the concept differs only where D97 and the real timeout are recorded.
    expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 2).join('.'))
        .filter((path, index, all) => all.indexOf(path) === index).sort())
-        .toEqual(['layout.1', 'layout.2', 'layout.3', 'layout.length', 'operations.0', 'operations.length', 'rows.11', 'rows.12',
+        .toEqual(['layout.1', 'layout.2', 'layout.length', 'operations.0', 'operations.length', 'rows.11', 'rows.12', 'rows.13',
            'rows.length', 'surface.tree'].sort());
    const measure = () => page.evaluate(measureAppearance, '#workspace-main');
    const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
@@ -618,21 +614,10 @@ const WATCHED = new Set(['watching', 'stopping']);
 const REFRESH_FILES = { title: 'Refresh files', description: 'Read every source again to find files added or removed outside ComfyUI.',
    label: 'Refresh' };

-// D158 (#247): the row production adds directly below "Watch for new outputs", in that row's markup.
-const FOREIGN_RUNS = { id: 'foreign-runs', label: 'Save prompts from other workflows',
-    description: 'New outputs of workflows without a PromptManager node add their prompt to the library when it is certain.' };
-
-/** D158: the concept's "Watch for new outputs" row as the inserted "Save prompts from other workflows" row. */
-function foreignRunsRow(monitoringRow, settings) {
-    return { ...monitoringRow, text: [['label', FOREIGN_RUNS.label, FOREIGN_RUNS.id], ['p', FOREIGN_RUNS.description, null]],
-        control: { ...monitoringRow.control, id: FOREIGN_RUNS.id, checked: settings.save_foreign_runs } };
-}
-
 /** The concept's Sources with the recorded deviations applied, given the server's real settings and sources. */
 function mapSourcesConcept(reference, { settings, sources }) {
    const [sample] = reference.sources;
    const scan = sample.actions[0];
-    const rowAt = reference.surface.tree.indexOf('div.setting-row');
    return {
        ...reference,
        // The real sources replace the two samples (without the "sample path" note). D98: each configured one has Remove,
@@ -640,15 +625,13 @@ function mapSourcesConcept(reference, { settings, sources }) {
        sources: sources.effective.map(source => ({ ...sample, title: source.label,
            description: `${source.path} · ${WATCH_TEXT[source.watch]}`,
            actions: [{ ...scan, text: WATCHED.has(source.watch) ? 'Scan changes' : 'Scan folder' }, { ...scan, text: 'Remove' }] })),
-        rows: reference.rows.flatMap(row => {
-            if (row.control.id === 'monitoring') return [{ ...row, control: { ...row.control, checked: settings.monitoring_enabled } },
-                foreignRunsRow(row, settings)];
+        rows: reference.rows.map(row => {
+            if (row.control.id === 'monitoring') return { ...row, control: { ...row.control, checked: settings.monitoring_enabled } };
            // D113: the range ends at the server's core count (the concept's fixed 16) and shows the real worker count.
-            return [{ ...row, control: { ...row.control, max: String(settings.cpu_count), value: String(settings.worker_threads) } }];
+            return { ...row, control: { ...row.control, max: String(settings.cpu_count), value: String(settings.worker_threads) } };
        }),
-        // D158: the inserted row after the first setting row; D98: "Refresh files" closes the surface.
-        surface: { ...reference.surface, tree: [...reference.surface.tree.slice(0, rowAt + 1), 'div.setting-row',
-            ...reference.surface.tree.slice(rowAt + 1), 'div.operation'] },
+        // D98: "Refresh files" closes the surface.
+        surface: { ...reference.surface, tree: [...reference.surface.tree, 'div.operation'] },
        operations: [...reference.operations, { ...reference.operations[0], title: REFRESH_FILES.title,
            description: REFRESH_FILES.description, actions: [{ ...reference.operations[0].actions[0], text: REFRESH_FILES.label }] }],
    };
@@ -702,12 +685,10 @@ test('sources comparison detects mutations', async ({ page, request }) => {
    const expected = mapSourcesConcept(concept, server);
    const production = await productionSources(page, 'dark', { notice: true });
    expect(diffInventory(expected, production)).toEqual([]);
-    // Unmapped, the concept differs only in the real sources, the D98 operation, the D158 row (which moves the D113
-    // range to the third row) and the D113 range.
+    // Unmapped, the concept differs only in the real sources, the D98 operation and the D113 range.
    expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 2).join('.'))
        .filter((path, index, all) => all.indexOf(path) === index).sort())
-        .toEqual(['operations.2', 'operations.length', 'rows.1', 'rows.2', 'rows.length', 'sources.0', 'sources.1',
-            'surface.tree'].sort());
+        .toEqual(['operations.2', 'operations.length', 'rows.1', 'sources.0', 'sources.1', 'surface.tree'].sort());
    const measure = () => page.evaluate(measureSources, '#workspace-main');
    const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
    // A removed notice and a removed source row.
@@ -721,13 +702,6 @@ test('sources comparison detects mutations', async ({ page, request }) => {
    await page.evaluate(() => { document.querySelector('#workspace-main label[for="monitoring"]').textContent = 'Watch for outputs'; });
    expect(await paths()).toEqual(['rows.0.text.0.1']);
    await page.evaluate(() => { document.querySelector('#workspace-main label[for="monitoring"]').textContent = 'Watch for new outputs'; });
-    // D158: the inserted row is compared too: a missing one and a changed label are caught.
-    const undoForeign = await mutate(page, { remove: ['#workspace-main .setting-row:has(#foreign-runs)'] });
-    expect(await paths()).toEqual(expect.arrayContaining(['rows.length', 'surface.tree.length']));
-    await undoForeign();
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="foreign-runs"]').textContent = 'Save other prompts'; });
-    expect(await paths()).toEqual(['rows.1.text.0.1']);
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="foreign-runs"]').textContent = 'Save prompts from other workflows'; });
    await page.evaluate(() => { document.querySelector('#workspace-main .panel-heading button').textContent = 'Add source'; });
    expect(await paths()).toEqual(['heading.action.text']);
    await page.evaluate(() => { document.querySelector('#workspace-main .panel-heading button').textContent = '+ Add source'; });
@@ -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();
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vito Sansevero	5068f505ee	test(browser): the System reset restores every settings value, safety_backup included The frontend coverage shard of #372 failed in workspace-system-tagging: the review read "No safety backup (the policy is off)". The backups spec saves safety_backup=false, and /__test__/system/reset restored config.json but not PromptManagerConfig.SAFETY_BACKUP (nor INFINITE_SCROLL), so a later spec on the same worker server saw the policy off. The reset now captures and restores every non-tagging value POST /settings can change.	2026-10-27 01:53:35 -07:00
Vito Sansevero	ade967204f	fix(threads): a later stop waits again for a worker or observer an earlier stop left running (#302 ) Review findings on #372: - ImageGenerationHandler keeps the workers a stop signalled that had not ended; every later shutdown/close joins them again, so a second call no longer returns True while the first worker still runs. - ImageMonitor.stop_monitoring keeps an observer or handler it left running and stops and joins it again on the next call. - A closed handler takes no awaiting history path, and a re-check that raced close() is not kept due. - Tests: second stops of a busy worker and a live observer, the closed handler's re-check paths, the handle test asserts the worker ended and stops before it asserts, and a no-new-thread check instead of set equality.	2026-10-27 01:40:56 -07:00
Vito Sansevero	020ce53c8e	test(history): drain the writer before asserting a bounded close it does not test (#370 )	2026-10-27 01:30:19 -07:00
Vito Sansevero	756509b7ea	fix(threads): stop and join the prompt cleanup thread, the image worker and the observer (#302 , #370 ) - PromptTracker: the cleanup thread waits on a stop event instead of time.sleep; new shutdown(timeout=2) joins it and returns whether it ended. - ImageGenerationHandler.shutdown(timeout=5) now joins the worker and returns a bool; new close() is final: schedule() refuses and a sealed run's history re-check is dropped, so no worker restarts afterwards. - ImageMonitor.stop_monitoring(timeout=5) closes the handler first, then stops and joins the watchdog observer within one deadline. - Every test that builds a real tracker, handler or monitor ends with its final stop and an assertion, before its folder and databases go. - #370: the wrapper/session history test drains before dispose(); the held-write bound test uses 30 s ceilings instead of tight wall clocks.	2026-10-27 01:28:43 -07:00