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

The frontend coverage gate found local-resolver-stages.mjs branches at 92.44% (< 93). Each way an earlier stage stops being a plain first stage (no latent, literal, missing or cyclic latent, a sampler-shaped node, a detailer) is now a resolver test and an anchor-first-stage-* parity vector.
fix(inspector): skip only plain first stages on shared links; an unfinished prefix scan anchors nothing (#381 )
2026-10-27 08:20:24 -07:00 · 2026-10-27 07:24:46 -07:00 · 2026-10-27 07:17:44 -07:00 · 2026-10-27 06:36:48 -07:00 · 2026-10-27 06:36:40 -07:00 · 2026-10-27 06:28:42 -07:00
315 changed files with 7088 additions and 39638 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,15 +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.
 jobs:
  frontend-coverage:
    name: frontend coverage (shard ${{ matrix.shard }}/3)
@@ -88,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
@@ -97,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
@@ -176,8 +164,6 @@ jobs:

  browser-workflows:
    name: page workflows (${{ matrix.browser }}, shard ${{ matrix.shard }}/2)
-    # Merge queue, main and manual runs only (#420); pull requests run the Chromium/touch coverage shards.
-    if: github.event_name != 'pull_request'
    runs-on: ubuntu-latest
    # Layout comparisons depend on the fonts each browser falls back to, so browser jobs run in the
    # same pinned Playwright image as local runs (tag = @playwright/test in tools/vendor/package-lock.json;
@@ -222,9 +208,7 @@ jobs:
          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 }}/2
-        timeout-minutes: 18
        run: npm run --prefix tools/vendor test:workflows -- --project ${{ matrix.browser }} --shard ${{ matrix.shard }}/2
-      # Traces and the blob report (test-results/blob/) of a failed, timed-out or cancelled step.
      - name: Upload browser traces
        if: always()
        uses: actions/upload-artifact@v7
@@ -234,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()
@@ -245,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.
@@ -195,26 +195,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."""
@@ -375,44 +355,6 @@ async def _stop_background_work_on_cleanup(app):
    _stop_background_work()


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

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


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

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

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

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

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

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

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

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

@@ -1163,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
@@ -1229,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
            )
@@ -1254,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()

@@ -35,9 +35,6 @@ _LIBRARY_SORTS = ("newest", "oldest", "name", "rating")
 _MEDIA = ("all", "image", "video")
 _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"


@@ -58,9 +55,6 @@ _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, ""),
@@ -131,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")

@@ -150,8 +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")
    encoded = json.dumps(
        {key: state[key] for key in fields}, ensure_ascii=False, separators=(",", ":")
    )
@@ -191,10 +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
    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,9 +13,7 @@ same connection before commit. Owner rows and their timestamps never change.

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

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


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


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

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


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


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

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

        The recomputed projection must still match the preview's token; a
        mismatch is ``vocabulary-conflict`` with nothing written.
@@ -458,15 +422,15 @@ class VocabularyOperations:
        _limit(limit)
        key = _category_after(after)
        total = conn.execute(
-            _CATEGORY_ROWS + "SELECT COUNT(*) FROM counted"
+            _CATEGORY_GROUPS + "SELECT COUNT(*) FROM grouped"
        ).fetchone()[0]
        where, params = "", []
        if key is not None:
            where = " WHERE first_pid>? OR (first_pid=? AND value>?)"
            params = [key[0], key[0], key[1]]
        rows = conn.execute(
-            _CATEGORY_ROWS
-            + "SELECT value,first_pid,prompt_count,image_count FROM counted"
+            _CATEGORY_GROUPS
+            + "SELECT value,first_pid,prompt_count FROM grouped"
            + where
            + " ORDER BY first_pid,value LIMIT ?",
            [*params, limit + 1],
@@ -476,11 +440,7 @@ class VocabularyOperations:
        return {
            "library_epoch": epoch,
            "categories": [
-                {
-                    "value": row["value"],
-                    "prompt_count": row["prompt_count"],
-                    "image_count": row["image_count"],
-                }
+                {"value": row["value"], "prompt_count": row["prompt_count"]}
                for row in rows
            ],
            "total": total,
@@ -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
@@ -48,7 +48,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
@@ -73,12 +72,9 @@ 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:
@@ -88,7 +84,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

@@ -300,10 +295,6 @@ async def _gzip_middleware(request, handler):
    if len(compressed) >= len(body):
        return response

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

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

        # Register gzip compression middleware (once)
        global _gzip_registered
@@ -1036,4 +1018,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.

@@ -586,56 +583,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:
@@ -1671,14 +1630,7 @@ class AdminRoutesMixin:
                if self._review_file_linked(media_file, roots):
                    outcome = "unchanged"  # already linked: not a review case
                else:
-                    # The records name the item versions that count; the
-                    # saver anchor (#390) is checked on the captured bytes.
-                    self._record_scanned_review(
-                        media_file,
-                        roots,
-                        review,
-                        scanned=(records.get("canonical"), None),
-                    )
+                    self._record_scanned_review(media_file, roots, review)
            elif untraced and outcome == "unresolved":
                # Untraced by the default profile: the inspection profile may
                # still offer a choice (queued for review, never linked).
@@ -1700,6 +1652,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 +1680,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 +1793,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 +1837,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
@@ -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
@@ -28,12 +27,10 @@ from .history_current import (
    snapshot_current_output_scope,
 )
 from .inspection_service import CurrentFileChanged, inspect_current_file
-from .images import image_category_key

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


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

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

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

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

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

 from aiohttp import web

@@ -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
@@ -59,17 +58,13 @@ from .inspection_service import (
 )

 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,
    )
@@ -82,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,
    )
@@ -107,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
@@ -115,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:
@@ -521,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:
@@ -590,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:
@@ -603,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):
@@ -622,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()
@@ -660,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")
@@ -681,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

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

@@ -1156,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()
@@ -1172,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")
@@ -1198,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:
@@ -1310,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
@@ -1329,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])
@@ -1367,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]
@@ -2051,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)
@@ -2070,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
@@ -2311,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)
@@ -2350,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",
@@ -2399,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(
@@ -2449,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":
@@ -2518,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,
@@ -2538,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:
@@ -3775,58 +3440,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]] = {}
@@ -3904,25 +3536,17 @@ class ImageRoutesMixin:
                    except Exception:
                        # The link stays known; only its title is withheld.
                        self.logger.warning("Inspection link title could not be read")
-                # An output file's own category (#332); LoRA roots have none.
-                own = (
-                    self._read_own_category(outputs, path)
-                    if index < len(outputs)
-                    else None
-                )
                try:
                    observed = inspect_current_file(
                        path,
                        source_label=_public_path(roots[index]),
                        saved=saved,
-                        library=apply_own_category(
-                            self._inspection_library(saved, unavailable=unavailable),
-                            own,
+                        library=self._inspection_library(
+                            saved, unavailable=unavailable
                        ),
                        image_tags=self._inspection_image_tags(
                            roots[index], Path(relative).parts
                        ),
-                        recorded=recorded_output_lookup(self.db),
                    )
                except CurrentFileChanged:
                    return None
@@ -3985,19 +3609,6 @@ class ImageRoutesMixin:

        return read

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

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

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

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

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

 from aiohttp import web

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

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

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

        Returns ``queued``, ``fresh`` (its preview is current) or ``skipped``
        (not a media file under a current root, a link, a preview itself,
-        already queued, after the app's cleanup, or when its worker is refused
-        at interpreter exit). Never writes on the caller's thread.
+        already queued, or after the app's cleanup). Never writes on the
+        caller's thread.
        """
        if self._auto_thumbnails_shut:
            return "skipped"
@@ -7,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
@@ -44,10 +44,8 @@ from .lora_manager_layout import (
 )

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

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

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

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

 # Security scanning
 bandit[toml]>=1.9.4
@@ -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})=>{
@@ -735,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([
@@ -757,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)=>{
@@ -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)]] },
        ],
    };
 }
@@ -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();
@@ -231,8 +231,6 @@ test('paired Tag dialog captures', async ({ page, request }, testInfo) => {
    await expect(await request.post('/__test__/tagging/suggestions', { data: { scored: ALPINE } })).toBeOK();
    const save = () => tagDialog(page).locator('.dialog-actions .ca-primary').click();
    const status = () => tagDialog(page).locator('#tag-generation-status');
-    // D147: a state that blocks Save shows its reason beside the actions, not in the status line.
-    const notice = () => tagDialog(page).locator('.dialog-actions > .tag-action-notice');

    // Unavailable model.
    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-swinv2'] } })).toBeOK();
@@ -271,8 +269,7 @@ test('paired Tag dialog captures', async ({ page, request }, testInfo) => {
    await saveImageTags(request, path, CONCEPT_TAGS);
    await openTagDialog(page, 'production', 'dark');
    await save();
-    await expect(notice()).toHaveText('The file changed since it was previewed. Reopen the Tag dialog.');
-    await expect(status()).toHaveText('');
+    await expect(status()).not.toHaveText('');
    await shot('production-file-changed');
    await page.unroute(writes);
    await page.keyboard.press('Escape');
@@ -281,7 +278,7 @@ test('paired Tag dialog captures', async ({ page, request }, testInfo) => {
    await page.route(writes, route => route.fulfill({ status: 504, body: 'Gateway Timeout' }));
    await openTagDialog(page, 'production', 'dark');
    await save();
-    await expect(notice()).toHaveText('The save could not be confirmed. Retry sends the same tags again.');
+    await expect(status()).toHaveText('The save could not be confirmed. Retry sends the same tags again.');
    expect((await inventory(page)).actions.buttons.map(button => [button.text, button.primary, button.disabled])).toEqual(
        [['Retry', false, false], ['Cancel', false, false], ['Save manual tags', true, true]]);
    await shot('production-unknown-outcome');
@@ -1,94 +0,0 @@
-// A restore the open workspace page has not noticed yet (#413).
-//
-// Specs that restore through the API while a page is open check what the page does with a restore it did not see:
-// its next write is refused as "Prompt storage was restored since this dialog opened". But the page's Activity store
-// reads the job list every 15 s (activity-store.mjs POLL_MS), and a read the server answers while the restore job runs
-// makes the page follow it: when it finishes, the page is shown again from the restored data (S9, index.mjs
-// onRestoreFinished), which closes any open dialog. On a slow runner a restore can take longer than the time left to
-// the next read (CI run 40646112668: the restore took 16 s), so whether the page saw it depended on timing.
-//
-// `armUnseenRestores(page)`, before the page loads, passes every job-list read of the page through one route, so it
-// knows which reads the server has not answered yet. `unseenRestore(page, restoring)` then closes the gate, waits
-// for those reads' answers (sent before the restore began, they cannot list it), runs `restoring()`, and only after
-// it has answered lets the held reads go on: they read the restore as already ended, as a tab that read its job list
-// just before and just after the restore does. A restore that is never seen running never reloads the page.
-const JOBS = '**/prompt_manager/jobs';
-const gates = new WeakMap();
-
-/** Route `page`'s job-list reads through the restore gate. Call before the page's first navigation. */
-export async function armUnseenRestores(page) {
-    const gate = { closed: null, inFlight: 0, idle: [] };
-    gates.set(page, gate);
-    await page.route(JOBS, async route => {
-        if (gate.closed) {
-            await gate.closed;
-            return route.fallback();
-        }
-        gate.inFlight += 1;
-        try {
-            const response = await route.fetch();
-            await route.fulfill({ response }).catch(() => {});
-        } catch {
-            await route.abort().catch(() => {});
-        } finally {
-            gate.inFlight -= 1;
-            if (gate.inFlight === 0) for (const resolve of gate.idle.splice(0)) resolve();
-        }
-    });
-}
-
-/** Run `restoring()` (an API restore) unseen by `page`'s Activity store; resolves with what it resolves with. */
-export async function unseenRestore(page, restoring) {
-    const gate = gates.get(page);
-    if (!gate) throw new Error('armUnseenRestores(page) must run before the page loads');
-    let open;
-    gate.closed = new Promise(resolve => { open = resolve; });
-    try {
-        // Reads already on their way were sent before the restore: their answers cannot list it.
-        if (gate.inFlight > 0) await new Promise(resolve => gate.idle.push(resolve));
-        return await restoring();
-    } finally {
-        gate.closed = null;
-        open();
-    }
-}
-
-// A restore the open page does see run and finish (#415), driven by the test instead of the 15 s poll's timing. The
-// job is shaped as the server's (py/api/backup_restore.py: kind `restore`, one `errors` group, not cancellable).
-const RESTORE_JOB_ID = '415415415415415415415415415415ab';
-const restoreJob = state => ({ id: RESTORE_JOB_ID, kind: 'restore', title: 'Database restore', state, started_at: 1,
-    finished_at: state === 'running' ? null : 2, progress: 0, status_line: state === 'running' ? '' : 'Restored the test snapshot.',
-    processed: 0, total: 0, counters: { errors: 0 }, scope: {}, listed: { errors: 0 }, log_length: 0, cancellable: false });
-/** The Activity pill's link while the page follows that restore. */
-export const SEEN_RESTORE_PILL = `#/activity/${RESTORE_JOB_ID}`;
-/** The toast the page shows when it sees that restore finish (activity-kinds.mjs `restore.finishToast`). */
-export const SEEN_RESTORE_TOAST = 'Database restore finished · Restored the test snapshot.';
-
-/**
- * Call before the page's first navigation, after `armUnseenRestores(page)` (a later route wins). The page's first
- * job-list read lists a restore job running, so its Activity store follows it; its job stream is refused, so the store
- * reads the list again, and every later read is held until `finish()`, which answers them with the job finished and
- * resolves once one of those answers reached the page. The real restore the test runs meanwhile goes through the API.
- */
-export async function followRestore(page) {
-    let release;
-    const released = new Promise(resolve => { release = resolve; });
-    let first = true;
-    await page.route(`${JOBS}/*/events`, route => route.abort().catch(() => {}));
-    await page.route(JOBS, async route => {
-        if (first) {
-            first = false;
-            return route.fulfill({ json: { success: true, jobs: [restoreJob('running')] } }).catch(() => {});
-        }
-        await released;
-        // A read the page has aborted since (a newer read supersedes it) can no longer be answered.
-        return route.fulfill({ json: { success: true, jobs: [restoreJob('finished')] } }).catch(() => {});
-    });
-    return {
-        async finish() {
-            const answered = page.waitForResponse(response => new URL(response.url()).pathname === '/prompt_manager/jobs');
-            release();
-            await answered;
-        },
-    };
-}
@@ -1,7 +1,6 @@
 // Concept-vs-production inventory for the native Tags & categories screen (concept renderTags, app.js:719-729).
 // pageInventoryOf runs in the page; dialogs reuse the editor's inventoryOf. The concept is never rewritten:
 // mapVocabularyConcept / mapVocabularyDialog apply only the recorded deviations, each named with its ruling.
-import {diffInventory} from './library-editor-canonical-comparison.mjs';
 export {inventoryOf, diffInventory} from './library-editor-canonical-comparison.mjs';

 export function pageInventoryOf(main) {
@@ -62,51 +61,23 @@ export function pageInventoryOf(main) {
    };
 }

-const countOf=(count,noun)=>`${count} ${noun}${count===1?'':'s'}`;
-
-/**
- * D143 (#332): a category row counts the images whose own category it is: "N positive prompts · M images" when
- * prompts hold it too, "M images" for a value only images hold. Image-only rows follow every prompt-backed row, before
- * the closing Manage category row, each drawn as the concept's last category row with its own text (vocabulary-visual
- * checks this against the concept page with those rows added at runtime). `images` is `{value: count}`; `only` lists
- * the image-only values in their order.
- */
-export function withImageCounts(operations,{images={},only=[]}={}) {
-    const rows=operations.map(row=>images[row.h3.text]&&!only.includes(row.h3.text)
-        ?{...row,p:{...row.p,text:`${row.p.text} · ${countOf(images[row.h3.text],'image')}`}}:row);
-    const manage=rows.at(-1),last=rows.at(-2);
-    const added=only.map(value=>({...last,h3:{...last.h3,text:value},p:{...last.p,text:countOf(images[value],'image')}}));
-    return [...rows.slice(0,-1),...added,manage];
-}
-
 // Recorded deviations only (plan "Mock inventory" + decisions D1-D15 + ledger rulings). Everything else must be equal.
-// `imageCategories` (#332 D143) is the fixture's own image categories, none by default.
-export function mapVocabularyConcept(reference,imageCategories={}) {
-    const operations=reference.operations.map(row=>({...row,p:{...row.p,
-        // Ledger ruling: "1 positive prompts" -> singular, consistent with the shared plural helper (#238/#243).
-        text:row.p.text.replace(/^1 positive prompts$/,'1 positive prompt')}}));
+export function mapVocabularyConcept(reference) {
    return {...reference,
        table:{...reference.table,rows:reference.table.rows.map(row=>({...row,
            // Data, not a deviation: the concept tags each sample image with its prompt's tags; the vocabulary fixture
            // tags no image, so every Images count is 0 (#249 C2 retired #245 D3).
            images:'0'}))},
-        operations:withImageCounts(operations,imageCategories),
+        operations:reference.operations.map(row=>({...row,p:{...row.p,
+            // Ledger ruling: "1 positive prompts" -> singular, consistent with the shared plural helper (#238/#243).
+            text:row.p.text.replace(/^1 positive prompts$/,'1 positive prompt')}})),
    };
 }

-/** The page comparison: concept rows are the concept's sample tags; production appends fixture-only tags (D4). */
-export function compareVocabularyPage(reference,actual,imageCategories={}) {
-    const expected=mapVocabularyConcept(reference,imageCategories);
-    const shared=expected.table.rows.length;
-    return {diff:diffInventory(expected,{...actual,table:{...actual.table,rows:actual.table.rows.slice(0,shared)}}),
-        extra:actual.table.rows.slice(shared).map(row=>row.tag)};
-}
-
 // Concept dialogs are simpleInput (app.js:1138-1143). donors are concept inventories for controls the concept
 // shows elsewhere: a `.field select` and a `p.small` (Filters dialog, app.js:1351) and a danger dialog action
 // (Archive… in the editor, app.js:976), so added controls are held to concept tokens, never to production values.
-// `preview` is the Manage categories sentence once Preview has been pressed (D9; D144, #332, adds its images).
-export function mapVocabularyDialog(mode,reference,{filters,editor,categories,preview=null}) {
+export function mapVocabularyDialog(mode,reference,{filters,editor,categories}) {
    const fields=reference.fields.map(item=>({...item,
        // Inventory rows 27-29: the name is `required` (blank Apply is blocked natively).
        required:true}));
@@ -127,9 +98,9 @@ export function mapVocabularyDialog(mode,reference,{filters,editor,categories,pr
                // D9 / Task 8: the proposed name offers a category datalist (no trailing commas: one value).
                ...fields.map(item=>({...item,listed:true,commaOptions:false}))],
            // D9: the preview sentence is a `p.small`, empty and hidden until Preview.
-            small:[{...filters.small[0],text:preview??''}],
+            small:[{...filters.small[0],text:''}],
            // D9: the primary is `Preview` until a preview is shown, then `Apply`.
-            actions:{...reference.actions,buttons:preview===null?buttons.map(item=>item.text==='Apply'?{...item,text:'Preview'}:item):buttons}};
+            actions:{...reference.actions,buttons:buttons.map(item=>item.text==='Apply'?{...item,text:'Preview'}:item)}};
    }
    return {...reference,fields,actions:{...reference.actions,buttons}};
 }
@@ -1,14 +1,11 @@
-import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
-import {pageInventoryOf,inventoryOf,diffInventory,mapVocabularyConcept,mapVocabularyDialog,compareVocabularyPage} from './vocabulary-canonical-comparison.mjs';

 // Artifact-only captures of Tags & categories states that have no concept counterpart: the Manage categories
 // preview, loading and 1,000-category cap notes, tag conflict and restore notes, the Delete tag confirmation (D14),
 // empty lists (D12), a failed read with Retry, and Load more (D5). The page and the three concept dialogs are captured
 // as concept/production pairs by workspace-vocabulary.spec.mjs. There are deliberately no pixel assertions or
-// baselines: the maintainer accepts these captures visually before any baseline is added. The last test (#332 D143,
-// D144) compares the category rows with image counts and the Manage category preview against the concept.
+// baselines: the maintainer accepts these captures visually before any baseline is added.
 test.use({locale:'en-US',timezoneId:'UTC',reducedMotion:'reduce'});
 const route='/prompt_manager/workspace#/tags';
 const main=page=>page.locator('#workspace-main');
@@ -104,87 +101,3 @@ for(const [width,height] of [[1600,1100],[390,844]])for(const theme of ['dark','
    await testInfo.attach(`production-load-more-${width}-${theme}`,{path,contentType:'image/png'});
    await expect(rows(page)).toHaveCount(100);
 });
-
-// D143 and D144 (#332): with own image categories seeded (`image_categories`: "Landscapes" on two images, "Portraits"
-// on one image only), the Categories panel and the Manage category preview against the concept (renderTags, app.js
-// 719-729; the Manage dialog is its simpleInput, 1138-1143). The page is compared with D143 mapped, a model checked
-// against the concept page with those rows added at runtime; the preview with D9's sentence and D144's images.
-const concept='/__test__/canonical/workspace';
-const IMAGE_CATEGORIES=Object.freeze({images:{Landscapes:2,Portraits:1},only:['Portraits']});
-// D9's sentence; D144 adds the images holding the value ("and 2 images").
-const PREVIEW='“Landscapes” is used by 3 positive prompts and 2 images. Apply renames it to “Scenery”.';
-const pageOf=(page,production)=>page.locator(production?'#workspace-main':'#main').evaluate(pageInventoryOf);
-async function openConceptRoute(page,route,theme) {
-    await page.goto('about:blank');await page.goto(`${concept}#${route}`);
-    await page.getByRole('combobox',{name:'Theme',exact:true}).selectOption(theme);
-}
-/** The concept page as D143 records it: image counts after the prompt counts, image-only rows before Manage category. */
-function conceptWithImageCounts(page) {
-    return page.evaluate(({images,only})=>{
-        const surface=document.querySelectorAll('#main .two-col > section.surface')[1];
-        const rows=[...surface.querySelectorAll('.operation')];
-        const count=value=>`${images[value]} image${images[value]===1?'':'s'}`;
-        for(const row of rows) {
-            const value=row.querySelector('h3').textContent;
-            if(images[value]&&!only.includes(value))row.querySelector('p').textContent+=` · ${count(value)}`;
-        }
-        const manage=rows.at(-1),last=rows.at(-2);
-        for(const value of only) {
-            const row=last.cloneNode(true);row.querySelector('h3').textContent=value;row.querySelector('p').textContent=count(value);manage.before(row);
-        }
-    },IMAGE_CATEGORIES);
-}
-/** Concept controls the Manage dialog adds (as in workspace-vocabulary.spec.mjs): the Filters field select and p.small. */
-async function conceptDonors(page,theme,categories) {
-    await openConceptRoute(page,'images',theme);
-    await page.locator('#main').getByRole('button',{name:'Filters',exact:true}).click();await expect(page.locator('#modal')).toBeVisible();
-    const filters=await page.locator('#modal').evaluate(inventoryOf);
-    await openConceptRoute(page,'prompt/alpine',theme);
-    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();await expect(page.locator('#modal')).toBeVisible();
-    const editor=await page.locator('#modal').evaluate(inventoryOf);
-    return {filters,editor,categories};
-}
-
-for(const [width,height] of [[1600,1100],[390,844]])for(const theme of ['dark','light'])test(`category rows and the Manage category preview match the concept with image categories ${width}x${height} ${theme} (D143, D144)`,async({page,request},testInfo)=>{
-    await page.setViewportSize({width,height});
-    const manifest=await seed(request,{image_categories:true});
-    expect(manifest.image_categories).toEqual(IMAGE_CATEGORIES.images);
-    await openConceptRoute(page,'tags',theme);await expect(page.locator('#main h1')).toHaveText('Tags & categories');
-    await page.mouse.move(0,0);
-    const reference=await pageOf(page,false);
-    await conceptWithImageCounts(page);
-    const oracle=await pageOf(page,false);
-    await captureCanonicalState(page,testInfo,`concept-image-categories-${width}-${theme}`,'#main');
-    const donors=await conceptDonors(page,theme,['Landscapes','Architecture','Environments','Illustration','Portraits']);
-    await openConceptRoute(page,'tags',theme);
-    await page.locator('#main').getByRole('button',{name:'Review',exact:true}).click();await expect(page.locator('#modal')).toBeVisible();
-    const referenceDialog=await page.locator('#modal').evaluate(inventoryOf);
-
-    await open(page,theme,manifest.tags.length);
-    await expect(categoryOperation(page,'Portraits')).toHaveCount(1);
-    // The pointer still rests where the concept's Review was pressed: park it so no row is hovered.
-    await page.mouse.move(0,0);
-    const actual=await pageOf(page,true);
-    await captureCanonicalState(page,testInfo,`production-image-categories-${width}-${theme}`,'#workspace-main');
-    const box=await openDialog(page,categoryOperation(page,'Manage category').getByRole('button',{name:'Review',exact:true}));
-    await expect(box.getByLabel('Category',{exact:true})).toHaveValue('Landscapes');
-    await box.getByLabel('Proposed new category name',{exact:true}).fill('Scenery');await button(box,'Preview').click();
-    await expect(box.locator('p.small')).toHaveText(PREVIEW);
-    // The pressed primary keeps the pointer and focus; the concept is measured as it opens (focus on ×, no hover),
-    // which workspace-vocabulary.spec.mjs compares, so this state is restored before measuring the preview.
-    await page.mouse.move(0,0);await box.locator('.dialog-header button').focus();
-    const actualDialog=await box.evaluate(inventoryOf);
-    await captureCanonicalState(page,testInfo,`production-image-categories-preview-${width}-${theme}`);
-    const path=testInfo.outputPath('vocabulary-image-categories.json');
-    await writeFile(path,JSON.stringify({reference,oracle,actual,referenceDialog,actualDialog},null,2));
-    await testInfo.attach('vocabulary-image-categories',{path,contentType:'application/json'});
-
-    // The D143 model reproduces the concept page with the rows added at runtime.
-    expect.soft(diffInventory(mapVocabularyConcept(reference,IMAGE_CATEGORIES).operations,mapVocabularyConcept(oracle).operations),'D143 model').toEqual([]);
-    const {diff,extra}=compareVocabularyPage(reference,actual,IMAGE_CATEGORIES);
-    expect.soft(actual.operations.map(row=>[row.h3.text,row.p.text]).slice(0,-1),'category rows').toEqual([['Landscapes','3 positive prompts · 2 images'],
-        ['Architecture','1 positive prompt'],['Environments','1 positive prompt'],['Illustration','1 positive prompt'],['Portraits','1 image']]);
-    expect.soft(diff,'page differences after the recorded deviations and D143').toEqual([]);
-    expect.soft(extra,'fixture-only rows').toEqual([manifest.pair_only_tag,manifest.archived_only_tag,manifest.negative_only_tag,manifest.unused_tag]);
-    expect.soft(diffInventory(mapVocabularyDialog('manage',referenceDialog,{...donors,preview:PREVIEW}),actualDialog),'preview differences after D9 and D144').toEqual([]);
-});
@@ -42,13 +42,8 @@ test('actual gallery form saves a prompt that the admin page can edit and reload
    await page.locator(`[data-action="edit"][data-prompt-id="${id}"]`).click();
    const editor = page.locator(`.prompt-text[data-id="${id}"]`);
    await editor.fill('Browser edited portrait');
-    // The page shows the edit at once and saves it after: reload only once the save answered (a reload that wins the
-    // race abandons the PUT, as seen on WebKit in CI).
-    const savedEdit = page.waitForResponse(item => item.request().method() === 'PUT'
-        && item.url().endsWith(`/prompt_manager/prompts/${id}`));
    await editor.press('Enter');
    await expect(page.locator('.prompt-text').filter({ hasText: 'Browser edited portrait' })).toBeVisible();
-    expect((await savedEdit).ok()).toBe(true);
    await page.reload();
    await expect(page.locator('.prompt-text').filter({ hasText: 'Browser edited portrait' })).toBeVisible();
    const saved = await request.post('/prompt_manager/save', { data: { text: 'Browser saved landscape' } });
@@ -104,9 +99,35 @@ for (const leave of ['beforeunload', 'pagehide']) {
    });
 }

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

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

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

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

+test('downloaded backup restores deleted prompts, tags, and image links through the actual upload form', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    await expect(page.locator('.prompt-text')).toHaveCount(2);
+    const before = await promptSnapshot(request);
+    expect(before.map(prompt => prompt.tags)).toEqual([['cats'], ['dogs']]);
+    expect(before.every(prompt => prompt.images.length === 1)).toBe(true);
+    const backup = await downloadBackup(page);
+    const button = await deletePromptButton(page, 'Cat portrait');
+    confirmNextDialog(page, true, 'delete this prompt');
+    await button.click();
+    await expect(page.locator('.prompt-text')).toHaveCount(1);
+    await expect(await request.post('/prompt_manager/save', { data: { text: 'Added after backup', tags: ['temporary'] } })).toBeOK();
+    expect(await promptSnapshot(request)).not.toEqual(before);
+    await chooseRestore(page, backup);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    await expect(page.locator('.prompt-text')).toHaveCount(2);
+    await page.reload();
+    await expect(page.locator('.prompt-text').filter({ hasText: 'Cat portrait' })).toBeVisible();
+    await expect(page.locator('.prompt-text').filter({ hasText: 'Added after backup' })).toHaveCount(0);
+    expect(await promptSnapshot(request)).toEqual(before);
+    await page.goto('/prompt_manager/admin#/tags');
+    await page.locator('[data-tag-name="cats"]').click();
+    await expect(page.locator('#tagPromptsGrid')).toContainText('Cat portrait');
+    await page.locator('#tagPromptsGrid img').first().click();
+    await expect(page.locator('.viewer-canvas img')).toBeVisible();
+    await expect.poll(() => page.locator('.viewer-canvas img').evaluate(image => image.complete && image.naturalWidth > 0)).toBe(true);
+});
+
+test('restore validation and cancellation preserve live data and allow a valid retry', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    const before = await promptSnapshot(request);
+    const backup = await downloadBackup(page);
+    let uploads = 0;
+    page.on('request', request => { if (request.url().endsWith('/prompt_manager/restore')) uploads++; });
+    await page.locator('#restoreBtn').click();
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText('Please select a database file to restore', { exact: true })).toBeVisible();
+    await page.locator('#restoreFileInput').setInputFiles({ ...backup, name: 'backup.txt' });
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText('Please select a valid .db file', { exact: true })).toBeVisible();
+    expect(uploads).toBe(0);
+    await page.locator('#restoreFileInput').setInputFiles(backup);
+    confirmNextDialog(page, false, 'replace your current database');
+    await page.locator('#confirmRestore').click();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    expect(uploads).toBe(0);
+    await page.locator('#restoreFileInput').setInputFiles({ name: 'corrupt.db', mimeType: 'application/octet-stream', buffer: Buffer.from('not a SQLite database') });
+    confirmNextDialog(page, true, 'corrupt.db');
+    const rejected = page.waitForResponse(response => response.url().endsWith('/prompt_manager/restore'));
+    await page.locator('#confirmRestore').click();
+    expect((await rejected).status()).toBe(400);
+    await expect(page.getByText(/Restore failed:/)).toBeVisible();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    await expect(page.locator('#confirmRestore')).toBeEnabled();
+    expect(await promptSnapshot(request)).toEqual(before);
+    await page.locator('#restoreFileInput').setInputFiles(backup);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    expect(await promptSnapshot(request)).toEqual(before);
+});
+
+test('backup and restore recover from interrupted network requests without losing data', async ({ page, request }) => {
+    await page.goto('/prompt_manager/admin');
+    const before = await promptSnapshot(request);
+    await page.route('**/prompt_manager/backup', route => route.abort('failed'), { times: 1 });
+    await page.locator('#backupBtn').click();
+    await expect(page.getByText(/Backup failed:/)).toBeVisible();
+    const backup = await downloadBackup(page);
+    await chooseRestore(page, backup);
+    await page.route('**/prompt_manager/restore', route => route.abort('failed'), { times: 1 });
+    confirmNextDialog(page, true, backup.name);
+    await page.locator('#confirmRestore').click();
+    await expect(page.getByText(/Restore failed:/)).toBeVisible();
+    await expect(page.locator('#confirmRestore')).toBeEnabled();
+    await expect(page.locator('#restoreModal')).toBeVisible();
+    expect(await promptSnapshot(request)).toEqual(before);
+    confirmNextDialog(page, true, backup.name);
+    await confirmRestoreAndWait(page);
+    expect(await promptSnapshot(request)).toEqual(before);
+});
+
 test('prompt deletion requires confirmation and can retry after a network failure', async ({ page, request }) => {
    await page.goto('/prompt_manager/admin');
    const before = await promptSnapshot(request);
@@ -261,3 +393,98 @@ test('prompt deletion requires confirmation and can retry after a network failur
        await expect(await request.get(url)).toBeOK();
    }
 });
+
+// The duplicate scan reads the output root only, but the fixture's input root holds a different
+// shared/same.png. A bare /images/serve/<path> URL tries every gallery root in turn, so once the
+// output copy is deleted it answers 200 with the input copy: check each file in its own root.
+const serveIn = (root, path) => `/prompt_manager/images/serve/${path.split(/[\\/]/).map(encodeURIComponent).join('/')}?root=${root}`;
+const rootOf = url => new URL(url, 'http://gallery.test').searchParams.get('root');
+
+// Which copy the scan keeps depends on file times: the fixture stamps shared/same.png with the
+// wall clock, and the kernel can stamp its bulk copies a fraction of a millisecond earlier.
+// listOrder rewrites the finished scan's groups so a test can pick the order it needs.
+async function openDuplicateScan(page, request, listOrder = null) {
+    await expect(await request.post('/__test__/reset', { data: { extra_images: 2 } })).toBeOK();
+    if (listOrder) {
+        await page.route('**/prompt_manager/scan_duplicates/stream', async route => {
+            const response = await route.fetch();
+            const body = (await response.text()).replace(/^data: (.*)$/gm, (line, json) => {
+                const event = JSON.parse(json);
+                if (event.type !== 'complete') return line;
+                for (const group of event.duplicates) group.images = listOrder(group.images);
+                return `data: ${JSON.stringify(event)}`;
+            });
+            await route.fulfill({ response, body });
+        });
+    }
+    await page.goto('/prompt_manager/gallery');
+    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(4);
+    const originals = await page.locator('#galleryGrid img[data-original]').evaluateAll(images => images.map(image => image.dataset.original));
+    const output = rootOf(originals.find(url => url.includes('/bulk/')));
+    const input = rootOf(originals.find(url => url.includes('/shared/same.png') && rootOf(url) !== output));
+    expect(output).not.toBeNull();
+    expect(input).not.toBeNull();
+    await page.locator('#settingsBtn').click();
+    await page.locator('#scanDuplicatesBtn').click();
+    await expect(page.locator('#duplicatesCount')).toHaveText('1');
+    const candidates = page.locator('.duplicate-checkbox');
+    await expect(candidates).toHaveCount(2);
+    return { originals, output, input, candidates };
+}
+
+async function expectOnlySelectedGone(page, request, { originals, output, input }, selected, retained) {
+    expect((await request.get(serveIn(output, selected))).status()).toBe(404);
+    await expect(await request.get(serveIn(output, retained))).toBeOK();
+    await expect(await request.get(serveIn(input, 'shared/same.png'))).toBeOK();
+    await page.reload();
+    await expect(page.locator('#galleryGrid .image-item')).toHaveCount(3);
+    const remaining = await page.locator('#galleryGrid img[data-original]').evaluateAll(images => images.map(image => image.dataset.original));
+    expect(remaining).toHaveLength(originals.length - 1);
+    for (const url of remaining) {
+        expect(originals).toContain(url);
+        await expect(await request.get(url)).toBeOK();
+    }
+}
+
+test('duplicate cleanup cancels safely and deletes only the selected file after a retry', async ({ page, request }) => {
+    const scan = await openDuplicateScan(page, request);
+    const { output, candidates } = scan;
+    const selected = await candidates.first().getAttribute('data-image-path');
+    const retained = await candidates.last().getAttribute('data-image-path');
+    await candidates.first().check();
+    let deletes = 0;
+    page.on('request', request => { if (request.url().endsWith('/delete_duplicate_images')) deletes++; });
+    confirmNextDialog(page, false, 'permanently delete 1 duplicate image files');
+    await page.locator('#removeDuplicatesBtn').click();
+    expect(deletes).toBe(0);
+    await expect(await request.get(serveIn(output, selected))).toBeOK();
+    await page.route('**/prompt_manager/delete_duplicate_images', route => route.abort('failed'), { times: 1 });
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    await page.locator('#removeDuplicatesBtn').click();
+    await expect(page.getByText('Failed to delete duplicate images', { exact: true })).toBeVisible();
+    await expect(page.locator('#removeDuplicatesBtn')).toBeEnabled();
+    await expect(await request.get(serveIn(output, selected))).toBeOK();
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    const deleted = page.waitForResponse(response => response.url().endsWith('/delete_duplicate_images'));
+    await page.locator('#removeDuplicatesBtn').click();
+    expect((await (await deleted).json())).toMatchObject({ success: true, deleted_count: 1, failed_count: 0 });
+    await expect(page.locator('#duplicatesModal')).toBeHidden();
+    await expectOnlySelectedGone(page, request, scan, selected, retained);
+});
+
+test('deleting a duplicate whose path another gallery root also holds removes only the scanned copy', async ({ page, request }) => {
+    // The order CI saw: a bulk copy stamped first, so shared/same.png is the first Delete candidate.
+    const ciOrder = ['bulk/0000.png', 'shared/same.png', 'bulk/0001.png'];
+    const rank = image => ciOrder.indexOf(image.path.replace(/\\/g, '/'));
+    const scan = await openDuplicateScan(page, request, images => [...images].sort((a, b) => rank(a) - rank(b)));
+    const selected = await scan.candidates.first().getAttribute('data-image-path');
+    const retained = await scan.candidates.last().getAttribute('data-image-path');
+    expect(selected.replace(/\\/g, '/')).toBe('shared/same.png');
+    await scan.candidates.first().check();
+    confirmNextDialog(page, true, 'permanently delete 1 duplicate image files');
+    const deleted = page.waitForResponse(response => response.url().endsWith('/delete_duplicate_images'));
+    await page.locator('#removeDuplicatesBtn').click();
+    expect((await (await deleted).json())).toMatchObject({ success: true, deleted_count: 1, failed_count: 0 });
+    await expect(page.locator('#duplicatesModal')).toBeHidden();
+    await expectOnlySelectedGone(page, request, scan, selected, retained);
+});
@@ -1,856 +0,0 @@
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-// Collections (#331): the sidebar COLLECTIONS group (D136, concept index.html 28–31, app.js 336–339), the collection
-// page `#/collection/<id>` with its Edit (D137, concept render a1186–1189) and saved views on a collection (D140).
-const workspace = '/prompt_manager/workspace';
-const API = '/prompt_manager/collections';
-const main = page => page.locator('#workspace-main');
-const heading = page => main(page).getByRole('heading', { level: 1 });
-const breadcrumb = page => page.locator('#workspace-breadcrumb');
-const description = page => main(page).locator('.heading p.muted');
-const missingNote = page => main(page).locator('.heading p.small');
-const search = page => page.getByRole('searchbox', { name: 'Search workspace', exact: true });
-const imageCards = page => page.locator('article[data-image-key]');
-const collectionsNav = page => page.getByRole('navigation', { name: 'Collections', exact: true });
-const collectionsLabel = page => page.locator('aside.sidebar .sidebar-label', { hasText: 'COLLECTIONS' });
-const rows = page => collectionsNav(page).locator('a[data-route^="collection/"]');
-const row = (page, name) => rows(page).filter({ hasText: name });
-const savedNav = page => page.getByRole('navigation', { name: 'Saved views', exact: true });
-const editButton = page => main(page).locator('.heading-actions > button').first();
-const editDialog = page => page.getByRole('dialog', { name: 'Edit collection', exact: true });
-const deleteDialog = page => page.getByRole('dialog', { name: 'Delete collection', exact: true });
-const nameField = page => editDialog(page).getByRole('textbox', { name: 'Collection name', exact: true });
-const toast = page => page.locator('#workspace-toast');
-
-async function seed(request) {
-    const response = await request.post('/__test__/collections/seed');
-    await expect(response).toBeOK();
-    return response.json();
-}
-
-async function listed(request) {
-    const response = await request.get(API);
-    await expect(response).toBeOK();
-    return (await response.json()).collections;
-}
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await expect(await request.post('/__test__/reset')).toBeOK();
-    page.collectionErrors = [];
-    page.on('pageerror', error => page.collectionErrors.push(error.message));
-    // D51: deleting asks inside the dialog; no browser dialog (window.confirm) may ever open.
-    page.on('dialog', dialog => { page.collectionErrors.push(`browser ${dialog.type()}`); dialog.dismiss().catch(() => {}); });
-});
-
-test.afterEach(async ({ page, browserName }) => {
-    await saveCoverage(page, browserName);
-    expect(page.collectionErrors).toEqual([]);
-});
-
-test('a collection row opens its page', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    await page.goto(`${workspace}#/images`);
-    // D136: name order, the listed-member count, no "PROPOSED" badge.
-    await expect(collectionsLabel(page)).toBeVisible();
-    await expect(collectionsLabel(page)).toHaveText('COLLECTIONS');
-    await expect(rows(page)).toHaveCount(2);
-    await expect(rows(page).nth(0)).toContainText('Experiments');
-    await expect(rows(page).nth(1)).toContainText('Landscapes');
-    await expect(row(page, 'Experiments').locator('.nav-count')).toHaveText('8');
-    await expect(row(page, 'Landscapes').locator('.nav-count')).toHaveText('12');
-    await expect(row(page, 'Landscapes')).toHaveAttribute('href', `#/collection/${id}`);
-    await expect(row(page, 'Landscapes').locator('svg')).toHaveCount(1);
-    await expect(page.locator('aside.sidebar .new-label')).toHaveCount(0);
-    await expect(imageCards(page)).toHaveCount(21);
-
-    await row(page, 'Landscapes').click();
-    await expect(page).toHaveURL(new RegExp(`#/collection/${id}$`));
-    await expect(heading(page)).toHaveText('Landscapes');
-    await expect(breadcrumb(page)).toHaveText('Collection');
-    await expect(page).toHaveTitle('Collection · Prompt Manager');
-    await expect(row(page, 'Landscapes')).toHaveAttribute('aria-current', 'page');
-    await expect(description(page)).toHaveText('Your generations, their prompts, and the next idea.');
-    await expect(imageCards(page)).toHaveCount(12);
-    for (const path of manifest.files.Landscapes) {
-        await expect(page.locator(`article[data-image-key$=":${path}"]`)).toHaveCount(1);
-    }
-    // MC3: the member whose file is gone is not listed and is counted in the note.
-    await expect(missingNote(page)).toHaveText('1 image in this collection is not in your current sources.');
-
-    // Every Images filter narrows the members.
-    await search(page).fill('landscape_03');
-    await expect(imageCards(page)).toHaveCount(1);
-    await search(page).fill('');
-    await expect(imageCards(page)).toHaveCount(12);
-
-    await row(page, 'Experiments').click();
-    await expect(heading(page)).toHaveText('Experiments');
-    await expect(imageCards(page)).toHaveCount(8);
-    await expect(missingNote(page)).toHaveCount(0);
-});
-
-test('without collections the group shows no label and no rows', async ({ page }) => {
-    await page.goto(`${workspace}#/images`);
-    await expect(imageCards(page).first()).toBeVisible();
-    await expect(collectionsNav(page)).toHaveCount(1);
-    await expect(rows(page)).toHaveCount(0);
-    await expect(collectionsLabel(page)).toBeHidden();
-});
-
-test('a collection page neither restores nor replaces the Images return state', async ({ page, request }) => {
-    const manifest = await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await search(page).fill('experiment');
-    await expect(imageCards(page)).toHaveCount(8);
-    await row(page, 'Landscapes').click();
-    await expect(search(page)).toHaveValue('');
-    await expect(imageCards(page)).toHaveCount(12);
-    await search(page).fill('landscape_01');
-    await expect(imageCards(page)).toHaveCount(1);
-    await page.goto(`${workspace}#/images`);
-    await expect(search(page)).toHaveValue('experiment');
-    expect(manifest.collections.Landscapes.count).toBe(12);
-});
-
-test('Edit renames the open collection; a taken name stays in the dialog', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(heading(page)).toHaveText('Landscapes');
-    await expect(editButton(page)).toHaveText('Edit');
-    await editButton(page).click();
-    await expect(nameField(page)).toHaveValue('Landscapes');
-    await expect(editDialog(page).locator('.dialog-actions button')).toHaveText(['Delete…', 'Cancel', 'Save']);
-
-    // CUJ 3: names are unique ignoring case.
-    await nameField(page).fill('experiments');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(editDialog(page).getByRole('alert')).toHaveText('A collection named “experiments” already exists.');
-    await expect(heading(page)).toHaveText('Landscapes');
-
-    await nameField(page).fill('  Landscape   grids ');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(editDialog(page)).toHaveCount(0);
-    await expect(toast(page)).toHaveText('Collection renamed.');
-    await expect(heading(page)).toHaveText('Landscape grids');
-    await expect(breadcrumb(page)).toHaveText('Collection');
-    await expect(row(page, 'Landscape grids')).toHaveAttribute('aria-current', 'page');
-    await expect(rows(page).nth(1)).toContainText('Landscape grids');
-    expect((await listed(request)).map(item => item.name)).toEqual(['Experiments', 'Landscape grids']);
-});
-
-test('a failed rename keeps the dialog; a failed delete changes nothing', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Experiments;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(heading(page)).toHaveText('Experiments');
-    let failing = true;
-    await page.route(`**${API}/${id}`, route => failing
-        ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"The collection could not be changed."}' })
-        : route.fallback());
-    await editButton(page).click();
-    await nameField(page).fill('Tests');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('The collection could not be renamed. Try again.');
-    await expect(editDialog(page)).toBeVisible();
-    await expect(heading(page)).toHaveText('Experiments');
-    await editDialog(page).getByRole('button', { name: 'Delete…', exact: true }).click();
-    await expect(deleteDialog(page).locator('p')).toHaveText(
-        'Delete “Experiments”? Its 8 images stay where they are; only the collection is removed.');
-    await deleteDialog(page).getByRole('button', { name: 'Delete', exact: true }).click();
-    await expect(toast(page)).toHaveText('The collection could not be deleted. Try again.');
-    await expect(page).toHaveURL(new RegExp(`#/collection/${id}$`));
-    expect(await listed(request)).toHaveLength(2);
-    failing = false;
-});
-
-test('Delete removes the collection only after confirming, and leaves every file', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await editButton(page).click();
-    await editDialog(page).getByRole('button', { name: 'Delete…', exact: true }).click();
-    // The stored count: 12 listed members and the missing one.
-    await expect(deleteDialog(page).locator('p')).toHaveText(
-        'Delete “Landscapes”? Its 13 images stay where they are; only the collection is removed.');
-    await deleteDialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(deleteDialog(page)).toHaveCount(0);
-    expect(await listed(request)).toHaveLength(2);
-
-    await editButton(page).click();
-    await editDialog(page).getByRole('button', { name: 'Delete…', exact: true }).click();
-    await deleteDialog(page).getByRole('button', { name: 'Delete', exact: true }).click();
-    await expect(toast(page)).toHaveText('Collection deleted.');
-    await expect(page).toHaveURL(/#\/images$/);
-    await expect(heading(page)).toHaveText('Images');
-    await expect(rows(page)).toHaveCount(1);
-    await expect(imageCards(page)).toHaveCount(21);
-    expect((await listed(request)).map(item => item.name)).toEqual(['Experiments']);
-});
-
-test('an unknown collection says it no longer exists, with the way back to Images', async ({ page, request }) => {
-    await seed(request);
-    await page.goto(`${workspace}#/collection/999999`);
-    await expect(heading(page)).toHaveText('Collection');
-    await expect(breadcrumb(page)).toHaveText('Collection');
-    await expect(description(page)).toHaveText('This collection no longer exists.');
-    await expect(imageCards(page)).toHaveCount(0);
-    await main(page).getByRole('link', { name: 'Open Images', exact: true }).click();
-    await expect(page).toHaveURL(/#\/images$/);
-    await expect(imageCards(page)).toHaveCount(21);
-});
-
-test('a failed list says so and Retry reads it again', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Experiments;
-    let failing = true;
-    await page.route(`**${API}`, route => failing
-        ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"Collections could not be read."}' })
-        : route.fallback());
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(description(page)).toHaveText('Collections could not be loaded. Your saved data has not changed.');
-    await expect(description(page)).toHaveAttribute('role', 'alert');
-    await expect(rows(page)).toHaveCount(0);
-    failing = false;
-    await main(page).getByRole('button', { name: 'Retry', exact: true }).click();
-    await expect(heading(page)).toHaveText('Experiments');
-    await expect(imageCards(page)).toHaveCount(8);
-    await expect(rows(page)).toHaveCount(2);
-});
-
-test('a saved view keeps its collection, and says so once the collection is deleted (MC6)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const view = manifest.saved_view;
-    await page.goto(`${workspace}#/images`);
-    await savedNav(page).locator(`a[data-route="saved/${view.id}"]`).click();
-    await expect(heading(page)).toHaveText(view.name);
-    await expect(breadcrumb(page)).toHaveText(view.name);
-    await expect(imageCards(page)).toHaveCount(8);
-    // A saved view is not the collection page: no missing note.
-    await expect(missingNote(page)).toHaveCount(0);
-
-    // Save view on a collection page stores the collection.
-    await row(page, 'Landscapes').click();
-    await expect(imageCards(page)).toHaveCount(12);
-    await search(page).fill('landscape_1');
-    await expect(imageCards(page)).toHaveCount(3);
-    await main(page).getByRole('button', { name: 'Save view', exact: true }).click();
-    const save = page.getByRole('dialog', { name: 'Save this view', exact: true });
-    await save.getByRole('textbox', { name: 'View name', exact: true }).fill('Grid seed');
-    await save.getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('Saved view added to the sidebar.');
-    const views = (await (await request.get('/prompt_manager/saved-views')).json()).views;
-    const saved = views.find(item => item.name === 'Grid seed');
-    expect(saved.state).toMatchObject({ q: 'landscape_1', favorites: false, collection: String(manifest.collections.Landscapes.id) });
-
-    await expect(await request.delete(`${API}/${manifest.collections.Experiments.id}`)).toBeOK();
-    await page.goto(`${workspace}#/saved/${view.id}`);
-    await expect(heading(page)).toHaveText(view.name);
-    await expect(main(page).locator('.empty')).toHaveText('The collection this view uses was deleted.');
-    await expect(main(page).locator('.empty')).toBeVisible();
-    await expect(imageCards(page)).toHaveCount(0);
-    await expect(main(page).getByRole('button', { name: 'Retry', exact: true })).toBeHidden();
-});
-
-test('a collection deleted in another tab shows the deleted-collection page', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Experiments;
-    await page.goto(`${workspace}#/images`);
-    await expect(rows(page)).toHaveCount(2);
-    await expect(await request.delete(`${API}/${id}`)).toBeOK();
-    await row(page, 'Experiments').click();
-    await expect(description(page)).toHaveText('This collection no longer exists.');
-    await expect(rows(page)).toHaveCount(1);
-});
-
-// D136 / CUJ 15: the rows show and open at desktop and phone width in both themes. The concept's own phone rule hides
-// every nav count there, so the rows keep their counts only at desktop width.
-for (const [width, height] of [[1600, 1100], [390, 844]]) for (const theme of ['dark', 'light']) {
-    test(`collection rows show and open at ${width}x${height} ${theme}`, async ({ page, request }) => {
-        const manifest = await seed(request);
-        await page.setViewportSize({ width, height });
-        await page.goto(`${workspace}#/images`);
-        await page.getByRole('combobox', { name: 'Theme', exact: true }).selectOption(theme);
-        for (const name of ['Experiments', 'Landscapes']) await expect(row(page, name)).toBeVisible();
-        const count = row(page, 'Landscapes').locator('.nav-count');
-        if (width > 950) await expect(count).toBeVisible();
-        else await expect(count).toBeHidden();
-        // Phone width: the label stays hidden as every sidebar label is; desktop shows it.
-        if (width > 950) await expect(collectionsLabel(page)).toBeVisible();
-        else await expect(collectionsLabel(page)).toBeHidden();
-        expect(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)).toBe(true);
-        await row(page, 'Landscapes').click();
-        await expect(page).toHaveURL(new RegExp(`#/collection/${manifest.collections.Landscapes.id}$`));
-        await expect(heading(page)).toHaveText('Landscapes');
-        await expect(imageCards(page)).toHaveCount(12);
-    });
-}
-
-test('a finished restore reads the collections again', async ({ page, request }) => {
-    await seed(request);
-    await expect(await request.post('/__test__/system/reset')).toBeOK();
-    await expect(await request.post('/__test__/jobs/restart')).toBeOK();
-    try {
-        const backup = await request.get('/prompt_manager/backup');
-        await expect(backup).toBeOK();
-        const bytes = await backup.body();
-        const [experiments] = await listed(request);
-        await expect(await request.delete(`${API}/${experiments.id}`)).toBeOK();
-        await page.goto(`${workspace}#/system/backups`);
-        await expect(rows(page)).toHaveCount(1);
-        const chooser = page.waitForEvent('filechooser');
-        await page.getByRole('button', { name: 'Review restore…', exact: true }).click();
-        await (await chooser).setFiles({ name: 'prompts_backup_20261027_093000.db', mimeType: 'application/octet-stream', buffer: bytes });
-        await page.locator('dialog#modal[open]').getByRole('button', { name: 'Restore', exact: true }).click();
-        await expect(toast(page)).toHaveText(/^Database restore finished · /);
-        // The list was read again without a reload.
-        await expect(rows(page)).toHaveCount(2);
-        await expect(row(page, 'Experiments').locator('.nav-count')).toHaveText('8');
-    } finally {
-        await request.post('/__test__/jobs/restart');
-        await request.post('/__test__/system/reset');
-    }
-});
-
-test('renaming a collection deleted in another tab says so and shows the deleted-collection page', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Experiments;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(heading(page)).toHaveText('Experiments');
-    await editButton(page).click();
-    await expect(await request.delete(`${API}/${id}`)).toBeOK();
-    await nameField(page).fill('Tests');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('That collection no longer exists.');
-    await expect(editDialog(page)).toHaveCount(0);
-    await expect(description(page)).toHaveText('This collection no longer exists.');
-    await expect(rows(page)).toHaveCount(1);
-});
-
-/** A Playwright hold on the collections list read: `held` fills as reads arrive; `release()` lets them all through. */
-async function holdListReads(page, answer = route => route.fallback()) {
-    const held = [];
-    let open = false;
-    await page.route(`**${API}`, route => {
-        if (route.request().method() !== 'GET') return route.fallback();
-        if (open) return answer(route);
-        held.push(route);
-        return undefined;
-    });
-    return {
-        held,
-        async release() {
-            open = true;
-            for (const route of held.splice(0)) await answer(route).catch(() => {});
-        },
-    };
-}
-
-test('a list read superseded by another read still opens a collection made since (review M1)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const listing = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1')).json();
-    const [file] = listing.images;
-    await page.goto(`${workspace}#/collection/${manifest.collections.Landscapes.id}`);
-    await expect(heading(page)).toHaveText('Landscapes');
-    // Another tab makes "Fresh"; this tab does not list it yet.
-    const added = await request.post(`${API}/items`, { data: { name: 'Fresh',
-        items: [{ root_index: file.root_index, root_scope: file.root_scope, path: file.path }] } });
-    await expect(added).toBeOK();
-    const fresh = (await added.json()).collection.id;
-    await expect(rows(page)).toHaveCount(2);
-    const hold = await holdListReads(page);
-    // A rename schedules the 300 ms count re-read; opening "Fresh" first reads the list once more. The timer's read
-    // supersedes that one while both are held.
-    await editButton(page).click();
-    await nameField(page).fill('Landscape grids');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('Collection renamed.');
-    await page.evaluate(hash => { window.location.hash = hash; }, `#/collection/${fresh}`);
-    await expect.poll(() => hold.held.length).toBeGreaterThanOrEqual(2);
-    await expect(main(page)).not.toContainText('Collections could not be loaded.');
-    await hold.release();
-    await expect(heading(page)).toHaveText('Fresh');
-    await expect(imageCards(page)).toHaveCount(1);
-});
-
-test('a listing that finds the collection gone while the list still has it offers Retry (review M2)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Experiments;
-    let gone = true;
-    await page.route('**/prompt_manager/images/output?*', route => gone && route.request().url().includes(`collection=${id}`)
-        ? route.fulfill({ status: 404, contentType: 'application/json',
-            body: '{"success":false,"error":"Collection not found","code":"collection-not-found"}' })
-        : route.fallback());
-    await page.goto(`${workspace}#/images`);
-    await expect(rows(page)).toHaveCount(2);
-    // The shell's re-read is held, then fails: the page must not stay blank.
-    const hold = await holdListReads(page, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: '{"success":false,"error":"Collections could not be read."}' }));
-    await row(page, 'Experiments').click();
-    await expect.poll(() => hold.held.length).toBe(1);
-    await hold.release();
-    const retry = main(page).getByRole('button', { name: 'Retry', exact: true });
-    await expect(retry).toBeVisible();
-    await expect(main(page).locator('#gallery-continuation p')).toHaveText('Images could not be loaded. Retry or rescan the collection.');
-    gone = false;
-    await page.unroute(`**${API}`);
-    await retry.click();
-    await expect(imageCards(page)).toHaveCount(8);
-
-    // The list read again still lists it: the same Retry, never a blank page.
-    gone = true;
-    await page.evaluate(() => { window.location.hash = '#/images'; });
-    await expect(heading(page)).toHaveText('Images');
-    await row(page, 'Experiments').click();
-    await expect(retry).toBeVisible();
-    gone = false;
-    await retry.click();
-    await expect(imageCards(page)).toHaveCount(8);
-});
-
-test('the missing-members note follows the list read again (review L2)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    let missing = null;
-    await page.route(`**${API}`, async route => {
-        if (route.request().method() !== 'GET' || missing === null) return route.fallback();
-        const response = await route.fetch();
-        const data = await response.json();
-        data.collections = data.collections.map(item => item.id === id ? { ...item, missing } : item);
-        return route.fulfill({ response, json: data });
-    });
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(missingNote(page)).toHaveText('1 image in this collection is not in your current sources.');
-    const rename = async name => {
-        await editButton(page).click();
-        await nameField(page).fill(name);
-        await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-        await expect(toast(page)).toHaveText('Collection renamed.');
-    };
-    missing = 3;
-    await rename('Landscapes A');
-    await expect(missingNote(page)).toHaveText('3 images in this collection are not in your current sources.');
-    missing = 0;
-    await rename('Landscapes B');
-    await expect(missingNote(page)).toHaveCount(0);
-    missing = 1;
-    await rename('Landscapes C');
-    await expect(missingNote(page)).toHaveText('1 image in this collection is not in your current sources.');
-});
-
-test('a rename that settles after its dialog closed leaves the next dialog open (review L1)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(imageCards(page)).toHaveCount(12);
-    let release;
-    const released = new Promise(resolve => { release = resolve; });
-    await page.route(`**${API}/${id}`, async route => {
-        if (route.request().method() !== 'PATCH') return route.fallback();
-        await released;
-        return route.fallback();
-    });
-    await editButton(page).click();
-    await nameField(page).fill('Later');
-    await editDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await page.keyboard.press('Escape');
-    await expect(editDialog(page)).toHaveCount(0);
-    await main(page).getByRole('button', { name: 'Save view', exact: true }).click();
-    const save = page.getByRole('dialog', { name: 'Save this view', exact: true });
-    await expect(save).toBeVisible();
-    release();
-    await expect(heading(page)).toHaveText('Later');
-    await expect(save).toBeVisible();
-});
-
-test('a page that says a collection or view could not be opened takes focus after a route change (review L3)', async ({ page, request }) => {
-    await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await expect(heading(page)).toHaveText('Images');
-    await page.evaluate(() => { window.location.hash = '#/collection/999999'; });
-    await expect(description(page)).toHaveText('This collection no longer exists.');
-    await expect(heading(page)).toBeFocused();
-
-    await page.route(`**${API}`, route => route.request().method() === 'GET'
-        ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"x"}' })
-        : route.fallback());
-    await page.evaluate(() => { window.location.hash = '#/images'; });
-    await expect(heading(page)).toHaveText('Images');
-    await page.evaluate(() => { window.location.hash = '#/collection/999998'; });
-    await expect(main(page).getByRole('button', { name: 'Retry', exact: true })).toBeVisible();
-    await expect(heading(page)).toBeFocused();
-
-    await page.route('**/prompt_manager/saved-views', route => route.request().method() === 'GET'
-        ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"x"}' })
-        : route.fallback());
-    await page.evaluate(() => { window.location.hash = '#/saved/5'; });
-    await expect(description(page)).toHaveText('Saved views could not be loaded. Your saved data has not changed.');
-    await expect(heading(page)).toBeFocused();
-});
-
-// #331 D138 (design §7): the selection bar's Add to collection and Remove from collection.
-const bar = page => page.locator('#bulkbar > .bulkbar');
-const barButton = (page, name) => bar(page).getByRole('button', { name, exact: true });
-const addDialog = page => page.getByRole('dialog', { name: 'Add selected images to collection', exact: true });
-const addField = page => addDialog(page).getByRole('combobox', { name: 'Collection name', exact: true });
-const check = (page, file) => page.getByRole('checkbox', { name: `Select ${file}`, exact: true }).check();
-const card = (page, path) => page.locator(`article[data-image-key$=":${path}"]`);
-
-/** Add the checked images under `name` through the bar's dialog. */
-async function addChecked(page, name) {
-    await barButton(page, 'Add to collection').click();
-    await expect(addDialog(page)).toBeVisible();
-    await addField(page).fill(name);
-    await addDialog(page).getByRole('button', { name: 'Add', exact: true }).click();
-    await expect(addDialog(page)).toHaveCount(0);
-}
-
-test('Add to collection creates a collection and adds to it ignoring case (CUJ 1–3)', async ({ page, request }) => {
-    await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await expect(imageCards(page)).toHaveCount(21);
-    for (const file of ['loose.png', 'landscape_01.png', 'experiment_01.png']) await check(page, file);
-    await expect(bar(page).locator('button')).toHaveText(['Add tags', 'Auto-tag selected', 'Set category', 'Add to collection',
-        'Export metadata', 'Clear']);
-    await barButton(page, 'Add to collection').click();
-    // The concept's simpleInput with Add (D138) and the existing names as suggestions.
-    await expect(addDialog(page).locator('label')).toHaveText('Collection name');
-    await expect(addField(page)).toHaveValue('');
-    await expect(addField(page)).toHaveAttribute('maxlength', '100');
-    await expect(addDialog(page).locator('datalist option')).toHaveCount(2);
-    expect(await addDialog(page).locator('datalist option').evaluateAll(options => options.map(option => option.value)))
-        .toEqual(['Experiments', 'Landscapes']);
-    await expect(addDialog(page).locator('.dialog-actions button')).toHaveText(['Cancel', 'Add']);
-    // An empty name keeps the dialog on its field.
-    await addDialog(page).getByRole('button', { name: 'Add', exact: true }).click();
-    await expect(addField(page)).toBeFocused();
-    await addField(page).fill('  LoRa   testing ');
-    await addDialog(page).getByRole('button', { name: 'Add', exact: true }).click();
-    await expect(toast(page)).toHaveText('Added 3 images to “LoRa testing”.');
-    await expect(bar(page).locator('strong')).toHaveText('3 selected');
-    await expect(row(page, 'LoRa testing').locator('.nav-count')).toHaveText('3');
-    await expect(rows(page)).toHaveCount(3);
-
-    // CUJ 2: one of two already in it.
-    await bar(page).getByRole('button', { name: 'Clear', exact: true }).click();
-    await check(page, 'loose.png');
-    await check(page, 'landscape_02.png');
-    await addChecked(page, 'LoRa testing');
-    await expect(toast(page)).toHaveText('Added 1 image to “LoRa testing”. 1 was already in it.');
-    await expect(row(page, 'LoRa testing').locator('.nav-count')).toHaveText('4');
-
-    // CUJ 3: a case variant joins the same collection.
-    await bar(page).getByRole('button', { name: 'Clear', exact: true }).click();
-    await check(page, 'landscape_03.png');
-    await addChecked(page, 'lora TESTING');
-    await expect(toast(page)).toHaveText('Added 1 image to “LoRa testing”.');
-    await expect(rows(page)).toHaveCount(3);
-    await expect(row(page, 'LoRa testing').locator('.nav-count')).toHaveText('5');
-    const created = (await listed(request)).find(item => item.name === 'LoRa testing');
-    expect(created).toMatchObject({ count: 5, missing: 0 });
-
-    // Everything already in it.
-    await addChecked(page, 'LoRa testing');
-    await expect(toast(page)).toHaveText('All selected images were already in “LoRa testing”.');
-});
-
-test('Remove from collection takes the checked images off the open collection (CUJ 5)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { id } = manifest.collections.Landscapes;
-    await page.goto(`${workspace}#/collection/${id}`);
-    await expect(imageCards(page)).toHaveCount(12);
-    await check(page, 'landscape_01.png');
-    await check(page, 'landscape_02.png');
-    await expect(bar(page).locator('button')).toHaveText(['Add tags', 'Auto-tag selected', 'Set category', 'Add to collection',
-        'Remove from collection', 'Export metadata', 'Clear']);
-    await barButton(page, 'Remove from collection').click();
-    await expect(toast(page)).toHaveText('Removed 2 images from “Landscapes”.');
-    await expect(imageCards(page)).toHaveCount(10);
-    await expect(card(page, 'collections/landscape_01.png')).toHaveCount(0);
-    // The removed files left the listing, so the bar has nothing checked.
-    await expect(bar(page)).toHaveCount(0);
-    await expect(row(page, 'Landscapes').locator('.nav-count')).toHaveText('10');
-    // A checked file still listed stays checked across the reload.
-    await check(page, 'landscape_03.png');
-    await check(page, 'landscape_04.png');
-    await page.route(`**${API}/items`, async route => {
-        if (route.request().method() !== 'DELETE') return route.fallback();
-        // Remove only landscape_04; landscape_03 stays listed and checked.
-        const body = route.request().postDataJSON();
-        await route.continue({ postData: JSON.stringify({ ...body, items: body.items.filter(item => item.path.endsWith('_04.png')) }) });
-    });
-    await barButton(page, 'Remove from collection').click();
-    await expect(toast(page)).toHaveText('Removed 1 image from “Landscapes”.');
-    await expect(imageCards(page)).toHaveCount(9);
-    await expect(bar(page).locator('strong')).toHaveText('1 selected');
-    await expect(page.getByRole('checkbox', { name: 'Select landscape_03.png', exact: true })).toBeChecked();
-    // No file changed: the plain Images page still lists all of them.
-    await page.goto(`${workspace}#/images`);
-    await expect(imageCards(page)).toHaveCount(21);
-});
-
-test('Images without a collection filter has no Remove from collection', async ({ page, request }) => {
-    const manifest = await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await check(page, 'loose.png');
-    await expect(barButton(page, 'Add to collection')).toBeVisible();
-    await expect(barButton(page, 'Remove from collection')).toHaveCount(0);
-    // A saved view on a collection has its filter active: Remove shows (design §5).
-    await page.goto(`${workspace}#/saved/${manifest.saved_view.id}`);
-    await expect(imageCards(page)).toHaveCount(8);
-    await check(page, 'experiment_01.png');
-    await barButton(page, 'Remove from collection').click();
-    await expect(toast(page)).toHaveText('Removed 1 image from “Experiments”.');
-    await expect(imageCards(page)).toHaveCount(7);
-});
-
-test('a failed add keeps the selection; a stale source reloads the images', async ({ page, request }) => {
-    await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await expect(imageCards(page)).toHaveCount(21);
-    let reply = { status: 500, body: { success: false, error: 'The collection could not be changed.' } };
-    await page.route(`**${API}/items`, route => route.fulfill({ status: reply.status, contentType: 'application/json',
-        body: JSON.stringify(reply.body) }));
-    await check(page, 'loose.png');
-    await check(page, 'landscape_05.png');
-    await addChecked(page, 'Grids');
-    await expect(toast(page)).toHaveText('The images could not be added. Try again.');
-    await expect(bar(page).locator('strong')).toHaveText('2 selected');
-    await expect(rows(page)).toHaveCount(2);
-
-    reply = { status: 404, body: { success: false, code: 'files-not-found', error: 'x' } };
-    await addChecked(page, 'Grids');
-    await expect(toast(page)).toHaveText('None of the selected images could be found. Refresh the images and try again.');
-    await expect(bar(page).locator('strong')).toHaveText('2 selected');
-
-    reply = { status: 409, body: { success: false, code: 'source-changed', error: 'x' } };
-    const reloaded = page.waitForRequest(request => request.url().includes('/prompt_manager/gallery/subfolders'));
-    await addChecked(page, 'Grids');
-    await expect(toast(page)).toHaveText('The sources changed. Refresh the images and try again.');
-    await reloaded;
-    await expect(imageCards(page)).toHaveCount(21);
-    await expect(bar(page)).toHaveCount(0);
-});
-
-test('more than 500 or an unloaded "all matching" selection is refused with the cap', async ({ page, request }) => {
-    await seed(request);
-    await page.goto(`${workspace}#/images`);
-    await expect(imageCards(page)).toHaveCount(21);
-    // Every loaded image checked and the listing says more match: "Select all N matching" (#392, D135).
-    await page.route('**/prompt_manager/images/output?*', async route => {
-        // A next page never answers, so the listing stays at its loaded 21 of 900.
-        if (new URL(route.request().url()).searchParams.has('cursor')) return;
-        const response = await route.fetch();
-        const data = await response.json();
-        await route.fulfill({ response, json: { ...data, total: 900, has_more: true, next_cursor: 'more' } });
-    });
-    await page.reload();
-    await expect(imageCards(page)).toHaveCount(21);
-    await page.locator('#image-grid .image-open').first().focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bar(page).getByRole('button', { name: 'Select all 900 matching', exact: true }).click();
-    await expect(bar(page).locator('strong')).toHaveText('All 900 matching selected');
-    await barButton(page, 'Add to collection').click();
-    await expect(toast(page)).toHaveText('Select at most 500 images.');
-    await expect(addDialog(page)).toHaveCount(0);
-});
-
-for (const theme of ['dark', 'light']) {
-    test(`the Add to collection dialog fits 390x844 ${theme}`, async ({ page, request }) => {
-        await seed(request);
-        await page.setViewportSize({ width: 390, height: 844 });
-        await page.goto(`${workspace}#/images`);
-        await page.getByRole('combobox', { name: 'Theme', exact: true }).selectOption(theme);
-        await check(page, 'loose.png');
-        await expect(barButton(page, 'Add to collection')).toBeVisible();
-        await barButton(page, 'Add to collection').click();
-        await expect(addDialog(page)).toBeVisible();
-        const fits = await addDialog(page).evaluate(dialog => {
-            const box = dialog.getBoundingClientRect();
-            return box.left >= 0 && box.right <= window.innerWidth && dialog.scrollWidth <= dialog.clientWidth;
-        });
-        expect(fits).toBe(true);
-        expect(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)).toBe(true);
-        await addField(page).fill('Phone');
-        await addDialog(page).getByRole('button', { name: 'Add', exact: true }).click();
-        await expect(toast(page)).toHaveText('Added 1 image to “Phone”.');
-        await expect(row(page, 'Phone')).toBeVisible();
-    });
-}
-
-// #331 D139 (design §8): the shared inspector's Collections… in the Images side panel and in the viewer.
-const panel = page => page.locator('#image-inspector');
-const collectionsDialog = page => page.getByRole('dialog', { name: 'Collections', exact: true });
-const choice = (page, name) => collectionsDialog(page).getByRole('checkbox', { name, exact: true });
-const newCollection = page => collectionsDialog(page).getByRole('textbox', { name: 'New collection', exact: true });
-
-async function membership(request, path) {
-    const [image] = (await (await request.get(`/prompt_manager/images/output?mode=workspace&q=${encodeURIComponent(path)}`)).json()).images;
-    const query = new URLSearchParams({ root_index: String(image.root_index), root_scope: image.root_scope, path: image.path });
-    const response = await request.get(`${API}/membership?${query}`);
-    await expect(response).toBeOK();
-    return (await response.json()).collection_ids;
-}
-
-test('Collections… in the side panel adds, removes and creates for one image (CUJ 6)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { Landscapes, Experiments } = manifest.collections;
-    await page.goto(`${workspace}#/images`);
-    // The newest image, landscape_01, is the panel's.
-    await expect(panel(page).getByRole('heading', { level: 2 })).toHaveText('landscape_01.png');
-    const open = panel(page).getByRole('button', { name: 'Collections…', exact: true });
-    await expect(panel(page).locator('.detail-footer > button').last()).toHaveText('Collections…');
-    await open.click();
-    await expect(collectionsDialog(page)).toBeVisible();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-    await expect(choice(page, 'Experiments')).not.toBeChecked();
-    await expect(collectionsDialog(page).locator('label.tag-suggestion')).toHaveText(['Experiments', 'Landscapes']);
-    await expect(collectionsDialog(page).locator('.dialog-actions button')).toHaveText(['Cancel', 'Save']);
-    await choice(page, 'Landscapes').uncheck();
-    await choice(page, 'Experiments').check();
-    await newCollection(page).fill('Grids');
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(collectionsDialog(page)).toHaveCount(0);
-    await expect(toast(page)).toHaveText('Collections updated.');
-    await expect(open).toBeFocused();
-    await expect(row(page, 'Grids').locator('.nav-count')).toHaveText('1');
-    await expect(row(page, 'Landscapes').locator('.nav-count')).toHaveText('11');
-    await expect(row(page, 'Experiments').locator('.nav-count')).toHaveText('9');
-    const grids = (await listed(request)).find(item => item.name === 'Grids');
-    expect((await membership(request, 'landscape_01')).sort()).toEqual([Experiments.id, grids.id].sort());
-    expect(Landscapes.id).not.toBe(grids.id);
-    // The Images page lists the same files; the dialog opened again shows the new state.
-    await expect(imageCards(page)).toHaveCount(21);
-    await open.click();
-    await expect(choice(page, 'Grids')).toBeChecked();
-    await expect(choice(page, 'Experiments')).toBeChecked();
-    await expect(choice(page, 'Landscapes')).not.toBeChecked();
-    // Save without a change sends nothing.
-    let writes = 0;
-    page.on('request', request => { if (request.url().includes(`${API}/items`)) writes++; });
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(collectionsDialog(page)).toHaveCount(0);
-    expect(writes).toBe(0);
-});
-
-test('Collections… in the viewer keeps the viewer until it closes (CUJ 7)', async ({ page, request }) => {
-    const manifest = await seed(request);
-    await page.goto(`${workspace}#/collection/${manifest.collections.Landscapes.id}`);
-    await expect(imageCards(page)).toHaveCount(12);
-    await page.getByRole('button', { name: 'Open landscape_01.png', exact: true }).click();
-    const viewer = page.locator('#viewer-dialog[open]');
-    await expect(viewer.locator('#viewer-title')).toContainText('landscape_01.png');
-    // Review L7: no listing request while the viewer is open.
-    let listings = 0;
-    const countListing = request => { if (new URL(request.url()).pathname === '/prompt_manager/images/output') listings++; };
-    page.on('request', countListing);
-    await viewer.locator('#viewer-details').getByRole('button', { name: 'Collections…', exact: true }).click();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-    // Review L6: focus moves to the first checkbox once listed.
-    await expect(choice(page, 'Experiments')).toBeFocused();
-    await choice(page, 'Landscapes').uncheck();
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('Collections updated.');
-    await expect(collectionsDialog(page)).toHaveCount(0);
-    // The viewer stays on the image; the page keeps listing it while the viewer is open.
-    await expect(viewer.locator('#viewer-title')).toContainText('landscape_01.png');
-    await expect(row(page, 'Landscapes').locator('.nav-count')).toHaveText('11');
-    await expect(imageCards(page)).toHaveCount(12);
-    expect(listings, 'no listing request while the viewer is open').toBe(0);
-    page.off('request', countListing);
-    await viewer.getByRole('button', { name: 'Close image viewer', exact: true }).click();
-    await expect(viewer).toHaveCount(0);
-    await expect(imageCards(page)).toHaveCount(11);
-    await expect(card(page, 'collections/landscape_01.png')).toHaveCount(0);
-});
-
-test('a failed membership read says so and Retry reads it again', async ({ page, request }) => {
-    await seed(request);
-    let failing = true;
-    await page.route(`**${API}/membership?*`, route => failing
-        ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"Collections could not be read."}' })
-        : route.fallback());
-    await page.goto(`${workspace}#/images`);
-    await panel(page).getByRole('button', { name: 'Collections…', exact: true }).click();
-    await expect(collectionsDialog(page).getByRole('alert').first()).toHaveText('Collections could not be loaded.');
-    await expect(collectionsDialog(page).getByRole('checkbox')).toHaveCount(0);
-    await expect(collectionsDialog(page).getByRole('button', { name: 'Save', exact: true })).toHaveAttribute('aria-disabled', 'true');
-    failing = false;
-    await collectionsDialog(page).getByRole('button', { name: 'Retry', exact: true }).click();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-    await expect(collectionsDialog(page).getByRole('button', { name: 'Retry', exact: true })).toBeHidden();
-    // A failed write keeps the dialog with the current membership.
-    await page.route(`**${API}/items`, route => route.fulfill({ status: 500, contentType: 'application/json',
-        body: '{"success":false,"error":"The collection could not be changed."}' }));
-    await choice(page, 'Experiments').check();
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(collectionsDialog(page).getByRole('alert')).toHaveText('The collections could not be updated. Try again.');
-    await expect(choice(page, 'Experiments')).not.toBeChecked();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-});
-
-test('a file in no collection with no collections at all can start one', async ({ page }) => {
-    await page.goto(`${workspace}#/images`);
-    await panel(page).getByRole('button', { name: 'Collections…', exact: true }).click();
-    await expect(collectionsDialog(page)).toContainText('No collections yet. Name one below.');
-    await newCollection(page).fill('First');
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('Collections updated.');
-    await expect(rows(page)).toHaveCount(1);
-    await expect(row(page, 'First').locator('.nav-count')).toHaveText('1');
-});
-
-for (const theme of ['dark', 'light']) {
-    test(`the Collections dialog fits 390x844 ${theme}`, async ({ page, request }) => {
-        await seed(request);
-        await page.setViewportSize({ width: 390, height: 844 });
-        await page.goto(`${workspace}#/images`);
-        await page.getByRole('combobox', { name: 'Theme', exact: true }).selectOption(theme);
-        await panel(page).getByRole('button', { name: 'Collections…', exact: true }).click();
-        await expect(choice(page, 'Landscapes')).toBeChecked();
-        const fits = await collectionsDialog(page).evaluate(dialog => {
-            const box = dialog.getBoundingClientRect();
-            return box.left >= 0 && box.right <= window.innerWidth && dialog.scrollWidth <= dialog.clientWidth;
-        });
-        expect(fits).toBe(true);
-        expect(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth)).toBe(true);
-    });
-}
-
-// Review M2: on a collection page, a Save that removed the file from the open collection and then failed keeps its
-// dialog and message; the listing is read again only once the dialog closes.
-test('a partly failed Save from the side panel keeps its dialog until it closes', async ({ page, request }) => {
-    const manifest = await seed(request);
-    const { Experiments, Landscapes } = manifest.collections;
-    // experiment_01 is in both collections; Experiments sorts first, so its remove is sent before Landscapes'.
-    const [image] = (await (await request.get('/prompt_manager/images/output?mode=workspace&q=experiment_01')).json()).images;
-    const item = { root_index: image.root_index, root_scope: image.root_scope, path: image.path };
-    await expect(await request.post(`${API}/items`, { data: { collection_id: Landscapes.id, items: [item] } })).toBeOK();
-    await page.route(`**${API}/items`, route => {
-        const body = route.request().postDataJSON();
-        return route.request().method() === 'DELETE' && body.collection_id === Landscapes.id
-            ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"x"}' })
-            : route.fallback();
-    });
-    await page.goto(`${workspace}#/collection/${Experiments.id}`);
-    await expect(imageCards(page)).toHaveCount(8);
-    await expect(panel(page).getByRole('heading', { level: 2 })).toHaveText('experiment_01.png');
-    await panel(page).getByRole('button', { name: 'Collections…', exact: true }).click();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-    await choice(page, 'Experiments').uncheck();
-    await choice(page, 'Landscapes').uncheck();
-    await collectionsDialog(page).getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(collectionsDialog(page).getByRole('alert')).toHaveText('The collections could not be updated. Try again.');
-    // The remove from Experiments went through; the dialog shows it and the page has not reloaded under it.
-    await expect(choice(page, 'Experiments')).not.toBeChecked();
-    await expect(choice(page, 'Landscapes')).toBeChecked();
-    await expect(imageCards(page)).toHaveCount(8);
-    await collectionsDialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(collectionsDialog(page)).toHaveCount(0);
-    await expect(imageCards(page)).toHaveCount(7);
-    await expect(card(page, 'collections/experiment_01.png')).toHaveCount(0);
-});
@@ -1,6 +1,5 @@
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {readFile,writeFile} from 'node:fs/promises';
 import {createHash} from 'node:crypto';

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

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

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

 test('actual restore with reused numeric owner rejects stale history and offers explicit saved recovery',async({page,request})=>{
    const f=page.fixture;await open(page,f.detail_id);const original=await exact(saved(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'));
-    const source=await request.get('/__test__/history/reused-snapshot');await expect(source).toBeOK();await restoreSnapshot(page,request,await source.body());
+    const source=await request.get('/__test__/history/reused-snapshot');await expect(source).toBeOK();await restoreSnapshot(request,await source.body());
    await marker(page,f.runs.shared).click();await expect(dialog(page)).toContainText('Recorded evidence changed');await page.keyboard.press('Escape');
    await expect(page.locator('.library-parent-status')).toContainText('changed');expect(await exact(saved(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'))).toBe(original);
    await expect(recorded(page).getByRole('button',{name:'Reload recorded history',exact:true})).toBeVisible();
@@ -143,12 +142,12 @@ for(const outcome of ['success','error'])test(`delayed actual old browser ${outc
    const f=page.fixture;await open(page,f.detail_id);const snapshot=await request.get('/__test__/history/snapshot');const bytes=await snapshot.body();
    let entered,release;const started=new Promise(resolve=>{entered=resolve;}),held=new Promise(resolve=>{release=resolve;});
    await page.route(new RegExp(`/history/runs/${f.runs.shared}\\?`),async route=>{
-        if(outcome==='error')await restoreSnapshot(page,request,bytes);
+        if(outcome==='error')await restoreSnapshot(request,bytes);
        const response=await route.fetch();expect(response.status()).toBe(outcome==='success'?200:409);entered();await held;
        await route.fulfill({response}).catch(()=>{});
    });
    try {
-        await marker(page,f.runs.shared).click();await started;if(outcome==='success')await restoreSnapshot(page,request,bytes);
+        await marker(page,f.runs.shared).click();await started;if(outcome==='success')await restoreSnapshot(request,bytes);
        await page.evaluate(()=>{location.hash='#/overview';});await expect(page.locator('#workspace-main h1')).toHaveText('Overview');release();
        await page.unroute(new RegExp(`/history/runs/${f.runs.shared}\\?`));await open(page,f.detail_id);
        await expect(recorded(page).locator('button[data-run-id]')).toHaveCount(0);
@@ -259,7 +258,7 @@ test('inspection first discovers a real restore and immediately retires every su
                if(changed)window.recordedRecoveryStates.push({receipts:run.querySelectorAll('[data-receipt]').length,active:[...run.querySelectorAll('[data-send-role],[data-copy-role],[data-view-receipt]')].filter(node=>!node.disabled&&node.checkVisibility()).length});
            });observer.observe(run,{subtree:true,childList:true,attributes:true,characterData:true});
        });
-        await restoreSnapshot(page,request,await snapshot.body());
+        await restoreSnapshot(request,await snapshot.body());
    } finally {await command(request,{action:'release'});}
    const response=await inspectionRead;expect(response.status()).toBe(409);expect((await response.json()).code).toBe('history-changed');
    await expect(dialog(page).locator('.recorded-run-status')).toContainText('Recorded evidence changed');
@@ -495,49 +494,6 @@ test('the inline current file names its prompts apart from the frozen run fields
    expect(await exact(dialog(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'))).toBe(before);
 });

-// #449 (D154): History's inline current file draws tags in the shared labelled sections, named with its context so they
-// stay apart from the frozen run's fields. The server sends History no image_tags facet today (D88), so the read is
-// given one here to prove the shared render in History.
-test('the inline current file labels its image tags after its negative prompt',async({page})=>{
-    await page.route(url=>url.pathname.endsWith('/inspection'),async route=>{const response=await route.fetch();const body=await response.json();
-        body.prompts={positive:{status:'resolved',text:'current file positive',source:'graph-inferred'},negative:{status:'resolved',text:'current file negative',source:'graph-inferred'}};
-        body.image_tags={state:'current',tags:['history_tag']};
-        await route.fulfill({response,json:body});});
-    await open(page,page.fixture.detail_id);await marker(page,page.fixture.runs.shared).click();await expect(dialog(page).locator('[data-receipt]')).toHaveCount(5);
-    await dialog(page).getByRole('button',{name:'Raw',exact:true}).click();
-    await dialog(page).locator('[data-receipt]').first().getByRole('button',{name:'View current file',exact:true}).click();
-    await expect(page.locator('dialog#viewer-dialog')).toBeVisible();await page.keyboard.press('Escape');await expect(dialog(page)).toBeVisible();
-    const current=dialog(page).getByRole('region',{name:'Current reported file',exact:true});
-    const tags=current.getByRole('region',{name:'Current file image tags',exact:true});
-    await expect(tags.locator('.role-label')).toHaveText('Image tags · 1');await expect(tags.locator('.tags > .chip')).toHaveText(['history_tag']);
-    const negative=current.getByRole('region',{name:'Current file negative prompt',exact:true});
-    expect(await negative.evaluate((node,section)=>({after:Boolean(node.compareDocumentPosition(section)&Node.DOCUMENT_POSITION_FOLLOWING),inside:node.contains(section)}),await tags.elementHandle())).toEqual({after:true,inside:false});
-});
-
-// #332 CUJ 5 (MC8, §5.3): History's current-file inspector reads the file's own category with the Images key rule, so
-// the inline current file and its viewer show "Portraits · this image"; current.png has two saved links, so it inherits
-// nothing and shows no chip before.
-test('the current file shows its own category with its origin in the recorded run and its viewer',async({page,request})=>{
-    const chip=scope=>scope.locator('span.chip:has(> span.chip-source)');
-    const current=dialog(page).getByRole('region',{name:'Current reported file',exact:true});
-    const viewCurrent=async()=>{await dialog(page).locator('[data-receipt]').first().getByRole('button',{name:'View current file',exact:true}).click();
-        const details=page.locator('dialog#viewer-dialog #viewer-details');await expect(details.locator('.panel-heading')).toBeVisible();return details;};
-    await open(page,page.fixture.detail_id);await marker(page,page.fixture.runs.shared).click();await expect(dialog(page).locator('[data-receipt]')).toHaveCount(5);
-    let details=await viewCurrent();await expect(details.locator('.panel-heading h2')).toBeVisible();await expect(chip(details)).toHaveCount(0);
-    await page.keyboard.press('Escape');await expect(current).toBeVisible();await expect(chip(current)).toHaveCount(0);
-    await dialog(page).getByRole('button',{name:'Close recorded run',exact:true}).click();
-    const {images}=await(await request.get('/prompt_manager/images/output?mode=workspace&subfolder=history&limit=40')).json();
-    const file=images.find(image=>image.root_index===0&&image.path==='history/current.png');
-    const put=await request.put('/prompt_manager/images/category',{data:{items:[{root_index:0,root_scope:file.root_scope,path:file.path}],category:'Portraits'}});
-    await expect(put).toBeOK();expect((await put.json()).updated).toBe(1);
-    await open(page,page.fixture.detail_id);await marker(page,page.fixture.runs.shared).click();await expect(dialog(page).locator('[data-receipt]')).toHaveCount(5);
-    details=await viewCurrent();
-    await expect(chip(details)).toHaveText('Image category: Portraits · this image');
-    await page.keyboard.press('Escape');await expect(current).toBeVisible();
-    await expect(chip(current)).toHaveText('Image category: Portraits · this image');
-    expect(await chip(current).locator('.chip-source').evaluate(node=>node.textContent)).toBe(' · this image');
-});
-
 // LI-4 (D117): the recorded history's current-file viewer is the shared full inspector, so it copies the legacy summary.
 test('the current file viewer copies its settings summary',async({page})=>{
    await page.addInitScript(()=>{window.__copied=[];Object.defineProperty(navigator,'clipboard',{configurable:true,value:{writeText:async text=>{window.__copied.push(text);}}});});
@@ -1,6 +1,6 @@
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';
-import { seedConcept, openConcept, openProduction, startInGrid } from './concept-inventory.mjs';
+import { seedConcept, openConcept, openProduction } from './concept-inventory.mjs';

 const workspace = '/prompt_manager/workspace#/images';
 const cards = page => page.locator('article[data-image-key]');
@@ -569,10 +569,6 @@ test('source and folder discovery failure stays visible and Import Rescan restor
 async function staleSourceRecovery(page, request, roots) {
    await expect(await request.post('/__test__/reset', { data: { extra_images: 80 } })).toBeOK();
    await page.setViewportSize({ width: 1600, height: 1100 });
-    // #430: the page first asks the server where a stale file is now. These tests cover the manual Refresh, so the
-    // file is never found; workspace-stale-source.spec.mjs covers a renumbered file that is found again.
-    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.goto(workspace);
    const source = refineDialog(page).getByLabel('Source', { exact: true });
    const folder = refineDialog(page).getByLabel('Folder', { exact: true });
@@ -814,8 +810,6 @@ test('leaving during Rescan cancels it without replacing the next workspace', as

 test('Images uses approved geometry while keeping real controls', async ({page,request}) => {
    await request.post('/__test__/reset',{data:{workspace_visual:true}});
-    // The approved Grid geometry (D157: the default layout is Masonry).
-    await startInGrid(page);
    await page.setViewportSize({width:1600,height:1100});
    await page.goto(workspace);
    await expect(cards(page)).toHaveCount(24);
@@ -897,8 +891,7 @@ test('images toolbar and filter row match the concept controls', async ({ page,
    // app.js toolbar() a347–360: search, category, sort, Save view, Filters.
    await expect(main.locator('search.toolbar > *')).toHaveCount(5);
    await expect(main.locator('search.toolbar > button')).toHaveText(['Save view', 'Filters']);
-    // D153 (#447): no "Highest rated", even with a rated prompt in the library.
-    await expect(sortBy(page).locator('option')).toHaveText(['Recently added', 'Name A–Z', 'Oldest first', 'Name Z–A']);
+    await expect(sortBy(page).locator('option')).toHaveText(['Recently added', 'Name A–Z', 'Highest rated', 'Oldest first', 'Name Z–A']);
    const row = main.locator('.filter-row');
    await expect(row.locator(':scope > *')).toHaveCount(5);
    await expect(row.locator(':scope > .segmented[role="group"][aria-label="Image layout"] > button')).toHaveText(['Grid', 'List', 'Masonry']);
@@ -917,8 +910,8 @@ test('images toolbar and filter row match the concept controls', async ({ page,
    await search(page).fill('');
    await expect(cards(page)).toHaveCount(2);
    await expect(cards(page).first()).toHaveAttribute('data-image-key', '0:shared/same.png');
-    await sortBy(page).selectOption('name-desc');
-    await expect(sortBy(page)).toHaveValue('name-desc');
+    await sortBy(page).selectOption('rating');
+    await expect(cards(page).first()).toHaveAttribute('data-image-key', '1:shared/same.png');
    await sortBy(page).selectOption('newest');
    await page.getByRole('combobox', { name: 'Filter by category', exact: true }).selectOption('Landscapes');
    await expect(cards(page)).toHaveCount(1);
@@ -1794,7 +1787,7 @@ test('card checkboxes select images into the concept bar and Clear empties it',
    await checkbox(first, 'same.png').check();
    await expect(bulkbar(page).locator('.bulkbar > strong')).toHaveText('1 selected');
    // D85: Add tags (the concept's) and Auto-tag selected lead the real actions.
-    await expect(barButtons(page)).toHaveText(['Add tags', 'Auto-tag selected', 'Set category', 'Add to collection', 'Export metadata', 'Clear']);
+    await expect(barButtons(page)).toHaveText(['Add tags', 'Auto-tag selected', 'Set category', 'Export metadata', 'Clear']);
    // Toggling neither opens the viewer, nor inspects, nor moves focus.
    await expect(page.locator('dialog[open]')).toHaveCount(0);
    await expect(checkbox(first, 'same.png')).toBeFocused();
@@ -1995,286 +1988,70 @@ test('Export metadata downloads nothing when no image can be read', async ({ pag
    await expect(bulkbar(page).locator('.bulkbar > strong')).toHaveText('2 selected');
 });

-// #332 (D140, MC6, MC7): Set category writes each selected image's own category (PUT /prompt_manager/images/category);
-// "Use prompt category" removes it after a confirmation (DELETE). It never writes a prompt: Images no longer posts
-// /prompt_manager/bulk/category (#259's prompt action is retired from Images).
+// #249 D8 follow-up (image selection, Task 3): Set category sets the linked positives' category (app.js simpleInput).
 const categoryButton = page => bulkbar(page).getByRole('button', { name: 'Set category', exact: true });
 const categoryDialog = page => page.getByRole('dialog', { name: 'Categorize selected images', exact: true });
-const removeDialog = page => page.getByRole('dialog', { name: 'Use prompt category', exact: true });
-const categoryFilter = page => page.getByRole('combobox', { name: 'Filter by category', exact: true });
-const categoryRoute = '**/prompt_manager/images/category';
-const IMAGE_CATEGORY = '/prompt_manager/images/category';
-const cardOf = (page, key) => page.locator(`article[data-image-key="${key}"]`);
-const keyOf = image => `${image.root_index}:${image.path}`;
-const cardKeys = page => cards(page).evaluateAll(nodes => nodes.map(node => node.dataset.imageKey).sort());
-// The four outputs of "Cat portrait" (CUJ 1's batch); the input root's same.png is linked to "Dog landscape".
-const BATCH = ['0:bulk/0000.png', '0:bulk/0001.png', '0:bulk/0002.png', '0:shared/same.png'];
-/** Every category write the page sends, Images' own route and #259's prompt route alike. */
-function categoryWrites(page) {
-    const writes = [];
-    page.on('request', item => {
-        const path = new URL(item.url()).pathname;
-        if (item.method() === 'GET' || !['/prompt_manager/images/category', '/prompt_manager/bulk/category'].includes(path)) return;
-        writes.push({ method: item.method(), path, body: item.postDataJSON() });
-    });
-    return writes;
-}
-async function listedImages(request, query = '') {
-    const response = await request.get(`/prompt_manager/images/output?mode=workspace&limit=40${query}`);
-    await expect(response).toBeOK();
-    return (await response.json()).images;
-}
-async function targetsOf(request, keys) {
-    const images = await listedImages(request);
-    return keys.map(key => {
-        const image = images.find(item => keyOf(item) === key);
-        return { root_index: image.root_index, root_scope: image.root_scope, path: image.path };
-    });
-}
-async function putOwnCategory(request, keys, category) {
-    const response = await request.put(IMAGE_CATEGORY, { data: { items: await targetsOf(request, keys), category } });
-    await expect(response).toBeOK();
-}
-const filteredKeys = async (request, category) => (await listedImages(request, `&category=${encodeURIComponent(category)}`)).map(keyOf).sort();
-async function positiveOf(request, id) {
-    const response = await request.get(`/prompt_manager/library/${id}`);
-    await expect(response).toBeOK();
-    const { positive } = await response.json();
-    return { id: positive.id, text: positive.text, category: positive.category };
-}
-/** CUJ 1's Given: four images linked to the positive "Cat portrait", whose category is "Landscapes". */
-async function seedBatch(request) {
-    await expect(await request.post('/__test__/reset', { data: { extra_images: 3 } })).toBeOK();
-    const response = await request.post('/prompt_manager/save', { data: { text: 'Cat portrait', category: 'Landscapes' } });
-    await expect(response).toBeOK();
-    const id = (await response.json()).prompt_id;
-    expect(await filteredKeys(request, 'Landscapes')).toEqual(BATCH);
-    return id;
-}
-async function openSetCategory(page) {
-    await categoryButton(page).click();
-    await expect(categoryDialog(page)).toBeVisible();
-    return categoryDialog(page);
-}
-async function applyCategory(page, category) {
-    const dialog = await openSetCategory(page);
-    await dialog.getByLabel('Category', { exact: true }).fill(category);
-    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
-    await expect(dialog).toBeHidden();
+const categoryRoute = '**/prompt_manager/bulk/category';
+/** Unlink the input root's card by deleting its prompt; returns the output card's positive id. */
+async function unlinkInputCard(request) {
+    const { images } = await (await request.get('/prompt_manager/images/output?mode=workspace')).json();
+    const byKey = Object.fromEntries(images.map(image => [`${image.root_index}:${image.path}`, image]));
+    const [output, input] = [byKey['0:shared/same.png'], byKey['1:shared/same.png']];
+    expect([output.linked.status, input.linked.status]).toEqual(['linked', 'linked']);
+    await expect(await request.delete(`/prompt_manager/delete/${input.linked.positive_id}`)).toBeOK();
+    return output.linked.positive_id;
 }

-test('Set category overrides one image of a batch and never writes its prompt (#332 CUJ 1)', async ({ page, request }) => {
-    const positiveId = await seedBatch(request);
-    const before = await positiveOf(request, positiveId);
-    const writes = categoryWrites(page);
+test('Set category applies the category to the linked positives and the category filter then matches', async ({ page, request }) => {
+    const outputPositive = await unlinkInputCard(request);
    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(5);
-    await checkbox(cardOf(page, '0:bulk/0001.png'), '0001.png').check();
-    const dialog = await openSetCategory(page);
-    // The concept's simpleInput plus "Use prompt category" between Cancel and Apply (primary).
+    await checkBoth(page);
+    const opener = categoryButton(page);
+    await opener.click();
+    const dialog = categoryDialog(page);
+    await expect(dialog).toBeVisible();
+    // The concept's simpleInput: one field and Cancel / Apply (primary).
    await expect(dialog.locator('#modal-body > .field > label[for="action-input"]')).toHaveText('Category');
    await expect(dialog.locator('#modal-body > .field > input#action-input')).toHaveValue('');
-    await expect(dialog.locator('#modal-body > .dialog-actions > button')).toHaveText(['Cancel', 'Use prompt category', 'Apply']);
+    await expect(dialog.locator('#modal-body > .dialog-actions > button')).toHaveText(['Cancel', 'Apply']);
    await expect(dialog.getByRole('button', { name: 'Apply', exact: true })).toHaveClass(/ca-primary/);
    await expect(dialog.getByLabel('Category', { exact: true })).toBeFocused();
-    await expect(dialog.getByLabel('Category', { exact: true })).toHaveAttribute('maxlength', '100');
    // An empty value applies nothing and keeps the dialog open.
+    const posts = [];
+    page.on('request', item => { if (item.method() === 'POST' && item.url().endsWith('/prompt_manager/bulk/category')) posts.push(item.postDataJSON()); });
    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
    await expect(dialog).toBeVisible();
-    await dialog.getByLabel('Category', { exact: true }).fill('  Portraits ');
+    await dialog.getByLabel('Category', { exact: true }).fill('  Landscapes ');
    const listings = [];
    page.on('request', item => { if (imagePages(new URL(item.url()))) listings.push(item.url()); });
    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
    await expect(dialog).toBeHidden();
-    await expect(toast(page)).toHaveText('Category “Portraits” set on 1 image.');
-    expect(writes).toEqual([{ method: 'PUT', path: IMAGE_CATEGORY,
-        body: { items: await targetsOf(request, ['0:bulk/0001.png']), category: 'Portraits' } }]);
+    await expect(toast(page)).toHaveText('Category set on 1 prompt. 1 selected image had no linked prompt and was skipped.');
+    expect(posts).toEqual([{ prompt_ids: [outputPositive], category: 'Landscapes' }]);
    // The listing and the category options reload; the reload clears the selection.
    await expect.poll(() => listings.length).toBeGreaterThan(0);
    await expect(bulkbar(page)).toBeEmpty();
-    await expect(categoryFilter(page).locator('option')).toHaveText(['All categories', 'Landscapes', 'Portraits']);
-    await categoryFilter(page).selectOption('Portraits');
-    await expect(cards(page)).toHaveCount(1);
-    await expect(cards(page)).toHaveAttribute('data-image-key', '0:bulk/0001.png');
-    await categoryFilter(page).selectOption('Landscapes');
-    await expect(cards(page)).toHaveCount(3);
-    expect(await cardKeys(page)).toEqual(BATCH.filter(key => key !== '0:bulk/0001.png'));
-    // The prompt keeps its category: only the image carries "Portraits".
-    expect(await positiveOf(request, positiveId)).toEqual(before);
-    expect(before.category).toBe('Landscapes');
-    expect(writes.filter(write => write.path === '/prompt_manager/bulk/category')).toEqual([]);
-});
-
-test('Set category categorizes unlinked images and lists the value in the toolbar and the suggestions (#332 CUJ 2)', async ({ page, request }) => {
-    // Unlink both images by deleting their prompts.
-    for (const image of await listedImages(request)) {
-        await expect(await request.delete(`/prompt_manager/delete/${image.linked.positive_id}`)).toBeOK();
-    }
-    expect((await listedImages(request)).filter(image => image.linked.status === 'linked')).toEqual([]);
-    const writes = categoryWrites(page);
-    await page.goto(workspace);
-    await checkBoth(page);
-    await applyCategory(page, 'Scans');
-    await expect(toast(page)).toHaveText('Category “Scans” set on 2 images.');
-    expect(writes).toEqual([{ method: 'PUT', path: IMAGE_CATEGORY,
-        body: { items: await targetsOf(request, ['0:shared/same.png', '1:shared/same.png']), category: 'Scans' } }]);
-    await expect(categoryFilter(page).locator('option')).toHaveText(['All categories', 'Scans']);
-    await categoryFilter(page).selectOption('Scans');
-    await expect(cards(page)).toHaveCount(2);
-    expect(await cardKeys(page)).toEqual(['0:shared/same.png', '1:shared/same.png']);
-    // The field suggests the toolbar's categories through its own datalist.
-    await checkbox(cards(page).first(), 'same.png').check();
-    const dialog = await openSetCategory(page);
-    await expect(dialog.getByLabel('Category', { exact: true })).toHaveAttribute('list', 'workspace-input-suggestions');
-    expect(await dialog.locator('datalist#workspace-input-suggestions option').evaluateAll(nodes => nodes.map(node => node.value))).toEqual(['Scans']);
-    await dialog.getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    expect(writes).toHaveLength(1);
-});
-
-test('Use prompt category removes the own category only after Remove in its confirmation (#332 CUJ 3)', async ({ page, request }) => {
-    const positiveId = await seedBatch(request);
-    await putOwnCategory(request, ['0:bulk/0001.png'], 'Portraits');
-    const writes = categoryWrites(page);
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(5);
-    await expect(categoryFilter(page).locator('option')).toHaveText(['All categories', 'Landscapes', 'Portraits']);
-    await checkbox(cardOf(page, '0:bulk/0001.png'), '0001.png').check();
-    // Cancel in the confirmation sends nothing and keeps the selection.
-    await (await openSetCategory(page)).getByRole('button', { name: 'Use prompt category', exact: true }).click();
-    await expect(categoryDialog(page)).toHaveCount(0);
-    const confirm = removeDialog(page);
-    await expect(confirm).toBeVisible();
-    await expect(confirm.locator('p').first()).toHaveText("Remove the image category from the 1 selected image? Each one then shows its prompt's category, or none if it has no linked prompt. This cannot be undone.");
-    await expect(confirm.locator('.dialog-actions > button')).toHaveText(['Cancel', 'Remove']);
-    await expect(confirm.getByRole('button', { name: 'Remove', exact: true })).toHaveClass(/danger/);
-    await expect(confirm.getByRole('button', { name: 'Cancel', exact: true })).toBeFocused();
-    await confirm.getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    expect(writes).toEqual([]);
-    expect(await filteredKeys(request, 'Portraits')).toEqual(['0:bulk/0001.png']);
-    // Remove sends exactly one DELETE naming the selected image.
-    await (await openSetCategory(page)).getByRole('button', { name: 'Use prompt category', exact: true }).click();
-    await removeDialog(page).getByRole('button', { name: 'Remove', exact: true }).click();
-    await expect(toast(page)).toHaveText('Removed the image category from 1 image.');
-    expect(writes).toEqual([{ method: 'DELETE', path: IMAGE_CATEGORY, body: { items: await targetsOf(request, ['0:bulk/0001.png']) } }]);
-    await expect(bulkbar(page)).toBeEmpty();
-    // The image shows its prompt's category again: "Landscapes" lists all four, and "Portraits" is gone.
-    await expect(categoryFilter(page).locator('option')).toHaveText(['All categories', 'Landscapes']);
-    await categoryFilter(page).selectOption('Landscapes');
-    await expect(cards(page)).toHaveCount(4);
-    expect(await cardKeys(page)).toEqual(BATCH);
-    expect((await positiveOf(request, positiveId)).category).toBe('Landscapes');
-});
-
-test('a saved view filtered by a category lists an image categorized after it was saved (#332 CUJ 8)', async ({ page, request }) => {
-    await seedBatch(request);
-    await putOwnCategory(request, ['0:bulk/0001.png'], 'Portraits');
-    await page.goto(workspace);
-    await categoryFilter(page).selectOption('Portraits');
-    await expect(cards(page)).toHaveCount(1);
-    await page.locator('#workspace-main search.toolbar').getByRole('button', { name: 'Save view', exact: true }).click();
-    const save = page.getByRole('dialog', { name: 'Save this view', exact: true });
-    await save.getByRole('textbox', { name: 'View name', exact: true }).fill('Portraits');
-    await save.getByRole('button', { name: 'Save', exact: true }).click();
-    await expect(toast(page)).toHaveText('Saved view added to the sidebar.');
-    // Another image gets "Portraits" through Set category.
-    await categoryFilter(page).selectOption('');
-    await expect(cards(page)).toHaveCount(5);
-    await checkbox(cardOf(page, '0:bulk/0002.png'), '0002.png').check();
-    await applyCategory(page, 'Portraits');
-    await expect(toast(page)).toHaveText('Category “Portraits” set on 1 image.');
-    // Reopening the view lists both.
-    await page.getByRole('navigation', { name: 'Saved views', exact: true }).getByRole('link', { name: 'Portraits', exact: true }).click();
-    await expect(page.locator('#workspace-main h1')).toHaveText('Portraits');
-    await expect(categoryFilter(page)).toHaveValue('Portraits');
-    await expect(cards(page)).toHaveCount(2);
-    expect(await cardKeys(page)).toEqual(['0:bulk/0001.png', '0:bulk/0002.png']);
-});
-
-test('at 390px in light theme the Set category dialog and the category chip fit (#332 CUJ 10)', async ({ page, request }) => {
-    const LONG = 'Portraits taken on a phone at the end of a long walk through the old harbour at dusk';
-    await page.addInitScript(() => { try { localStorage.setItem('pm_workspace_theme', 'light'); } catch { /* the default theme */ } });
-    await page.setViewportSize({ width: 390, height: 844 });
-    await seedBatch(request);
-    await putOwnCategory(request, ['0:bulk/0001.png'], LONG);
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(5);
-    await expect(page.locator('html')).toHaveCSS('color-scheme', 'light');
-    const card = cardOf(page, '0:bulk/0001.png');
-    // The chip wraps inside the side panel; its origin never splits.
-    await card.getByRole('button', { name: 'Inspect 0001.png', exact: true }).click();
-    const chip = details(page).locator('span.chip', { has: page.locator('span.chip-source') });
-    await expect(chip).toHaveText(`Image category: ${LONG} · this image`);
-    const fit = await chip.evaluate(node => {
-        const panel = node.closest('aside, [role="complementary"]').getBoundingClientRect(), box = node.getBoundingClientRect();
-        const source = node.querySelector('.chip-source');
-        const line = parseFloat(getComputedStyle(source).lineHeight) || source.getBoundingClientRect().height;
-        return { inside: box.left >= panel.left - 0.5 && box.right <= panel.right + 0.5, sourceLines: source.getClientRects().length,
-            wrapped: box.height > line * 1.5, pageScroll: document.documentElement.scrollWidth - window.innerWidth };
-    });
-    expect(fit).toEqual({ inside: true, sourceLines: 1, wrapped: true, pageScroll: 0 });
-    // The dialog fits the width with no horizontal scroll, and its three buttons wrap without overlap.
-    await checkbox(card, '0001.png').check();
-    const dialog = await openSetCategory(page);
-    const geometry = await dialog.evaluate(node => {
-        const box = node.getBoundingClientRect();
-        const buttons = [...node.querySelectorAll('.dialog-actions > button')].map(button => button.getBoundingClientRect())
-            .map(({ left, right, top, bottom }) => ({ left, right, top, bottom }));
-        const overlaps = buttons.some((a, i) => buttons.some((b, j) => j > i && a.left < b.right && b.left < a.right && a.top < b.bottom && b.top < a.bottom));
-        const scrollers = [node, ...node.querySelectorAll('*')].filter(item => item.scrollWidth > item.clientWidth + 1 && getComputedStyle(item).overflowX !== 'visible');
-        return { fits: box.left >= 0 && box.right <= window.innerWidth, scrollers: scrollers.length, count: buttons.length, overlaps,
-            inside: buttons.every(b => b.left >= box.left && b.right <= box.right), pageScroll: document.documentElement.scrollWidth - window.innerWidth };
-    });
-    expect(geometry).toEqual({ fits: true, scrollers: 0, count: 3, overlaps: false, inside: true, pageScroll: 0 });
-});
-
-test('Set category of more than 500 images says so before any dialog or request (#332)', async ({ page, request }) => {
-    await page.route(url => url.pathname === '/prompt_manager/images/output' && url.searchParams.get('limit') !== '1', async route => {
-        const response = await route.fetch();
-        const body = await response.json();
-        await route.fulfill({ response, json: { ...body, total: 501 } });
-    });
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 501 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 501 matching selected');
-    const writes = categoryWrites(page);
-    await categoryButton(page).click();
-    await expect(toast(page)).toHaveText('Select at most 500 images.');
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    expect(writes).toEqual([]);
-    await expect(selectedCount(page)).toHaveText('All 501 matching selected');
-});
-
-test('a changed source says so and reloads the listing (#332)', async ({ page }) => {
-    await page.goto(workspace);
-    await checkBoth(page);
-    await page.route(categoryRoute, route => route.fulfill({ status: 409,
-        json: { success: false, code: 'source-changed', error: 'The output sources changed. Refresh the images and try again.' } }));
-    const reloaded = page.waitForRequest(item => imagePages(new URL(item.url())));
-    await applyCategory(page, 'Landscapes');
-    await expect(toast(page)).toHaveText('The sources changed. Refresh the images and try again.');
-    await reloaded;
-    await expect(cards(page)).toHaveCount(2);
-    // The reload hides the bar with Set category in it: focus moves to the page heading, as after a success.
    await expect(page.locator('#workspace-main h1')).toBeFocused();
+    await expect(cards(page).getByRole('checkbox', { checked: true })).toHaveCount(0);
+    const filter = page.getByRole('combobox', { name: 'Filter by category', exact: true });
+    await expect(filter.locator('option')).toContainText(['Landscapes']);
+    await filter.selectOption('Landscapes');
+    await expect(cards(page)).toHaveCount(1);
+    await expect(cards(page)).toHaveAttribute('data-image-key', '0:shared/same.png');
 });

-test('a recipe-linked image is listed under its recipe\'s category (#332 D142)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/reset', { data: { native_library: true } })).toBeOK();
+test('Set category without a linked image posts nothing and opens no dialog', async ({ page, request }) => {
+    await unlinkInputCard(request);
    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(3);
-    await expect(categoryFilter(page).locator('option')).toHaveText(['All categories', 'Animals', 'Experiments', 'Portraits']);
-    // The output same.png is linked to recipe "Portrait variant 1" (Portraits), the input copy to variant 2 (Experiments);
-    // only the image without a recipe shows its positive's "Animals".
-    for (const [category, keys] of [['Portraits', ['0:shared/same.png']], ['Experiments', ['1:shared/same.png']], ['Animals', ['0:legacy-unassigned.png']]]) {
-        await categoryFilter(page).selectOption(category);
-        await expect(cards(page)).toHaveCount(keys.length);
-        expect(await cardKeys(page)).toEqual(keys);
-    }
+    await expect(cards(page)).toHaveCount(2);
+    let posted = 0;
+    await page.route(categoryRoute, route => { posted += 1; return route.continue(); });
+    await checkbox(cards(page).last(), 'same.png').check();
+    await categoryButton(page).click();
+    await expect(toast(page)).toHaveText("None of the selected images is linked to a saved prompt, so there is no prompt category to set.");
+    await expect(page.locator('dialog[open]')).toHaveCount(0);
+    expect(posted).toBe(0);
+    await expect(bulkbar(page).locator('.bulkbar > strong')).toHaveText('1 selected');
 });

 test('Set category reports a failure, keeps the selection and ignores a second press while it runs', async ({ page }) => {
@@ -2282,7 +2059,9 @@ test('Set category reports a failure, keeps the selection and ignores a second p
    await checkBoth(page);
    const held = [];
    await page.route(categoryRoute, route => { held.push(route); });
-    await applyCategory(page, 'Landscapes');
+    await categoryButton(page).click();
+    await categoryDialog(page).getByLabel('Category', { exact: true }).fill('Landscapes');
+    await categoryDialog(page).getByRole('button', { name: 'Apply', exact: true }).click();
    await expect.poll(() => held.length).toBe(1);
    await expect(categoryButton(page)).toHaveAttribute('aria-disabled', 'true');
    // Playwright waits on an aria-disabled control, so the second press is a dispatched click.
@@ -2319,12 +2098,14 @@ test('leaving Images during Set category finishes the write, and the return relo
    await checkBoth(page);
    const held = [];
    await page.route(categoryRoute, route => { held.push(route); });
-    await applyCategory(page, 'Landscapes');
+    await categoryButton(page).click();
+    await categoryDialog(page).getByLabel('Category', { exact: true }).fill('Landscapes');
+    await categoryDialog(page).getByRole('button', { name: 'Apply', exact: true }).click();
    await expect.poll(() => held.length).toBe(1);
    await page.evaluate(() => { window.location.hash = '/overview'; });
    await expect(page.locator('#workspace-main h1')).toHaveText('Overview');
    // The write is not aborted with the page: the server still receives and answers it.
-    const answered = page.waitForResponse(response => new URL(response.url()).pathname === IMAGE_CATEGORY);
+    const answered = page.waitForResponse(response => response.url().endsWith('/prompt_manager/bulk/category'));
    await held[0].continue();
    expect((await answered).ok()).toBe(true);
    await page.evaluate(() => new Promise(resolve => setTimeout(resolve, 150)));
@@ -2335,25 +2116,23 @@ test('leaving Images during Set category finishes the write, and the return relo
    await expect(cards(page)).toHaveCount(2);
    await expect(bulkbar(page)).toBeEmpty();
    await expect(cards(page).getByRole('checkbox', { checked: true })).toHaveCount(0);
-    await expect(categoryFilter(page).locator('option')).toContainText(['Landscapes']);
+    await expect(page.getByRole('combobox', { name: 'Filter by category', exact: true }).locator('option')).toContainText(['Landscapes']);
 });

-test('Set category shows the server counts and coded refusals, and a rejection keeps the selection', async ({ page }) => {
+test('Set category limits the field to the server length, shows the server count, and a rejection keeps the selection', async ({ page }) => {
    await page.goto(workspace);
    await checkBoth(page);
    const answers = [
        { status: 400, json: { success: false, error: 'Category cannot exceed 100 characters' } },
-        { status: 404, json: { success: false, code: 'files-not-found', error: 'None of the images could be found.' } },
-        { status: 200, json: { success: true, category: 'Landscapes', updated: 1, unchanged: 0, not_found: 1 } },
+        { status: 200, json: { success: true, updated_count: 0 } },
    ];
    await page.route(categoryRoute, route => route.fulfill(answers.shift()));
-    for (const expected of ['Category could not be set. Try again.',
-        'None of the selected images could be found. Refresh the images and try again.',
-        'Category “Landscapes” set on 1 image. 1 could not be found.']) {
-        const dialog = await openSetCategory(page);
-        await expect(dialog.getByLabel('Category', { exact: true })).toHaveAttribute('maxlength', '100');
-        await dialog.getByLabel('Category', { exact: true }).fill('Landscapes');
-        await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
+    for (const expected of ['Category could not be set. Try again.', 'Category set on 0 prompts.']) {
+        await categoryButton(page).click();
+        const field = categoryDialog(page).getByLabel('Category', { exact: true });
+        await expect(field).toHaveAttribute('maxlength', '100');
+        await field.fill('Landscapes');
+        await categoryDialog(page).getByRole('button', { name: 'Apply', exact: true }).click();
        await expect(toast(page)).toHaveText(expected);
        if (answers.length) await expect(bulkbar(page).locator('.bulkbar > strong')).toHaveText('2 selected');
    }
@@ -2410,246 +2189,3 @@ test('scan for metadata opens the review dialog from Import', async ({ page, req
    await expect.poll(async () => (await (await request.get('/prompt_manager/jobs')).json()).jobs
        .map(job => [job.kind, job.state])).toEqual([['backup', 'finished']]);
 });
-
-// #392 (D135): file-manager selection beyond the concept's checkbox.
-const selectedCount = page => bulkbar(page).locator('.bulkbar > strong');
-const cardAt = (page, index) => page.locator(`article[data-image-key][data-index="${index}"]`);
-const boxAt = (page, index) => cardAt(page, index).getByRole('checkbox', { name: /^Select / });
-const checkedIndexes = page => page.locator('article[data-image-key]').evaluateAll(nodes => nodes
-    .filter(node => node.querySelector('.image-overlays input[type="checkbox"]').checked)
-    .map(node => Number(node.dataset.index)).sort((a, b) => a - b));
-const range = (from, to) => Array.from({ length: to - from + 1 }, (_, index) => from + index);
-async function bulkReset(page, request) {
-    await page.addInitScript(() => { window.IntersectionObserver = undefined; });
-    await expect(await request.post('/__test__/reset', { data: { extra_images: 200 } })).toBeOK();
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(40);
-}
-/** A touch press on `locator` the way a finger makes one: pointerdown, (held), pointerup. */
-const touchDown = locator => locator.evaluate(node => {
-    const { left, top } = node.getBoundingClientRect();
-    node.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, isPrimary: true, pointerType: 'touch', clientX: left + 5, clientY: top + 5 }));
-});
-const touchUpAndClick = locator => locator.evaluate(node => {
-    node.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, isPrimary: true, pointerType: 'touch' }));
-    // A tap's click counts one press (`detail` 1); a keyboard click (and `HTMLElement.click()`) counts none.
-    node.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, detail: 1 }));
-});
-async function touchTap(locator) {
-    await touchDown(locator);
-    await touchUpAndClick(locator);
-}
-
-test('Shift+click selects a range across an appended batch in Grid, List and Masonry', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    for (const mode of ['Grid', 'List', 'Masonry']) {
-        await page.getByRole('group', { name: 'Image layout', exact: true }).getByRole('button', { name: mode, exact: true }).click();
-        // The anchor is the last image toggled on its own (List hides the concept's checkbox: the card carries it).
-        await cardAt(page, 3).locator('.media-info h3').click({ modifiers: ['ControlOrMeta'] });
-        await expect(selectedCount(page)).toHaveText('1 selected');
-        // The range runs into the second batch (index 40 on), and backwards from the same anchor.
-        await cardAt(page, 45).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('43 selected');
-        expect(await checkedIndexes(page)).toEqual(range(3, 45));
-        await cardAt(page, 0).locator('.media-info h3').click({ modifiers: ['Shift'] });
-        await expect(selectedCount(page)).toHaveText('46 selected');
-        expect(await checkedIndexes(page)).toEqual(range(0, 45));
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-        if (mode !== 'List') {
-            // A Shift+click on a checkbox gives its range the box's new state: here, unchecked.
-            await boxAt(page, 3).uncheck();
-            await boxAt(page, 10).click({ modifiers: ['Shift'] });
-            await expect(boxAt(page, 10)).not.toBeChecked();
-            await expect(selectedCount(page)).toHaveText('38 selected');
-            expect(await checkedIndexes(page)).toEqual([0, 1, 2, ...range(11, 45)]);
-        }
-        await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).click();
-        await expect(bulkbar(page)).toBeEmpty();
-    }
-});
-
-test('Ctrl/Cmd+click toggles a card without opening it, and a plain click still opens the viewer', async ({ page }) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const first = cards(page).first();
-    const inspectorBefore = await details(page).innerText();
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    await cards(page).last().getByRole('button', { name: 'Inspect same.png', exact: true }).click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await star(first, 'same.png').click({ modifiers: ['ControlOrMeta'] });
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await expect(star(first, 'same.png')).toHaveAttribute('aria-pressed', 'false');
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    expect(await details(page).innerText()).toBe(inspectorBefore);
-    // A plain click keeps its meaning: the image opens the viewer.
-    await first.getByRole('button', { name: 'Open same.png', exact: true }).click();
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await expect(selectedCount(page)).toHaveText('1 selected');
-});
-
-test('Ctrl/Cmd+A, Select all N matching and Add tags tag every matching image on the server', async ({ page, request }) => {
-    await bulkReset(page, request);
-    // Ctrl/Cmd+A in the search box stays the field's own.
-    await search(page).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(bulkbar(page)).toBeEmpty();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    const offer = bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true });
-    await expect(offer).toBeVisible();
-    await expect(bulkbar(page).locator('.bulkbar > *').nth(1)).toHaveText('Select all 202 matching');
-    await offer.click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    await expect(offer).toHaveCount(0);
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).toHaveAttribute('aria-disabled', 'true');
-    // A later batch arrives checked.
-    await page.getByRole('button', { name: 'Load more images', exact: true }).click();
-    await expect(caption(page)).toContainText('80 of 202 images');
-    await expect(boxAt(page, 70)).toBeChecked();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Unchecking one image leaves "all matching": the other loaded images stay selected.
-    await boxAt(page, 0).uncheck();
-    await expect(selectedCount(page)).toHaveText('79 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true })).not.toHaveAttribute('aria-disabled', 'true');
-    await cardAt(page, 1).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Add tags sends the listing filter, not 202 identities, and the server tags every match.
-    await bulkbar(page).getByRole('button', { name: 'Add tags', exact: true }).click();
-    const dialog = page.getByRole('dialog', { name: 'Tag selected images', exact: true });
-    await dialog.getByRole('textbox', { name: 'Tags, separated by commas', exact: true }).fill('picked392');
-    const started = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/jobs/image-tags');
-    await dialog.getByRole('button', { name: 'Apply', exact: true }).click();
-    expect((await started).postDataJSON()).toEqual({ mode: 'add', filter: { sort: 'newest' }, tags: ['picked392'] });
-    await expect.poll(async () => (await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&tags=picked392')).json()).total,
-        { timeout: 20000 }).toBe(202);
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Escape in the grid clears the selection.
-    await cardAt(page, 2).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(boxAt(page, 2)).not.toBeChecked();
-});
-
-test('Shift+arrow keys extend the selection from the focused card, and Escape in the bar clears it', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('Shift+ArrowRight');
-    await page.keyboard.press('Shift+ArrowRight');
-    await expect(cardAt(page, 2).getByRole('button', { name: /^Open / })).toBeFocused();
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    expect(await checkedIndexes(page)).toEqual([0, 1, 2]);
-    // A plain arrow moves without selecting; Shift+End reaches the last loaded card from the same anchor.
-    await page.keyboard.press('ArrowRight');
-    await expect(selectedCount(page)).toHaveText('3 selected');
-    await page.keyboard.press('Shift+End');
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('#workspace-main h1')).toBeFocused();
-});
-
-test('a touch long-press starts selection mode, taps then toggle, and an empty selection ends it', async ({ page }, testInfo) => {
-    await page.goto(workspace);
-    await expect(cards(page)).toHaveCount(2);
-    const [first, second] = [cards(page).first(), cards(page).last()];
-    const open = card => card.getByRole('button', { name: 'Open same.png', exact: true });
-    await touchDown(open(first));
-    // The context menu of a held press belongs to the long press.
-    expect(await open(first).evaluate(node => !node.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true })))).toBe(true);
-    // Held: the long press selects the card once its delay passed.
-    await expect(selectedCount(page)).toHaveText('1 selected');
-    await touchUpAndClick(open(first));
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    await expect(checkbox(first, 'same.png')).toBeChecked();
-    // Taps now toggle instead of opening.
-    if (testInfo.project.name === 'touch') await open(second).tap();
-    else await touchTap(open(second));
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    // A keyboard Enter keeps its meaning in touch selection mode: the image opens.
-    await open(first).focus();
-    await page.keyboard.press('Enter');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-    await page.keyboard.press('Escape');
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(0);
-    await expect(selectedCount(page)).toHaveText('2 selected');
-    await touchTap(open(first));
-    await touchTap(open(second));
-    await expect(bulkbar(page)).toBeEmpty();
-    await expect(page.locator('dialog[open]')).toHaveCount(0);
-    // The selection is empty, so touch selection mode ended: a tap opens the image again.
-    await touchTap(open(first));
-    await expect(page.locator('#viewer-dialog[open]')).toHaveCount(1);
-});
-
-test('all matching sets the category through the listing filter and survives a return visit as the loaded images', async ({ page, request }) => {
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    // The offer left with its press: focus moves to the bar's first action.
-    await expect(bulkbar(page).getByRole('button', { name: 'Add tags', exact: true })).toBeFocused();
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // Export metadata waits for loaded images: a press does nothing.
-    const exportButton = bulkbar(page).getByRole('button', { name: 'Export metadata', exact: true });
-    await expect(exportButton).toHaveAttribute('title', 'Export metadata reads each image in the browser, so it works on loaded images only.');
-    // No match listed any more (a stubbed answer): the not-found sentence, and the selection stays.
-    await page.route(categoryRoute, route => route.fulfill({ status: 404, json: { success: false, code: 'files-not-found', error: 'None of the images could be found.' } }), { times: 1 });
-    await applyCategory(page, 'Bulk392');
-    await expect(toast(page)).toHaveText('None of the selected images could be found. Refresh the images and try again.');
-    await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // The real write: one PUT with the listing filter sets every matching image's own category; no prompt changes.
-    const writes = categoryWrites(page);
-    await applyCategory(page, 'Bulk392');
-    await expect(toast(page)).toHaveText('Category “Bulk392” set on 202 images.');
-    expect(writes).toEqual([{ method: 'PUT', path: IMAGE_CATEGORY, body: { filter: { sort: 'newest' }, category: 'Bulk392' } }]);
-    await expect(bulkbar(page)).toBeEmpty();
-    const filtered = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&category=Bulk392')).json();
-    expect(filtered.total).toBe(202);
-    expect((await (await request.get('/prompt_manager/library/options')).json()).categories).not.toContain('Bulk392');
-    // A return visit keeps "all matching" as the loaded images, and the offer shows again.
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true }).click();
-    await page.evaluate(() => { window.location.hash = '/overview'; });
-    await expect(page.locator('#workspace-main h1')).toHaveText('Overview');
-    await page.evaluate(() => { window.location.hash = '/images'; });
-    await expect(selectedCount(page)).toHaveText('40 selected');
-    await expect(bulkbar(page).getByRole('button', { name: 'Select all 202 matching', exact: true })).toBeVisible();
-    // Escape in the bar with nothing selected does nothing; with a selection it clears.
-    await bulkbar(page).getByRole('button', { name: 'Clear', exact: true }).focus();
-    await page.keyboard.press('Escape');
-    await expect(bulkbar(page)).toBeEmpty();
-});
-
-test('all matching over 10,000 images says so before any dialog or request', async ({ page, request }) => {
-    await page.route(url => url.pathname === '/prompt_manager/images/output' && url.searchParams.get('limit') !== '1', async route => {
-        const response = await route.fetch();
-        const body = await response.json();
-        await route.fulfill({ response, json: { ...body, total: 20002 } });
-    });
-    await bulkReset(page, request);
-    await cardAt(page, 0).getByRole('button', { name: /^Open / }).focus();
-    await page.keyboard.press('ControlOrMeta+a');
-    await bulkbar(page).getByRole('button', { name: 'Select all 20,002 matching', exact: true }).click();
-    await expect(selectedCount(page)).toHaveText('All 20,002 matching selected');
-    let posted = 0;
-    page.on('request', item => { if (item.method() !== 'GET') posted += 1; });
-    // Set category names at most 500 images (#332); the tagging jobs take up to 10,000.
-    for (const [action, sentence] of [['Set category', 'Select at most 500 images.'], ['Add tags', 'Narrow the view to at most 10,000 images.'],
-        ['Auto-tag selected', 'Narrow the view to at most 10,000 images.']]) {
-        await bulkbar(page).getByRole('button', { name: action, exact: true }).click();
-        await expect(toast(page)).toHaveText(sentence);
-        await expect(page.locator('dialog[open]')).toHaveCount(0);
-    }
-    expect(posted).toBe(0);
-});
@@ -1,7 +1,6 @@
 import {writeFile} from 'node:fs/promises';
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore,followRestore,SEEN_RESTORE_PILL,SEEN_RESTORE_TOAST} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
 import {inventoryOf,mapConcept,diffInventory} from './library-editor-canonical-comparison.mjs';

@@ -9,13 +8,12 @@ import {inventoryOf,mapConcept,diffInventory} from './library-editor-canonical-c
 test.use({locale:'en-US',timezoneId:'UTC',reducedMotion:'reduce'});
 const workspace='/prompt_manager/workspace';
 const ACTIONS={new:['Cancel','Save'],metadata:['Create text revision','Archive…','Cancel','Save'],revision:['Cancel','Save'],negative:['Cancel','Save']};
-// D153 (#447): no Rating field; the fixture's positive stays stored with rating 4 through every workspace save.
-const LABELS=['Title','Positive prompt','Negative prompt (optional)','Category','Tags, separated by commas','Notes'];
-const UNAPPLIED='Saved as a new negative variant of an existing prompt. The title, category, tags and notes you entered were not applied.';
+const LABELS=['Title','Positive prompt','Negative prompt (optional)','Category','Tags, separated by commas','Rating','Notes'];
+const RATINGS=[['5','5 / 5'],['4','4 / 5'],['3','3 / 5'],['2','2 / 5'],['1','1 / 5'],['0','Unrated']];
 const editorDialog=page=>page.locator('dialog.library-editor');

 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);
+    await startCoverage(page,browserName);
    const reset=await request.post('/__test__/library-editor/reset',{data:{}});await expect(reset).toBeOK();page.fixture=await reset.json();
    page.editorErrors=[];page.on('pageerror',error=>page.editorErrors.push(error.message));
    page.writes=[];page.on('request',item=>{if(item.method()!=='GET')page.writes.push({method:item.method(),url:new URL(item.url()).pathname,body:item.postDataJSON()});});
@@ -66,8 +64,9 @@ test('edit recipe metadata shows the concept fields with the selected saved nega
    await expect(dialog.getByRole('region')).toHaveCount(0);
    await expect(field(dialog,'Category')).toHaveValue('Portraits');
    await expect(field(dialog,'Tags, separated by commas')).toHaveValue('studio, window light');
+    await expect(field(dialog,'Rating')).toHaveValue('4');
    await expect(field(dialog,'Notes')).toHaveValue(f.metadata.notes);
-    await expect(dialog.getByLabel('Rating')).toHaveCount(0);await expect(dialog.locator('select, #recipe-rating')).toHaveCount(0);
+    expect(await field(dialog,'Rating').locator('option').evaluateAll(nodes=>nodes.map(node=>[node.value,node.textContent]))).toEqual(RATINGS);
    expect(await field(dialog,'Category').evaluate(node=>[...node.list.options].map(option=>option.value))).toEqual(['Portraits','Sketches']);
    expect(await field(dialog,'Tags, separated by commas').evaluate(node=>[...node.list.options].map(option=>option.value))).toEqual(['draft,','studio,','window light,']);
    await expect(dialog.locator('[placeholder]')).toHaveCount(0);
@@ -82,20 +81,19 @@ test('editor modes persist through reload with selected saved negative',async({p
    const f=page.fixture;await mountEditor(page);
    let dialog=await openEditor(page,{mode:'metadata',positiveId:f.positive_id,pairId:f.pair_id});await ready(dialog);
    await field(dialog,'Title').fill('Edited portrait');await field(dialog,'Category').fill('');
-    await field(dialog,'Tags, separated by commas').fill('studio, moody');
+    await field(dialog,'Tags, separated by commas').fill('studio, moody');await field(dialog,'Rating').selectOption('0');
    await field(dialog,'Notes').fill('Edited notes');await button(dialog,'Save').click();
    await expect(dialog).toHaveCount(0);
    expect(page.writes.map(write=>`${write.method} ${write.url}`)).toEqual([`PATCH /prompt_manager/library/${f.positive_id}`]);
-    expect(page.writes[0].body.metadata).toEqual({title:'Edited portrait',category:'',tags:['studio','moody'],notes:'Edited notes'});
+    expect(page.writes[0].body.metadata).toEqual({title:'Edited portrait',category:'',tags:['studio','moody'],rating:null,notes:'Edited notes'});
    await expect.poll(()=>page.evaluate(()=>window.editorEvents.reconciled.length)).toBe(1);
    const saved=(await detail(request,f.positive_id)).positive;
-    // D153: the edit never sends a rating, so the stored 4 stays.
-    expect(f.metadata.rating).toBe(4);expect(saved).toMatchObject({title:'Edited portrait',category:null,rating:4,notes:'Edited notes'});expect([...saved.tags].sort()).toEqual(['moody','studio']);
+    expect(saved).toMatchObject({title:'Edited portrait',category:null,rating:null,notes:'Edited notes'});expect([...saved.tags].sort()).toEqual(['moody','studio']);

    await page.reload();await mountEditor(page);
    dialog=await openEditor(page,{mode:'metadata',positiveId:f.positive_id,pairId:f.pair_id});await ready(dialog);
    await expect(field(dialog,'Title')).toHaveValue('Edited portrait');await expect(field(dialog,'Category')).toHaveValue('');
-    await expect(field(dialog,'Negative prompt (optional)')).toHaveValue(f.selected_negative);
+    await expect(field(dialog,'Rating')).toHaveValue('0');await expect(field(dialog,'Negative prompt (optional)')).toHaveValue(f.selected_negative);
    await button(dialog,'Create text revision').click();
    await expect(dialog.getByRole('heading',{name:'Create text revision',exact:true})).toBeVisible();
    await expect(editorDialog(page)).toHaveCount(1);expect(await dialog.evaluate(node=>node.open&&node.matches(':modal'))).toBe(true);
@@ -107,15 +105,12 @@ test('editor modes persist through reload with selected saved negative',async({p
    await button(dialog,'Save').click();await expect(dialog).toHaveCount(0);
    const create=page.writes.at(-1);expect(`${create.method} ${create.url}`).toBe('POST /prompt_manager/library');
    expect(create.body).toMatchObject({positive_text:'Editor portrait, revised dusk light',negative_text:f.selected_negative,
-        parent_metadata:{title:'Edited portrait',category:'Uncategorized',notes:'Edited notes'}});
-    expect(Object.hasOwn(create.body.parent_metadata,'rating'),'D153: a revision sends no rating').toBe(false);
+        parent_metadata:{title:'Edited portrait',category:'Uncategorized',rating:null,notes:'Edited notes'}});
    expect([...create.body.parent_metadata.tags].sort()).toEqual(['moody','studio']);
    await expect.poll(()=>page.evaluate(()=>window.editorEvents.reconciled.length)).toBe(1);
    const revision=await page.evaluate(()=>window.editorEvents.committed.at(-1).receipt);
    expect(revision).toMatchObject({positive_created:true,pair_created:true});expect(revision.positive.id).not.toBe(f.positive_id);
-    // D153: the revision is a new, unrated positive; the revised prompt keeps its stored rating.
-    expect((await detail(request,revision.positive.id)).positive).toMatchObject({title:'Edited portrait',category:'Uncategorized',rating:null});
-    expect((await detail(request,f.positive_id)).positive.rating).toBe(4);
+    expect((await detail(request,revision.positive.id)).positive).toMatchObject({title:'Edited portrait',category:'Uncategorized'});

    dialog=await openEditor(page,{mode:'new'});await expect(dialog.getByRole('heading',{name:'New prompt',exact:true})).toBeVisible();await ready(dialog);
    expect(await actionNames(dialog)).toEqual(ACTIONS.new);
@@ -124,9 +119,9 @@ test('editor modes persist through reload with selected saved negative',async({p
    await expect(field(dialog,'Title')).toBeFocused();expect(await field(dialog,'Title').evaluate(node=>node.validity.valueMissing)).toBe(true);
    expect(page.writes).toHaveLength(before);
    await field(dialog,'Title').fill('Fresh idea');await field(dialog,'Positive prompt').fill('A fresh lighthouse at dawn');
-    await button(dialog,'Save').click();await expect(dialog).toHaveCount(0);
+    await field(dialog,'Rating').selectOption('5');await button(dialog,'Save').click();await expect(dialog).toHaveCount(0);
    expect(page.writes.at(-1).body).toEqual({expected_epoch:expect.any(String),positive_text:'A fresh lighthouse at dawn',negative_text:'',
-        parent_metadata:{title:'Fresh idea',category:'Uncategorized',tags:[],notes:''}});
+        parent_metadata:{title:'Fresh idea',category:'Uncategorized',tags:[],rating:5,notes:''}});

    dialog=await openEditor(page,{mode:'negative',positiveId:f.positive_id});
    await expect(dialog.getByRole('heading',{name:'Add a negative variant',exact:true})).toBeVisible();await ready(dialog);
@@ -138,7 +133,6 @@ test('editor modes persist through reload with selected saved negative',async({p
    const added=await page.evaluate(()=>window.editorEvents.committed.at(-1).receipt);
    expect(added).toMatchObject({positive_created:false,pair_created:true,pair:{negative_text:'grain, dust'}});
    await expect(page.locator('#editor-trigger')).toBeFocused();
-    expect((await detail(request,f.positive_id)).positive.rating,'D153: adding a negative keeps the stored rating').toBe(4);
 });

 test('archive confirms the selected pair with fresh counts and writes only on confirm',async({page,request})=>{
@@ -266,8 +260,7 @@ test('recovery states render inline and never replay a write',async({page,reques
    page.writes.length=0;
    dialog=await openEditor(page,{mode:'new'});await ready(dialog);
    const snapshot=await request.get('/__test__/library-editor/snapshot');await expect(snapshot).toBeOK();
-    const buffer=await snapshot.body();
-    const restore=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer}}}));
+    const restore=await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:await snapshot.body()}}});
    await expect(restore).toBeOK();page.writes.length=0;
    await field(dialog,'Title').fill('After restore');await field(dialog,'Positive prompt').fill('Restored storage prompt');await button(dialog,'Save').click();
    await expect(note(dialog)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was saved.');
@@ -459,37 +452,6 @@ async function leaveAndReturn(page,id) {
 }
 const laneLabel=(page,text)=>variantsPanel(page).locator('.variant-lane').filter({hasText:text});

-// #415: a restore the page sees finish while New prompt is open keeps the dialog and its entries; the Library is shown
-// again from the restored data only once the dialog has closed.
-test('a restore seen finishing keeps New prompt open and reloads the Library after it closes',async({page,request})=>{
-    const f=page.fixture;const snapshot=await request.get('/__test__/library-editor/snapshot');await expect(snapshot).toBeOK();
-    const buffer=await snapshot.body();
-    const current=await detail(request,f.positive_id,'active');
-    await expect(await request.patch(`/prompt_manager/library/${f.positive_id}`,{data:{expected_epoch:current.library_epoch,if_match:current.positive.edit_token,metadata:{title:'Retitled elsewhere'}}})).toBeOK();
-    const restoreRun=await followRestore(page);
-    await page.goto(`${workspace}#/library`);const card=page.locator(`article[data-prompt-id="${f.positive_id}"]`);
-    await expect(card).toContainText('Retitled elsewhere');
-    await expect(page.locator('#activity-pill')).toHaveAttribute('href',SEEN_RESTORE_PILL);
-    await headingActions(page).getByRole('button',{name:'+ New prompt',exact:true}).click();
-    const dialog=editorDialog(page);await expect(dialog.getByRole('heading',{name:'New prompt',exact:true})).toBeVisible();await ready(dialog);
-    await field(dialog,'Title').fill('Typed before restore');await field(dialog,'Positive prompt').fill('A prompt typed while storage was restored');
-    await expect(await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer}}})).toBeOK();
-    page.writes.length=0;
-    await restoreRun.finish();
-    await expect(toast(page)).toHaveText(SEEN_RESTORE_TOAST);
-    await expect(dialog).toBeVisible();
-    await expect(field(dialog,'Title')).toHaveValue('Typed before restore');
-    await expect(field(dialog,'Positive prompt')).toHaveValue('A prompt typed while storage was restored');
-    await expect(card).toContainText('Retitled elsewhere');
-    await button(dialog,'Save').click();
-    await expect(note(dialog)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was saved.');
-    await expect(button(dialog,'Save')).toBeDisabled();expect(page.writes).toHaveLength(1);
-    await button(dialog,'Cancel').click();await expect(dialog).toHaveCount(0);
-    await expect(card).not.toContainText('Retitled elsewhere');await expect(card).toContainText('Editor portrait');
-    await expect(page.locator('#workspace-main h1')).toBeFocused();
-    expect(page.writes).toHaveLength(1);
-});
-
 test('library heading offers Export then + New prompt, and New opens the saved prompt history',async({page,request})=>{
    await page.goto(`${workspace}#/library`);await expect(page.locator('article[data-prompt-id]').first()).toBeVisible();
    const actions=headingActions(page).locator('button');
@@ -626,7 +588,7 @@ test('saved refresh failure retries only reads',async({page})=>{

 test('restored storage after a confirmed save or before an archive offers an explicit Library reload',async({page,request})=>{
    const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
    await openHistory(page,f.positive_id);
    await page.route(`**/prompt_manager/library/${f.positive_id}`,async route=>{
        if(route.request().method()!=='PATCH')return route.continue();
@@ -653,7 +615,7 @@ test('restored storage after a confirmed save or before an archive offers an exp
 const DISCARDS='Leaving this dialog discards your entries.';
 test('restored storage before an Edit or Add negative save offers only the Library reload exit',async({page,request})=>{
    const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
    await openHistory(page,f.positive_id);
    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();let dialog=editorDialog(page);await ready(dialog);
    await expect(await restore()).toBeOK();
@@ -809,20 +771,20 @@ test('archived reuse is reported, shown under Show archived and selected read-on
    await uniqueDotNames(page);
    await page.goto(`${workspace}#/library`);await page.getByRole('button',{name:'+ New prompt',exact:true}).click();dialog=editorDialog(page);await ready(dialog);
    await field(dialog,'Title').fill(f.metadata.title);await field(dialog,'Positive prompt').fill(f.positive_text);await field(dialog,'Negative prompt (optional)').fill(f.archived_negative);
-    await field(dialog,'Category').fill(f.metadata.category);await field(dialog,'Tags, separated by commas').fill(f.metadata.tags.join(', '));await field(dialog,'Notes').fill(f.metadata.notes);
+    await field(dialog,'Category').fill(f.metadata.category);await field(dialog,'Tags, separated by commas').fill(f.metadata.tags.join(', '));await field(dialog,'Rating').selectOption(String(f.metadata.rating));await field(dialog,'Notes').fill(f.metadata.notes);
    await button(dialog,'Save').click();await expect(page).toHaveURL(new RegExp(`#/library/${f.positive_id}$`));
    await expect(toast(page)).toHaveText(message);
    await expect(variantsPanel(page).locator('.library-variant-archived .variant-dot')).toHaveAttribute('aria-pressed','true');
    expect(page.writes.every(write=>write.method==='POST')).toBe(true);
 });

-test('reuse that leaves parent metadata unapplied discloses it and keeps the draft for Edit metadata',async({page,request})=>{
+test('reuse that leaves parent metadata unapplied discloses it and keeps the draft for Edit metadata',async({page})=>{
    const f=page.fixture;await page.goto(`${workspace}#/library`);
    await page.getByRole('button',{name:'+ New prompt',exact:true}).click();let dialog=editorDialog(page);await ready(dialog);
    await field(dialog,'Title').fill('A different title');await field(dialog,'Positive prompt').fill(f.positive_text);await field(dialog,'Negative prompt (optional)').fill('brand new negative');
    await field(dialog,'Notes').fill('Draft notes');await button(dialog,'Save').click();
    await expect(page).toHaveURL(new RegExp(`#/library/${f.positive_id}$`));
-    await expect(toast(page)).toHaveText(UNAPPLIED);
+    await expect(toast(page)).toHaveText('Saved as a new negative variant of an existing prompt. The title, category, tags, rating and notes you entered were not applied.');
    await expect(page.locator('#workspace-main h1')).toHaveText(f.metadata.title);
    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();dialog=editorDialog(page);await ready(dialog);
    await expect(field(dialog,'Title')).toHaveValue('A different title');await expect(field(dialog,'Notes')).toHaveValue('Draft notes');
@@ -830,8 +792,6 @@ test('reuse that leaves parent metadata unapplied discloses it and keeps the dra
    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();dialog=editorDialog(page);await ready(dialog);
    await expect(field(dialog,'Title')).toHaveValue(f.metadata.title);await button(dialog,'Cancel').click();
    expect(page.writes).toHaveLength(1);
-    // D153: neither the reuse nor the kept draft touches the stored rating.
-    expect((await detail(request,f.positive_id)).positive.rating).toBe(4);
 });

 test('reuse with the stored parent metadata entered does not claim it was not applied',async({page})=>{
@@ -839,7 +799,7 @@ test('reuse with the stored parent metadata entered does not claim it was not ap
    await page.getByRole('button',{name:'+ New prompt',exact:true}).click();let dialog=editorDialog(page);await ready(dialog);
    await field(dialog,'Title').fill(f.metadata.title);await field(dialog,'Positive prompt').fill(f.positive_text);await field(dialog,'Negative prompt (optional)').fill('another brand new negative');
    await field(dialog,'Category').fill(f.metadata.category);await field(dialog,'Tags, separated by commas').fill(f.metadata.tags.join(', '));
-    await field(dialog,'Notes').fill(f.metadata.notes);
+    await field(dialog,'Rating').selectOption(String(f.metadata.rating));await field(dialog,'Notes').fill(f.metadata.notes);
    await button(dialog,'Save').click();await expect(page).toHaveURL(new RegExp(`#/library/${f.positive_id}$`));
    await expect(toast(page)).toHaveText('Saved as a new negative variant of an existing prompt.');
    await page.getByRole('button',{name:'Edit metadata',exact:true}).click();dialog=editorDialog(page);await ready(dialog);
@@ -855,13 +815,13 @@ test('reuse of an uncategorized prompt with the category left blank is not unapp
        await page.goto(`${workspace}#/library`);await page.getByRole('button',{name:'+ New prompt',exact:true}).click();const dialog=editorDialog(page);await ready(dialog);
        await field(dialog,'Title').fill(f.metadata.title);await field(dialog,'Positive prompt').fill(f.positive_text);await field(dialog,'Negative prompt (optional)').fill(negative);
        await field(dialog,'Category').fill(category);await field(dialog,'Tags, separated by commas').fill(f.metadata.tags.join(', '));
-        await field(dialog,'Notes').fill(f.metadata.notes);
+        await field(dialog,'Rating').selectOption(String(f.metadata.rating));await field(dialog,'Notes').fill(f.metadata.notes);
        await button(dialog,'Save').click();await expect(page).toHaveURL(new RegExp(`#/library/${f.positive_id}$`));
    };
    await reuse('','blank category negative');
    await expect(toast(page)).toHaveText('Saved as a new negative variant of an existing prompt.');
    await reuse('Landscapes','different category negative');
-    await expect(toast(page)).toHaveText(UNAPPLIED);
+    await expect(toast(page)).toHaveText('Saved as a new negative variant of an existing prompt. The title, category, tags, rating and notes you entered were not applied.');
    expect(page.writes.map(write=>`${write.method} ${write.url}`)).toEqual(['POST /prompt_manager/library','POST /prompt_manager/library']);
 });

@@ -1,294 +0,0 @@
-import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
-import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
-
-// #437 D148: select prompts on the Library shelf and set their category in one step (the legacy admin's Set Category).
-const route='/prompt_manager/workspace#/library';
-const cards=page=>page.locator('article[data-prompt-id]');
-const card=(page,id)=>page.locator(`article[data-prompt-id="${id}"]`);
-const box=(page,id)=>card(page,id).locator('.image-overlays input[type="checkbox"]');
-const bar=page=>page.locator('#library-bulkbar > .bulkbar');
-const dialog=page=>page.getByRole('dialog',{name:'Categorize selected prompts',exact:true});
-const toast=page=>page.locator('.toast');
-const heading=page=>page.locator('#workspace-main h1');
-const tagsDialog=page=>page.getByRole('dialog',{name:'Tag selected prompts',exact:true});
-const chips=(page,id)=>card(page,id).locator('.tags > .chip');
-async function addTags(page,value) {
-    await bar(page).getByRole('button',{name:'Add tags',exact:true}).click();
-    await expect(tagsDialog(page)).toBeVisible();
-    await tagsDialog(page).locator('#action-input').fill(value);
-    await tagsDialog(page).getByRole('button',{name:'Apply',exact:true}).click();
-}
-
-async function shelf(request) {
-    const body=await(await request.get('/prompt_manager/library?limit=100')).json();
-    return body.items;
-}
-/** Every POST to the bulk category route, with its body. */
-function recordWrites(page) {
-    const writes=[];
-    page.on('request',item=>{if(item.method()==='POST'&&new URL(item.url()).pathname==='/prompt_manager/bulk/category')writes.push(item.postDataJSON());});
-    return writes;
-}
-/** The first mounted card's index once two frames in a row agree (the shelf's window follows scrolling a frame later). */
-async function stableFirstIndex(page) {
-    return page.evaluate(()=>new Promise(resolve=>{
-        const first=()=>document.querySelector('article[data-prompt-id]')?.dataset.index;
-        let previous=first();
-        const check=()=>requestAnimationFrame(()=>requestAnimationFrame(()=>{const now=first();if(now===previous)resolve(Number(now));else{previous=now;check();}}));
-        check();
-    }));
-}
-async function setCategory(page,value) {
-    await bar(page).getByRole('button',{name:'Set category',exact:true}).click();
-    await expect(dialog(page)).toBeVisible();
-    await dialog(page).locator('#action-input').fill(value);
-    await dialog(page).getByRole('button',{name:'Apply',exact:true}).click();
-}
-
-test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await expect(await request.post('/__test__/reset',{data:{native_library:true}})).toBeOK();
-    page.libraryErrors=[];page.on('pageerror',error=>page.libraryErrors.push(error.message));
-});
-test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.libraryErrors).toEqual([]);});
-
-test('Set category writes the selected prompts on the server, reloads the shelf and clears the selection',async({page,request})=>{
-    const items=await shelf(request);const [first,second,third]=items;
-    const writes=recordWrites(page);
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    // The checkbox is named after the card's title, as the Images overlay names its file.
-    await expect(box(page,first.id)).toHaveAccessibleName(new RegExp(`^Select `));
-    await box(page,first.id).check();await expect(bar(page).locator('strong')).toHaveText('1 selected');
-    await box(page,second.id).check();await expect(bar(page).locator('strong')).toHaveText('2 selected');
-    // Two of three loaded are checked, so Select all N loaded follows the count (D151, #444 ruling).
-    await expect(bar(page).getByRole('button')).toHaveText([`Select all ${items.length} loaded`,'Add tags','Set category','Clear']);
-    await setCategory(page,'  Studio set  ');
-    await expect(toast(page)).toHaveText('Category “Studio set” set on 2 prompts.');
-    await expect(dialog(page)).toHaveCount(0);
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    for(const item of [first,second]) await expect(card(page,item.id).locator('.card-title .chip')).toHaveText('Studio set');
-    await expect(card(page,third.id).locator('.card-title .chip')).toHaveText(third.category || 'Uncategorized');
-    await expect(box(page,first.id)).not.toBeChecked();
-    const after=await shelf(request);
-    expect(after.filter(item=>item.category==='Studio set').map(item=>item.id).sort()).toEqual([first.id,second.id].sort());
-    const epoch=(await(await request.get('/prompt_manager/library/options')).json()).library_epoch;
-    expect(writes).toEqual([{prompt_ids:[first.id,second.id],category:'Studio set',expected_epoch:epoch}]);
-    // The toolbar's category list now offers the new value, and so does the next dialog.
-    await expect(page.locator('#category-filter option',{hasText:'Studio set'})).toHaveCount(1);
-    await box(page,third.id).check();
-    await bar(page).getByRole('button',{name:'Set category',exact:true}).click();
-    await expect(dialog(page).locator('datalist option[value="Studio set"]')).toHaveCount(1);
-    await dialog(page).getByRole('button',{name:'Cancel',exact:true}).click();await expect(dialog(page)).toHaveCount(0);
-    expect(writes).toHaveLength(1);
-});
-
-test('a blank or control-character category keeps the dialog open; Clear and Escape clear the selection',async({page,request})=>{
-    const items=await shelf(request);const writes=recordWrites(page);
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await box(page,items[0].id).check();
-    await bar(page).getByRole('button',{name:'Set category',exact:true}).click();
-    const field=dialog(page).locator('#action-input');
-    await field.fill('   ');await dialog(page).getByRole('button',{name:'Apply',exact:true}).click();
-    await expect(dialog(page)).toBeVisible();await expect(field).toBeFocused();
-    await field.fill('bad\tvalue');await dialog(page).getByRole('button',{name:'Apply',exact:true}).click();
-    await expect(dialog(page)).toBeVisible();
-    expect(await field.evaluate(node=>node.validationMessage)).toBe('A category cannot contain control characters.');
-    await dialog(page).getByRole('button',{name:'Cancel',exact:true}).click();await expect(dialog(page)).toHaveCount(0);
-    expect(writes).toHaveLength(0);
-    await bar(page).getByRole('button',{name:'Clear',exact:true}).click();
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();await expect(heading(page)).toBeFocused();
-    await expect(box(page,items[0].id)).not.toBeChecked();
-    await box(page,items[1].id).check();
-    await bar(page).getByRole('button',{name:'Set category',exact:true}).focus();await page.keyboard.press('Escape');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();await expect(heading(page)).toBeFocused();
-    // A filter change replaces the shelf and clears the selection too.
-    await box(page,items[1].id).check();await expect(bar(page)).toBeVisible();
-    await page.locator('#search').fill('portrait');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-});
-
-test('Shift+click selects a range across windowed cards, Tab reaches the checkbox at the window edge, and a return keeps the fence',async({page,request,isMobile})=>{
-    await expect(await request.post('/__test__/reset',{data:{native_library:true,extra_prompts:200}})).toBeOK();
-    if(!isMobile)await page.setViewportSize({width:1600,height:1100});
-    const writes=recordWrites(page);
-    await page.goto(route);await expect(cards(page).first()).toBeVisible();
-    const more=page.getByRole('button',{name:'Load more prompts',exact:true});
-    for(let index=0;index<3;index++) {
-        await expect(more).toHaveAttribute('aria-disabled','false');
-        const response=page.waitForResponse(item=>{const url=new URL(item.url());return url.pathname==='/prompt_manager/library'&&url.searchParams.has('cursor');});
-        await more.evaluate(node=>node.click());await response;
-    }
-    await expect(more).toHaveAttribute('aria-disabled','false');
-    const firstId=Number(await cards(page).first().getAttribute('data-prompt-id'));
-    await box(page,firstId).check();
-    // Windowed: fewer cards are mounted than are loaded.
-    expect(await cards(page).count()).toBeLessThan(160);
-    // Tab from the last mounted card's last control lands on the next (unmounted) card's checkbox.
-    const last=cards(page).last();const lastIndex=Number(await last.getAttribute('data-index'));
-    await last.locator('button').last().focus();await page.keyboard.press('Tab');
-    const next=page.locator(`article[data-index="${lastIndex+1}"]`);
-    await expect(next.locator('.image-overlays input')).toBeFocused();
-    // Shift+click that card's checkbox: every card from the first to it is selected, mounted or not.
-    await next.locator('.image-overlays > label').click({modifiers:['Shift']});
-    await expect(bar(page).locator('strong')).toHaveText(`${lastIndex+2} selected`);
-    // Shift+Tab from a checkbox whose previous card is unmounted lands on that card's last control.
-    // Halfway down the loaded cards (short of the continuation, so no page loads), once the window stops moving.
-    await page.evaluate(()=>{const grid=document.querySelector('.library-grid');scrollTo(0,grid.getBoundingClientRect().top+scrollY+grid.offsetHeight/2);});
-    await expect.poll(()=>page.locator('article[data-index="0"]').count()).toBe(0);
-    const topIndex=await stableFirstIndex(page);
-    await page.locator(`article[data-index="${topIndex}"] .image-overlays input`).focus();await page.keyboard.press('Shift+Tab');
-    await expect(page.locator(`article[data-index="${topIndex-1}"] .card-footer .row-actions > button`).last()).toBeFocused();
-    // Leaving for a prompt's history and coming back restores the shelf without a read; its epoch still fences.
-    await page.locator(`article[data-index="${topIndex}"]`).getByRole('button',{name:'Explore history',exact:true}).click();
-    await page.getByRole('button',{name:'← Prompt library',exact:true}).click();
-    await expect(cards(page).first()).toBeVisible();await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    const visible=Number(await cards(page).first().getAttribute('data-prompt-id'));
-    await box(page,visible).check();await setCategory(page,'Returned');
-    await expect(toast(page)).toHaveText('Category “Returned” set on 1 prompt.');
-    const epoch=(await(await request.get('/prompt_manager/library/options')).json()).library_epoch;
-    expect(writes).toEqual([{prompt_ids:[visible],category:'Returned',expected_epoch:epoch}]);
-});
-
-test('a restore the page did not see refuses the write, changes nothing and reloads the shelf',async({page,request})=>{
-    await armUnseenRestores(page);
-    const items=await shelf(request);
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await box(page,items[0].id).check();
-    const backup=await request.get('/prompt_manager/backup');await expect(backup).toBeOK();const buffer=await backup.body();
-    const restore=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'library.db',mimeType:'application/octet-stream',buffer}}}));
-    await expect(restore).toBeOK();
-    const reload=page.waitForResponse(item=>{const url=new URL(item.url());return url.pathname==='/prompt_manager/library'&&!url.searchParams.has('cursor');});
-    await setCategory(page,'After restore');
-    await expect(toast(page)).toHaveText('Prompt storage was restored since this page loaded. No category was changed.');
-    await reload;await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    expect((await shelf(request)).filter(item=>item.category==='After restore')).toEqual([]);
-    // The reloaded shelf reads the new epoch: the next write goes through.
-    await box(page,items[0].id).check();await setCategory(page,'After reload');
-    await expect(toast(page)).toHaveText('Category “After reload” set on 1 prompt.');
-});
-
-test('an answer that may follow a committed write says so and reloads; a refused write keeps the selection',async({page,request})=>{
-    const items=await shelf(request);
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await box(page,items[0].id).check();
-    await page.route('**/prompt_manager/bulk/category',route=>route.fulfill({status:500,contentType:'application/json',body:'{"success":false,"error":"boom"}'}),{times:1});
-    await setCategory(page,'Refused');
-    await expect(toast(page)).toHaveText('Category could not be set. Try again.');
-    await expect(bar(page).locator('strong')).toHaveText('1 selected');
-    let sent=false;
-    await page.route('**/prompt_manager/bulk/category',async route=>{sent=true;await route.fetch();await route.abort('failed');},{times:1});
-    await setCategory(page,'Unconfirmed');
-    await expect(toast(page)).toHaveText('The category change could not be confirmed. The Library was reloaded.');
-    expect(sent).toBe(true);
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    await expect(card(page,items[0].id).locator('.card-title .chip')).toHaveText('Unconfirmed');
-});
-
-// #442: Add tags writes prompt tags (never image tags) on the selected prompts.
-function recordTagWrites(page) {
-    const writes=[];
-    page.on('request',item=>{if(item.method()==='POST'&&new URL(item.url()).pathname==='/prompt_manager/bulk/tags')writes.push(item.postDataJSON());});
-    return writes;
-}
-async function promptTags(request,id) {
-    return (await shelf(request)).find(item=>item.id===id).tags;
-}
-
-test('Add tags adds prompt tags to the selected prompts, suggests the vocabulary and reloads the shelf',async({page,request})=>{
-    const items=await shelf(request);const [first,second,third]=items;const writes=recordTagWrites(page);
-    const vocabulary=(await(await request.get('/prompt_manager/tags')).json()).tags;
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await box(page,first.id).check();await box(page,second.id).check();
-    await bar(page).getByRole('button',{name:'Add tags',exact:true}).click();
-    await expect(tagsDialog(page).locator('datalist option')).toHaveCount(vocabulary.length);
-    await tagsDialog(page).getByRole('button',{name:'Cancel',exact:true}).click();await expect(tagsDialog(page)).toHaveCount(0);
-    await addTags(page,' studio-lit , Night ,studio-lit');
-    await expect(toast(page)).toHaveText('Added “studio-lit, Night” to 2 prompts.');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    for(const item of [first,second]) {
-        await expect(chips(page,item.id).filter({hasText:'studio-lit'})).toHaveCount(1);
-        expect(await promptTags(request,item.id)).toEqual(expect.arrayContaining(['studio-lit','Night']));
-    }
-    expect(await promptTags(request,third.id)).not.toContain('studio-lit');
-    const epoch=(await(await request.get('/prompt_manager/library/options')).json()).library_epoch;
-    expect(writes).toEqual([{prompt_ids:[first.id,second.id],tags:['studio-lit','Night'],expected_epoch:epoch}]);
-    // A second add of the same names changes nothing and says so.
-    await box(page,first.id).check();await addTags(page,'Studio-Lit');
-    await expect(toast(page)).toHaveText('1 prompt already had “Studio-Lit”.');
-});
-
-test('the Add tags field states what it refuses, and a restore the page did not see adds nothing',async({page,request})=>{
-    await armUnseenRestores(page);
-    const items=await shelf(request);const writes=recordTagWrites(page);
-    await page.goto(route);await expect(cards(page)).toHaveCount(items.length);
-    await box(page,items[0].id).check();
-    await bar(page).getByRole('button',{name:'Add tags',exact:true}).click();
-    const field=tagsDialog(page).locator('#action-input');
-    for(const [value,message] of [[' , ','Enter at least one tag.'],['x'.repeat(51),'A tag can have at most 50 characters.'],
-        [Array.from({length:21},(_,i)=>`t${i}`).join(','),'Enter at most 20 tags.']]) {
-        await field.fill(value);await tagsDialog(page).getByRole('button',{name:'Apply',exact:true}).click();
-        await expect(tagsDialog(page)).toBeVisible();
-        expect(await field.evaluate(node=>node.validationMessage)).toBe(message);
-    }
-    await tagsDialog(page).getByRole('button',{name:'Cancel',exact:true}).click();
-    expect(writes).toHaveLength(0);
-    const backup=await request.get('/prompt_manager/backup');await expect(backup).toBeOK();const buffer=await backup.body();
-    const restore=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'library.db',mimeType:'application/octet-stream',buffer}}}));
-    await expect(restore).toBeOK();
-    await addTags(page,'after-restore');
-    await expect(toast(page)).toHaveText('Prompt storage was restored since this page loaded. No tags were added.');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    expect((await(await request.get('/prompt_manager/tags')).json()).tags).not.toContain('after-restore');
-});
-
-// #444 ruling (D151): select every loaded prompt, as the legacy page's select-all checkbox did for its page.
-test('Ctrl/Cmd+A and Select all N loaded select every loaded prompt, windowed ones included',async({page,request,isMobile})=>{
-    await expect(await request.post('/__test__/reset',{data:{native_library:true,extra_prompts:200}})).toBeOK();
-    if(!isMobile)await page.setViewportSize({width:1600,height:1100});
-    const writes=recordTagWrites(page);
-    await page.goto(route);await expect(cards(page).first()).toBeVisible();
-    const more=page.getByRole('button',{name:'Load more prompts',exact:true});
-    for(let index=0;index<3;index++) {
-        await expect(more).toHaveAttribute('aria-disabled','false');
-        const response=page.waitForResponse(item=>{const url=new URL(item.url());return url.pathname==='/prompt_manager/library'&&url.searchParams.has('cursor');});
-        await more.evaluate(node=>node.click());await response;
-    }
-    await expect(more).toHaveAttribute('aria-disabled','false');
-    const loaded=160;expect(await cards(page).count()).toBeLessThan(loaded);
-    // In the search box Ctrl/Cmd+A keeps its text meaning: it selects the box's text, no prompt.
-    await page.locator('#search').focus();await page.keyboard.press('ControlOrMeta+a');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();
-    // One checked card offers the rest; the offer selects every loaded prompt and focus moves to the first action.
-    const firstId=Number(await cards(page).first().getAttribute('data-prompt-id'));
-    await box(page,firstId).check();
-    const offer=bar(page).getByRole('button',{name:`Select all ${loaded} loaded`,exact:true});
-    await expect(bar(page).locator(':scope > *').nth(1)).toHaveText(`Select all ${loaded} loaded`);
-    await offer.click();
-    await expect(bar(page).locator('strong')).toHaveText(`${loaded} selected`);
-    await expect(offer).toHaveCount(0);
-    await expect(bar(page).getByRole('button',{name:'Add tags',exact:true})).toBeFocused();
-    // Another batch arrives unchecked: the offer comes back with the new N.
-    {
-        const response=page.waitForResponse(item=>{const url=new URL(item.url());return url.pathname==='/prompt_manager/library'&&url.searchParams.has('cursor');});
-        await more.evaluate(node=>node.click());await response;
-    }
-    await expect(bar(page).getByRole('button',{name:`Select all ${loaded+40} loaded`,exact:true})).toBeVisible();
-    await expect(bar(page).locator('strong')).toHaveText(`${loaded} selected`);
-    // Escape in the grid clears; Ctrl/Cmd+A in the grid selects them all again.
-    const title=cards(page).first().locator('.card-title > button');
-    await title.focus();await page.keyboard.press('Escape');
-    await expect(page.locator('#library-bulkbar')).toBeEmpty();await expect(title).toBeFocused();
-    await page.keyboard.press('ControlOrMeta+a');
-    const all=loaded+40;
-    await expect(bar(page).locator('strong')).toHaveText(`${all} selected`);
-    // While the write runs, every bar action and the offer are aria-disabled.
-    await box(page,firstId).uncheck();
-    let release;const held=new Promise(resolve=>{release=resolve;});
-    await page.route('**/prompt_manager/bulk/tags',async route=>{await held;await route.continue();},{times:1});
-    await addTags(page,'everyone');
-    for(const name of ['Add tags','Set category',`Select all ${all} loaded`]) await expect(bar(page).getByRole('button',{name,exact:true})).toHaveAttribute('aria-disabled','true');
-    release();
-    await expect(toast(page)).toHaveText(`Added “everyone” to ${all-1} prompts.`);
-    expect(writes).toHaveLength(1);expect(new Set(writes[0].prompt_ids).size).toBe(all-1);
-});
@@ -57,26 +57,6 @@ test('library groups reusable negatives under one positive without exposing nega
    for(const item of rows.items) await expect(page.locator(`article[data-prompt-id="${item.id}"] .card-meta > span`).nth(1)).toHaveText(`${item.run_count} run${item.run_count===1?'':'s'}`);
 });

-// #464: a starved renderer (headless WebKit under CPU load, a background tab) can hold animation frames for seconds;
-// a loaded page of prompts is shown without waiting for one.
-test('a held animation frame does not hide a loaded page of prompts, the first or a later one',async({page,request})=>{
-    await expect(await request.post('/__test__/reset',{data:{native_library:true,extra_prompts:45}})).toBeOK();
-    const {total}=await(await request.get('/prompt_manager/library?limit=100')).json();
-    await page.addInitScript(()=>{
-        const request=window.requestAnimationFrame.bind(window),cancel=window.cancelAnimationFrame.bind(window);
-        const held=new Map(),real=new Map();let holding=true,next=0;
-        window.requestAnimationFrame=callback=>{const id=--next;if(holding)held.set(id,callback);else real.set(id,request(callback));return id;};
-        window.cancelAnimationFrame=id=>{held.delete(id);if(real.has(id))cancel(real.get(id));real.delete(id);};
-        window.__releaseAnimationFrames=()=>{holding=false;for(const [id,callback] of held)real.set(id,request(callback));held.clear();};
-    });
-    await page.goto(route);
-    const more=page.getByRole('button',{name:'Load more prompts',exact:true});
-    await expect(more).toHaveAttribute('aria-disabled','false');await expect(cards(page)).toHaveCount(40);
-    await more.evaluate(node=>node.click());await expect(page.locator('.library-status')).toHaveText('You’re all caught up.');
-    await expect(cards(page)).toHaveCount(total);
-    await page.evaluate(()=>window.__releaseAnimationFrames());await nextFrame(page);
-    await expect(cards(page)).toHaveCount(total);await expect(page.locator('.library-row-spacer')).toHaveCount(0);
-});
 test('history displays the selected full negative beneath its positive and filters one shared physical gallery',async({page,request})=>{
    const rows=await(await request.get('/prompt_manager/library')).json();const cat=rows.items.find(item=>item.text==='Cat portrait');
    const data=await(await request.get(`/prompt_manager/library/${cat.id}`)).json();
@@ -172,25 +152,13 @@ test('failed library reads retry while late search responses cannot overwrite ne
    await expect(cards(page)).toHaveCount(1);await expect(cards(page).first()).toContainText('Dog landscape');release();await expect(cards(page).first()).toContainText('Dog landscape');
 });

-// D153 (#447): a Browse visit that still names the retired "Highest rated" sort opens the shelf on Recently added.
-test('a Library visit with the retired rating sort opens on Recently added',async({page})=>{
-    await page.goto(route);await expect(cards(page)).toHaveCount(3);
-    const sorts=[];page.on('request',item=>{const url=new URL(item.url());if(url.pathname==='/prompt_manager/library')sorts.push(url.searchParams.get('sort'));});
-    await page.goto('/prompt_manager/workspace#/overview');await expect(page.locator('#workspace-main h1')).toHaveText('Overview');
-    await page.evaluate(async()=>{const {browseLibrary}=await import('/prompt_manager/js/workspace/library.mjs');browseLibrary({sort:'rating'});});
-    await expect(cards(page)).toHaveCount(3);
-    await expect(page.getByRole('combobox',{name:'Sort results',exact:true})).toHaveValue('newest');
-    expect(sorts).toEqual(['newest']);
-});
-
 test('library toolbar matches the concept and tags live in Refine this view',async({page})=>{
    await page.goto(route);await expect(cards(page)).toHaveCount(3);
    // app.js toolbar() a347–360: search.toolbar > label.search-field (input#search), select#category-filter, select#sort, Save view, Filters.
    const toolbar=page.locator('#workspace-main search.toolbar');await expect(toolbar).toHaveCount(1);
    expect(await toolbar.evaluate(node=>[...node.children].map(child=>child.tagName.toLowerCase()+(child.id?`#${child.id}`:'')+(child.className?`.${child.className.split(' ').filter(name=>!name.startsWith('ca-')).join('.')}`:'')))).toEqual(['label.search-field','select#category-filter','select#sort','button','button']);
    await expect(toolbar.locator('#search')).toHaveAttribute('placeholder','Search prompts, tags, filenames…');
-    // D153 (#447): no "Highest rated".
-    await expect(toolbar.locator('#sort option')).toHaveText(['Recently added','Name A–Z','Oldest first']);
+    await expect(toolbar.locator('#sort option')).toHaveText(['Recently added','Name A–Z','Highest rated','Oldest first']);
    await expect(toolbar.getByRole('button')).toHaveText(['Save view','Filters']);
    await expect(page.getByRole('button',{name:'Refresh library',exact:true})).toHaveCount(0);
    await expect(page.getByRole('textbox',{name:'Tags',exact:true})).toHaveCount(0);
@@ -271,8 +239,7 @@ test('a sort change atomically discards old row geometry and renders changed par
    } finally {await page.evaluate(()=>window.releaseLibraryFrames());}
    await expect(cards(page)).toHaveCount(3);
    const changed=page.locator(`article[data-prompt-id="${id}"]`);await expect(changed).toContainText('Revised dog landscape');
-    // D153: a stored rating of 5 still draws no stars.
-    await expect(changed.locator('.card-footer > span')).not.toContainText('★');await expect(changed.locator('.card-footer > span > *')).toHaveCount(0);
+    await expect(changed.locator('.card-footer .ca-visually-hidden')).toHaveText('Rated 5 out of 5');await expect(changed.locator('.card-footer > span > [aria-hidden="true"]')).toHaveText('★★★★★');
    await expect(page.getByRole('button',{name:'Retry prompt library',exact:true})).toBeHidden();
 });

@@ -478,8 +445,8 @@ test('Library cards clamp long prompts and keep real content inside the card',as
        for(const item of data.items) {
            const card=page.locator(`article[data-prompt-id="${item.id}"]`);
            const footer=card.locator('.card-footer > span');
-            // D153: no stars or "Rated N out of 5", whatever the stored rating.
-            await expect(footer.locator('> *')).toHaveCount(0);
+            await expect(footer.locator('[aria-hidden="true"]')).toHaveText(item.rating?'★'.repeat(item.rating):[]);
+            await expect(footer.locator('.ca-visually-hidden')).toHaveText(item.rating?`Rated ${item.rating} out of 5`:[]);
            await expect(card.locator('.card-content > .tags .chip')).toHaveText(item.tags);
            await expect(card.locator('.card-meta > span').nth(1)).toHaveText(`${item.run_count} run${item.run_count===1?'':'s'}`);
        }
@@ -631,7 +598,7 @@ async function patchShelf(page,patch) {
        await route.fulfill({response,json:body});
    });
 }
-/** The footer line as seen: everything but visually hidden text (D153: there is no rating sentence any more). */
+/** The footer line as seen: everything but its visually hidden rating sentence. */
 const shownText=node=>[...node.childNodes].filter(child=>!child.classList?.contains('ca-visually-hidden')).map(child=>child.textContent).join('');
 const longPrompt=[`${'A luminous alpine observatory with layered glass terraces '.repeat(6)}`,'second paragraph keeps the full text',`final line ${'detail '.repeat(30)}end of prompt`].join('\n');

@@ -651,8 +618,7 @@ test('card matches the concept and never wraps the category mid-word',async({pag
        const card=page.locator(`article[data-prompt-id="${cat.id}"]`);
        // app.js renderLibrary a586: article.prompt-card > .card-art, .card-content, .card-footer.
        await expect(card).toHaveClass('prompt-card');
-        // D148 (#437): the concept's Images selection overlay leads the card.
-        expect(await card.evaluate(node=>[...node.children].map(child=>child.className))).toEqual(['image-overlays','card-art','card-content','card-footer']);
+        expect(await card.evaluate(node=>[...node.children].map(child=>child.className))).toEqual(['card-art','card-content','card-footer']);
        expect(await card.locator('.card-art').evaluate(node=>[...node.children].map(child=>child.tagName))).toEqual(['IMG','IMG']);
        expect(await card.locator('.card-content').evaluate(node=>[...node.children].map(child=>child.className))).toEqual(['card-title','prompt-inspector','card-meta','tags']);
        expect(await card.locator('.card-title').evaluate(node=>[...node.children].map(child=>`${child.tagName}.${child.className}`))).toEqual(['BUTTON.','SPAN.chip']);
@@ -667,13 +633,13 @@ test('card matches the concept and never wraps the category mid-word',async({pag
        await expect(card.locator('.tags > .chip')).toHaveText(['cats','studio']);
        const footer=card.locator('.card-footer');
        expect(await footer.evaluate(node=>[...node.children].map(child=>`${child.tagName}.${child.className}`))).toEqual(['SPAN.','DIV.row-actions']);
-        // D153 (#447): the stored rating 5 draws no stars; the footer reads only the last use.
-        await expect(footer.locator('> span > *')).toHaveCount(0);
-        expect(await footer.locator('> span').evaluate(shownText)).toBe('Used today');
+        await expect(footer.locator('> span > [aria-hidden="true"]')).toHaveText('★★★★★');
+        await expect(footer.locator('> span > .ca-visually-hidden')).toHaveText('Rated 5 out of 5');
+        expect(await footer.locator('> span').evaluate(shownText)).toBe('★★★★★ · Used today');
        const actions=footer.locator('.row-actions > button');await expect(actions).toHaveCount(2);
        await expect(actions.first()).toHaveClass('send icon-btn');await expect(actions.first()).toHaveAccessibleName('Send positive prompt to ComfyUI: Cat portrait');
        await expect(actions.nth(1)).toHaveAccessibleName('Explore history');await expect(actions.nth(1).locator('svg')).toHaveCount(1);
-        // Never used: the used label alone; no negatives still reads as a count.
+        // Unrated and never used: the used label alone; no negatives still reads as a count.
        const unrated=page.locator(`article[data-prompt-id="${dual.id}"]`);
        expect(await unrated.locator('.card-footer > span').evaluate(shownText)).toBe('Not used yet');
        await expect(unrated.locator('.card-footer > span > [aria-hidden="true"]')).toHaveCount(0);
@@ -23,7 +23,7 @@ const heading = page => main(page).getByRole('heading', { level: 1 });
 const saveDialog = page => page.getByRole('dialog', { name: 'Save this view', exact: true });
 const refineDialog = page => page.getByRole('dialog', { name: 'Refine this view', exact: true });
 const toast = page => page.locator('#workspace-toast');
-const IMAGE_DEFAULTS = { q: '', category: '', sort: 'newest', source: 'all', folder: '', media: 'all', tags: [], favorites: false, collection: '' };
+const IMAGE_DEFAULTS = { q: '', category: '', sort: 'newest', source: 'all', folder: '', media: 'all', tags: [], favorites: false };

 async function refine(page, values) {
    await filtersButton(page).click();
@@ -73,8 +73,7 @@ test('Save view saves the Images toolbar and Refine filters, and its sidebar row
    await page.goto(`${workspace}#/images`);
    await expect(imageCards(page)).toHaveCount(2);
    // The concept's sidebar group: SAVED VIEWS without its PROPOSED badge (D49), empty until a view is saved.
-    // D136: the COLLECTIONS label stays hidden while no collection is listed.
-    await expect(page.locator('aside.sidebar .sidebar-label:not([hidden])')).toHaveText(['WORKSPACE', 'SAVED VIEWS']);
+    await expect(page.locator('aside.sidebar .sidebar-label')).toHaveText(['WORKSPACE', 'SAVED VIEWS']);
    await expect(viewRows(page)).toHaveCount(0);

    await search(page).fill('dogs');
@@ -230,31 +229,6 @@ test('a view stored under older rules still lists and opens with its usable valu
    await expect(promptCards(page)).toHaveCount(1);
 });

-// D153 (#447): the workspace no longer offers "Highest rated"; the API still stores such a view as it was saved.
-test('a view saved under Highest rated opens on Recently added on Images and the Library', async ({ page, request }) => {
-    const images = await create(request, { page: 'images', name: 'Rated cats', state: { ...IMAGE_DEFAULTS, q: 'cat', sort: 'rating' } });
-    const library = await create(request, { page: 'library', name: 'Rated dogs', state: { q: 'dog', category: '', sort: 'rating', tags: [] } });
-    expect((await listed(request)).map(view => view.state.sort)).toEqual(['rating', 'rating']);
-    const listings = [];
-    page.on('request', item => {
-        const url = new URL(item.url());
-        if (['/prompt_manager/images/output', '/prompt_manager/library'].includes(url.pathname)) listings.push(url.searchParams.get('sort'));
-    });
-    await page.goto(`${workspace}#/saved/${images.id}`);
-    await expect(heading(page)).toHaveText('Rated cats');
-    await expect(sortBy(page)).toHaveValue('newest');
-    expect(await sortBy(page).locator('option').allTextContents()).not.toContain('Highest rated');
-    await expect(search(page)).toHaveValue('cat');
-    await expect(imageCards(page)).toHaveCount(1);
-    await savedNav(page).getByRole('link', { name: 'Rated dogs', exact: true }).click();
-    await expect(heading(page)).toHaveText('Rated dogs');
-    await expect(sortBy(page)).toHaveValue('newest');
-    await expect(search(page)).toHaveValue('dog');
-    await expect(promptCards(page)).toHaveCount(1);
-    expect(listings.length).toBeGreaterThan(1);
-    expect(listings).not.toContain('rating');
-});
-
 test('leaving a saved view returns Images and the Library to their own last state (#249 M2)', async ({ page, request }) => {
    const dogs = await create(request, { page: 'images', name: 'Dogs', state: { ...IMAGE_DEFAULTS, q: 'dogs' } });
    const cats = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [] } });
@@ -1,236 +0,0 @@
-// #430: an open workspace page whose sources changed under it. A ComfyUI restart no longer changes any scope (the
-// key is persisted, see tests/test_api_workspace_restart.py); what is left is a real source change. Renumbered
-// sources (`/__test__/sources/reverse`) are found again: the Tag image dialog stays open on its file and works, and
-// the panel keeps the file. A scope that cannot be mapped (`/__test__/scope-key/rotate`, a lost key) blocks Generate
-// and Save visibly, says why beside them and offers Refresh. Both commands are undone by every reset.
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-const images = '/prompt_manager/workspace#/images';
-const FIRST = 'tagging/dunes_00001.png', SECOND = 'tagging/dunes_00002.png';
-const SOURCE_CHANGED = 'The source changed. Refresh the image collection before tagging this file.';
-const card = (page, path, root = 0) => page.locator(`article[data-image-key="${root}:${path}"]`);
-const cards = page => page.locator('.gallery-body article[data-image-key]');
-const tagButton = (page, path, root = 0) => card(page, path, root).getByRole('button', { name: `Tag or auto-tag ${path.split('/').pop()}`, exact: true });
-const infoButton = (page, path, root = 0) => card(page, path, root).getByRole('button', { name: `Inspect ${path.split('/').pop()}`, exact: true });
-const dialog = page => page.getByRole('dialog', { name: 'Tag image', exact: true });
-const manual = page => dialog(page).getByRole('textbox', { name: 'Image tags · edit manually', exact: true });
-const generate = page => dialog(page).getByRole('button', { name: 'Generate suggestions', exact: true });
-const primary = page => dialog(page).locator('.dialog-actions .ca-primary');
-const notice = page => dialog(page).locator('.dialog-actions > .tag-action-notice');
-const status = page => dialog(page).locator('#tag-generation-status');
-const chips = page => dialog(page).locator('#tag-suggestions .chip.tag-suggestion');
-const panel = page => page.getByRole('complementary', { name: 'Selected image details', exact: true });
-const toast = page => page.locator('#workspace-toast');
-const answered = (page, suffix, method = 'POST') => page.waitForResponse(item => new URL(item.url()).pathname.endsWith(suffix) && item.request().method() === method);
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await expect(await request.post('/__test__/tagging/reset', { data: {} })).toBeOK();
-    page.staleErrors = [];
-    page.on('pageerror', error => page.staleErrors.push(error.message));
-});
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    expect(page.staleErrors).toEqual([]);
-    // The next spec file starts on the standard sources and key.
-    await expect(await request.post('/__test__/tagging/reset', { data: {} })).toBeOK();
-});
-
-async function openTag(page, path = FIRST, root = 0) {
-    const observed = answered(page, '/image-annotations/observe');
-    await tagButton(page, path, root).click();
-    await expect(dialog(page)).toBeVisible();
-    return observed;
-}
-async function savedTags(request, path, root) {
-    const listing = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=40')).json();
-    const item = listing.images.find(image => image.path === path && image.root_index === root);
-    const target = { root_index: root, root_scope: item.root_scope, path };
-    const observed = await (await request.post('/prompt_manager/image-annotations/observe', { data: { target } })).json();
-    await request.delete(`/prompt_manager/image-annotations/capture/${observed.capture.token}`);
-    return observed.tags;
-}
-
-test('renumbered sources under an open Tag dialog: it finds the file again, keeps the draft and Generate works', async ({ page, request }) => {
-    await page.goto(images);
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    expect((await openTag(page)).status()).toBe(200);
-    await manual(page).fill('kept_draft');
-    await expect(await request.post('/__test__/sources/reverse')).toBeOK();
-
-    // Generate is refused (the held scope names another index now); the page asks where the file is and retargets.
-    const refused = answered(page, '/image-annotations/suggest');
-    const rescoped = answered(page, '/images/rescope');
-    const observedAgain = answered(page, '/image-annotations/observe');
-    await generate(page).click();
-    expect((await refused).status()).toBe(409);
-    const mapped = await (await rescoped).json();
-    expect([mapped.image.root_index, mapped.image.path]).toEqual([1, FIRST]);
-    const observed = await observedAgain;
-    expect(observed.status()).toBe(200);
-    expect(observed.request().postDataJSON().target).toEqual({ root_index: 1, root_scope: mapped.image.root_scope, path: FIRST });
-    await expect(dialog(page)).toBeVisible();
-    await expect(notice(page)).toHaveCount(0);
-    await expect(manual(page)).toHaveValue('kept_draft');
-    await expect(dialog(page).locator('img.tag-image-preview')).toHaveAttribute('src', /\/image-annotations\/capture\//);
-
-    // The page listed again under the new numbering and kept the file selected.
-    await expect(card(page, FIRST, 1)).toHaveClass(/\bselected\b/);
-    await expect(card(page, FIRST, 0)).toHaveCount(0);
-
-    const suggested = answered(page, '/image-annotations/suggest');
-    await generate(page).click();
-    expect((await suggested).status()).toBe(200);
-    await expect(chips(page).first()).toBeVisible();
-    const saved = answered(page, '/image-annotations/tags', 'PUT');
-    await primary(page).click();
-    expect((await saved).request().postDataJSON().target.root_index).toBe(1);
-    await expect(toast(page)).toContainText('tags saved for dunes_00001.png.');
-    expect(await savedTags(request, FIRST, 1)).toContain('kept_draft');
-});
-
-test('the inspector finds a renumbered file again; checked files from the old numbering are cleared', async ({ page, request }) => {
-    await page.goto(images);
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await card(page, FIRST).getByRole('checkbox', { name: /^Select / }).check();
-    await expect(page.locator('.bulkbar')).toBeVisible();
-    await expect(await request.post('/__test__/sources/reverse')).toBeOK();
-
-    const refused = page.waitForResponse(item => new URL(item.url()).pathname === `/prompt_manager/images/inspect/${SECOND}` &&
-        new URL(item.url()).searchParams.get('root') === '0');
-    const reread = page.waitForResponse(item => new URL(item.url()).pathname === `/prompt_manager/images/inspect/${SECOND}` &&
-        new URL(item.url()).searchParams.get('root') === '1');
-    await infoButton(page, SECOND).click();
-    expect((await refused).status()).toBe(409);
-    expect((await reread).status()).toBe(200);
-    await expect(card(page, SECOND, 1)).toHaveClass(/\bselected\b/);
-    await expect(panel(page)).not.toContainText('The source changed');
-    await expect(panel(page).getByRole('button', { name: 'Refresh image collection', exact: true })).toHaveCount(0);
-    // A checked key of the old list could name a same-named file in another source: nothing stays checked.
-    await expect(page.locator('.bulkbar')).toBeHidden();
-    await expect(cards(page).getByRole('checkbox', { checked: true })).toHaveCount(0);
-});
-
-test('a scope that cannot be mapped: Generate and Save are visibly disabled, the reason and Refresh sit beside them', async ({ page }) => {
-    await page.goto(images);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(await page.request.post('/__test__/scope-key/rotate')).toBeOK();
-    const rescoped = answered(page, '/images/rescope');
-    expect((await openTag(page)).status()).toBe(409);
-    expect((await rescoped).status()).toBe(409);
-
-    await expect(notice(page)).toContainText(SOURCE_CHANGED);
-    await expect(status(page)).toHaveText('');
-    const refresh = notice(page).getByRole('button', { name: 'Refresh image collection', exact: true });
-    await expect(refresh).toBeVisible();
-    for (const button of [generate(page), primary(page)]) {
-        await expect(button).toHaveAttribute('aria-disabled', 'true');
-        await expect(button).toHaveCSS('opacity', '0.55');
-    }
-    // The notice is its own first row of the sticky actions, above the buttons.
-    const rows = await dialog(page).locator('.dialog-actions').evaluate(actions => {
-        const noticeBox = actions.firstElementChild.getBoundingClientRect();
-        return { first: actions.firstElementChild.className, below: [...actions.querySelectorAll(':scope > button')].every(button => button.getBoundingClientRect().top >= noticeBox.bottom - 1) };
-    });
-    expect(rows).toEqual({ first: 'tag-action-notice', below: true });
-    const preview = dialog(page).locator('.tag-image-preview');
-    await expect(preview).toHaveText('Preview unavailable');
-    await expect(preview).toHaveAttribute('role', 'img');
-    const suggest = [];
-    page.on('request', item => { if (item.url().endsWith('/image-annotations/suggest')) suggest.push(item.url()); });
-    // Pressed anyway (Playwright refuses an aria-disabled target, so the press is dispatched), nothing is sent.
-    await generate(page).dispatchEvent('click');
-    await primary(page).dispatchEvent('click');
-    expect(suggest).toEqual([]);
-    await page.screenshot({ path: test.info().outputPath('stale-source-tag-dialog.png') });
-
-    // Refresh closes the dialog and lists again with the current scopes; Tag then works.
-    const relisted = page.waitForResponse(item => item.url().includes('/images/output?'));
-    await refresh.click();
-    await expect(dialog(page)).toHaveCount(0);
-    await relisted;
-    await expect(card(page, FIRST)).toBeVisible();
-    expect((await openTag(page)).status()).toBe(200);
-    await expect(notice(page)).toHaveCount(0);
-    await expect(generate(page)).not.toHaveAttribute('aria-disabled', 'true');
-});
-
-test('an unmappable inspector read keeps its visible Refresh, and Refresh recovers the panel', async ({ page }) => {
-    await page.goto(images);
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(await page.request.post('/__test__/scope-key/rotate')).toBeOK();
-    const rescoped = answered(page, '/images/rescope');
-    await infoButton(page, SECOND).click();
-    expect((await rescoped).status()).toBe(409);
-    await expect(panel(page)).toContainText('The source changed. Refresh the image collection before inspecting this file.');
-    const relisted = page.waitForResponse(item => item.url().includes('/images/output?'));
-    await panel(page).getByRole('button', { name: 'Refresh image collection', exact: true }).click();
-    await relisted;
-    await expect(cards(page).first()).toHaveClass(/\bselected\b/);
-    await expect(panel(page)).not.toContainText('The source changed');
-});
-
-test('a Load more cursor the server cannot verify offers Refresh instead of a dead Retry', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/reset', { data: { extra_images: 60 } })).toBeOK();
-    await page.goto(images);
-    await expect(cards(page).first()).toBeVisible();
-    await expect(page.locator('#gallery-continuation')).toContainText('more load as you scroll');
-    await expect(await request.post('/__test__/scope-key/rotate')).toBeOK();
-    const stale = page.waitForResponse(item => item.url().includes('/images/output?') && new URL(item.url()).searchParams.has('cursor'));
-    await page.locator('#gallery-continuation').scrollIntoViewIfNeeded();
-    const answer = await stale;
-    expect(answer.status()).toBe(400);
-    expect((await answer.json()).code).toBe('cursor-stale');
-    const continuation = page.locator('#gallery-continuation');
-    await expect(continuation).toContainText('The image collection changed. Refresh image collection to continue.');
-    const relisted = page.waitForResponse(item => item.url().includes('/images/output?') && !new URL(item.url()).searchParams.has('cursor'));
-    await continuation.getByRole('button', { name: 'Refresh image collection', exact: true }).click();
-    expect((await relisted).status()).toBe(200);
-    await expect(continuation).not.toContainText('The image collection changed');
-});
-
-test('a viewer whose media source was renumbered closes onto the file, kept selected', async ({ page, request }) => {
-    await page.goto(images);
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(await request.post('/__test__/sources/reverse')).toBeOK();
-    const rescoped = answered(page, '/images/rescope');
-    await card(page, FIRST).locator('.image-open').click();
-    const mapped = await (await rescoped).json();
-    expect([mapped.image.root_index, mapped.image.path]).toEqual([1, FIRST]);
-    await expect(page.locator('#viewer-dialog')).toHaveCount(0);
-    await expect(card(page, FIRST, 1)).toHaveClass(/\bselected\b/);
-    // Opened again, it shows the file under its current source.
-    await card(page, FIRST, 1).locator('.image-open').click();
-    await expect(page.locator('#viewer-dialog[open]')).toBeVisible();
-    await expect(page.locator('#viewer-dialog').getByText('Media could not be loaded. Retry this file.', { exact: true })).toBeHidden();
-    await expect.poll(() => page.locator('#viewer-dialog img').first().evaluate(image => image.complete && image.naturalWidth > 0)).toBe(true);
-});
-
-test('a collection page finds a renumbered member again and stays on its members', async ({ page, request }) => {
-    // Members are stored by root path, not index (#331), so a renumbering keeps them; the page's scopes go stale.
-    const listing = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=40')).json();
-    const first = listing.images.find(image => image.path === FIRST && image.root_index === 0);
-    const name = `Stale ${test.info().workerIndex}-${Date.now()}`;
-    const added = await request.post('/prompt_manager/collections/items', { data: { name, items: [
-        { root_index: 0, root_scope: first.root_scope, path: FIRST }] } });
-    await expect(added).toBeOK();
-    const collections = (await (await request.get('/prompt_manager/collections')).json()).collections;
-    const { id } = collections.find(item => item.name === name);
-    await page.goto(`/prompt_manager/workspace#/collection/${id}`);
-    await expect(cards(page)).toHaveCount(1);
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(await request.post('/__test__/sources/reverse')).toBeOK();
-
-    const rescoped = answered(page, '/images/rescope');
-    const relisted = page.waitForResponse(item => item.url().includes('/images/output?') && new URL(item.url()).searchParams.get('collection') === String(id));
-    await card(page, FIRST).locator('.image-open').click();
-    expect((await (await rescoped).json()).image.root_index).toBe(1);
-    expect((await relisted).status()).toBe(200);
-    await expect(page).toHaveURL(new RegExp(`#/collection/${id}$`));
-    await expect(cards(page)).toHaveCount(1);
-    await expect(card(page, FIRST, 1)).toHaveClass(/\bselected\b/);
-    // Tag image works on the member under its new source.
-    expect((await openTag(page, FIRST, 1)).status()).toBe(200);
-    await expect(notice(page)).toHaveCount(0);
-});
@@ -1,7 +1,6 @@
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';
 import { seedConcept } from './concept-inventory.mjs';
-import { followRestore, SEEN_RESTORE_PILL, SEEN_RESTORE_TOAST } from './unseen-restore.mjs';

 // System › Backup & export (#249 System S9 Task 24) on the S8 backend and the concept-shaped fixture: Back up and its
 // status line (D103), the restore review (D105) and its job, the exports, Import / inspect and the recovery policy
@@ -48,17 +47,6 @@ async function serverJson(request, url) {
    return response.json();
 }

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

-// #415: an open dialog waits out a finished restore, except a review: the plan it staged no longer describes storage,
-// so it closes as dismissed (its stage discarded), as before.
-test('a restore seen finishing elsewhere closes an open restore review and discards its stage', async ({ page, request }) => {
-    const bytes = await backupBytes(request);
-    const restoreRun = await followRestore(page);
-    await openBackups(page);
-    await expect(page.locator('#activity-pill')).toHaveAttribute('href', SEEN_RESTORE_PILL);
-    await chooseBackup(page, bytes);
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Restore preview');
-    expect((await serverJson(request, '/__test__/system/backups')).stages).toBe(1);
-    const discarded = page.waitForResponse(response => response.url().includes(`${PREVIEW_URL}/`) && response.request().method() === 'DELETE');
-    await restoreRun.finish();
-    await expect(toast(page)).toHaveText(SEEN_RESTORE_TOAST);
-    expect((await discarded).status()).toBe(200);
-    await expect(dialog(page)).toHaveCount(0);
-    expect((await serverJson(request, '/__test__/system/backups')).stages).toBe(0);
-});
-
 test('invalid file shows the validator message; nothing is staged', async ({ page, request }) => {
    const before = await serverJson(request, '/__test__/system/digest');
    await openBackups(page);
@@ -414,15 +382,14 @@ test('a failed settings read leaves the policy disabled with the reason', async
    await expect(row.locator('input')).toBeDisabled();
 });

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

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

-const NEEDS_LLAMA = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-    + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-
-test('a downloaded model whose backend package is missing says so and is not offered as ready (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-vit'],
-        missing_packages: { gguf: ['llama-cpp-python'], 'wd14-vit': ['onnxruntime'] } } })).toBeOK();
-    await openTagging(page);
-    const line = modelRow(page).locator('p').first();
-    await page.locator('#tag-model').selectOption('gguf');
-    await expect(line).toHaveText('Downloaded. Needs llama-cpp-python: pip install llama-cpp-python. '
-        + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python');
-    // Files and packages are separate: Download (again) stays offered.
-    await expect(actionOf(page, 'Download again')).not.toHaveAttribute('aria-disabled', 'true');
-    // Review explains instead of reviewing; nothing is previewed.
-    await expect(reviewButton(page)).toHaveAttribute('aria-disabled', 'true');
-    await reviewButton(page).dispatchEvent('click');
-    await expect(toast(page)).toHaveText(NEEDS_LLAMA);
-    expect(page.modelCalls.filter(call => call.endsWith('/autotag/batch/preview'))).toEqual([]);
-    // Not downloaded reads differently and still names what it will need.
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    await expect(line).toHaveText('Not downloaded. Download size ~400 MB. Also needs onnxruntime.');
-    await page.locator('#tag-model').selectOption('wd14-swinv2');
-    await expect(line).toHaveText('Downloaded. Not loaded.');
-    await expect(reviewButton(page)).not.toHaveAttribute('aria-disabled', 'true');
-});
-
 test('entering the section makes no model call besides status', async ({ page }) => {
    await openTagging(page);
    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Integrations', exact: true }).click();
@@ -341,28 +315,22 @@ test('Preview tagging review without a selection toasts the D115 sentence', asyn
    await expect(tagDialog(page)).toHaveCount(0);
 });

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

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

 // System › Overview (#249 System S2 Task 6) on the concept-shaped real fixture: the metrics, rows, Statistics dialog and
 // Health report read the server, never sample values (D93, D95, D96). The hooks are workspace_system_fixture.py's.
@@ -79,7 +78,7 @@ test('overview shows real counts and Not checked', async ({ page, request }) =>
    expect(await rowsOf(layout, 'Workspace preferences')).toEqual([
        ['One display configuration', 'Grid and density settings are shared across views.', 'Appearance'],
        ['2 output sources', 'Monitoring and enrichment share one source list.', 'Manage sources'],
-        ['Statistics', 'Runs by category, with library totals.', 'Explore'],
+        ['Statistics', 'Runs and ratings by category, with library totals.', 'Explore'],
    ]);
    expect(writes).toEqual([]);
 });
@@ -373,12 +372,13 @@ test('statistics dialog lists runs by category and library totals', async ({ pag
    await expect(dialog.locator('#modal-title')).toHaveText('Usage statistics');
    const tables = dialog.locator('#modal-body > table');
    await expect(tables.locator('caption')).toHaveText(['Runs by category', 'Library totals']);
-    // D153 (#447): no rating column and no rated-images total.
-    await expect(tables.first().locator('thead th')).toHaveText(['Category', 'Runs']);
+    await expect(tables.first().locator('thead th')).toHaveText(['Category', 'Runs', 'Avg. rating']);
    const cells = table => table.locator('tbody tr').evaluateAll(rows => rows.map(row => [...row.cells].map(cell => cell.textContent)));
-    expect(await cells(tables.first())).toEqual(statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs)]));
+    expect(await cells(tables.first())).toEqual(statistics.by_category.map(row => [row.category ?? 'Uncategorized',
+        number(row.runs), row.average_rating === null ? 'Not rated' : `${number(row.average_rating)} / 5`]));
    expect(await cells(tables.nth(1))).toEqual([['Prompts', number(statistics.totals.total_prompts)],
-        ['Tags', number(statistics.totals.total_tags)], ['Images', number(statistics.totals.total_images)]]);
+        ['Tags', number(statistics.totals.total_tags)], ['Images', number(statistics.totals.total_images)],
+        ['Rated images', number(statistics.rated_images)]]);
    await page.keyboard.press('Escape');
    await expect(explore).toBeFocused();
    // A statistics read that fails says so; the Overview stays.
@@ -412,16 +412,15 @@ test('out-of-order overview responses never repaint a newer section', async ({ p
    await nav.getByRole('button', { name: 'Appearance', exact: true }).click();
    await nav.getByRole('button', { name: 'Overview', exact: true }).click();
    await expect.poll(held).toBe(2);
-    // Diagnostics & logs is native (S12): its body is its two surfaces.
+    // Diagnostics still hands off (S12), so its body is one known panel.
    await nav.getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
-    await expect(layout.locator(':scope > section.surface')).toHaveCount(2);
    await expect(await request.post('/__test__/release')).toBeOK();
    await expect.poll(held).toBe(0);
    // Both late answers reached a section that had left: Diagnostics keeps its own body.
+    await expect(layout.locator(':scope > section.handoff')).toBeVisible();
    await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
    await expect(layout.locator('.summary-metrics')).toHaveCount(0);
-    expect(await layout.evaluate(node => [...node.children].map(child => `${child.localName}.${child.className}`)))
-        .toEqual(['section.surface', 'section.surface', 'div.save-row']);
+    expect(await layout.evaluate(node => [...node.children].map(child => child.className))).toEqual(['surface handoff', 'save-row']);
    // Back on Overview, one fresh read paints one set of metrics.
    await nav.getByRole('button', { name: 'Overview', exact: true }).click();
    await expect(layout.locator('.summary-metrics')).toHaveCount(1);
@@ -471,7 +470,7 @@ async function openImages(page) {

 test('defaults apply to a new visit but not to the current view or a saved view', async ({ page, request }) => {
    const created = await request.post('/prompt_manager/saved-views', { data: { page: 'images', name: 'Everything',
-        state: { q: '', category: '', sort: 'newest', source: 'all', folder: '', media: 'all', tags: [], favorites: false, collection: '' } } });
+        state: { q: '', category: '', sort: 'newest', source: 'all', folder: '', media: 'all', tags: [], favorites: false } } });
    expect(created.status()).toBe(201);
    const view = (await created.json()).view;
    try {
@@ -480,19 +479,17 @@ test('defaults apply to a new visit but not to the current view or a saved view'
        await page.getByRole('group', { name: 'Image layout' }).getByRole('button', { name: 'List', exact: true }).click();
        await expect(page.locator('.image-grid')).toHaveAttribute('data-layout', 'list');
        await openAppearance(page);
-        // #451: a fresh browser's Default layout is Masonry.
-        await expect(page.locator('#default-view')).toHaveValue('masonry');
-        await page.locator('#default-view').selectOption('grid');
+        await expect(page.locator('#default-view')).toHaveValue('grid');
+        await page.locator('#default-view').selectOption('masonry');
        await page.locator('#density').selectOption('compact');
        await expect(statusOf(page)).toHaveText('Unsaved changes.');
        await saveAppearance(page, 'Saved in this browser.');
        const stored = await storedSettings(page);
-        expect([stored.workspaceLayout, stored.workspaceDensity]).toEqual(['grid', 'compact']);
-        // Back in Images (the page session's last visit): the toolbar's List is the current view's own and stays; the
-        // size the toolbar never changed follows the newer default (#451).
+        expect([stored.workspaceLayout, stored.workspaceDensity]).toEqual(['masonry', 'compact']);
+        // Back in Images (the page session's last visit): the current view keeps its own layout and size.
        await page.locator('#primary-nav a[data-route="images"]').click();
        await expect(page.locator('.image-grid')).toHaveAttribute('data-layout', 'list');
-        await expect(page.locator('.image-grid')).toHaveAttribute('data-density', 'compact');
+        await expect(page.locator('.image-grid')).toHaveAttribute('data-density', 'comfortable');
        // The saved view opens as before.
        await page.goto(`${workspace}#/saved/${view.id}`);
        await expect(imageCards(page).first()).toBeVisible();
@@ -502,109 +499,15 @@ test('defaults apply to a new visit but not to the current view or a saved view'
        await openImages(page);
        await page.reload();
        await expect(imageCards(page).first()).toBeVisible();
-        await expect(page.locator('.image-grid')).toHaveAttribute('data-layout', 'grid');
+        await expect(page.locator('.image-grid')).toHaveAttribute('data-layout', 'masonry');
        await expect(page.locator('.image-grid')).toHaveAttribute('data-density', 'compact');
-        await expect(page.getByRole('group', { name: 'Image layout' }).getByRole('button', { name: 'Grid', exact: true }))
+        await expect(page.getByRole('group', { name: 'Image layout' }).getByRole('button', { name: 'Masonry', exact: true }))
            .toHaveAttribute('aria-pressed', 'true');
    } finally {
        await request.delete(`/prompt_manager/saved-views/${view.id}`);
    }
 });

-/** Choose a Default layout in System › Appearance and save it. */
-async function saveDefaultLayout(page, value) {
-    await openAppearance(page);
-    await page.locator('#default-view').selectOption(value);
-    await saveAppearance(page, 'Saved in this browser.');
-}
-
-const imageLayoutOf = page => page.locator('#workspace-main .image-grid');
-const layoutButton = (page, name) => page.getByRole('group', { name: 'Image layout' }).getByRole('button', { name, exact: true });
-
-test('a fresh browser opens Images in Masonry (#451)', async ({ page }) => {
-    await openImages(page);
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'masonry');
-    await expect(layoutButton(page, 'Masonry')).toHaveAttribute('aria-pressed', 'true');
-    // Nothing was stored for it: the default is the gallery settings' own.
-    expect(await page.evaluate(() => localStorage.getItem('gallerySettings'))).toBeNull();
-    // A stored explicit choice is kept.
-    await page.evaluate(() => localStorage.setItem('gallerySettings', JSON.stringify({ workspaceLayout: 'grid' })));
-    await page.reload();
-    await expect(imageCards(page).first()).toBeVisible();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'grid');
-});
-
-test('a Default layout saved later reaches the next Images visit in this tab (#451)', async ({ page }) => {
-    // The visit starts from Grid, then System saves Masonry without a reload.
-    await page.addInitScript(() => { if (!localStorage.getItem('gallerySettings')) localStorage.setItem('gallerySettings', '{"workspaceLayout":"grid"}'); });
-    await openImages(page);
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'grid');
-    await page.locator('#system-nav a[data-route="system"]').click();
-    await expect(page.locator('#workspace-main .settings-layout')).toBeVisible();
-    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Appearance', exact: true }).click();
-    await expect(page.locator('#timeout')).toBeEnabled();
-    await page.locator('#default-view').selectOption('masonry');
-    await saveAppearance(page, 'Saved in this browser.');
-    await page.locator('#primary-nav a[data-route="images"]').click();
-    await expect(imageCards(page).first()).toBeVisible();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'masonry');
-    await expect(layoutButton(page, 'Masonry')).toHaveAttribute('aria-pressed', 'true');
-});
-
-test('a Default layout saved in another tab reaches this tab\'s next Images visit (#451)', async ({ page, context }) => {
-    await page.addInitScript(() => { if (!localStorage.getItem('gallerySettings')) localStorage.setItem('gallerySettings', '{"workspaceLayout":"grid"}'); });
-    await openImages(page);
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'grid');
-    const other = await context.newPage();
-    try {
-        await saveDefaultLayout(other, 'list');
-    } finally {
-        await other.close();
-    }
-    await page.locator('#primary-nav a[data-route="library"]').click();
-    await expect(page.locator('#workspace-main .prompt-card').first()).toBeVisible();
-    await page.locator('#primary-nav a[data-route="images"]').click();
-    await expect(imageCards(page).first()).toBeVisible();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'list');
-    // A toolbar choice afterwards is this view's own again: a return keeps it.
-    await layoutButton(page, 'Masonry').click();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'masonry');
-    await page.locator('#primary-nav a[data-route="library"]').click();
-    await expect(page.locator('#workspace-main .prompt-card').first()).toBeVisible();
-    await page.locator('#primary-nav a[data-route="images"]').click();
-    await expect(imageCards(page).first()).toBeVisible();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'masonry');
-});
-
-// #451 D157: a cover crop keeps a portrait image's top; Masonry shows the whole image and keeps the centre.
-test('cover crops keep the top of a portrait image; Masonry stays centred (#451)', async ({ page }) => {
-    const position = locator => locator.evaluate(node => getComputedStyle(node).objectPosition);
-    const portrait = page.locator('#workspace-main article.media-card .image-open img[width="1024"][height="1536"]').first();
-    await openImages(page);
-    await layoutButton(page, 'Grid').click();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'grid');
-    await expect(portrait).toBeVisible();
-    expect(await position(portrait)).toBe('50% 20%');
-    await layoutButton(page, 'List').click();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'list');
-    expect(await position(portrait)).toBe('50% 20%');
-    // The side panel's cover (also History's media inspector).
-    await portrait.locator('xpath=ancestor::article[1]').locator('.image-card-actions button').first().click();
-    await expect(panel(page).locator('.detail-cover')).toBeVisible();
-    expect(await position(panel(page).locator('.detail-cover'))).toBe('50% 20%');
-    await layoutButton(page, 'Masonry').click();
-    await expect(imageLayoutOf(page)).toHaveAttribute('data-layout', 'masonry');
-    expect(await position(portrait)).toBe('50% 50%');
-    // The Library's card art and a prompt history's shared gallery.
-    await page.goto(`${workspace}#/library`);
-    const art = page.locator('#workspace-main .prompt-card .card-art img').first();
-    await expect(art).toBeVisible();
-    expect(await position(art)).toBe('50% 20%');
-    await page.goto(`${workspace}#/library/${page.manifest.prompts[0].positive_id}`);
-    await expect(imageCards(page).first()).toBeVisible();
-    expect(await position(imageCards(page).first().locator('.image-open img'))).toBe('50% 20%');
-});
-
 test('the defaults reach the Images page only; embedded galleries keep their own presentation', async ({ page }) => {
    await openAppearance(page);
    await page.locator('#default-view').selectOption('list');
@@ -882,54 +785,11 @@ test('reset restores defaults without touching other keys', async ({ page }) =>
    await expect(page.locator('#default-view')).toHaveValue('list');
    const reset = page.locator('#workspace-main .operation').filter({ hasText: 'Reset display defaults' }).getByRole('button', { name: 'Reset', exact: true });
    await reset.click();
-    // #451 D157: the default layout is Masonry.
-    await expect(page.locator('#default-view')).toHaveValue('masonry');
+    await expect(page.locator('#default-view')).toHaveValue('grid');
    await expect(page.locator('#video-muted')).toBeChecked();
    await expect(statusOf(page)).toHaveText('Unsaved changes.');
    await saveAppearance(page, 'Saved in this browser.');
    const stored = await storedSettings(page);
-    expect(stored).toEqual({ gridColumns: 5, defaultLimit: 200, thumbnailPromptDismissed: 'kept', workspaceLayout: 'masonry',
+    expect(stored).toEqual({ gridColumns: 5, defaultLimit: 200, thumbnailPromptDismissed: 'kept', workspaceLayout: 'grid',
        videoMute: true, showImageInfo: true });
 });
-
-// TESTING.md "Legacy System capability coverage" (#249 System S12, #329): each `covered` row's native control is on its
-// System section, found by role and accessible name (a `term` by its text, a disclosure by its summary). Collapsed
-// `details` are opened first, so a control inside one counts once it is shown. tests/vendor/legacy-coverage.test.mjs
-// checks the rest of each row.
-test('every covered legacy System capability has its native control', async ({ page, request }) => {
-    // Download is offered for a model that is not on disk ("Download again" otherwise): the selected default's file is
-    // missing here.
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-swinv2'] } })).toBeOK();
-    try {
-        await findControls(page);
-    } finally {
-        await request.post('/__test__/tagging/reset', { data: {} });
-    }
-});
-
-async function findControls(page) {
-    const covered = readCoverageTable().filter(row => row.Status === 'covered')
-        .map(row => ({ capability: row.Capability, ...parseControl(row['Native control']) }));
-    // A covered row without a control is one of the recorded exemptions, never silently skipped.
-    expect(covered.filter(row => !row.section).map(row => row.capability)).toEqual(Object.keys(CONTROL_EXEMPTIONS));
-    const controls = covered.filter(row => row.section);
-    expect(controls.length).toBeGreaterThan(40);
-    const sections = [...new Set(controls.map(row => row.section))];
-    for (const section of sections) {
-        await page.goto(`${workspace}#/system/${section}`);
-        const main = page.locator('#workspace-main');
-        await expect(layoutOf(page).locator(':scope > *').first()).toBeVisible();
-        for (const details of await main.locator('details:not([open]) > summary').all()) await details.click();
-        for (const { capability, role, name, row } of controls.filter(item => item.section === section)) {
-            // A name several rows share is looked up inside the row the table names.
-            const within = row ? main.locator('.operation').filter({ has: page.locator(`h3:text-is("${row}")`) }) : main;
-            const exact = new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
-            // A `dt` (term) and a `details` disclosure (group) have no name from content: the term's text, the summary's.
-            const control = role === 'term' ? within.getByRole('term').filter({ hasText: exact })
-                : role === 'group' ? within.locator('details').filter({ has: page.locator(':scope > summary', { hasText: exact }) })
-                    .or(within.getByRole('group', { name, exact: true }))
-                    : within.getByRole(role, { name, exact: true });
-            await expect(control.first(), `${capability}: ${section} · ${role} · "${name}"${row ? ` in "${row}"` : ''}`).toBeVisible();
-        }
-    }
-}
@@ -16,7 +16,7 @@ const toasts = page => page.evaluate(() => window.__toasts);
 const chips = page => modal(page).locator('#tag-suggestions .chip.tag-suggestion');
 const actionButtons = page => modal(page).locator('.dialog-actions button');
 const panel = page => page.getByRole('complementary', { name: 'Selected image details', exact: true });
-const imageTags = page => panel(page).getByRole('region', { name: 'Image tags', exact: true }).locator('.tags');
+const tagRow = page => panel(page).locator('.detail-inner > .tags').last();
 const NOT_DOWNLOADED = 'WD14 SwinV2 is not downloaded. Download it in System › Auto-tagging.';

 test.beforeEach(async ({ page, request, browserName }) => {
@@ -73,7 +73,7 @@ const jobStart = page => page.waitForRequest(item => item.method() === 'POST' &&

 test('selection bar shows Add tags then Auto-tag selected before Set category', async ({ page }) => {
    await select(page, FIRST);
-    await expect(bar(page).locator(':scope > *')).toHaveText(['1 selected', 'Add tags', 'Auto-tag selected', 'Set category', 'Add to collection', 'Export metadata', 'Clear']);
+    await expect(bar(page).locator(':scope > *')).toHaveText(['1 selected', 'Add tags', 'Auto-tag selected', 'Set category', 'Export metadata', 'Clear']);
 });

 test('Add tags runs a job and the cards show the tags after it finishes', async ({ page, request }) => {
@@ -110,7 +110,7 @@ test('Add tags runs a job and the cards show the tags after it finishes', async
    await expect(bar(page).locator('strong')).toHaveText('2 selected');
    expect((await ended(request, job.id)).counters).toEqual({ tagged: 2, unchanged: 0, skipped: 0, errors: 0 });
    // The finished job's files are read again: the selected card's panel shows its new image tags.
-    await expect(imageTags(page).locator('button.chip')).toHaveText(['sunset', 'blue_hour']);
+    await expect(tagRow(page).locator('button.chip')).toHaveText(['sunset', 'blue_hour']);
    expect(await savedTags(request, SECOND)).toEqual(['sunset', 'blue_hour']);
    expect(await savedTags(request, UNLINKED)).toEqual([]);
 });
@@ -186,26 +186,6 @@ test('a model that is not downloaded keeps Start disabled and says why', async (
    expect(posted).toBe(0);
 });

-const NEEDS_LLAMA = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-    + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-
-test('a model missing its backend package keeps Start disabled and names the install command (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: [],
-        missing_packages: { gguf: ['llama-cpp-python'] } } })).toBeOK();
-    await select(page, FIRST);
-    await barButton(page, 'Auto-tag selected').click();
-    const status = modal(page).locator('#tag-generation-status');
-    const start = actionButtons(page).last();
-    await modal(page).getByRole('combobox', { name: 'Tagging model', exact: true }).selectOption('gguf');
-    await expect(status).toHaveText(NEEDS_LLAMA);
-    await expect(start).toHaveAttribute('aria-disabled', 'true');
-    await modal(page).getByRole('combobox', { name: 'Tagging model', exact: true }).selectOption('wd14-vit');
-    await expect(status).toHaveText('');
-    await expect(start).not.toHaveAttribute('aria-disabled', 'true');
-    await actionButtons(page).first().click();
-    await expect(modal(page)).toHaveCount(0);
-});
-
 test('Suggestions field prefills from the setting and caps chips at the entered count', async ({ page, request }) => {
    await expect(await request.post('/__test__/tagging/defaults', { data: { general: 0.5, character: 0.9, limit: 7 } })).toBeOK();
    await select(page, FIRST);
@@ -275,7 +255,7 @@ test('Review each image walks the selection one dialog at a time and only approv
    expect(await savedTags(request, SECOND)).toEqual([]);
    expect(await savedTags(request, UNLINKED)).toEqual(['sandstone', 'desert']);
    // The reviewed file's panel shows its saved tags without reselecting.
-    await expect(imageTags(page).locator('button.chip')).toHaveText(['mine', 'sandstone']);
+    await expect(tagRow(page).locator('button.chip')).toHaveText(['mine', 'sandstone']);
    await expect.poll(async () => (await (await request.get('/__test__/tagging/captures')).json()).captures).toBe(0);
 });

@@ -21,8 +21,6 @@ const model = page => dialog(page).getByRole('combobox', { name: 'Tagging model'
 const generate = page => dialog(page).getByRole('button', { name: 'Generate suggestions', exact: true });
 const chips = page => dialog(page).locator('#tag-suggestions .chip.tag-suggestion');
 const status = page => dialog(page).locator('#tag-generation-status');
-// D147: the reason a state blocks Save, on its own row in the sticky actions.
-const notice = page => dialog(page).locator('.dialog-actions > .tag-action-notice');
 const toast = page => page.locator('#workspace-toast');
 const nav = (page, label) => page.locator('aside.sidebar nav').getByRole('link', { name: new RegExp(`^${label}(?:\\s*[\\d,]+)?$`) });
 const FIRST = 'tagging/dunes_00001.png', SECOND = 'tagging/dunes_00002.png', COPY = 'copies/dunes_00001.png';
@@ -262,18 +260,6 @@ test('unavailable model shows inline status and never downloads', async ({ page,
    await expect(dialog(page).locator('.dialog-actions .ca-primary')).toBeFocused();
 });

-test('a missing backend package is the server\'s install sentence, no traceback page (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: [],
-        missing_packages: { 'wd14-swinv2': ['onnxruntime'] } } })).toBeOK();
-    await openTag(page);
-    const answer = await generated(page);
-    expect(answer.status()).toBe(409);
-    expect(await answer.json()).toMatchObject({ success: false, code: 'model-unavailable' });
-    await expect(status(page)).toHaveText('WD14 SwinV2 needs onnxruntime. Install it into ComfyUI\'s Python: '
-        + 'pip install onnxruntime. Use onnxruntime-gpu for CUDA.');
-    await expect(chips(page)).toHaveCount(0);
-});
-
 test('video tag is manual only', async ({ page, request }) => {
    await openTag(page, VIDEO);
    const preview = dialog(page).locator('video.tag-image-preview');
@@ -458,32 +444,27 @@ test('virtualized cards release listeners on unmount', async ({ page, request })
    expect(await count()).toBe(mounted);
 });

-// Task C3 (D88), #449 (D154): the side panel and the viewer details draw the file's own current image tags in their own
-// "Image tags" section, then D21's linked tags in a "Prompt tags" or "Recipe tags" section after it. Panel image tags are
-// Tags filter buttons; the viewer's chips are plain.
+// Task C3 (D88): the side panel and the viewer details draw the file's own current image tags first, then D21's linked
+// tags not already shown (case-insensitive). Panel image tags are Tags filter buttons; the viewer's chips are plain.
 const panel = page => page.getByRole('complementary', { name: 'Selected image details', exact: true });
-const imageTags = page => panel(page).getByRole('region', { name: 'Image tags', exact: true }).locator('.tags');
-const linkedTags = page => panel(page).locator('.tag-section.linked-tags > .tags');
+const tagRow = page => panel(page).locator('.detail-inner > .tags').last();
 const inspected = (page, path) => page.waitForResponse(item => new URL(item.url()).pathname === `/prompt_manager/images/inspect/${path}`);
 const infoButton = (page, path) => card(page, path).getByRole('button', { name: `Inspect ${path.split('/').pop()}`, exact: true });

 test('inspector shows saved image tags after Save without reselecting', async ({ page }) => {
    await page.goto(images);
    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    // D21/D39: the linked recipe's own tag, plain, and no image tags yet.
-    await expect(linkedTags(page).locator('.chip')).toHaveText(manifest.pair_tags);
-    await expect(linkedTags(page).locator('button.chip')).toHaveCount(0);
-    await expect(panel(page).locator('.tag-section.image-tags')).toHaveCount(0);
+    // D21/D39: the linked recipe's own tag, plain.
+    await expect(tagRow(page).locator('.chip')).toHaveText(manifest.pair_tags);
+    await expect(tagRow(page).locator('button.chip')).toHaveCount(0);
    await openTag(page, FIRST, { goto: false });
    await manual(page).fill('dunes_tag, Editorial');
    const reread = inspected(page, FIRST);
    await dialog(page).getByRole('button', { name: 'Save manual tags', exact: true }).click();
    expect((await (await reread).json()).image_tags).toEqual({ state: 'current', tags: ['dunes_tag', 'Editorial'] });
-    // The image tags lead as filter buttons in their own section; the recipe keeps its "editorial" in its own (D154).
-    await expect(imageTags(page).locator('.chip')).toHaveText(['dunes_tag', 'Editorial']);
-    await expect(imageTags(page).locator('button.chip')).toHaveText(['dunes_tag', 'Editorial']);
-    await expect(panel(page).locator('.tag-section.image-tags .role-label')).toHaveText('Image tags · 2');
-    await expect(linkedTags(page).locator('.chip')).toHaveText(manifest.pair_tags);
+    // The image tags lead as filter buttons; the recipe's "editorial" is already shown as "Editorial".
+    await expect(tagRow(page).locator('.chip')).toHaveText(['dunes_tag', 'Editorial']);
+    await expect(tagRow(page).locator('button.chip')).toHaveText(['dunes_tag', 'Editorial']);
    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
 });
@@ -495,10 +476,9 @@ test('clicking an image tag chip filters Images to the tagged unlinked file', as
    await infoButton(page, UNLINKED).click();
    await read;
    await expect(panel(page).locator('.panel-heading h2')).toHaveText('unlinked.png');
-    await expect(imageTags(page).locator('.chip')).toHaveText(['loose_tag']);
-    await expect(panel(page).locator('.tag-section.linked-tags')).toHaveCount(0);
+    await expect(tagRow(page).locator('.chip')).toHaveText(['loose_tag']);
    const listing = page.waitForRequest(item => item.url().includes('/images/output?') && new URL(item.url()).searchParams.get('tags') === 'loose_tag');
-    await imageTags(page).getByRole('button', { name: 'loose_tag', exact: true }).click();
+    await tagRow(page).getByRole('button', { name: 'loose_tag', exact: true }).click();
    await listing;
    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(1);
    await expect(card(page, UNLINKED)).toBeVisible();
@@ -508,53 +488,18 @@ test('clicking an image tag chip filters Images to the tagged unlinked file', as
 test('viewer details show the same chips', async ({ page, request }) => {
    await saveImageTags(request, FIRST, ['dunes_tag', 'Editorial', 'sunlit']);
    await page.goto(images);
-    await expect(imageTags(page).locator('button.chip')).toHaveText(['dunes_tag', 'Editorial', 'sunlit']);
+    await expect(tagRow(page).locator('button.chip')).toHaveText(['dunes_tag', 'Editorial', 'sunlit']);
    await card(page, FIRST).locator('.image-open').click();
    const details = page.locator('#viewer-dialog[open] #viewer-details');
    await expect(details.locator('.panel-heading h2')).toHaveText(manifest.title);
-    const row = details.getByRole('region', { name: 'Image tags', exact: true }).locator('.tags');
+    const row = details.locator('.tags').last();
    await expect(row.locator('.chip')).toHaveText(['dunes_tag', 'Editorial', 'sunlit']);
    await expect(row.locator('span.chip')).toHaveCount(3);
    await expect(row.locator('button')).toHaveCount(0);
-    await expect(details.locator('.tag-section.linked-tags .chip')).toHaveText(manifest.pair_tags);
    // A file without image tags: the viewer shows only D21's linked tags.
    await page.getByRole('button', { name: 'Next media', exact: true }).click();
    await expect(page.locator('#viewer-dialog[open] #viewer-title')).toHaveText(`${manifest.title} · dunes_00002.png`);
-    await expect(details.locator('.tag-section.linked-tags .chip')).toHaveText(manifest.pair_tags);
-    await expect(details.locator('.tag-section.image-tags')).toHaveCount(0);
-});
-
-// #449 (D154): the image tags are a labelled region of their own after the negative prompt, framed like a prompt section,
-// so they never read as part of it; the same in the side panel and the viewer details.
-async function tagSectionPlacement(root) {
-    return root.evaluate(node => {
-        const negative = node.querySelector('section.prompt-section.negative'), tags = node.querySelector('section.tag-section.image-tags');
-        const style = getComputedStyle(tags), label = getComputedStyle(tags.querySelector('.prompt-heading .role-label'));
-        return {
-            after: Boolean(negative.compareDocumentPosition(tags) & Node.DOCUMENT_POSITION_FOLLOWING), inside: negative.contains(tags),
-            below: tags.getBoundingClientRect().top >= negative.getBoundingClientRect().bottom,
-            border: `${style.borderTopWidth} ${style.borderTopStyle}`, paddingTop: style.paddingTop, marginTop: style.marginTop,
-            label: {transform: label.textTransform, size: label.fontSize, sameColorAsNegative: label.color === getComputedStyle(negative.querySelector('.role-label')).color},
-        };
-    });
-}
-const PLACED = {after: true, inside: false, below: true, border: '1px solid', paddingTop: '15px', marginTop: '15px',
-    label: {transform: 'uppercase', size: '10px', sameColorAsNegative: false}};
-
-test('D154: image tags sit in their own labelled section after the negative prompt, in the panel and the viewer', async ({ page, request }) => {
-    await saveImageTags(request, FIRST, ['dunes_tag', 'sunlit']);
-    await page.goto(images);
-    const section = panel(page).getByRole('region', { name: 'Image tags', exact: true });
-    await expect(section.locator('.role-label')).toHaveText('Image tags · 2');
-    await expect(section.locator('.tags > button.chip')).toHaveText(['dunes_tag', 'sunlit']);
-    expect(await tagSectionPlacement(panel(page))).toEqual(PLACED);
-    await card(page, FIRST).locator('.image-open').click();
-    const details = page.locator('#viewer-dialog[open] #viewer-details');
-    await expect(details.locator('.panel-heading h2')).toHaveText(manifest.title);
-    const viewerSection = details.getByRole('region', { name: 'Image tags', exact: true });
-    await expect(viewerSection.locator('.role-label')).toHaveText('Image tags · 2');
-    await expect(viewerSection.locator('.tags > span.chip')).toHaveText(['dunes_tag', 'sunlit']);
-    expect(await tagSectionPlacement(details)).toEqual(PLACED);
+    await expect(details.locator('.tags').last().locator('.chip')).toHaveText(manifest.pair_tags);
 });

 test('search finds an image by its image tag', async ({ page, request }) => {
@@ -568,41 +513,6 @@ test('search finds an image by its image tag', async ({ page, request }) => {
    await expect(card(page, UNLINKED)).toBeVisible();
 });

-// #379 CUJ 8: the Tags filter finds images by their own image tags through the tag index; no prompt carries them, and
-// selecting a match shows its prompt. A linked prompt's tag still combines with the image tags.
-test('the Tags filter finds images by image tags only, and selecting one shows its prompt (#379)', async ({ page, request }) => {
-    await saveImageTags(request, FIRST, ['beach', '1girl', 'waves']);
-    await saveImageTags(request, SECOND, ['beach', 'waves']);
-    await saveImageTags(request, UNLINKED, ['beach', '1girl', 'waves', 'gulls']);
-    await page.goto(images);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(manifest.files.length);
-    const filters = page.locator('#workspace-main search.toolbar').getByRole('button', { name: /^Filters(?: · \d+)?$/ });
-    const refine = page.getByRole('dialog', { name: 'Refine this view', exact: true });
-    const applyTags = async value => {
-        await filters.click();
-        await refine.getByLabel('Tags', { exact: true }).fill(value);
-        const listing = page.waitForRequest(item => item.url().includes('/images/output?')
-            && new URL(item.url()).searchParams.get('tags') !== null);
-        await refine.getByRole('button', { name: 'Apply filters', exact: true }).click();
-        await listing;
-    };
-    await applyTags('beach, 1girl, waves');
-    // Every listed image whose image tags hold all three; SECOND lacks 1girl.
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, UNLINKED)).toBeVisible();
-    await expect(card(page, SECOND)).toHaveCount(0);
-    // The newest match is selected; the inspector shows its linked prompt.
-    await infoButton(page, FIRST).click();
-    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
-    // The linked positive's own tag combines: SECOND has beach and waves itself and minimal through its prompt.
-    await applyTags(`beach, waves, ${manifest.prompt_tags[0]}`);
-    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
-    await expect(card(page, FIRST)).toBeVisible();
-    await expect(card(page, SECOND)).toBeVisible();
-});
-
 // Task C4 rulings: a save re-reads the selected file's details without a loading flash, and under a Tags filter or a
 // search the loaded listing is re-read in place (scroll and selection kept while the file still matches).
 const cards = page => page.locator('.gallery-body article[data-image-key]');
@@ -611,7 +521,7 @@ const listingOf = (page, check) => page.waitForResponse(item => item.url().inclu
 test('the post-save re-read keeps the panel content until the new read lands', async ({ page }) => {
    await page.goto(images);
    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
-    await expect(linkedTags(page).locator('.chip')).toHaveText(manifest.pair_tags);
+    await expect(tagRow(page).locator('.chip')).toHaveText(manifest.pair_tags);
    await page.evaluate(() => {
        const node = document.querySelector('aside[aria-label="Selected image details"]');
        window.__loadingSeen = false;
@@ -630,13 +540,12 @@ test('the post-save re-read keeps the panel content until the new read lands', a
    await expect(toast(page)).toHaveText('1 tags saved for dunes_00001.png.');
    // While the re-read is held, the panel still shows the file's details.
    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
-    await expect(linkedTags(page).locator('.chip')).toHaveText(manifest.pair_tags);
+    await expect(tagRow(page).locator('.chip')).toHaveText(manifest.pair_tags);
    expect(await page.evaluate(() => window.__loadingSeen)).toBe(false);
    const landed = inspected(page, FIRST);
    release();
    await landed;
-    await expect(imageTags(page).locator('.chip')).toHaveText(['held_tag']);
-    await expect(linkedTags(page).locator('.chip')).toHaveText(manifest.pair_tags);
+    await expect(tagRow(page).locator('.chip')).toHaveText(['held_tag', ...manifest.pair_tags]);
    expect(await page.evaluate(() => { window.__loadingWatch.disconnect(); return window.__loadingSeen; })).toBe(false);
    await page.unroute(matcher);
 });
@@ -649,7 +558,7 @@ test('a save under a Tags filter re-reads the listing: the selection stays while
    await infoButton(page, SECOND).click();
    await read;
    const filtered = listingOf(page, query => query.get('tags') === 'shared');
-    await imageTags(page).getByRole('button', { name: 'shared', exact: true }).click();
+    await tagRow(page).getByRole('button', { name: 'shared', exact: true }).click();
    await filtered;
    await expect(cards(page)).toHaveCount(2);
    // The newest match (SECOND) is selected once the filter applies.
@@ -772,8 +681,7 @@ test('D116: Retry leads the actions after an unconfirmed save and resends the sa
    let lost = true;
    await page.route('**/prompt_manager/image-annotations/tags', route => (lost ? (lost = false, route.fulfill({ status: 504, body: 'Gateway Timeout' })) : route.continue()));
    await dialog(page).getByRole('button', { name: 'Save manual tags', exact: true }).click();
-    await expect(notice(page)).toHaveText('The save could not be confirmed. Retry sends the same tags again.');
-    await expect(status(page)).toHaveText('');
+    await expect(status(page)).toHaveText('The save could not be confirmed. Retry sends the same tags again.');
    const inventory = await page.locator('dialog#modal').evaluate(taggingInventory);
    expect(inventory.actions.buttons.map(button => [button.text, button.primary, button.disabled])).toEqual(
        [['Retry', false, false], ['Cancel', false, false], ['Save manual tags', true, true]]);
@@ -809,7 +717,7 @@ test('a tag save from Tags reloads a filtered Images visit instead of restoring
    await page.goto(images);
    await infoButton(page, SECOND).click();
    const filtered = listingOf(page, query => query.get('tags') === 'shared');
-    await imageTags(page).getByRole('button', { name: 'shared', exact: true }).click();
+    await tagRow(page).getByRole('button', { name: 'shared', exact: true }).click();
    await filtered;
    await expect(cards(page)).toHaveCount(2);
    await expect(card(page, SECOND)).toHaveClass(/\bselected\b/);
@@ -834,7 +742,7 @@ test('a failed listing re-read after a save says so and keeps the cards (M2)', a
    await page.goto(images);
    await infoButton(page, SECOND).click();
    const filtered = listingOf(page, query => query.get('tags') === 'shared');
-    await imageTags(page).getByRole('button', { name: 'shared', exact: true }).click();
+    await tagRow(page).getByRole('button', { name: 'shared', exact: true }).click();
    await filtered;
    await expect(cards(page)).toHaveCount(2);
    await openTag(page, SECOND, { goto: false });
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vito Sansevero	9579cd8bb6	test(inspector): cover every plain-first-stage outcome on both resolvers (#381 ) The frontend coverage gate found local-resolver-stages.mjs branches at 92.44% (< 93). Each way an earlier stage stops being a plain first stage (no latent, literal, missing or cyclic latent, a sampler-shaped node, a detailer) is now a resolver test and an anchor-first-stage-* parity vector.	2026-10-27 08:20:24 -07:00
Vito Sansevero	acdc7c3561	fix(inspector): skip only plain first stages on shared links; an unfinished prefix scan anchors nothing (#381 ) Review of the saver anchor: a same-links earlier stage is skipped only when it is not a detailer, sets no prompt override and continues no other sampler, so an earlier prompt or override behind it is never hidden. A work limit while tracing a saver prefix ends the match scan without an anchor instead of counting that saver as no match.	2026-10-27 07:24:46 -07:00
Vito Sansevero	93fbe5757c	fix(inspector): anchor on the saver that wrote the file and resolve stages on shared links (#381 ) An inspected file's name now anchors the inspection on the one saver whose filename_prefix (literal or traced) makes the file's stem <prefix>_<digits>[_]; the samplers in that saver's image ancestry are the candidates. No match, several matches or an unreadable walk anchor nothing, so the file stays "several possible prompts". In a latent walk, an earlier sampler reading the same conditioning links as the later one is the same prompt, not an unattributed stage. Python and the browser resolver behave the same; the legacy parity gate states each graph that differs from legacy on purpose.	2026-10-27 07:17:44 -07:00
Vito Sansevero	6f7ae47924	Merge remote-tracking branch 'origin/main' into fix/381-switch-nodes	2026-10-27 06:36:48 -07:00
Vito Sansevero	4f927549fd	fix(inspector): keep recorded pair text, string-only seed rule, role inputs and unique candidates (#381 ) Review of the pass-through: a walk through an unknown node never overrides a PromptManagerPair's execution record (any outcome but work-limit is unverifiable while the record is checked); the run-time seed rule reads only string outputs; a node with positive/negative inputs follows only the role of the requested slot, nothing when it is unlinked; one text offered twice is one candidate.	2026-10-27 06:36:40 -07:00
Vito Sansevero	a842a3c256	fix(inspector): pass text through unknown nodes instead of refusing them (#381 ) The inspector refused any node class missing from the semantics table, so a PromptManagerPair behind an rgthree Any Switch showed "Prompt uses a node the inspector does not support". The inspection resolver (Python and browser) now reads through unknown nodes: a text input is the text, positive/negative route by output slot, a conditioning input is followed alone, otherwise every linked input except core type inputs (pass_through.skip_inputs). PromptManager nodes are authoritative; several different texts become one candidate each ("Several prompts reach the sampler"). A seeded text node with no conditioning input is generated at run time, and a recorded PromptManager execution is not checked against text that passed through an unknown node. INSPECTION_RESOLVER_VERSION goes to 2; ingestion keeps the default profile. A legacy parity gate records every committed graph whose inspection positive matches the legacy parser's; no graph may leave it.	2026-10-27 06:28:42 -07:00