Merge remote-tracking branch 'origin/main' into fix/398-select-width

The concept's phone cap (120px) cut Existing tags ("Replace after review").
#tag-existing now never shrinks for its row text and keeps its natural width
at phone width, beside the text. The comparison expects selectsFit for every
select, and a new test walks every option of both selects at 390 and 320 px
in both themes. TESTING.md D132 records the decision.

.github/branch-protection.json

@@ -3,10 +3,17 @@
     "strict": false,
     "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)"

.github/workflows/portability.yml

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

.github/workflows/test.yml

@@ -28,18 +28,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 +40,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,9 +63,6 @@ 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
@@ -232,10 +221,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 +235,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 +248,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"

.github/workflows/viewerjs-check.yml

@@ -27,15 +27,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 +79,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 +87,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 +165,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 +209,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 +219,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 +229,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

.pre-commit-config.yaml

@@ -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/)

README.md

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

TESTING.md

@@ -181,12 +181,10 @@ check, so run it before pushing a new or deleted frontend file instead of
 waiting for the `frontend coverage` jobs.
 
 The `viewerjs` check runs on every PR, including backend-only changes. It is an
-aggregate job. It requires the three `frontend coverage (shard N/3)` jobs and
-`frontend coverage (merge)` to succeed on every event. The four
-`page workflows (firefox|webkit, shard N/2)` jobs run only in the merge queue,
-on `main` and on `workflow_dispatch` (see "Pull requests and the merge queue").
-`viewerjs` requires them to be skipped on a pull request and to succeed
-everywhere else. Any other failed, cancelled or skipped job fails it. Every browser job runs with `PM_TEST_WORKERS: 3` (the public
+aggregate job that passes only when every frontend job succeeds: the three
+`frontend coverage (shard N/3)` jobs, `frontend coverage (merge)`, and the four
+`page workflows (firefox|webkit, shard N/2)` jobs. A failed, cancelled or skipped
+job fails it. Every browser job runs with `PM_TEST_WORKERS: 3` (the public
 runners have 4 vCPUs). Each coverage shard runs `test:coverage:shard -- N/3`
 (shard 1 also runs the node units and the viewer suite, shard 3 the vendor pins
 and tooling tests) and uploads its raw V8 files as `coverage-raw-N` (kept 3
@@ -262,31 +260,6 @@ watchdog dump, is a failure like any other: read the dump, find the blocking
 call, fix it. Never raise a limit or rerun to get green; a limit changes only
 with new measurements written next to it.
 
-Browser jobs (#425): GitHub keeps no log of a job killed at its limit and skips
-its upload steps, so the test step in each browser job in `viewerjs-check.yml`
-has its own `timeout-minutes` (18, below the job's 20). At the step limit
-GitHub sends SIGTERM, which would end Playwright without any report; under `CI`
-`tools/vendor/running-tests-reporter.mjs` catches the first one, prints
-`Still running when the run ended (SIGTERM): N` and one line per unfinished
-test (path relative to the suite's `rootDir`), then sends Playwright its own
-SIGINT, so the workers stop, the run ends interrupted and the blob report is
-written to `tools/vendor/test-results/blob/`. In the coverage job npm signals
-only `frontend-coverage.mjs`, which forwards SIGTERM and SIGINT to the child it
-is running (started in its own process group, so a group-wide signal still
-arrives once). Delivery is proven locally in the pinned image for a SIGTERM to
-the whole process group (`timeout -s TERM`). A SIGTERM to npm alone
-(`timeout --foreground`) reaches nothing: npm forwards it to the `sh -c` that
-runs the script, and that shell exits without passing it on. Delivery in CI,
-where the step runs through `docker exec`, is not yet observed; the next real
-step timeout will show it. That directory and the traces
-upload with `if: always()`; `npx playwright merge-reports` opens the blob.
-Each test keeps the 30 s default and there is no `globalTimeout`. Two limits
-of this: it assumes the npm cache hits (a cold cache adds up to 5 minutes to
-`npm ci`, and the job limit can then still win), and coverage shard 1 (12m53s
-measured) is the tight one in its 18-minute step. Local runs keep the `list`
-reporter only; reproduce with `CI=1 timeout -s TERM 40 npm run --prefix
-tools/vendor test:workflows -- --project=firefox`.
-
 ### After a push
 
 Follow the run for the commit you pushed, never an older one:
@@ -298,13 +271,6 @@ gh run view <run id> --json jobs                          # shows a job that alr
 gh run view --job <job id> --log-failed                   # that job's failed log, at once
 ```
 
-Python 3.13/3.14, real ComfyUI and Firefox/WebKit failures first show up in the
-merge queue, on the merge-group commit rather than the
-pushed one. Find that run with `gh run list --event merge_group --workflow test.yml`
-(or `viewerjs-check.yml`) and match its head branch
-(`gh-readonly-queue/main/pr-<N>-...`). Windows and macOS failures show up only
-after the merge, in `gh run list --workflow portability.yml`.
-
 Start fixing as soon as a failed log shows the cause, but push the fix only after
 the run for that commit has finished: pull-request runs use `cancel-in-progress`,
 so a push cancels the running jobs and can hide a second failure.
@@ -347,26 +313,6 @@ from the tests' package unload (`cleanup_package`), and it removes its own
 ComfyUI-Manager restart through `os.execv`, a closed Windows console, or
 ComfyUI Desktop stopping its server. SQLite's WAL journal covers those.
 
-Jobs running at exit (#376): before any `atexit` callback, Python joins every
-executor thread (`concurrent.futures` registers that join with
-`threading._register_atexit`). The package registers its own callback there
-(`utils/exit_signal.install`, after `concurrent.futures`, so it runs first):
-it sets the exit signal and kills the running encoder processes
-(`shutdown_encoders`, the ffmpeg that never sees Ctrl+C on Windows). The call in
-flight then stops at its next safe point: `Job.cancelled` is True, so every
-check a job already makes between files stops it, `map_parallel` starts no
-further item (`ExitRequested`), the scan walk stops between folders, LoRA
-import staging stops before its next sidecar (also for the legacy scan) and a
-tagging model download stops before its next chunk where huggingface_hub takes
-`tqdm_class` (1.x removes its temp file; 0.x `hf_hub_download` does not take it
-and finishes the file). Xet transfers ignore that checkpoint, so the hook also
-calls hub's own `abort_xet_session` when huggingface_hub is loaded. The
-trigger-word cache load (small JSON sidecars) has no checkpoint. No check sits
-inside a library write. That hook is
-CPython-internal; without it (or when it is refused) `install` returns False and
-exit waits for the call in flight, as before. `tests/test_exit_cancel.py` runs a
-child process with three such calls running and requires its exit within 15 s.
-
 Stop contract: `PromptTracker.shutdown(timeout)`,
 `ImageGenerationHandler.shutdown(timeout)` (restartable),
 `ImageGenerationHandler.close(timeout)` (final: `schedule()` refuses and a
@@ -416,10 +362,6 @@ A spec performance budget gets two tests:
   `test_filter_budget` (Images filters, spec D12: p95 < 150 ms at 50,000 files
   and 20,000 links).
 
-A hot SQLite read that returns many rows aggregates them into one step
-(`json_group_array`) instead of stepping once per row, so it does not wait for
-the GIL once per row while ComfyUI generates (#354, `get_image_link_matches`).
-
 The `perf budget` job in `.github/workflows/test.yml` is the reference
 measurement: `ubuntu-latest`, one Python, no coverage, only the wall-clock tests.
 It runs on every push to `main` and on `workflow_dispatch`, never on pull
@@ -577,95 +519,29 @@ Before changing paths, SQLite, streams, restore or cleanup:
   open with `FirstWriterHold`) and give peers that must all succeed the
   ordinary busy timeout; cross-thread handoffs wait on events with generous
   ceilings, never a short wall clock (#242).
-- Run native Windows CI early for these changes. Pull requests and the merge
-  queue run only Linux, so start Windows and macOS on the branch with
-  `gh workflow run portability.yml --ref <branch>`.
-  Include a Windows impact and evidence note in the PR. All six Windows/macOS
-  combinations in that run, every Linux leg and every applicable
+- Run native Windows CI early for these changes and include a Windows impact and
+  evidence note in the PR. All twelve OS/Python combinations and every applicable
   exact-head check must pass before merge. Portable `ntpath`/`PureWindowsPath`
   controls do not establish native filesystem, locking or cleanup success.
 
-## Pull requests and the merge queue
-
-Each PR runs the full matrix once, in the merge queue (#420). The event decides
-what runs:
-
-| Job | `pull_request` | `merge_group`, push to `main`, `workflow_dispatch` |
-| --- | --- | --- |
-| `py3.12 on ubuntu-latest` | runs | runs |
-| `py3.13 on ubuntu-latest`, `py3.14 on ubuntu-latest` | not created | run |
-| `real ComfyUI compatibility` | skipped | runs |
-| `coverage gate (85%)`, `black and flake8`, `frontend modules`, `bandit (high severity)` | run | run |
-| `frontend coverage (shard N/3)`, `frontend coverage (merge)` (vendor pins and tooling tests on shard 3) | run | run |
-| `page workflows (firefox\|webkit, shard N/2)` | skipped | run |
-| `all tests`, `viewerjs` (gates) | run | run |
-| `perf budget` | skipped | push and dispatch only (not in the queue) |
-| `py3.12-3.14 on windows-latest/macos-latest` (`portability.yml`) | not run | push to `main`, nightly, `workflow_dispatch` only; never required |
-
-GitHub has one required set for pull requests and the queue. A job skipped by
-its `if:` reports Success. A dropped matrix leg never reports, so it would stay
-pending. That is why `all tests` (in `test.yml`) and `viewerjs` carry the
-guarantee:
-- On a pull request they require the subset to succeed and the queue-only jobs
-  to be skipped.
-- On every other event they require every job to succeed.
-
-So a merge group cannot turn green unless all three Linux Python legs, real
-ComfyUI and the four browser shards passed.
-
-Windows and macOS (Python 3.12-3.14) are out of the blocking path for now
-(maintainer, 2026-10-28). They run in `portability.yml` on every push to `main`,
-nightly and on demand, and no context there is required. A red portability run
-is still a failure: fix it at its cause, not by rerunning, and have every one
-green before the workspace cutover (#334). `tests/vendor/ci-workflow.test.mjs` pins the
-event split and runs both gate scripts for each event.
-
 ## Required merge checks
 
-`.github/branch-protection.json` records the required checks:
-`py3.12 on ubuntu-latest`, `coverage gate (85%)`, `black and flake8`,
-`frontend modules`, `all tests`, `viewerjs`, `real ComfyUI compatibility` and
-`bandit (high severity)`. Each one reports on a pull request.
-The same set lives in two places, and both must change together: the `main`
-ruleset (25960526, which also holds the merge queue) and the classic branch
-protection on `main`, which the manifest mirrors. GitHub requires the union of
-the two, so a context left in either one blocks every PR that does not report it.
+`.github/branch-protection.json` records the required checks: all twelve Python/OS
+combinations, Python coverage, formatting, frontend modules, `viewerjs`, `real ComfyUI compatibility`,
+and `bandit (high severity)`.
+The branch must be current with main, and administrators follow the same checks.
 It does not require an additional human approval.
 
 A repository administrator applies the configuration after the new workflow is
 passing, then verifies it:
 
-```sh
-gh api repos/ComfyAssets/ComfyUI_PromptManager/rulesets/25960526 \
-  | jq '.rules[] | select(.type == "required_status_checks") | [.parameters.required_status_checks[].context]'
-```
-
-A PUT replaces the whole `rules` array, so edit the current ruleset in place.
-Keep the `deletion`, `non_fast_forward` and `merge_queue` rules, and give every
-context `integration_id` 15368 (GitHub Actions), so no other integration can
-post a required check. Save the current ruleset first; it is the rollback:
-
-```sh
-gh api repos/ComfyAssets/ComfyUI_PromptManager/rulesets/25960526 > ruleset-before.json
-jq '{name, target, enforcement, conditions, bypass_actors, rules: [.rules[]
-     | if .type == "required_status_checks"
-       then .parameters.required_status_checks = [$ARGS.positional[] | {context: ., integration_id: 15368}]
-       else . end]}' ruleset-before.json --args "py3.12 on ubuntu-latest" "..." > ruleset-new.json
-gh api --method PUT repos/ComfyAssets/ComfyUI_PromptManager/rulesets/25960526 --input ruleset-new.json
-```
-
-Afterwards, read it back. Check that the `merge_queue` rule is still there and
-that every context keeps its `integration_id`. Then apply the manifest to the
-classic protection and read both back:
-
 ```sh
 gh api --method PUT repos/ComfyAssets/ComfyUI_PromptManager/branches/main/protection \
   --input .github/branch-protection.json
 gh api repos/ComfyAssets/ComfyUI_PromptManager/branches/main/protection/required_status_checks
-gh api repos/ComfyAssets/ComfyUI_PromptManager/rules/branches/main
 ```
- Update the manifest whenever
-required job names change. Keep the frontend check
+
+Update the manifest whenever required job names change. Keep the frontend check
 free of path filters so a required check is never silently skipped.
 
 ## Unified workspace
@@ -688,7 +564,7 @@ The shared inline and collection inspector reads the current rooted file's suppo
 embedded records, exact generation facts and recorded or inferred prompt evidence.
 It renders in two concept surfaces (#249 D20–D22, D38). The Images side panel shows
 only the concept content: cover, title, filename, the evidence badge with a category
-chip naming its origin (D146), the + and − prompt blocks with copy and send, tag chips (the file's own image
+chip, the + and − prompt blocks with copy and send, tag chips (the file's own image
 tags first, D88, then the linked tags; image tags and the linked positive's own tags
 filter Images, D21), the six facts, and a footer with "Send to ComfyUI" and
 "Prompt history" only when prompt roles resolved or a link is saved; the sticky panel
@@ -918,25 +794,6 @@ unattributed stage, when it is a plain first stage: not a detailer, no prompt ov
 set, and no listed sampler in its own latent ancestry (else it stays unattributed) (`tests/test_resolver_saver_anchor.py`, shapes in
 `tests/saver_anchor_graphs.py` from the maintainer's `gpu_unlock_bench`, dataset and
 ANIMA runs; browser parity through the `anchor-*` cases, which carry `__file_name`).
-Recorded run history (#386): both inspect routes (Images and a history occurrence)
-ask `database.run_attribution.recorded_output` inside the file's stat window. It
-answers only for a file that exactly one recorded run reported and that was written
-during that run (the #342 rules): the one output node that run reported it from (none
-when several did) and, per sampler anchor, the effective texts PromptManager recorded
-at execution (a role only inferred from the graph is none). Only when the file alone
-leaves the prompt open (`ambiguous` or `unresolved`) the inspector resolves again
-anchored on that node (`recorded_saver_id`, walked like a file-name match; a file
-name naming a different saver contradicts history and anchors nothing), and keeps
-that result only when history's saver chose its samplers (`recorded_anchor`) and it
-names the positive (resolved, or a guider with no negative); its `graph-inferred`
-sides read `recorded-run` ("Recorded run" badge, ranked below every "Workflow
-inferred" source). Still open at the one sampler that saver leads to, with that
-sampler's positive text recorded (a language model's output feeding PromptManager),
-the recorded texts show as `execution`. Outputs and texts are read in one
-transaction. A result the file resolves alone never changes; a lookup failure is
-logged and judges the file alone; local Inspect and ingestion are unchanged
-(`tests/test_recorded_saver_anchor.py`, `tests/test_run_attribution.py`,
-`tests/test_api_history_outputs.py`).
 
 `tools/inspection_corpus.py --root DIR --out JSONL [--workers N] [--baseline JSONL]
 [--summary TXT] [--code TREE]` measures a media folder read-only against the #240
@@ -1369,7 +1226,7 @@ How the earlier workspace Images filters moved (old → new). The legacy `/galle
 | Folder | "Refine this view" → Folder (D14); shown in the scope chip |
 | Media (All media / Images / Videos) | "Refine this view" → Media (D14) |
 | Sort: Newest first / Oldest first / Filename A–Z / Filename Z–A | toolbar sort: Recently added / Oldest first / Name A–Z / Name Z–A, plus Highest rated (D13, D14) |
-| (none) | toolbar category (the effective category, D141) and "Refine this view" → Tags, through the linked positive (D13, D14) |
+| (none) | toolbar category and "Refine this view" → Tags, through the linked positive (D13, D14) |
 | Refresh | Import → "Scan an output folder" → Rescan (D15) |
 | Grid / List / Masonry, Comfortable / Large / Compact | the same choices in the concept filter row |
 | Card image → side panel; preview icon → viewer | image → viewer; Info → side panel (D19) |
@@ -1399,18 +1256,22 @@ Recorded deviations on this page (spec §8):
   inspector's own "Download metadata JSON" envelopes in listing order); the button is
   `aria-disabled` and ignores a second press while it runs, the selection is kept, and
   the toast names the unread images (none read: no download); leaving Images aborts the
-  reads with no download and no toast. Set category (amended by D140, #332) sets the
-  checked images' own categories: it opens the concept's `simpleInput` dialog
-  ("Categorize selected images", `input#action-input` labelled Category) and writes
-  `PUT`/`DELETE /prompt_manager/images/category`, never a prompt (see D140). Prompt
-  categories are changed in the Prompt library editor and on the legacy admin page's
-  "Set Category"; `POST /prompt_manager/bulk/category` is unchanged and serves that
-  legacy page only. The write carries no page signal: leaving Images while it runs lets
-  it finish without a toast, and the return loads the collection afresh instead of the
-  saved visit. Its success reloads the categories and the listing together (clearing
-  the selection, focus to the heading, and, as any replaced collection does, the
-  inspector moves to the first listed image); a failure keeps the selection, except a
-  changed source (409), which reloads the listing as a success does. `images selection bar matches
+  reads with no download and no toast. Set category opens the
+  concept's `simpleInput` dialog ("Categorize selected images", `input#action-input`
+  labelled Category, Cancel / Apply) and posts the selection's distinct linked positive
+  ids to `/prompt_manager/bulk/category` (images have no category; the filter matches
+  the linked positive's). With no linked image checked it posts nothing and opens no
+  dialog; an empty value keeps the dialog open; the field stops at the server's 100
+  characters; success reloads the categories and the listing together (clearing the
+  selection, focus to the heading, and, as any replaced collection does, the inspector
+  moves to the first listed image); failure keeps the selection. The write carries no
+  page signal: leaving Images while it runs lets it finish without a toast, and the return
+  loads the collection afresh instead of the saved visit. Three deviations from the
+  concept's `simpleInput`: the field starts empty (the concept pre-fills its demo
+  "Landscapes"), the action reads "Apply" (not "Apply in prototype"), and the
+  nothing-linked check runs on the Set category press, so no dialog opens. The route
+  rejects anything but 1-1000 positive integer ids within SQLite's INTEGER range
+  (deduplicated) and a category that fails `validate_category`. `images selection bar matches
   the concept` compares the bar and the checked card with one card checked; the omitted
   actions flow again from the concept's own boxes, checked against the concept page with
   them removed at runtime.
@@ -1448,8 +1309,7 @@ Recorded deviations on this page (spec §8):
   `overscroll-behavior: contain`.
 - **D35**: counts pluralize ("1 positive prompt", "1 image", "1 more image loaded").
 - **D36**: the category list is the Library's, sorted alphabetically (case-insensitive)
-  by the page, whatever order the server sends (amended by D141: Images adds its
-  image categories).
+  by the page, whatever order the server sends.
 - **D37**: production loads 40 images per page (the concept 12), so the continuation
   and toast use 40; after Escape production returns focus to the opening image.
 - **D44** (#249 PR E): Filters reads "Filters · N" while N of Source, Folder, Media and
@@ -1477,9 +1337,6 @@ Recorded deviations on this page (spec §8):
   filters, while recipe, recorded-run and embedded tags stay plain `span.chip`.
   Amended by D88 (#249 PR C): the file's own current image tags lead the same row
   and are filters too; a linked tag already shown (case-insensitive) is left out.
-  Amended by D146 (#332): the category chip also names its origin in visible text
-  after the category (" · this image", " · prompt", " · recipe"), and an image's own
-  category shows for an unlinked or ambiguous file too.
 - **D22**: an empty positive reads "No positive prompt (explicitly empty)" (the concept
   applies its negative wording to both roles), and a confirmed `p.prompt-text` is
   focusable (`tabindex=0`, marked focus ring) so long prompts stay keyboard-readable.
@@ -1538,97 +1395,15 @@ Recorded deviations on this page (spec §8):
 - **D39** (ruled 2026-10-21: fallback): a recipe-linked image shows its recipe's own
   category when set, otherwise the linked positive prompt's, and its recipe's own tags
   when it has any, otherwise the positive's; each field falls back on its own and the
-  two tag sets are never merged. The Images Tags filter matches the positive's tags.
-  The category filter matches the same inherited category as the panel (D142, #332), and
-  an image's own category overrides both (D141, D146). The inspection response names each
+  two tag sets are never merged. Set category (#259) writes the positive's category and
+  the Images category and Tags filters match the positive's, so the panel now agrees
+  with them whenever the recipe adds nothing. The inspection response names each
   field's source (`library.category_scope`, `library.tags_scope`: `pair`, `positive` or
-  null, or `image` for an own category, #332); the category chip's visually hidden
-  prefix (D21) says "Recipe category: ", "Positive prompt category: " or "Image category: "
-  from it, and its visible origin (D146) " · recipe", " · prompt" or " · this image", and tag chips are Tags filter buttons only when
+  null); the category chip's visually hidden prefix (D21) says "Recipe category: " or
+  "Positive prompt category: " from it, and tag chips are Tags filter buttons only when
   they are the positive's (#260 D2). History's media inspector uses the same rule. The
   concept shows the prompt's category and tags for every image and the concept
   fixture's recipes have neither, so the inspector comparison needs no mapping for it.
-- **D141** (#332, amends D13 and D36): the Images category filter matches each image's
-  effective category: its own category (Images Set category, PR 3) when it has one,
-  else its inherited one (D142), else none. An image whose own category differs never
-  matches its prompt's category, and an unlinked or ambiguous image with an own
-  category is listed under it (the members-only gate now applies to the Tags filter
-  only). "Select all N matching" and saved views use the same value. The caption's
-  positive-prompt count still counts the linked positives of the images shown. With a
-  category set the listing reads the own categories once per source (a primary-key
-  range); a failed read is the existing 500 `listing-failed`, never an unfiltered page.
-  The link read then keeps only links whose raw recipe or positive category is the
-  value (a superset of those that inherit it; Python decides), and reads the links of
-  files whose own category is the value by path, so their rating and positive count.
-  `test_filter_budget` seeds 2,000 own categories on its 50,000-file fixture.
-  The option list adds the image categories of listed files
-  (`GET /prompt_manager/images/categories`, PR 3), merged with the Library's and sorted
-  (D36); if only that read fails, the prompt categories show and the categories alert is
-  raised. `images category options and Set category dialog match the concept` sets one
-  image's own category ("Portraits") through the real route and compares the toolbar
-  with it sorted into the concept's options; unmapped, only the options differ.
-- **D142** (#332 MC4, amends D39's filter note): the inherited category is one rule,
-  `inherited_category` in `utils/inspection_response.py`: a linked recipe's own
-  category when it is not blank, else the linked positive's. Before #332 the filter
-  matched the positive's even when the chip showed the recipe's. The link reads select
-  the raw recipe and positive categories and never decide inheritance in SQL
-  (`tests/test_api_workspace_image_categories.py` checks the filter and the chip agree
-  on blank values stored as spaces, tabs, U+00A0 and BLOB). The concept has no recipe
-  categories, so this is behavior only.
-- **D145** (#332, DC4): History's media inspector shows an image's own category with
-  the chip rule of the side panel and viewer. Only the inspection request reads it, once,
-  inside the History snapshot: the file is the symlink-resolved output folder plus the
-  receipt's subfolder and filename, keyed with `image_category_key` over the configured
-  output sources, as Images keys it. A temp output or a file no source holds has none;
-  a failed read hides the chip (DC5). The outputs list and media requests read nothing
-  new. The chip's hidden prefix reads "Image category: " for an own category; the
-  visible origin text and its comparison are D146 (PR 3). `history media inspector
-  category chip matches the concept` (history-concept.spec) sets an own category on the
-  Quality baseline's newest output, opens its Recorded run and "View current file", and
-  compares the viewer's chip with the concept viewer's category chip (app.js a402) laid
-  out at runtime with the D146 origin and that category; its place is not compared (what
-  precedes it differs), only its size, tokens, text, prefix and origin. Unmapped, the two
-  differ only in the text, the prefix, the width and `span.chip-source`.
-- **D140** (#332, amends D8): Set category sets the checked images' own categories, so
-  every checked file is a target (no nothing-linked check). More than 500 checked (or
-  "all N matching" over 500) toasts "Select at most 500 images." and opens nothing.
-  The dialog is the concept's `simpleInput` with three recorded differences: the field
-  starts empty (the concept pre-fills its demo "Landscapes") and suggests the toolbar's
-  current categories (`datalist#workspace-input-suggestions`, `openInputDialog`'s
-  `suggestions`); "Use prompt category", a plain button between Cancel and Apply
-  (`secondary`), closes it and opens the "Use prompt category" confirmation ("Remove the
-  image category from the 1 selected image? / … the N selected images? Each one then
-  shows its prompt's category, or none if it has no linked prompt. This cannot be
-  undone.", Cancel and a danger Remove, built like saved views' delete confirmation);
-  and the action reads "Apply" (D8). Apply sends `PUT /prompt_manager/images/category`
-  `{items | filter, category}`, Remove `DELETE` `{items | filter}`; Cancel sends
-  nothing. An empty value keeps the dialog open and the field stops at 100 characters.
-  Toasts: "Category “X” set on 1 image." / "… on N images." (unchanged files count as
-  set) plus " N could not be found." for unlisted files; "Removed the image category
-  from N images." or "None of the selected images had its own category."; 404 "None of
-  the selected images could be found. Refresh the images and try again."; 409 "The
-  sources changed. Refresh the images and try again." (the listing reloads); anything
-  else "Category could not be set. Try again.". `images category options and Set
-  category dialog match the concept` (images-concept.spec) checks a card, opens the
-  dialog in both documents and compares it (title, body tree, field, input, suggestions,
-  actions and every button's box and tokens) with the concept's own dialog changed at
-  runtime as recorded: field emptied, the datalist added after the field, a clone of
-  its Cancel reading "Use prompt category" after Cancel, the primary renamed "Apply".
-  Unmapped, the dialog differs only in the input's value and list, the body's tree, the
-  suggestions and the actions.
-- **D146** (#332, amends D21 and D39): the category chip names its origin in visible
-  text. It is `span.chip` > `span.ca-visually-hidden` (the D21 prefix) + the category +
-  `span.chip-source` (" · this image", " · prompt" or " · recipe"; muted
-  `--ca-muted`, `white-space: nowrap`, so at 390px the origin never splits; the chip may wrap
-  before it or inside a long category). It shows when the inspection names a non-empty category and either the
-  scope is `image` (any link status, so an unlinked or ambiguous file with an own
-  category shows it) or the file is linked. The concept's chip shows the bare name
-  (app.js a402). The inspector comparison (inspector-concept.spec) measures each chip's
-  `span.chip-source` (text, font, color, `white-space`, box) and lays the concept's own
-  chip out with the recorded rule and " · prompt" added at runtime (`withChipSource` in
-  `concept-inventory.mjs`), in the side panel and the viewer's details; unmapped they
-  differ only in the chip's text, width and `span.chip-source`. Its mutation check
-  removes the origin. History's chip (D145) is compared the same way.
 - **D42**: the concept never shows a toast and a page alert together. Production keeps
   the concept's fixed toast (centred, 22px from the bottom, 12px at 700px and below)
   and, when an Import → Rescan toast leaves the Images discovery alert
@@ -1653,8 +1428,7 @@ applies D3 (the `.file-inspector` class of the production-only rules), D20 (the
 viewer's plain tag chips, laid out by the concept page itself with its chips made
 plain at runtime), the D20/D21 side-panel scroll (`overflow: auto`,
 `max-height: calc(100dvh - 40px)` above 700px), D21 (the category's hidden scope
-prefix), D22 (focusable prompt text) and D146 (the chip's visible " · prompt", laid out
-by the concept page itself). `inspector comparison detects mutations`
+prefix) and D22 (focusable prompt text). `inspector comparison detects mutations`
 changes `.prompt-heading .role-label` letter spacing and removes `.detail-footer`.
 
 Manual check (quick), after a browser refresh on Images: hover an image (it zooms);
@@ -1989,13 +1763,11 @@ ranges include cards that bounded rendering has unmounted.
   Over the limit, the client toasts "Narrow the view to at most 10,000 images." and the
   server answers 400 `too-many-images`. No match is 400 `no-images`. Auto-tag in this
   mode does not offer Review each image, because the review walks images in the
-  browser. Set category (D140, #332) sends `{filter, category}` to
-  `PUT /prompt_manager/images/category` (Use prompt category `{filter}` to `DELETE`),
-  which sets or removes each matching image's own category; over 500 matches the client
-  toasts "Select at most 500 images." and opens no dialog, and the server answers 400
-  `too-many-images`. (`POST /prompt_manager/bulk/category` still accepts
-  `{images_filter, category}` and sets the linked positives' category, but no workspace
-  control sends it any more.) Export metadata reads every image in
+  browser. Set category posts `{images_filter, category}` to `/prompt_manager/bulk/category`.
+  The server sets the category on the distinct linked positives and answers
+  `prompt_count` and `skipped`. A listing whose `positive_count` is 0 toasts the
+  nothing-linked sentence and opens no dialog, and over 10,000 matches it toasts the
+  limit sentence. Export metadata reads every image in
   the browser, so it is `aria-disabled` in this mode, and its `title` says why.
 
 Tests: `tests/browser/workspace-images.spec.mjs` ("Shift+click selects a range across
@@ -2667,14 +2439,6 @@ production hub `#/overview` is unchanged (D28); its System card opens
 the pressed section button and disposes the previous section's scope, so its reads,
 listeners and dialogs never outlive it.
 
-System is the home for settings and maintenance (#330 System S13). The legacy pages keep
-their prompt list, tags, Scan Images, auto-tag batch and review and gallery browsing; their
-Settings, Diagnostics, View Logs, Maintenance, Backup DB, Restore DB, the gallery's
-thumbnail, cache, rescan and duplicate tools and the auto-tag model downloads open the
-System section that owns them in a new tab (`legacy-system-links.spec.mjs`). Each page
-keeps only its own settings in Page options. What left the legacy pages is listed in
-"Legacy System UI removed by S13".
-
 Drafts (`system-state.mjs`) live for the page session (Q10). Save writes the dirty
 browser fields, then the host fields (`POST /prompt_manager/settings` with
 `expected_revision`, #220), then the runtime fields. A failed domain keeps its drafts and
@@ -4219,30 +3983,7 @@ modals use the same routes and keep working.
   other: each file's identity is checked just before its unlink.
 - **Clear all logs** (`POST /logs/truncate`, also the admin page's Clear) empties the
   active log through its handler, deletes the rotated copies (Rule R) and clears the
-  buffer; other files and links are kept. Response keys are unchanged. It deletes or
-  empties no more than its confirmation showed (#389):
-  - `/logs/files` rows carry `identity`, the string `"<size>:<mtime_ns>:<ino>"` (a
-    string: `mtime_ns` and many inodes are beyond a browser's exact integers). The
-    workspace sends `{"expected": [{name, identity}]}` with the active and rotated rows
-    its dialog was built from. Under the files lock and every handler lock each listed
-    rotated copy must still match (`_matches_review`) and the listed active log must be
-    the same inode, or nothing changes: 409 `logs-changed`. Only listed copies are
-    deleted; one that appeared after the confirmation is kept. A malformed list is 400.
-  - Without a body (the legacy admin page, whose confirm lists nothing; also the
-    workspace when the file list could not be read and the dialog said "deletes its
-    rotated copies") every rotated copy present at the locked rescan is deleted.
-  - Either way, before anything changes (best effort, not a cross-process lock: a
-    write before our own last write, or any while file logging is off here, is not
-    seen): a second writer of the active log (our
-    handler's flushed stream is behind the file's size, or its file is now a rotated
-    copy: another ComfyUI sharing the folder) is 409 `logs-foreign-writer`; an active
-    log with more than one name (`st_nlink > 1` by `lstat` or the handler's `fstat`,
-    NTFS included) is 409 `logs-hard-link`, never truncated (replacing it instead would
-    rename a file our handler holds open, which Windows refuses). Each copy is
-    `lstat`-checked again just before its unlink; one that changed stops the clear there
-    and keeps it, the copies after it and the active log, which is emptied last.
-  - The browser fixture grows the active log through the handler's own stream, since a
-    second handle appending to it is exactly what Clear refuses.
+  buffer; other files and links are kept. Response keys are unchanged.
 - **Runtime settings** (`GET/POST /logs/config`): the level (DEBUG…CRITICAL) and console
   logging apply until the server restarts; the retention values are shown read-only in
   the workspace and the API keeps accepting them.
@@ -4289,9 +4030,6 @@ auto-tag / review", which the Images selection bar owns, not a System section. A
 is not `covered` names none (`—`). Test is the exact title of a test that runs, then its
 file. Anchors are line numbers on `main` at this PR.
 
-S13 (#330) removed the legacy copy of the `covered` rows the legacy pages linked to System;
-"Legacy System UI removed by S13" below lists every removed element against its row.
-
 `tests/vendor/legacy-coverage.test.mjs` fails on a row with any of these problems:
 - no owner, or a status outside the three;
 - a malformed Native control cell;
@@ -4365,62 +4103,6 @@ list stay unscoped: any row's control proves them.
 | API timeout `apiTimeout` | `gallery-settings.js:37` | Legacy gallery (S12-10; read by no request) | kept in legacy | — | defaults are a complete, sane settings object (gallery-settings.test.js) |
 | config.json-only keys | `py/config.py:212–234,722–739`; `py/api/diagnostics_report.py:185` | S12 report (read-only) | covered | `diagnostics` · button · "Download diagnostic report" | test_report_lists_config_only_keys (test_api_diagnostics_report.py) |
 
-### Legacy System UI removed by S13
-
-System S13 (#330) points the legacy pages' System buttons at native System (a link that
-opens `workspace#/system/<id>` in a new tab) and removes the legacy copy of a capability
-only when its row above is `covered`. One row per removed capability: Capability is the
-exact Capability cell of its coverage row, Page is `admin` or `gallery`, Removed ids and
-Removed methods list what went (`—` for none), and Native test copies that row's Test
-cell. An id that stays on a System link is not listed, only its handler. The gallery's
-Default View Mode left Page options too: System › Appearance's Default layout is the one
-default-layout control. Nothing writes the legacy `defaultViewMode` any more; a stored
-value still picks the view the legacy gallery opens in (grid otherwise), and Page options
-Save and Reset keep it.
-
-`tests/vendor/legacy-coverage.test.mjs` fails when a row cites a capability that is not
-`covered` or copies another test, when an id or method is listed twice for one page, or
-when a listed id is still on its page (`id="…"` in the markup or the script, a
-`getElementById`/`querySelector('#…')` lookup, an entry of a modal-id list) or a listed
-method is still defined or called (`.name(`). A deletion listed nowhere is caught by the
-kept-flow tests (`kept admin flows still work` in `legacy-system-links.spec.mjs` and the
-legacy page workflows), not by this check.
-
-| Capability | Page | Removed ids | Removed methods | Native test |
-| --- | --- | --- | --- | --- |
-| Diagnostics run | admin | `#diagnosticsModal`, `#runDiagnosticsBtn`, `#diagnosticsContent` | `showDiagnosticsModal()`, `closeDiagnostics()`, `runDiagnostics()`, `renderDiagnostics()` | Run checks opens the shared Health report (workspace-system-diagnostics.spec.mjs) |
-| Synthetic image-link test | admin | `#testImageLinkBtn` | `testImageLink()` | Create test link confirms first and names the prompt (workspace-system-diagnostics.spec.mjs) |
-| View logs with level and limit | admin | `#logsModal`, `#logLevel`, `#logLimit`, `#refreshLogsBtn`, `#logsContainer` | `showLogsModal()`, `closeLogs()`, `refreshLogs()`, `displayLogs()` | level filter is minimum-level over all six choices (workspace-system-diagnostics.spec.mjs) |
-| Log statistics | admin | `#logStatsTotal`, `#logStatsErrors`, `#logStatsWarnings`, `#logStatsLevel`, `#logStatsSize` | `loadLogStats()`, `formatBytes()` | log statistics show entries, errors, warnings, files and size (workspace-system-diagnostics.spec.mjs) |
-| Log files list and download | admin | `#downloadLogsBtn`, `#logFilesList` | `loadLogFiles()`, `downloadLogs()`, `downloadLogFile()` | each listed file downloads by its returned name and a link has no Download (workspace-system-diagnostics.spec.mjs) |
-| Clear/truncate logs | admin | `#clearLogsBtn` | `clearLogs()` | Clear all logs states both counts, confirms first and reads everything again (workspace-system-diagnostics.spec.mjs) |
-| Set log level (incl. CRITICAL), console logging | admin | `#updateLogConfigBtn`, `#setLogLevel`, `#consoleLogging` | `loadLogConfig()`, `updateLogConfig()` | runtime level (including CRITICAL) and console logging save and say they apply until the server restarts (workspace-system-diagnostics.spec.mjs) |
-| Image scan directories add/remove | admin | `#scanPathsList`, `#addScanPathBtn` | `renderScanPaths()`, `addScanPath()`, `removeScanPath()`, `_collectScanPaths()` | Add source validates on the server, then marks the host draft dirty; Save persists (workspace-system-sources.spec.mjs) |
-| Currently monitoring list + Refresh | admin | `#refreshMonitoringStatus`, `#monitoringStatus` | `updateMonitoringStatus()` | watching only with a live observer; restart pending otherwise (workspace-system-sources.spec.mjs) |
-| Search results auto-hide `result_timeout` | admin | `#resultTimeout` | — | host fields round-trip through /settings with revision (workspace-system.spec.mjs) |
-| Web UI display mode | admin | `#webuiDisplayMode` | — | host fields round-trip through /settings with revision (workspace-system.spec.mjs) |
-| Worker threads | admin | `#workerThreads`, `#workerThreadsValue` | `renderWorkerThreads()` | worker range max is cpu_count (workspace-system-sources.spec.mjs) |
-| LoraManager badge, enable, path, trigger words, CivitAI key, clear key | admin | `#loraDetectionBadge`, `#loraEnabled`, `#loraSettings`, `#loraManagerPath`, `#loraTriggerWords`, `#civitaiApiKey`, `#clearCivitaiKey` | `detectLoraManager()`, `_bindLoraEvents()`, `saveLoraSettings()` | LoRA rows show detected / enabled / cache-loaded separately (workspace-system-integrations.spec.mjs) |
-| LoRA data import with progress | admin | `#loraImportModal`, `#loraImportBtn`, `#loraImportStatus`, `#loraImportPercent`, `#loraImportBar`, `#loraImportProcessed`, `#loraImportImported` | `runLoraImport()` | Review import shows replacement, blocked items and network effects with the backup box; Start opens the job (D107) (workspace-system-integrations.spec.mjs) |
-| Maintenance cleanup_duplicates, vacuum, cleanup_orphaned_images, prune_orphaned_prompts | admin | `#maintenanceModal`, `#cleanup_duplicates`, `#vacuum`, `#cleanup_orphaned_images`, `#prune_orphaned_prompts`, `#runMaintenanceBtn`, `#maintenanceResults` | `showMaintenanceModal()`, `closeMaintenance()`, `runMaintenance()`, `renderMaintenanceResults()` | Apply reviewed operation closes, toasts, opens the job in Activity (workspace-system-maintenance.spec.mjs) |
-| Maintenance check_hash_duplicates, check_consistency | admin | `#check_hash_duplicates`, `#check_consistency` | — | Run health checks opens Health report and updates metric 4 (workspace-system.spec.mjs) |
-| Maintenance statistics (database info) | admin | `#statistics` | — | meta-grid shows real database and source status, the pinned Viewer.js version and the host renderers (workspace-system-diagnostics.spec.mjs) |
-| Maintenance select all / clear all / run | admin | `#selectAllMaintenanceBtn`, `#clearAllMaintenanceBtn` | `selectAllMaintenance()`, `clearAllMaintenance()` | plan dialog shows the server's scope, protected, backup policy and media lines with the backup box (D100); Cancel writes nothing (workspace-system-maintenance.spec.mjs) |
-| Database backup | admin | — | `backupDatabase()` | Back up downloads through the api client and revokes the object URL (D103) (workspace-system-backups.spec.mjs) |
-| Restore from file | admin | `#restoreModal`, `#restoreFileInput`, `#confirmRestore`, `#cancelRestore` | `showRestoreModal()`, `confirmRestore()` | Review restore stages the chosen file and shows the real summary with the backup box (D105) (workspace-system-backups.spec.mjs) |
-| Gallery thumbnail generation | gallery | `#generateThumbnailsBtn`, `#thumbnailStatus`, `#thumbnailProgress`, `#progressText`, `#progressPercent`, `#cancelThumbnailsBtn`, `#progressBar`, `#progressDetails`, `#progressETA` | `generateThumbnails()`, `generateThumbnailsWithProgress()` | Start closes the dialog, toasts, and opens the job in Activity (workspace-system-sources.spec.mjs) |
-| Default view mode, image quality | gallery | `#defaultViewModeSelect`, `#imageQualitySelect` | — | defaults apply to a new visit but not to the current view or a saved view (workspace-system.spec.mjs) |
-| Image info on cards; sidebar collapsed | gallery | `#showImageInfoToggle`, `#sidebarCollapsedByDefaultToggle` | — | added rows reach their consumers (workspace-system.spec.mjs) |
-| Video autoplay, mute, loop | gallery | `#videoAutoplayToggle`, `#videoMuteToggle`, `#videoLoopToggle` | — | video defaults reach the viewer (workspace-system.spec.mjs) |
-| Auto-load metadata, cache metadata, show file paths | gallery | `#autoLoadMetadataToggle`, `#cacheMetadataToggle`, `#showFilePathsToggle` | — | metadata off shows an explicit load and loads once on request (workspace-system.spec.mjs) |
-| Browser cache clear | gallery | `#clearCacheBtn` | `clearCache()` | Metadata cache reviews and clears only owned browser entries when there are some (D102) (workspace-system-maintenance.spec.mjs) |
-| Clear server thumbnails | gallery | — | — | Thumbnail cache opens the S5 dialog (workspace-system-maintenance.spec.mjs) |
-| Refresh file listing | gallery | `#rescanFolderBtn` | `rescanFolder()` | Refresh files calls /gallery/rescan and toasts its counts (workspace-system-sources.spec.mjs) |
-| Duplicate image scan, review, delete | gallery | `#scanDuplicatesBtn`, `#dupScanPill`, `#dupScanPillText`, `#duplicatesModal`, `#closeDuplicatesBtn`, `#duplicatesScanStatus`, `#dupProgressText`, `#dupProgressBar`, `#duplicatesContent`, `#duplicatesList`, `#duplicatesFooter`, `#duplicatesCount`, `#selectAllBtn`, `#removeDuplicatesBtn` | `scanDuplicates()`, `attachDuplicateStream()`, `resumeDuplicateScan()`, `applyDuplicateEvent()`, `renderDuplicateProgress()`, `setDuplicateButton()`, `showDuplicatePill()`, `hideDuplicatePill()`, `openDuplicatesModal()`, `showDuplicatesModal()`, `hideDuplicatesModal()`, `displayDuplicates()`, `selectAllDuplicates()`, `removeDuplicates()` | Find duplicates starts a job; its view links Review groups; Keep radios build a duplicate_files plan (D101) (workspace-system-maintenance.spec.mjs) |
-| Auto-tag model download | admin | `#autoTagDownloadModal`, `#downloadModelName`, `#downloadStatus`, `#downloadProgressPercent`, `#downloadProgressBar`, `#cancelDownloadBtn` | `downloadModel()`, `cancelDownload()` | Download starts the job and Activity shows it without Cancel (workspace-system-tagging.spec.mjs) |
-| Auto-tag model download | gallery | `#autoTagDownloadModal`, `#downloadModelName`, `#downloadStatus`, `#downloadProgressPercent`, `#downloadProgressBar`, `#cancelDownloadBtn` | `downloadModel()`, `cancelDownload()` | Download starts the job and Activity shows it without Cancel (workspace-system-tagging.spec.mjs) |
-| Unload model | gallery | — | `unloadModel()` | Unload is enabled only while a model is loaded, and a held gate's refusal names the operation (workspace-system-tagging.spec.mjs) |
-
 ### Browser cache ownership (#222)
 
 The legacy gallery's Clear cache used to delete every localStorage key starting `pm_` or
@@ -4438,15 +4120,17 @@ page writes a key that is neither a preference nor inventoried, writes one it ca
 CacheStorage or IndexedDB; `the storage scan reports every way of writing browser
 storage` pins those patterns. It skips `web/lib` (third-party builds) and the pinned
 Toolkit build (`web/js/shared/toolkit`, never hand-edited, verified by `npm run check`;
-its storage belongs to the Toolkit repository and a new pin is reviewed on its own). Since
-System S13 (#330) the legacy gallery no longer offers Clear cache: System › Maintenance's
-Metadata cache and Thumbnail cache reviews own both parts (removal table above), and
-`cache-ownership.js` serves the native review.
+its storage belongs to the Toolkit repository and a new pin is reviewed on its own). The
+gallery's server thumbnail clear stays its own request and runs first: refused or
+unreachable, it changes nothing and says so (the old code toasted success when the
+request failed); refused browser storage is reported, never hidden
+(`tests/js/legacy-refusals.test.js`; the browser case `the gallery cache clear keeps
+preferences and other tools caches` in `workflows.spec.mjs`).
 
-The duplicates dialog's View Full named its source (`?root=<index>`, with the path
-URL-encoded) when the gallery's output folder is a listed source
-(`test_view_full_names_the_gallery_folder_source`); S13 removed the legacy dialog, and the
-route keeps that behaviour for System › Maintenance's duplicate review.
+The legacy duplicates dialog's View Full now names its source (`?root=<index>`, with the
+path URL-encoded) when the gallery's output folder is a listed source; before, the serve
+route opened the first source holding a file at that path
+(`test_view_full_names_the_gallery_folder_source`).
 
 ### Library location contract (#249 System S6b)
 
@@ -4738,18 +4422,8 @@ Filters (`mode=workspace`; anything invalid is 400 "Invalid gallery filters"):
   rating 5 to 1, then linked but unrated, then unlinked and ambiguous; ties break
   newest first. A signed cursor covers every filter and the sort, so reusing it
   with a change is 400.
-- One link read (`get_image_link_matches`) serves the filters, the rating sort
-  and the count. SQLite returns its rows as one JSON value in one step (#354):
-  Python's `sqlite3` releases and retakes the GIL around every step, and while
-  ComfyUI generates each retake can wait on the busy thread, so a read that
-  stepped once per linked row took seconds. The result keeps only the listed
-  paths; peak memory grows with the database's matching linked rows (about
-  530 bytes each, freed on return). When the JSON step fails (a SQLite without
-  JSON functions, a BLOB value, a JSON text over SQLite's length limit) the read
-  streams the rows as before and logs one warning per process; a missing JSON
-  function stops the attempt for the rest of the process. An interrupted read
-  (Move library) raises as before. `tests/test_database_link_matches.py` proves both reads
-  equal on every filter and on odd values.
+- One link read (`get_image_link_matches`, streamed and bounded to the listed
+  paths) serves the filters, the rating sort and the count.
 
 `positive_count` is the number of distinct linked positives over the full matching
 set, not the page:
@@ -4800,85 +4474,6 @@ concept fixture stars the concept's favorites (each other prompt's first image).
   restore. Old backups without the table restore, and backup plus restore keeps
   WAL-resident favorites and closes every handle (`tests/test_database_backup.py`).
 
-Image categories (#332, store and routes): an image file may carry its own
-category; without one it shows the category its link supplies.
-
-- The table is `image_categories(root_key, relative_path, category, updated_at)`
-  with primary key `(root_key, relative_path)` and the index
-  `idx_image_categories_category`. `migrate_image_categories` creates both empty
-  inside a savepoint, with no backfill. It reads only `sqlite_master` and its own
-  table's PRAGMAs, and writes only its two objects. `tests/test_image_categories.py`
-  checks this with an SQLite authorizer on a 23,000-link library, and checks that
-  `prompts` and `prompt_pairs` `(id, category, updated_at)` are byte-for-byte equal
-  afterwards.
-- The **file key** is `image_category_key(sources, absolute path)` in
-  `py/api/images.py`: the deepest output source that contains the path (compared
-  lexically, never resolving the path, so a symlinked subfolder keeps its listed
-  spelling) and the path below it, keyed with the favorites helpers. A source
-  matches by its real path or its configured spelling (a detected output folder
-  can be a symlink). Without nested sources it equals a favorite's key. Every write and read uses it. A path
-  that no source contains has no key, so it has no own category.
-- `image_categories_schema_error` checks the structure at startup (a value saved
-  under older rules never stops the library opening; a table without its index,
-  which this code never leaves, is repaired by the install). Restore also checks the
-  values: text columns, keys within the favorites bound, `category` 1 to 100
-  characters with no character below U+0020 and no leading or trailing space, and
-  `updated_at` of at most 64 bytes. Backups made before #332 restore without the
-  table; a migrated restore stage must have it (`require_library_state`).
-- `PUT /prompt_manager/images/category` `{items, category}` answers
-  `{success, category, updated, unchanged, not_found}`.
-  `DELETE /prompt_manager/images/category` `{items}` answers `{success, cleared}`.
-  `GET /prompt_manager/images/categories` answers `{success, categories}`: the
-  sorted distinct own values whose file is in some source's listing.
-- `items` are 1 to 500 Images targets `{root_index, root_scope, path}`, checked by
-  `py/api/media_target.py` (shared with Collections, #331). Refusals:
-  - 400: a malformed body, a field other than `items` and `category`, a
-    `root_index` outside the output sources (a LoRA folder), or a category that is
-    blank after stripping, over 100 characters, or holds a control character;
-  - 403: traversal, a drive, a backslash, a non-media name ("Only media files can
-    have a category") or a key over the stored bound;
-  - 409 `source-changed`: a stale `root_scope`;
-  - 413: a body over 1 MiB.
-  Any invalid item fails the whole request before a write. Targets that fold to one
-  key are written and counted once. Instead of `items` a request may send `filter`,
-  the Images listing's own query ("Select all N matching", #392, keys as in
-  `parse_listing_filter`), resolved now: over 500 matches is a 400
-  `too-many-images` ("Select at most 500 images."), a renumbered source a 409
-  `source-changed`.
-- PUT writes only files the source's listing holds and counts the rest in
-  `not_found`; when none is listed it answers 404 `files-not-found` and writes
-  nothing. A file that already has the value counts as `unchanged` and keeps its
-  `updated_at`. DELETE accepts any well-formed target, so a missing file's
-  category can still be removed. An unexpected failure is a logged 500 ("The
-  category could not be changed." / "Image categories could not be read.") without
-  the exception text. The routes never read or write `prompts`, `prompt_pairs` or
-  `generated_images`; `POST /prompt_manager/bulk/category` is unchanged.
-- Duplicate cleanup (System › Maintenance): the kept copy's own category wins. A
-  kept copy without one receives the removed copy's (`COPY_SQL`, part of the
-  cleanup's query-plan check). The removed copy's row is never deleted, so a
-  give-back (the kept copy changed) and a failed delete lose nothing. The job log
-  says "Kept N image categories on the kept copies".
-  `tests/test_duplicate_image_categories.py` covers nested sources in both orders.
-- A moved, renamed or deleted file's row stays and is hidden; a file that later
-  appears at the same path shows it. The real-host check is the last test in
-  `tests/comfyui/image-attribution.spec.mjs`: PUT, list, DELETE on a generated
-  output.
-- Interface (PR 3, a browser refresh; no restart beyond PR 1-2's): the Images
-  selection bar's Set category writes these routes (D140, which amends D8); the toolbar
-  category options add the listed images' own categories (D141); the inspector's
-  category chip names its origin, " · this image", " · prompt" or " · recipe" (D146), in
-  the side panel, the viewer and History's media inspector (D145); Tags & categories
-  counts images on each category row and lists image-only values (D143), and Manage
-  category previews and renames image rows too (D144). Prompt categories are changed in
-  the Prompt library editor and on the legacy admin page's "Set Category". Concept
-  comparisons, at 1600x1100 and 390x844 in both themes: `images-concept.spec.mjs` (the
-  Set category dialog and the options), `inspector-concept.spec.mjs` (the chip),
-  `history-concept.spec.mjs` (History's chip) and `vocabulary-visual.spec.mjs` (rows and
-  preview, with `vocabulary-canonical-comparison.mjs`). Behavior: `workspace-images`,
-  `full-inspector`, `workspace-history` and `workspace-vocabulary` specs, and
-  `tests/js/workspace-images-category.test.js`, `workspace-file-inspector.test.js`,
-  `workspace-vocabulary-state.test.js`, `workspace-toolbar.test.js`.
-
 Image annotations schema (#249, `database/annotation_schema.py`): the group
 `media_annotation_metadata` (one row: schema version, `image_index_revision`),
 `media_annotation_files` (one private locator per physical file,
@@ -5001,23 +4596,7 @@ files, oldest forgotten first, keyed by 16-byte digests: 8.6 MiB measured at
 the cap). A file whose inspection raises is logged, counted in
 `review_errors` and reported `unresolved`; the scan goes on. An older version's
 pending, undecided item of bytes now untraced leaves the queue
-(`settle_stale_review_items`), so an item never stays stuck at 409.
-Saver anchor (#390, `tests/test_review_saver_anchor.py`): the scan and Apply
-resolve with the file's name as the workspace inspector does, so the one saver
-whose `filename_prefix` names the file anchors its branch. A file is never both
-unlinked and unqueued (maintainer ruling): when only that anchor resolves it
-(the named inspection run resolves, the unnamed one does not) and neither the
-default profile nor the parser floor links it, the scan queues it with the
-anchor's pair as its one candidate (evidence `anchor: "saver"`; the page
-preselects it), never linking it. Such an item counts as a choice for the
-untraced settle. Files already linked or resolved by the default path are
-unchanged. No match, several matches or an unfinished walk anchor nothing, and
-the file is queued as before. `REVIEW_RULE_VERSION` is folded into inspection
-item versions, so older inspection items are recorded again once. Apply accepts
-the anchored pair and refuses a choice the anchor contradicts. Measured on the
-maintainer's 40,890 outputs: the queue is unchanged (249 files); the 242
-`gpu_unlock_bench` files the inspector resolves are linked by the parser
-floor. The 16-candidate limited
+(`settle_stale_review_items`), so an item never stays stuck at 409. The 16-candidate limited
 rule and the 8 MiB bound apply unchanged. The queue heals itself: after each batch, the scan removes the pending
 items of every listed file (read or skipped as known) that a saved row now
 links, and the monitor does the same for each ambiguous output it links
@@ -5342,75 +4921,6 @@ same as a file the scan could not attribute, so the file stays on disk and in th
 gallery as unlinked, and its favorite and tags (kept by file) are untouched. Every
 run prints this. Queue-linked batch images can't be proven after the fact and read
 `unlink`, so review before applying. Stop ComfyUI first.
-
-### Foreign workflows (#247): the shared per-file decision
-
-The output scan decides each file through `utils/file_prompt.py`
-(`decide_file_prompt`, the ladder), which the monitor will share for outputs of
-workflows without a PromptManager node. It does no file or database I/O.
-
-- **Save to library (#90).** Before anything else, a file whose PromptManager
-  node had Save to library off is `not_saved`, and one whose switch is wired
-  from a node the file cannot show is `not_saved_wired`: nothing is written, no
-  recorded-run fallback, no Needs review item. A resolved pair whose negative's
-  node is off stores the positive alone (source `opted-out-negative`). The
-  #90 graph walk follows only prompt-like inputs, so the ladder also walks
-  every input upstream of each sampler or guider positive (not negative, model,
-  clip, latent or image inputs; every PromptManager node of a graph without a
-  sampler) and checks the text later steps name: a resolved or inspected
-  positive whose path passes such a node (`side_opted_out`), or a legacy answer
-  that is such a node's text (resolved, else literal). A switch that is off
-  makes the file `not_saved`; one wired from a node the graph cannot read makes
-  it `not_saved_wired`, as #90's direct check does.
-- **Order.** The default profile decides first, exactly as before (resolved
-  pair, A1111, sampler-less). Only a graph it leaves ambiguous or unresolved
-  reaches the inspector's resolve (`inspection_resolution` in
-  `utils/prompt_inspector.py`, the inspection profile, then the recorded saver
-  anchor of #386; `name_anchor=False`: the file-name anchor never decides a
-  link; the scan's legacy floor may still link the file, as before #247, and a
-  file nothing links is queued with the anchor's choice per #390), and only that positive's `storage_text` is stored (never
-  prepend or append text, never `recorded_texts`). Then the #170 browser parser
-  (`graph_prompt_text`), the legacy floor, then the recorded run's stored
-  prompt. The legacy answer is refused when a PromptManager-family node has a
-  prepend or append part and the answer is not that node's own `text` (the
-  parser joins the parts, so the stored text cannot be told from it). History is asked once per file and only at that step; the scan's
-  batch lookup stays lazy and makes one `recorded_runs` pass for the stored
-  prompt and the saver (`_BatchHistory`).
-- **Policies.** `SCAN` keeps the legacy floor for every undecided file.
-  `MONITOR` waits for history inside the output folder (`history`) and stores
-  nothing for a file the inspector calls ambiguous; an untraceable or
-  malformed one still gets the legacy floor.
-- **Junk.** `junk_text` refuses `blank`, `number` (the #252 `_numeric` rule),
-  `lora-only` (only `<lora:...>` tags and separators) and `model-file` (one
-  token ending in a model extension) at whichever step found the text and
-  nothing later is tried; the file reports `found`, except at the undecided
-  graph step, which keeps its own status (an ambiguous file is still queued).
-- **One prompt per file.** `database/scanned_prompts.py` stores a positive in
-  one `BEGIN IMMEDIATE` transaction: a file already linked to another prompt
-  (either spelling, `file_link_rows`/`link_conflict`, the pair ingester's rule)
-  is `conflict` and nothing is written; a failed link rolls the new prompt back
-  (`found`); two writers of one text store one prompt. A recorded run's stored
-  prompt links the same way (`link_stored_prompt_or_raise`). A rescan therefore
-  never adds a second link to a file an older scan linked to the legacy answer;
-  the row reads "Kept: already linked to a different prompt". Link rows are
-  matched under the path and its `realpath` spelling (`file_link_rows`), so a
-  file the scan stored through the resolved folder is found when it arrives
-  through a symlinked or junction folder. The reverse order (a row stored under
-  the watcher's raw spelling, then a scan whose root resolves differently) is
-  matched only when that raw spelling equals the realpath. Every scan write
-  runs through `survive_library_switch`, so a library move reruns it.
-- **Marks.** Every prompt ingestion creates, pair components included, carries
-  category `scanned`, tag `auto-scanned` and the note `Auto-scanned from
-  <file>` (`SCAN_MARKS`); a reused prompt keeps its fields. Run counts are
-  never touched.
-
-Tests: `tests/test_file_prompt.py` (one test per ladder step and junk class),
-`tests/test_scanned_prompts.py` (store, conflict, rollback, concurrency with
-`FirstWriterHold`, pair marks), `tests/test_pair_scan.py` `TestScanDecision`,
-`tests/test_run_attribution.py` (dataset branches linked by the recorded
-saver, a legacy-linked file left as it is, `_BatchHistory.recorded`) and
-`tests/test_recorded_saver_anchor.py` `TestInspectionResolution`.
-
 ## Linked prompt text (#343)
 
 A link drives `text` on every PromptManager node, and `negative_text` on the Pair,
@@ -5477,7 +4987,7 @@ which used to save `null` under a link.
   Primitive or through `PreviewAny`, for PromptManager, PromptManagerText, Focused, Split
   and the Pair (positive, negative, both, neither linked, and a Primitive negative). A
   wildcard Primitive on PromptManager (queued as written) and Focused (one choice) saves
-  and counts what was queued. The linked text is saved, counted once per job, recorded as
+  and counts what was queued. The linked text is saved, counted once, recorded as
   the run's raw positive/negative, and after a scan the run's image links to it. Text
   only known at run time (`PreviewAny`) cannot be read from the image; the case only
   requires that it is never linked to another prompt (its attribution from the recorded
@@ -5491,39 +5001,6 @@ PM_COMFY_ROOT=... PM_TEST_PYTHON=... npm run --prefix tools/vendor test:comfyui
 PM_COMFY_ROOT=... PM_TEST_PYTHON=... npm run --prefix tools/vendor test:executions -- execution-text-link
 ```
 
-## Cached runtime-linked runs (#347)
-
-Text only known at run time (a `PreviewAny` or LLM link, a list node) is counted by the
-node when it executes; the queue hook cannot read it. When ComfyUI serves such a node from
-its output cache, `utils/cached_runs.py` counts the job instead: every execution records
-a receipt (digests of its STRING outputs and hashes of the text it stores, per run key and
-queue item), and on `execution_cached` the receipt whose digests equal the cache entry's
-text is replayed once. The role (positive, negative, which Pair outputs are used) and what
-the hook already saw are recomputed from the job's own graph, and the node and replay
-decide through the same `own_counts`.
-
-- Fail closed: no receipt in this process (after a restart, an external cache provider),
-  changed cached text, more than 64 list values, a node the job's outputs do not need, or
-  a host without the queue/executor interfaces: nothing is counted, as before #347.
-- A cached node counts at job start like the hook: a job failing later still counts it.
-  A node that executes after its replay in the same job (RAM-pressure freed the entry)
-  skips its own count but still consumes the pending first-use catch-up.
-- No backfill: earlier cached jobs keep their counts. The history page's "tracked runs"
-  can stay below the Library count for these prompts (#403).
-- Tests: `tests/test_cached_runs.py` (whole jobs with the real nodes, a real database,
-  fake host caches); `tests/comfyui/execution-text-link.spec.mjs` "#347" cases on the
-  managed host: PreviewAny into each node kind, 3 jobs changing only the sampler seed,
-  count 3 in both renderers; in one renderer the Classic, LRU, RAM-pressure and no-cache
-  modes, A, B, A from the owned `PMCycledText` under LRU, typed text, a downstream
-  failure, a "run selected output" job that does not need the node, and a rewire to the
-  negative input. The RAM-pressure eviction path cannot be forced on a real host and is
-  covered by the Python tests.
-
-```sh
-python3 -m unittest discover -s tests -p "test_cached_runs.py"
-PM_COMFY_ROOT=... PM_TEST_PYTHON=... npm run --prefix tools/vendor test:executions -- execution-text-link --grep "#347"
-```
-
 ## Durable execution ledger
 
 `npm run --prefix tools/vendor test:executions` runs 52 real execution cases
@@ -5943,20 +5420,6 @@ rotates the epoch, so a pre-restore `expected_epoch` is refused with `storage-ch
 Owner rows and their timestamps never change on a tag command; a category apply only
 touches rows carrying the exact source.
 
-Image categories (#332 §7, MC9, MC10, DC7): each `GET categories` row also carries
-`image_count`, the stored `image_categories` rows holding that exact value (files
-missing on disk included). A value prompts and images share appears once, ordered by
-its oldest positive; a value only images hold appears once after every prompt-backed
-value (`first_pid` 9223372036854775807 in the keyset cursor), ordered by value, with
-`prompt_count` 0. `/library/options` keeps its own query and never lists image-only
-values. Category preview and apply report `impact.images` (rows holding the source),
-the target exists when an image row holds it, an image-only value can be renamed, the
-apply renames the image rows in the same transaction (file keys and rowids kept, so a
-merge cannot collide), and the impact token hashes the sorted image rowids, so an image
-row gaining or losing the value between preview and apply is 409
-`vocabulary-conflict` with nothing written. Every image-category statement reads
-`idx_image_categories_category` (`test_category_reads_use_the_image_category_index`).
-
 Two legacy routes change additively: `GET /tags` now lists unused registry tags, and
 `/tags/suggest` without context appends unused names at count 0. Unused tags become
 deletable only through the native Delete tag (vocabulary UI PR), not on the legacy
@@ -5974,18 +5437,13 @@ Deploying this backend needs a ComfyUI restart (Python and route changes).
 longer hands off to the legacy tag manager. That page stays reachable from Overview's
 "Open existing tag manager" card for tag search and sort, the untagged entry and
 multi-tag AND/OR browsing; bulk prompt actions (delete, tag, category) stay on the
-legacy admin page. A prompt's category is changed in the Prompt library editor or with
-the legacy admin page's "Set Category" (`POST /prompt_manager/bulk/category`, unchanged);
-the Images selection bar's Set category sets images' own categories only (D140, #332),
-and Manage category renames a value on prompts, recipes and images together (D144). The screen consumes only the `/prompt_manager/vocabulary/*` routes
+legacy admin page. The screen consumes only the `/prompt_manager/vocabulary/*` routes
 above and adds no route, so PR B needs no ComfyUI restart: a browser refresh is enough.
 
 Screen: a `+ Create tag` heading action, a Tag vocabulary table (columns Tag, Prompts,
 Images counting the files that carry the tag (`image_count`, #249 C2), and Actions with Browse and
 Rename / merge), and a Categories panel whose category rows end with the Manage
-category row (Review). A category row reads "N positive prompts", "N positive prompts ·
-M images" when images hold the value as their own category too, or "M images" for a
-value only images hold (D143, #332). Lists load 100 rows at a time, append when scrolled into view
+category row (Review). Lists load 100 rows at a time, append when scrolled into view
 and keep `Load more tags` / `Load more categories` while more remain. Prompts counts
 are the Library Browse totals.
 
@@ -6028,34 +5486,7 @@ Recorded deviations from the concept (maintainer acceptance): bounded lists with
 Load more; title "Tags"; Manage categories adds a Category select and Preview before
 Apply; "Apply" instead of "Apply in prototype"; Delete tag… inside Rename or merge;
 Browse sets the exact filter; singular "1 positive prompt"; the production list appends
-fixture-only tags after the concept's sample tags.
-
-- **D143** (#332): category rows count the images whose own category is the value
-  (`image_count`, the stored rows, missing files included): "N positive prompts · M
-  images" beside prompts, "M images" for an image-only value, which follows every
-  prompt-backed row (by value) before Manage category. Browse on an image-only row opens
-  Images with exactly that Category filter (its Library would be empty), as a fresh
-  Images visit that becomes the Images return state, the way Browse seeds the Library's; every other
-  row opens the Library as before. Manage category's select lists image-only values
-  last, so past 1,000 categories they are the first left out (the dialog says the list is
-  capped).
-- **D144** (#332): Manage category's preview counts the images holding the value ("“X”
-  is used by N positive prompts and M images. Apply renames it to “Y”."; D9's sentence
-  with "M images" added when above 0), an image-only value can be renamed, and Apply
-  renames the image rows in the same transaction; an image row gaining or losing the
-  value between Preview and Apply is 409 `vocabulary-conflict` with nothing written.
-- `category rows and the Manage category preview match the concept with image
-  categories` (vocabulary-visual.spec, 1600x1100 and 390x844, both themes) seeds the
-  fixture with `image_categories: true` ("Landscapes" on two images, "Portraits" on one
-  image only, rows keyed as Images keys them) and compares the page with D143 mapped
-  (`mapVocabularyConcept(reference, imageCategories)`, whose row model is checked against
-  the concept page with those rows added at runtime) and the Manage dialog after
-  Preview with D9 and D144 (`mapVocabularyDialog`'s `preview`). Before the preview is
-  measured the pointer leaves the pressed Apply and focus returns to ×, the state the
-  opening comparison in workspace-vocabulary.spec measures. Unmapped, the page differs
-  in the Landscapes row's text and the added Portraits row, the dialog only in the
-  sentence. The default fixture seeds no image category, so the other vocabulary
-  comparisons are unchanged. Paired concept/production captures
+fixture-only tags after the concept's sample tags. Paired concept/production captures
 for both themes and widths are attached as test artifacts; no PNG baseline is added
 until acceptance. Not compared: hover states and the dialog focus ring (the page-level
 keyboard ring and link ring offsets are asserted). No coverage floor was lowered;

__init__.py

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

database/duplicate_copies.py

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

database/image_categories.py

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

database/image_collections.py

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

database/models.py

@@ -22,10 +22,6 @@ 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,
@@ -38,7 +34,6 @@ from .review_schema import (
     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,7 +337,6 @@ 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).
@@ -356,8 +350,6 @@ class PromptModel:
         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 +1155,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 +1220,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
             )

database/operations.py

@@ -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."""
 
@@ -2638,94 +2541,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 +2583,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 +2592,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 +2608,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]:

database/pair_ingestion.py

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

database/restore_stage.py

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

database/review_schema.py

@@ -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:

database/run_attribution.py

@@ -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()
 

database/saved_views.py

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

database/scanned_prompts.py

@@ -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"

database/vocabulary.py

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

prompt_manager.py

@@ -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,10 +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)
         return result
 
     @classmethod

prompt_manager_base.py

@@ -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,34 +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
-    ) -> None:
-        """Remember this execution's outputs and stored text for cached jobs (#347)."""
-        if unique_id is None:
-            return
-        try:
-            self._cached_runs().record_item(
-                unique_id, outputs, stored_facts(text, negative_text)
-            )
-        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)."""
@@ -263,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).
 

prompt_manager_pair.py

@@ -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,9 +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
-        )
         return result
 
     def _save_and_track_pair(
@@ -235,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)
@@ -247,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)

prompt_manager_text.py

@@ -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,10 +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)
         return result
 
     @classmethod

py/api/__init__.py

@@ -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,11 +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
 
 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:
@@ -87,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
 
@@ -318,7 +314,6 @@ class PromptManagerAPI(
     ReviewRecordingMixin,
     ReviewEventsMixin,
     SavedViewRoutesMixin,
-    CollectionRoutesMixin,
     HistoryRoutesMixin,
     PromptRoutesMixin,
     ImageRoutesMixin,
@@ -341,7 +336,6 @@ class PromptManagerAPI(
     AutotagRoutesMixin,
     LoraIntegrationMixin,
     LoraImportRoutesMixin,
-    ImageCategoryRoutesMixin,
 ):
     """REST API handler for PromptManager operations and web interface.
 
@@ -690,7 +684,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)
@@ -707,7 +700,6 @@ class PromptManagerAPI(
         self._register_autotag_routes(routes)
         self._register_lora_routes(routes)
         self._register_lora_import_routes(routes)
-        self._register_image_category_routes(routes)
 
         # Register gzip compression middleware (once)
         global _gzip_registered
@@ -1033,4 +1025,85 @@ 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

py/api/admin.py

@@ -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, sampler_less_prompt
+    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, sampler_less_prompt
+    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,122 @@ 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"]
+        elif canonical.get("prompt"):
+            # No node takes a positive or negative input (a guider or wrapper
+            # graph): the one wired text, never a guess (#252).
+            found = sampler_less_prompt(canonical["prompt"])
+            prompt_text = found["text"]
+            if prompt_text is None and isinstance(canonical.get("parameters"), str):
+                # A metadata saver also wrote A1111 text: its positive prompt.
+                parsed = self._parse_comfyui_prompt(metadata)["positive_prompt"]
+                prompt_text = parsed.strip() if parsed and parsed.strip() else None
+            if prompt_text is None:
+                linked = self._link_recorded_run(
+                    media_file, canonical, detailed, history
+                )
+                if linked is not None:
+                    return linked
+                return "unresolved" if found["state"] == "ambiguous" else "found"
+        else:
+            prompt_text = self._parse_comfyui_prompt(metadata)["positive_prompt"]
+            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 +1804,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 +1848,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"

py/api/annotation_suggest.py

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

py/api/annotations.py

@@ -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)
@@ -595,7 +623,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 +661,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 +682,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(

py/api/autotag_routes.py

@@ -102,17 +102,6 @@ def size_label(size: str) -> str:
     return f"{match.group(1)} {match.group(2)}" if match else str(size or "")
 
 
-def package_entry(flags: dict) -> dict:
-    """The public package fields of one status entry (#424): the pip names
-    that cannot be imported, the install command and note (strings or null)."""
-    missing = flags.get("missing_packages") or []
-    text = {
-        key: flags[key] if isinstance(flags.get(key), str) else None
-        for key in ("install_command", "install_note")
-    }
-    return {"missing_packages": [str(name) for name in missing], **text}
-
-
 def public_models(status: dict, loaded_type: Optional[str]) -> dict:
     """Each engine model's public entry: names and sizes from ``MODELS``, the
     flags from ``status``; never a path (``model_path`` is dropped)."""
@@ -133,7 +122,6 @@ def public_models(status: dict, loaded_type: Optional[str]) -> dict:
         for key in ("model_exists", "mmproj_exists"):
             if key in flags:
                 entry[key] = bool(flags[key])
-        entry.update(package_entry(flags))
         models[model_type] = entry
     return models
 
@@ -762,7 +750,6 @@ class AutotagRoutesMixin:
                     "downloaded": bool(
                         (status.get(model_type) or {}).get("downloaded")
                     ),
-                    **package_entry(status.get(model_type) or {}),
                 },
                 "existing": existing,
                 "review_required": existing == "replace_after_review",
@@ -1086,8 +1073,8 @@ class AutotagRoutesMixin:
         return self.db.current_image_tags({locator: fingerprint}).get(locator, [])
 
     async def _suggest_single(self, target, model_type, options, base):
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
-        from .annotation_suggest import model_refusal
+        from ..autotag import MODELS, get_autotag_service
+        from .annotation_suggest import unavailable_message
         from .annotations import _pinned_suggestions, _settled, _submit
 
         try:
@@ -1097,8 +1084,8 @@ class AutotagRoutesMixin:
 
         service = get_autotag_service()
         status = await self._run_in_executor(service.get_models_status)
-        message = model_refusal(status, model_type, MODELS[model_type]["name"])
-        if message is not None:
+        if not (status.get(model_type) or {}).get("downloaded"):
+            message = unavailable_message(MODELS[model_type]["name"])
             return self._coded_error(409, "model-unavailable", message)
         owner = model_gate.new_owner("legacy-single")
         if not model_gate.try_acquire(owner):
@@ -1144,9 +1131,6 @@ class AutotagRoutesMixin:
                     options,
                     on_skipped=functools.partial(store.release_use, capture.token),
                 )
-            except MissingBackendPackages as exc:
-                # A package gone since the status read (load_model logged it).
-                return self._coded_error(409, "model-unavailable", str(exc))
             finally:
                 store.release(capture.token)
         finally:

py/api/backup_restore.py

@@ -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."""
 

py/api/collections.py

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

py/api/duplicate_files.py

@@ -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')} "

py/api/duplicate_spellings.py

@@ -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)]

py/api/history.py

@@ -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)

py/api/image_categories.py

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

py/api/image_tag_jobs.py

@@ -42,7 +42,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 (
@@ -58,9 +58,7 @@ from .annotations import (
 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,
@@ -195,17 +193,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:
@@ -512,8 +506,10 @@ class ImageTagJobsMixin:
             )
         )
         label = MODELS[model_type]["label"]
-        message = model_refusal(status, model_type, label)
-        if message is not None:
+        if not (status.get(model_type) or {}).get("downloaded"):
+            message = (
+                f"{label} is not downloaded. Download it in System › Auto-tagging."
+            )
             return None, _refusal(409, "model-unavailable", message)
         if backup_on and short is not None:
             return None, _refusal(507, "insufficient-space", short_space_message(short))
@@ -689,8 +685,6 @@ class ImageTagJobsMixin:
             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:
@@ -790,13 +784,13 @@ class ImageTagJobsMixin:
 
     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 +802,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)

py/api/images.py

@@ -18,7 +18,7 @@ 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
@@ -58,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,17 +78,13 @@ try:
         reveal_in_file_manager,
     )
 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,
     )
@@ -112,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:
@@ -586,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:
@@ -824,53 +800,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.
 
@@ -1127,9 +1056,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()
@@ -1143,10 +1071,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")
@@ -1169,8 +1095,7 @@ 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",
     }
 
 
@@ -1188,8 +1113,6 @@ LISTING_FILTER_KEYS = frozenset(
         "media",
         "sort",
         "favorites",
-        # A collection page's filter (#331): bulk actions act on its members.
-        "collection",
     }
 )
 MAX_LISTING_FILTER_VALUE = 2048
@@ -1246,29 +1169,22 @@ def _admitted_entries(
     entries: list,
     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.
 
-    *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. *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
     exact = filters.get("path", "")
@@ -1281,18 +1197,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
@@ -1309,9 +1219,8 @@ def _filtered_page(
     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,
 ) -> tuple[int, list, int | None]:
     """Count the *entries* the filters admit and take *size* from *start* on.
 
@@ -1321,7 +1230,7 @@ def _filtered_page(
     """
     total, page, positives = 0, [], set()
     for position, entry, match in _admitted_entries(
-        entries, filters, links, members, image_tags, own_categories
+        entries, filters, links, favorites, image_tags
     ):
         total += 1
         if match is not None:
@@ -2025,7 +1934,6 @@ class ImageRoutesMixin:
                         filters["category"],
                         filters["tags"],
                         filters["favorites"],
-                        filters["collection"],
                     ]
                 ).encode()
             ).hexdigest()
@@ -2036,19 +1944,17 @@ class ImageRoutesMixin:
         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
@@ -2264,10 +2170,9 @@ class ImageRoutesMixin:
         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
@@ -2297,9 +2202,11 @@ 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
 
@@ -2308,16 +2215,10 @@ class ImageRoutesMixin:
     ) -> tuple:
         """The ordered entries and what admits them (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
+        Returns ``(entries, key, links, image_tags, favorites)``: the listing in
+        the filters' order, its keyset key, and the link, image-tag and favorite
+        maps _admitted_entries reads. One SELECT (get_image_link_matches) reads
+        every linked positive when *read_links*. 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
@@ -2329,10 +2230,10 @@ class ImageRoutesMixin:
             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":
@@ -2346,13 +2247,6 @@ 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:
@@ -2396,37 +2290,10 @@ class ImageRoutesMixin:
             def key(entry):
                 return _workspace_key(entry, order)
 
-        return (
-            entries,
-            key,
-            links,
-            image_tags,
-            self._workspace_members(listings, filters),
-            own,
+        favorites = (
+            self._workspace_favorite_paths(listings) if filters["favorites"] else None
         )
-
-    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
+        return entries, key, links, image_tags, favorites
 
     def _select_workspace_page(
         self,
@@ -2455,7 +2322,7 @@ class ImageRoutesMixin:
             or bool(filters["tags"])
             or order == "rating"
         )
-        entries, key, links, image_tags, members, own = self._workspace_admission(
+        entries, key, links, image_tags, favorites = self._workspace_admission(
             listings, filters, read_links=needed or after is None
         )
         start = 0
@@ -2466,7 +2333,7 @@ class ImageRoutesMixin:
             else:
                 start = bisect_right(entries, after, key=key)
         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
@@ -2488,12 +2355,12 @@ class ImageRoutesMixin:
 
         The links are read strictly: the positives must be the listing's own.
         """
-        entries, _key, links, image_tags, members, own = self._workspace_admission(
+        entries, _key, links, image_tags, favorites = 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
+            entries, filters, links, favorites, image_tags
         ):
             if len(targets) == cap:
                 return ListingSelection(targets, list(positives), unlinked, True)
@@ -2515,11 +2382,9 @@ class ImageRoutesMixin:
     ) -> ListingSelection:
         """The images a parse_listing_filter result admits right now (#392).
 
-        Raises ValueError for a root outside the current roots,
+        Raises ValueError for a root outside the current roots, and
         ListingSourceChanged when the filter's ``root_scope`` no longer names
-        its root (the sources were renumbered since the listing), and
-        CollectionMissing when its ``collection`` no longer exists (checked
-        before any scan and again after the members are read).
+        its root (the sources were renumbered since the listing).
         """
         output_dirs = list(self._get_all_output_dirs())
         root_index = _workspace_root(params, output_dirs)
@@ -2529,11 +2394,11 @@ class ImageRoutesMixin:
                 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)
+        listings = [
+            (index, root, await self._get_gallery_files(root))
+            for index, root in enumerate(output_dirs)
+            if root_index is None or index == root_index
+        ]
         return await self._run_in_executor(
             self._select_workspace_matches, listings, filters, cap
         )
@@ -3718,58 +3583,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]] = {}
@@ -3847,25 +3679,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
@@ -3928,19 +3752,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 = {

py/api/inspection_service.py

@@ -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": {

py/api/jobs.py

@@ -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"

py/api/logging_routes.py

@@ -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(
                 {

py/api/media_target.py

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

py/api/prompts.py

@@ -1227,9 +1227,7 @@ class PromptRoutesMixin:
         """
         from .images import (
             MAX_LISTING_SELECTION,
-            CollectionMissing,
             ListingSourceChanged,
-            collection_not_found,
             parse_listing_filter,
         )
 
@@ -1254,8 +1252,6 @@ class PromptRoutesMixin:
                 },
                 status=409,
             )
-        except CollectionMissing:
-            return collection_not_found()
         except ValueError as exc:
             return refused(str(exc))
         if selection.truncated:

py/api/review.py

@@ -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)

py/api/review_recording.py

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

py/api/thumbnail_auto.py

@@ -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"

py/autotag.py

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

py/lora_import.py

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

requirements-dev.txt

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

tests/browser/classic-node.spec.mjs

@@ -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';});

tests/browser/concept-inventory.mjs

@@ -187,33 +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();
-    };
-}
-
 /**
  * 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)
@@ -642,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)};

tests/browser/focused-node.spec.mjs

@@ -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});

tests/browser/full-inspector.spec.mjs

@@ -136,8 +136,7 @@ test('panel matches the concept order and copy',async({page,request})=>{
     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).
     await expect(panel.locator('.detail-inner > .tags').last().locator('span.chip')).toHaveText(['fixture','geometric']);
@@ -186,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;
@@ -724,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([
@@ -746,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);

tests/browser/history-concept.spec.mjs

@@ -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)=>{

tests/browser/images-concept.spec.mjs

@@ -85,17 +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};
     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=>{
@@ -165,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. */
@@ -288,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')))};
@@ -472,117 +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');
 });
 
-/** #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)=>{

tests/browser/inspector-concept.spec.mjs

@@ -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} 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,18 +38,14 @@ 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 and D146); 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.
@@ -118,7 +112,6 @@ async function openProductionPanel(page,theme) {
  */
 async function plainViewerChips(page) {
     const restoreTargets=await mutate(page,{css:D34_COARSE_TARGETS});
-    const restoreSource=await withChipSource(page,'#viewer-details',ORIGIN);
     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;
@@ -133,7 +126,7 @@ async function plainViewerChips(page) {
     return async()=>{
         await page.evaluate(()=>{for(const [span,button] of window.__plainChips)span.replaceWith(button);delete window.__plainChips;
             window.__summaryButton.remove();delete window.__summaryButton;});
-        await restoreSource();await restoreTargets();
+        await restoreTargets();
     };
 }
 
@@ -169,11 +162,7 @@ async function viewerOf(page,concept,mutation=null) {
     return {viewerDetails,viewerPlain,fileControls};
 }
 async function inventory(page,concept=false) {
-    // D146: the concept panel's category chip with its visible origin, laid out by the concept page itself.
-    const restoreSource=concept?await withChipSource(page,'#image-inspector',ORIGIN):null;
-    if(concept)await settle(page);
     const {panel}=await inspectorOf(page);
-    await restoreSource?.();
     const {viewerDetails,viewerPlain,fileControls}=await viewerOf(page,concept);
     return concept?{panel,viewerDetails,viewerPlain,fileControls}:{panel,viewerDetails,fileControls};
 }
@@ -239,8 +228,7 @@ async function productionSendOf(page,context) {
 async function tagOf(page) {
     const before=await page.locator('#result-count').textContent();
     await panelOf(page).locator('.detail-inner > .tags').last().getByRole('button',{name:'cinematic',exact:true}).click();
-    // Production's caption reads "Loading images…" until the tag's listing answers (#391); the concept's search is instant.
-    await expect.poll(async()=>{const text=await page.locator('#result-count').textContent();return text!==before&&text!=='Loading images…';}).toBe(true);
+    await expect.poll(()=>page.locator('#result-count').textContent()).not.toBe(before);
     await settle(page);
     return {count:await page.locator('#result-count').textContent(),
         cards:await page.locator(`${CARDS} .image-open`).evaluateAll(nodes=>nodes.map(node=>node.getAttribute('aria-label')))};
@@ -299,8 +287,7 @@ 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']);
 
     expect.soft(diff,'differences after the recorded deviations').toEqual([]);
@@ -334,34 +321,13 @@ test('a recipe-linked image without recipe metadata shows its positive prompt me
     await expect(panelOf(page).locator('.panel-heading h2')).toHaveText('Quiet geometry');
     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 · prompt']);
+    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: ');
-    // D146 (#332): the visible origin names where the value came from.
-    await expect(rows.first().locator('.chip .chip-source')).toHaveText(' · prompt');
     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']);
 });
 
-// #391: a tag chip replaces the collection; until its listing answers the caption says it is loading, never that the
-// filter matched nothing ("0 of 0 images" was painted before the response and read by a fast reader).
-test('a tag chip collection reads as loading, not empty, until its listing answers (#391)',async({page})=>{
-    await page.setViewportSize({width:1600,height:1100});
-    await openProductionPanel(page,'dark');
-    let release,arrived;
-    const held=new Promise(resolve=>{release=resolve;}),reached=new Promise(resolve=>{arrived=resolve;});
-    await page.route(url=>url.pathname==='/prompt_manager/images/output'&&url.searchParams.get('tags')==='cinematic',
-        async route=>{arrived();await held;await route.continue();},{times:1});
-    const count=page.locator('#result-count');
-    await panelOf(page).locator('.detail-inner > .tags').last().getByRole('button',{name:'cinematic',exact:true}).click();
-    await reached;
-    await expect(count).toHaveText('Loading images…');
-    await expect(page.locator(CARDS)).toHaveCount(0);
-    release();
-    await expect(count).toHaveText(countCopy('8 of 8 images · 2 positive prompts'));
-    await expect(page.locator(CARDS)).toHaveCount(8);
-});
-
 // Task C3 (D88, #249 PR C): the concept's chip row is the image's own tags (`i.tags`, app.js a402). With those names
 // saved as the file's current image tags, production draws the row from them (Tags filter buttons in the panel, plain
 // in the viewer, the linked positive's equal tags not repeated) and still equals the concept, in both sizes.
@@ -414,13 +380,6 @@ test('inspector comparison detects mutations',async({page})=>{
     expect(()=>assertInspectorMatch(reference,withoutSummary,viewport)).toThrow(/viewerDetails\.structure\.inner/);
     assertInspectorMatch(reference,await viewerMutated(),viewport);
 
-    // 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/);

tests/browser/legacy-autotag.spec.mjs

@@ -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.
@@ -114,6 +171,25 @@ test('admin review opens the first image', async ({ page }) => {
     await expect(page.getByText('Failed to start review mode')).toHaveCount(0);
 });
 
+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();
+    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();
+});
+
 /** 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.

tests/browser/legacy-system-links.spec.mjs

@@ -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');
-    }
-});

tests/browser/pair-node.spec.mjs

@@ -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);

tests/browser/server.py

@@ -47,7 +47,6 @@ from tests.browser.workspace_library_editor_fixture import (
 from tests.browser.workspace_vocabulary_fixture import register_vocabulary_commands
 from tests.browser.workspace_tagging_fixture import register_tagging_commands
 from tests.browser.workspace_review_fixture import register_review_commands
-from tests.browser.workspace_collections_fixture import register_collections_commands
 from tests.browser.workspace_diagnostics_fixture import (
     register_diagnostics_commands,
     repoint_logs,
@@ -76,8 +75,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
@@ -85,13 +82,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
         }
@@ -233,7 +227,6 @@ def create_app(root: Path) -> web.Application:
     register_vocabulary_commands(routes, api, root)
     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)
@@ -269,15 +262,12 @@ def create_app(root: Path) -> web.Application:
         with target.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",

tests/browser/shell-concept.spec.mjs

@@ -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]]);

tests/browser/unseen-restore.mjs

@@ -1,54 +0,0 @@
-// A restore the open workspace page has not noticed yet (#413).
-//
-// Specs that restore through the API while a page is open check what the page does with a restore it did not see:
-// its next write is refused as "Prompt storage was restored since this dialog opened". But the page's Activity store
-// reads the job list every 15 s (activity-store.mjs POLL_MS), and a read the server answers while the restore job runs
-// makes the page follow it: when it finishes, the page is shown again from the restored data (S9, index.mjs
-// onRestoreFinished), which closes any open dialog. On a slow runner a restore can take longer than the time left to
-// the next read (CI run 40646112668: the restore took 16 s), so whether the page saw it depended on timing.
-//
-// `armUnseenRestores(page)`, before the page loads, passes every job-list read of the page through one route, so it
-// knows which reads the server has not answered yet. `unseenRestore(page, restoring)` then closes the gate, waits
-// for those reads' answers (sent before the restore began, they cannot list it), runs `restoring()`, and only after
-// it has answered lets the held reads go on: they read the restore as already ended, as a tab that read its job list
-// just before and just after the restore does. A restore that is never seen running never reloads the page.
-const JOBS = '**/prompt_manager/jobs';
-const gates = new WeakMap();
-
-/** Route `page`'s job-list reads through the restore gate. Call before the page's first navigation. */
-export async function armUnseenRestores(page) {
-    const gate = { closed: null, inFlight: 0, idle: [] };
-    gates.set(page, gate);
-    await page.route(JOBS, async route => {
-        if (gate.closed) {
-            await gate.closed;
-            return route.fallback();
-        }
-        gate.inFlight += 1;
-        try {
-            const response = await route.fetch();
-            await route.fulfill({ response }).catch(() => {});
-        } catch {
-            await route.abort().catch(() => {});
-        } finally {
-            gate.inFlight -= 1;
-            if (gate.inFlight === 0) for (const resolve of gate.idle.splice(0)) resolve();
-        }
-    });
-}
-
-/** Run `restoring()` (an API restore) unseen by `page`'s Activity store; resolves with what it resolves with. */
-export async function unseenRestore(page, restoring) {
-    const gate = gates.get(page);
-    if (!gate) throw new Error('armUnseenRestores(page) must run before the page loads');
-    let open;
-    gate.closed = new Promise(resolve => { open = resolve; });
-    try {
-        // Reads already on their way were sent before the restore: their answers cannot list it.
-        if (gate.inFlight > 0) await new Promise(resolve => gate.idle.push(resolve));
-        return await restoring();
-    } finally {
-        gate.closed = null;
-        open();
-    }
-}

tests/browser/vocabulary-canonical-comparison.mjs

@@ -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}};
 }

tests/browser/vocabulary-visual.spec.mjs

@@ -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([]);
-});

tests/browser/workflows.spec.mjs

@@ -104,6 +104,33 @@ 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 }) => {
@@ -199,7 +226,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 +246,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 +292,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 +401,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);
+});

tests/browser/workspace-collections.spec.mjs

@@ -1,493 +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();
-});

tests/browser/workspace-history.spec.mjs

@@ -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,30 +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);
 });
 
-// #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);}}});});

tests/browser/workspace-images.spec.mjs

@@ -1988,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 }) => {
@@ -2275,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.
@@ -2312,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)));
@@ -2328,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');
     }
@@ -2595,20 +2381,24 @@ test('all matching sets the category through the listing filter and survives a r
     // 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.');
+    // No match linked (a stubbed answer): the nothing-linked sentence, and the selection stays.
+    await page.route('**/prompt_manager/bulk/category', route => route.fulfill({ json: { success: true, updated_count: 0, prompt_count: 0, skipped: 202 } }), { times: 1 });
+    const categorize = page.getByRole('dialog', { name: 'Categorize selected images', exact: true });
+    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
+    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
+    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
+    await expect(toast(page)).toHaveText("None of the selected images is linked to a saved prompt, so there is no prompt category to set.");
     await expect(selectedCount(page)).toHaveText('All 202 matching selected');
-    // The real write: one 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' } }]);
+    // The real write: one request with the filter, every matching image's positive changes.
+    await bulkbar(page).getByRole('button', { name: 'Set category', exact: true }).click();
+    await categorize.getByRole('textbox', { name: 'Category', exact: true }).fill('Bulk392');
+    const posted = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === '/prompt_manager/bulk/category');
+    await categorize.getByRole('button', { name: 'Apply', exact: true }).click();
+    expect((await posted).postDataJSON()).toEqual({ images_filter: { sort: 'newest' }, category: 'Bulk392' });
+    await expect(toast(page)).toHaveText(/^Category set on \d+ prompts?\.$/);
     await expect(bulkbar(page)).toBeEmpty();
     const filtered = await (await request.get('/prompt_manager/images/output?mode=workspace&limit=1&category=Bulk392')).json();
     expect(filtered.total).toBe(202);
-    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');
@@ -2636,12 +2426,10 @@ test('all matching over 10,000 images says so before any dialog or request', asy
     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.']]) {
+    page.on('request', item => { if (item.method() === 'POST') posted += 1; });
+    for (const action of ['Set category', 'Add tags', 'Auto-tag selected']) {
         await bulkbar(page).getByRole('button', { name: action, exact: true }).click();
-        await expect(toast(page)).toHaveText(sentence);
+        await expect(toast(page)).toHaveText('Narrow the view to at most 10,000 images.');
         await expect(page.locator('dialog[open]')).toHaveCount(0);
     }
     expect(posted).toBe(0);

tests/browser/workspace-library-editor.spec.mjs

@@ -1,7 +1,6 @@
 import {writeFile} from 'node:fs/promises';
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
 import {inventoryOf,mapConcept,diffInventory} from './library-editor-canonical-comparison.mjs';
 
@@ -14,7 +13,7 @@ const RATINGS=[['5','5 / 5'],['4','4 / 5'],['3','3 / 5'],['2','2 / 5'],['1','1 /
 const editorDialog=page=>page.locator('dialog.library-editor');
 
 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);
+    await startCoverage(page,browserName);
     const reset=await request.post('/__test__/library-editor/reset',{data:{}});await expect(reset).toBeOK();page.fixture=await reset.json();
     page.editorErrors=[];page.on('pageerror',error=>page.editorErrors.push(error.message));
     page.writes=[];page.on('request',item=>{if(item.method()!=='GET')page.writes.push({method:item.method(),url:new URL(item.url()).pathname,body:item.postDataJSON()});});
@@ -261,8 +260,7 @@ test('recovery states render inline and never replay a write',async({page,reques
     page.writes.length=0;
     dialog=await openEditor(page,{mode:'new'});await ready(dialog);
     const snapshot=await request.get('/__test__/library-editor/snapshot');await expect(snapshot).toBeOK();
-    const buffer=await snapshot.body();
-    const restore=await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer}}}));
+    const restore=await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:await snapshot.body()}}});
     await expect(restore).toBeOK();page.writes.length=0;
     await field(dialog,'Title').fill('After restore');await field(dialog,'Positive prompt').fill('Restored storage prompt');await button(dialog,'Save').click();
     await expect(note(dialog)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was saved.');
@@ -590,7 +588,7 @@ test('saved refresh failure retries only reads',async({page})=>{
 
 test('restored storage after a confirmed save or before an archive offers an explicit Library reload',async({page,request})=>{
     const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
     await openHistory(page,f.positive_id);
     await page.route(`**/prompt_manager/library/${f.positive_id}`,async route=>{
         if(route.request().method()!=='PATCH')return route.continue();
@@ -617,7 +615,7 @@ test('restored storage after a confirmed save or before an archive offers an exp
 const DISCARDS='Leaving this dialog discards your entries.';
 test('restored storage before an Edit or Add negative save offers only the Library reload exit',async({page,request})=>{
     const f=page.fixture;const snapshot=await(await request.get('/__test__/library-editor/snapshot')).body();
-    const restore=()=>unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}}));
+    const restore=()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'editor.db',mimeType:'application/octet-stream',buffer:snapshot}}});
     await openHistory(page,f.positive_id);
     await page.getByRole('button',{name:'Edit metadata',exact:true}).click();let dialog=editorDialog(page);await ready(dialog);
     await expect(await restore()).toBeOK();

tests/browser/workspace-saved-views.spec.mjs

@@ -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');

tests/browser/workspace-system-backups.spec.mjs

@@ -47,17 +47,6 @@ async function serverJson(request, url) {
     return response.json();
 }
 
-/**
- * The restore job's own end (#361): its progress stream closes when the job takes its final state, however long the
- * disk-bound publish takes (bounded by the test, not by a 5 s expect), and the job finished. The toast the page shows
- * for it is then the page's reaction alone, checked with the default timeout.
- */
-async function restoreFinished(request, id) {
-    await expect(await request.get(`/prompt_manager/jobs/${id}/events`)).toBeOK();
-    const { job } = await serverJson(request, `/prompt_manager/jobs/${id}`);
-    expect([job.kind, job.state]).toEqual(['restore', 'finished']);
-}
-
 async function openBackups(page) {
     // A fresh page each time: the drafts live for the page session (Q10), and a hash-only goto would not reload.
     if (page.url().endsWith('#/system/backups')) await page.reload();
@@ -227,7 +216,6 @@ test('Restore starts the job, opens Activity; views reload after it finishes', a
     const { job } = await (await applied).json();
     expect([job.kind, job.title, job.cancellable]).toEqual(['restore', 'Database restore', false]);
     await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    await restoreFinished(request, job.id);
     await expect(toast(page)).toHaveText(/^Database restore finished · Restored \d+ prompts?, /);
     // The library is the backup's again, and the page says so without a reload: the sidebar counts were read again.
     expect(await libraryTotal(request)).toBe(restoredTotal);
@@ -256,8 +244,7 @@ test('a finished restore shows the open page again from the restored data', asyn
     const card = page.locator('#workspace-main article.prompt-card').filter({ hasText: 'S9 prompt the restore removes' });
     await expect(card).toHaveCount(1);
     await expect(await request.post('/__test__/release')).toBeOK();
-    const { job } = await (await applied).json();
-    await restoreFinished(request, job.id);
+    await applied;
     await expect(toast(page)).toHaveText(/^Database restore finished · /);
     // The shelf was read again from the restored library, on the same route.
     await expect(card).toHaveCount(0);
@@ -395,15 +382,14 @@ test('a failed settings read leaves the policy disabled with the reason', async
     await expect(row.locator('input')).toBeDisabled();
 });
 
-test('the legacy Backup and Restore routes keep working and the admin page links to System', async ({ page, request }) => {
+test('the legacy admin Backup and Restore keep working', async ({ page, request }) => {
     const bytes = await backupBytes(request);
     const restored = await request.post('/prompt_manager/restore', { multipart: { database_file: {
         name: 'prompts_backup.db', mimeType: 'application/octet-stream', buffer: bytes } } });
     await expect(restored).toBeOK();
     expect((await restored.json()).success).toBe(true);
-    // #330: the admin page's Backup DB and Restore DB open System › Backup & export.
     await page.goto('/prompt_manager/admin');
-    for (const id of ['#backupBtn', '#restoreBtn']) await expect(page.locator(id)).toHaveAttribute('href', 'workspace#/system/backups');
+    await expect(page.locator('#restoreFileInput')).toHaveCount(1);
 });
 
 /** Start a fake running job (a metadata scan another tab started), which an exclusive restore must wait for. */
@@ -436,7 +422,6 @@ test('a refused restore reopens its review: Restore retries it, Discard releases
     await dialog(page).getByRole('button', { name: 'Restore', exact: true }).click();
     const { job } = await (await applied).json();
     await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    await restoreFinished(request, job.id);
     await expect(toast(page)).toHaveText(/^Database restore finished · /);
     expect(await stagesOf(request)).toBe(0);
 });

tests/browser/workspace-system-diagnostics.spec.mjs

@@ -516,7 +516,7 @@ test('a rollover after the review deletes nothing and Activity offers Review aga
 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()); });
+    page.on('request', item => { if (item.url().endsWith('/prompt_manager/logs/truncate')) truncates.push(item.url()); });
     await openDiagnostics(page);
     await expect(lines(page)).toContainText('Database backup verified');
     const details = await openFiles(page);
@@ -535,10 +535,6 @@ test('Clear all logs states both counts, confirms first and reads everything aga
     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$/);
@@ -568,23 +564,6 @@ test('Clear all logs reads the files again before it states what it deletes', as
     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);

tests/browser/workspace-system-tagging.spec.mjs

@@ -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();

tests/browser/workspace-system.spec.mjs

@@ -472,7 +472,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 {

tests/browser/workspace-tagging-bulk.spec.mjs

@@ -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);

tests/browser/workspace-tagging.spec.mjs

@@ -260,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');

tests/browser/workspace-vocabulary.spec.mjs

@@ -1,7 +1,6 @@
 import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
 import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores,unseenRestore} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
 import {pageInventoryOf,inventoryOf,diffInventory,mapVocabularyConcept,mapVocabularyDialog} from './vocabulary-canonical-comparison.mjs';
 
@@ -41,7 +40,7 @@ async function expectLibrary(page,{tags='',category='',count}) {
 
 let manifest;
 test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);manifest=await seed(request);
+    await startCoverage(page,browserName);manifest=await seed(request);
     page.vocabularyErrors=[];page.on('pageerror',error=>page.vocabularyErrors.push(error.message));
 });
 test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.vocabularyErrors).toEqual([]);});
@@ -265,8 +264,7 @@ const toast=page=>page.locator('#workspace-toast');
 const actionNames=scope=>scope.locator('.dialog-actions button').evaluateAll(nodes=>nodes.map(node=>node.textContent.trim()));
 const snapshot=async request=>{const response=await request.get('/__test__/vocabulary/snapshot');await expect(response).toBeOK();return response.json();};
 const backup=async request=>{const response=await request.get('/__test__/vocabulary/backup');await expect(response).toBeOK();return response.body();};
-// A restore the open page has not seen, so its dialog stays to report it (#413).
-const restore=async(page,request,buffer)=>expect(await unseenRestore(page,()=>request.post('/prompt_manager/restore',{multipart:{database_file:{name:'vocabulary.db',mimeType:'application/octet-stream',buffer}}}))).toBeOK();
+const restore=async(request,buffer)=>expect(await request.post('/prompt_manager/restore',{multipart:{database_file:{name:'vocabulary.db',mimeType:'application/octet-stream',buffer}}})).toBeOK();
 const tagNames=rows=>rows.tags.map(([,name])=>name);
 function trackWrites(page) {
     const writes=[];page.on('request',item=>{if(item.method()!=='GET')writes.push({method:item.method(),url:new URL(item.url()).pathname,body:item.postDataJSON()});});return writes;
@@ -383,62 +381,6 @@ test('manage categories previews real impact before applying',async({page,reques
     expect(after.prompts.filter(row=>row[2]==='Scenery')).toHaveLength(3);
 });
 
-// #332 MC9, MC10: image categories (their own, set on Images) count beside the prompts. The vocabulary fixture has no
-// image files, so these tests add two committed files to the output folder and set their categories through the API.
-async function imageCategories(request,category) {
-    for(const name of ['f02.png','f03.png']) await expect(await request.post('/__test__/add-local-inspect-file',{data:{name}})).toBeOK();
-    const listing=await(await request.get('/prompt_manager/images/output?mode=workspace&subfolder=local-inspect&limit=40')).json();
-    const items=listing.images.map(({root_index,root_scope,path})=>({root_index,root_scope,path}));expect(items).toHaveLength(2);
-    const response=await request.put('/prompt_manager/images/category',{data:{items,category}});await expect(response).toBeOK();
-    expect((await response.json()).updated).toBe(2);
-}
-const ownCategories=async request=>(await(await request.get('/prompt_manager/images/categories')).json()).categories;
-const IMAGE_KEYS=['0:local-inspect/f02.png','0:local-inspect/f03.png'];
-
-test('manage categories renames the images\' own categories too and the preview counts them (#332 CUJ 6)',async({page,request})=>{
-    await imageCategories(request,'Landscapes');
-    const writes=trackWrites(page);await openPage(page);
-    await expect(categoryRow(page,'Landscapes').locator('p')).toHaveText('3 positive prompts · 2 images');
-    const box=await openManage(page);
-    await expect(field(box,'Category')).toHaveValue('Landscapes');
-    await field(box,'Proposed new category name').fill('Landscape');await button(box,'Preview').click();
-    await expect(box.locator('p.small')).toHaveText('“Landscapes” is used by 3 positive prompts and 2 images. Apply renames it to “Landscape”.');
-    await button(box,'Apply').click();
-    await expect(box).toHaveCount(0);await expect(toast(page)).toHaveText('Category renamed.');
-    expect(writes.at(-1)).toMatchObject({url:'/prompt_manager/vocabulary/categories/apply',body:{source:'Landscapes',target:'Landscape'}});
-    await expect(categoryRow(page,'Landscapes')).toHaveCount(0);
-    await expect(categoryRow(page,'Landscape').locator('p')).toHaveText('3 positive prompts · 2 images');
-    // The prompts and both images carry the new name; nothing keeps the old one.
-    expect((await snapshot(request)).prompts.filter(row=>row[2]==='Landscape')).toHaveLength(3);
-    expect(await ownCategories(request)).toEqual(['Landscape']);
-    for(const [category,total] of [['Landscape',2],['Landscapes',0]]) {
-        const listing=await(await request.get(`/prompt_manager/images/output?mode=workspace&limit=40&category=${category}`)).json();
-        expect(listing.images.map(image=>`${image.root_index}:${image.path}`).sort()).toEqual(total?IMAGE_KEYS:[]);
-    }
-});
-
-test('a category only images hold is listed after the prompt-backed ones and Browse opens Images (#332 CUJ 7)',async({page,request})=>{
-    await imageCategories(request,'Scans');
-    await openPage(page);
-    const operations=surfaces(page).nth(1).locator('.operation');
-    await expect(operations.locator('h3')).toHaveText([...CATEGORIES.map(([name])=>name),'Scans','Manage category']);
-    await expect(categoryRow(page,'Scans').locator('p')).toHaveText('2 images');
-    for(const [name,count] of CATEGORIES) await expect(categoryRow(page,name).locator('p')).toHaveText(`${count} positive prompt${count===1?'':'s'}`);
-    // Manage category can rename it: its select lists it last.
-    const box=await openManage(page);
-    await expect(field(box,'Category').locator('option')).toHaveText([...CATEGORIES.map(([name])=>name),'Scans']);
-    await button(box,'Cancel').click();await expect(box).toHaveCount(0);
-    // Browse opens Images filtered by it (its Library would be empty).
-    await categoryRow(page,'Scans').getByRole('button',{name:'Browse',exact:true}).click();
-    await expect(page).toHaveURL(/#\/images$/);
-    await expect(main(page).getByRole('heading',{level:1})).toHaveText('Images');
-    await expect(page.getByRole('combobox',{name:'Filter by category',exact:true})).toHaveValue('Scans');
-    const cards=page.locator('article[data-image-key]');await expect(cards).toHaveCount(2);
-    expect((await cards.evaluateAll(nodes=>nodes.map(node=>node.dataset.imageKey))).sort()).toEqual(IMAGE_KEYS);
-    await expect(page.getByRole('searchbox',{name:'Search workspace',exact:true})).toHaveValue('');
-    await expect(page.locator('#workspace-main search.toolbar').getByRole('button',{name:'Filters',exact:true})).toBeVisible();
-});
-
 test('an edit during a pending preview needs a new Preview; Apply never sends the old values',async({page,request})=>{
     const writes=trackWrites(page);await openPage(page);const before=await snapshot(request);
     let release;const held=new Promise(resolve=>{release=resolve;});
@@ -540,7 +482,7 @@ test('conflict and restore states keep the dialog and write nothing',async({page
 
     const before=await snapshot(request);
     box=await openDialog(page,main(page).getByRole('button',{name:'+ Create tag',exact:true}),'Create tag');
-    await restore(page,request,saved);
+    await restore(request,saved);
     await field(box,'Tag name').fill('sunrise');await button(box,'Apply').click();
     await expect(note(box)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was changed.');
     await expect(button(box,'Apply')).toBeDisabled();
@@ -680,7 +622,7 @@ test('delete confirmation read failure, missing tag and restore keep Delete disa
     await expect(button(box,'Delete')).toBeDisabled();await expect(tagRow(page,'calm').locator('td:nth-child(2)')).toHaveText('2');
     await button(box,'Cancel').click();
 
-    box=await openRename(page,'mist');await restore(page,request,saved);
+    box=await openRename(page,'mist');await restore(request,saved);
     await button(box,'Delete tag…').click();
     await expect(note(box)).toHaveText('Prompt storage was restored since this dialog opened. Nothing was changed.');
     await expect(button(box,'Delete')).toBeDisabled();expect(await actionNames(box)).toEqual(['Reload','Cancel','Delete']);

tests/browser/workspace.spec.mjs

@@ -548,16 +548,12 @@ test('sidebar matches the concept groups and shows real counts', async ({ page,
     await expect(page.locator('.workspace-shell, .workspace-body, .sidebar-footer, .connection-dot, .workspace-icon')).toHaveCount(0);
     const sidebar = page.locator('aside.sidebar');
     expect(await childShape(sidebar)).toEqual(['a.brand', 'div.sidebar-label', 'nav#primary-nav', 'div.sidebar-label',
-        'nav#saved-nav', 'div.sidebar-label', 'nav#collections-nav', 'div.sidebar-bottom']);
+        'nav#saved-nav', 'div.sidebar-bottom']);
     await expect(sidebar.locator('.brand')).toHaveAttribute('href', '#/images');
-    // D49: SAVED VIEWS without the concept's PROPOSED badge. D136: COLLECTIONS without it either, its label hidden
-    // and its nav empty while no collection exists.
-    await expect(sidebar.locator('.sidebar-label')).toHaveText(['WORKSPACE', 'SAVED VIEWS', 'COLLECTIONS']);
-    await expect(sidebar.locator('.sidebar-label').nth(2)).toBeHidden();
+    // D49: SAVED VIEWS without the concept's PROPOSED badge; D28: still no COLLECTIONS.
+    await expect(sidebar.locator('.sidebar-label')).toHaveText(['WORKSPACE', 'SAVED VIEWS']);
     await expect(page.locator('nav#saved-nav')).toHaveAttribute('aria-label', 'Saved views');
-    await expect(page.locator('nav#collections-nav')).toHaveAttribute('aria-label', 'Collections');
-    await expect(page.locator('nav#collections-nav > a')).toHaveCount(0);
-    await expect(page.locator('.new-label')).toHaveCount(0);
+    await expect(page.locator('#collections-nav, .new-label')).toHaveCount(0);
     const primary = page.locator('nav#primary-nav');
     await expect(primary).toHaveAttribute('aria-label', 'Workspace');
     for (const [id] of NAV_TOTALS) await expect(navCount(page, id)).toHaveText(totals[id].toLocaleString('en-US'));
@@ -584,7 +580,7 @@ test('sidebar matches the concept groups and shows real counts', async ({ page,
     // At phone width the concept wraps the links and hides counts and the connection (concept 950px block).
     await page.setViewportSize({ width: 390, height: 844 });
     await expect(navCount(page, 'library')).toBeHidden();
-    await expect(page.locator('.sidebar-label, .connection')).toHaveCount(4);
+    await expect(page.locator('.sidebar-label, .connection')).toHaveCount(3);
     for (const hidden of await page.locator('.sidebar-label, .connection').all()) await expect(hidden).toBeHidden();
     await expect(primary.locator('a[href="#/inspect"]')).toBeVisible();
 });

tests/browser/workspace_collections_fixture.py

@@ -1,131 +0,0 @@
-"""Owned, deterministic collections for the workspace collection workflows (#331).
-
-Twenty-one PNGs under the output source: twelve listed members of
-"Landscapes", eight of "Experiments" and one loose file in neither. Landscapes
-also holds one member whose file does not exist (MC3: hidden, counted as
-missing). One saved view reopens "Experiments" (D140). Members are added
-through ``ImageCollectionOperations`` with favorites' keys
-(``_favorite_root_key``, ``_favorite_relative_key``), as the routes add them.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-from aiohttp import web
-from PIL import Image
-from tests.browser.folder_trash import replace_folder
-
-if TYPE_CHECKING:
-    from py.api import PromptManagerAPI
-
-FOLDER = "collections"
-LANDSCAPES = "Landscapes"
-EXPERIMENTS = "Experiments"
-LANDSCAPE_FILES = tuple(f"landscape_{index:02d}.png" for index in range(1, 13))
-EXPERIMENT_FILES = tuple(f"experiment_{index:02d}.png" for index in range(1, 9))
-LOOSE_FILE = "loose.png"
-MISSING_FILE = "gone.png"
-SAVED_VIEW = "Experiments view"
-_TABLES = (
-    "image_collection_items",
-    "image_collections",
-    "saved_views",
-    "image_favorites",
-    "media_review_decisions",
-    "media_review_items",
-    "media_image_tags",
-    "media_annotation_bytes",
-    "media_annotation_files",
-    "image_prompt_pairs",
-    "prompt_pair_tags",
-    "prompt_pairs",
-    "generated_images",
-    "prompt_tags",
-    "tags",
-    "prompt_library_state",
-    "prompts",
-)
-_IMAGES_STATE = {
-    "q": "",
-    "category": "",
-    "sort": "newest",
-    "source": "all",
-    "folder": "",
-    "media": "all",
-    "tags": [],
-    "favorites": False,
-}
-
-
-def _write_png(path: Path, shade: int, stamp: float) -> None:
-    with Image.new("RGB", (64, 48), (shade, 120, 255 - shade)) as image:
-        image.save(path)
-    os.utime(path, (stamp, stamp))
-
-
-def seed_collections(api: PromptManagerAPI, root: Path) -> dict:
-    """Replace this server's disposable rows and files with the two collections."""
-    # The API package needs the host stubs the server installs before importing it.
-    from py.api.images import _favorite_relative_key, _favorite_root_key
-
-    db = api.db
-    with db.model.get_connection() as conn:
-        for table in _TABLES:
-            conn.execute(f"DELETE FROM {table}")
-    for name in ("output", "input"):
-        replace_folder(root / name)
-    folder = root / "output" / FOLDER
-    folder.mkdir()
-    # Newest first in this order: Landscapes, then Experiments, then the loose file.
-    now = time.time()
-    ordered = (*LANDSCAPE_FILES, *EXPERIMENT_FILES, LOOSE_FILE)
-    for index, name in enumerate(ordered):
-        _write_png(folder / name, (index * 11) % 256, now - 60 - index * 60)
-    root_key = _favorite_root_key(list(api._get_all_output_dirs())[0])
-    members = {
-        LANDSCAPES: (*LANDSCAPE_FILES, MISSING_FILE),
-        EXPERIMENTS: EXPERIMENT_FILES,
-    }
-    ids = {}
-    for name, files in members.items():
-        added = db.add_to_collection(
-            name=name,
-            items=[
-                (root_key, _favorite_relative_key(f"{FOLDER}/{file}")) for file in files
-            ],
-        )
-        ids[name] = added["collection"]["id"]
-    view = db.create_saved_view(
-        "images", SAVED_VIEW, {**_IMAGES_STATE, "collection": str(ids[EXPERIMENTS])}
-    )
-    api.invalidate_gallery_cache()
-    return {
-        "collections": {
-            LANDSCAPES: {"id": ids[LANDSCAPES], "count": 12, "missing": 1},
-            EXPERIMENTS: {"id": ids[EXPERIMENTS], "count": 8, "missing": 0},
-        },
-        "files": {
-            LANDSCAPES: [f"{FOLDER}/{file}" for file in LANDSCAPE_FILES],
-            EXPERIMENTS: [f"{FOLDER}/{file}" for file in EXPERIMENT_FILES],
-            "loose": f"{FOLDER}/{LOOSE_FILE}",
-        },
-        "saved_view": {"id": view["id"], "name": SAVED_VIEW},
-    }
-
-
-def register_collections_commands(
-    routes: web.RouteTableDef, api: PromptManagerAPI, root: Path
-) -> None:
-    """Register the fixed seed command; no path or SQL comes from a request."""
-
-    @routes.post("/__test__/collections/seed")
-    async def seed(request: web.Request) -> web.Response:
-        data = await request.json() if request.can_read_body else {}
-        if data != {} or request.query:
-            raise web.HTTPBadRequest()
-        manifest = await api._run_in_executor(seed_collections, api, root)
-        return web.json_response({"success": True, **manifest})

tests/browser/workspace_concept_fixture.py

@@ -174,8 +174,6 @@ _TABLES = (
     "execution_contexts",
     "execution_prompt_snapshots",
     "execution_context_texts",
-    "image_collection_items",
-    "image_collections",
     "saved_views",
     "image_favorites",
     "media_review_decisions",
@@ -183,7 +181,6 @@ _TABLES = (
     "media_image_tags",
     "media_annotation_bytes",
     "media_annotation_files",
-    "image_categories",
     "image_prompt_pairs",
     "prompt_pair_tags",
     "prompt_pairs",
@@ -195,10 +192,6 @@ _TABLES = (
 )
 
 
-# The concept's collections and the slice of its images each holds (#331).
-CONCEPT_COLLECTIONS = (("Landscapes", slice(0, 12)), ("Experiments", slice(12, 20)))
-
-
 def concept_starred(prompt_index: int, round_index: int) -> bool:
     """The concept's favorites (app.js ``starred``): each other prompt's first image."""
     return round_index == 0 and prompt_index % 2 == 0
@@ -501,19 +494,6 @@ def seed_workspace_concept(
         )
     images.reverse()
     runs.reverse()
-    # The concept's COLLECTIONS rows (app.js a336–339): "Landscapes" holds the
-    # first 12 images in the concept's order and "Experiments" the next 8, so
-    # the rows and counts compare as the concept shows them (#331 D136).
-    collections = {}
-    for name, members in CONCEPT_COLLECTIONS:
-        added = db.add_to_collection(
-            name=name,
-            items=[
-                (favorite_root, _favorite_relative_key(image["path"]))
-                for image in images[members]
-            ],
-        )
-        collections[name] = added["collection"]["id"]
     seedless = []
     for number in range(seedless_images):
         name = f"seedless_{number + 1:05}.png"
@@ -550,5 +530,4 @@ def seed_workspace_concept(
         "images": images,
         "runs": runs,
         "tags": tags,
-        "collections": collections,
     }

tests/browser/workspace_diagnostics_fixture.py

@@ -123,34 +123,6 @@ def _touch(path: Path, size: int, moment: datetime.datetime) -> None:
     os.utime(path, (stamp, stamp))
 
 
-def _append_active(manager, log_dir: Path, size: int) -> None:
-    """Grow the active log as this process's handler does (#389).
-
-    A second handle appending to the file the handler writes is what Clear
-    all logs refuses as another program writing to it, so the bytes go
-    through the handler's own stream; with file logging off, to the file.
-    """
-
-    def same(path) -> bool:
-        return os.path.normcase(os.path.realpath(path)) == os.path.normcase(
-            os.path.realpath(log_dir / ACTIVE)
-        )
-
-    for handler in manager._file_handlers():
-        stream = getattr(handler, "stream", None)
-        if stream is None or not same(handler.baseFilename):
-            continue
-        handler.acquire()
-        try:
-            stream.write("x" * size)
-            stream.flush()
-        finally:
-            handler.release()
-        return
-    with open(log_dir / ACTIVE, "ab") as handle:
-        handle.write(b"x" * size)
-
-
 def _bounded(value, name, top=MAX_SEED_BYTES):
     if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= top:
         raise web.HTTPBadRequest(text=f"{name} must be an integer 0..{top}")
@@ -197,7 +169,8 @@ def register_diagnostics_commands(app, routes, api, root: Path):
         for index, (time_text, level, message) in enumerate(CONCEPT_RECORDS):
             record = _record(time_text, level, message, index)
             manager.add_to_buffer(record, record.getMessage())
-        _append_active(manager, log_dir, CONCEPT_ACTIVE)
+        with open(log_dir / ACTIVE, "ab") as handle:
+            handle.write(b"x" * CONCEPT_ACTIVE)
         for number, size in enumerate(CONCEPT_ROTATED, start=1):
             moment = ROTATED_TIME - datetime.timedelta(hours=number)
             _touch(log_dir / f"{ACTIVE}.{number}", size, moment)
@@ -221,7 +194,8 @@ def register_diagnostics_commands(app, routes, api, root: Path):
             manager.add_to_buffer(record, record.getMessage())
         active = _bounded(data.get("active", 0), "active")
         if active:
-            _append_active(manager, log_dir, active)
+            with open(log_dir / ACTIVE, "ab") as handle:
+                handle.write(b"x" * active)
         rotated = data.get("rotated", [])
         if not isinstance(rotated, list) or len(rotated) > 20:
             raise web.HTTPBadRequest(text="rotated must be a list of sizes")

tests/browser/workspace_library_editor_fixture.py

@@ -26,8 +26,6 @@ EDITOR_METADATA = {
     "notes": "Keep the soft light.",
 }
 _TABLES = (
-    "image_collection_items",
-    "image_collections",
     "saved_views",
     "image_favorites",
     "media_review_decisions",
@@ -35,7 +33,6 @@ _TABLES = (
     "media_image_tags",
     "media_annotation_bytes",
     "media_annotation_files",
-    "image_categories",
     "image_prompt_pairs",
     "prompt_pair_tags",
     "prompt_pairs",

tests/browser/workspace_review_fixture.py

@@ -78,8 +78,6 @@ LIMITED_SAMPLERS = 17
 # More than one queue page (40), so Load more has a second page.
 MAX_ITEMS = 45
 _TABLES = (
-    "image_collection_items",
-    "image_collections",
     "saved_views",
     "image_favorites",
     "media_review_decisions",
@@ -87,7 +85,6 @@ _TABLES = (
     "media_image_tags",
     "media_annotation_bytes",
     "media_annotation_files",
-    "image_categories",
     "image_prompt_pairs",
     "prompt_pair_tags",
     "prompt_pairs",

tests/browser/workspace_system_fixture.py

@@ -35,8 +35,7 @@ read. These per-server hooks only change what a System test needs on top:
   previews for Convert outdated;
 - ``POST /__test__/system/jxl-encoder`` ``{available}`` (#317) makes the
   server read as having (``cjxl``) or lacking a JPEG XL encoder without
-  probing, whatever the host has installed (#371: ``false`` stands in for the
-  detector itself); reset restores the thumbnail settings and the real detection.
+  probing; reset restores the thumbnail settings and the real detection.
 
 - ``POST /__test__/system/duplicate-prompts`` (S7) adds two prompts whose
   text differs only in case and spacing (a duplicate prompt text group);
@@ -119,11 +118,6 @@ def register_system_commands(app, routes, api, root: Path):
     }
     from py.api import thumbnail_encode
 
-    real_detect = thumbnail_encode._detect
-
-    def _no_encoder():
-        return None
-
     monitor = getattr(image_monitor, "_monitor_instance", None)
     failures: dict[str, int] = {}
 
@@ -153,7 +147,6 @@ def register_system_commands(app, routes, api, root: Path):
         api._health_report = None
         for (owner, name), value in host_values.items():
             setattr(owner, name, value)
-        thumbnail_encode._detect = real_detect
         thumbnail_encode.reset_encoders()
         image_monitor._monitor_instance = monitor
         api.__dict__.pop("_library_resolver", None)
@@ -305,12 +298,7 @@ def register_system_commands(app, routes, api, root: Path):
         available = data.get("available")
         if not isinstance(available, bool):
             raise web.HTTPBadRequest()
-        # Test-only: the fixture, not the host, decides (#371). Without an encoder the
-        # detector itself stands in, so a re-probe (a "none found" is probed again on
-        # every settings read) cannot find the host's real encoder; with one the cached
-        # answer stands, and a failed write still probes the real detector as before.
-        # Reset restores the real detector.
-        thumbnail_encode._detect = real_detect if available else _no_encoder
+        # Test-only: stand in the cached detection (no probe).
         with thumbnail_encode._detect_lock:
             thumbnail_encode._detected = "cjxl" if available else None
         return web.json_response({"success": True})

tests/browser/workspace_tagging_fixture.py

@@ -41,23 +41,9 @@ FILES = (
     ("loose/unlinked.png", "unlinked"),
 )
 MODELS = ("wd14-swinv2", "wd14-vit", "gguf", "hf")
-
-
-def _valid_missing(value) -> bool:
-    """``{"<model>": ["<pip name>", ...]}`` with known models and string names."""
-    return isinstance(value, dict) and all(
-        name in MODELS
-        and isinstance(names, list)
-        and all(isinstance(pip, str) and pip for pip in names)
-        for name, names in value.items()
-    )
-
-
 # Unlinked copies enough to virtualize the Images grid (it renders all up to 120).
 MAX_EXTRA_IMAGES = 160
 _TABLES = (
-    "image_collection_items",
-    "image_collections",
     "saved_views",
     "image_favorites",
     "media_review_decisions",
@@ -65,7 +51,6 @@ _TABLES = (
     "media_image_tags",
     "media_annotation_bytes",
     "media_annotation_files",
-    "image_categories",
     "image_prompt_pairs",
     "prompt_pair_tags",
     "prompt_pairs",
@@ -231,7 +216,6 @@ def register_tagging_commands(
         if not 0 <= extra <= MAX_EXTRA_IMAGES:
             raise web.HTTPBadRequest()
         model.unavailable = set()
-        model.missing_packages = {}
         model.suggestions = None
         model.loaded = None
         restore_download()
@@ -250,41 +234,17 @@ def register_tagging_commands(
 
     @routes.post("/__test__/tagging/models")
     async def models(request: web.Request) -> web.Response:
-        """Mark fake models as not downloaded (``{"unavailable": [...]}``) and,
-        optionally, as missing backend packages (``"missing_packages":
-        {"<model>": ["<pip name>", ...]}``, #424)."""
+        """Mark fake models as not downloaded (``{"unavailable": [...]}``)."""
         data = await request.json() if request.can_read_body else None
         if (
             request.query
             or not isinstance(data, dict)
-            or "unavailable" not in data
-            or set(data) - {"unavailable", "missing_packages"}
+            or set(data) != {"unavailable"}
             or not isinstance(data["unavailable"], list)
             or any(name not in MODELS for name in data["unavailable"])
-            or not _valid_missing(data.get("missing_packages", {}))
         ):
             raise web.HTTPBadRequest()
         model.unavailable = set(data["unavailable"])
-        model.missing_packages = {
-            name: list(names)
-            for name, names in data.get("missing_packages", {}).items()
-        }
-        return web.json_response({"success": True})
-
-    @routes.post("/__test__/tagging/loaded")
-    async def loaded(request: web.Request) -> web.Response:
-        """Mark one fake model loaded (``{"model": "<key>"}``), as a batch that
-        kept it in memory leaves it; ``/autotag/models`` then reports
-        ``model_loaded``. Reset unloads it."""
-        data = await request.json() if request.can_read_body else None
-        if (
-            request.query
-            or not isinstance(data, dict)
-            or set(data) != {"model"}
-            or data["model"] not in MODELS
-        ):
-            raise web.HTTPBadRequest()
-        model.loaded = data["model"]
         return web.json_response({"success": True})
 
     @routes.post("/__test__/tagging/download")

tests/browser/workspace_visual_fixture.py

@@ -112,8 +112,6 @@ def seed_workspace_visual(api: PromptManagerAPI, root: Path) -> None:
     """Replace only the owned browser harness records and media roots."""
     with api.db.model.get_connection() as conn:
         for table in (
-            "image_collection_items",
-            "image_collections",
             "saved_views",
             "image_favorites",
             "media_review_decisions",
@@ -121,7 +119,6 @@ def seed_workspace_visual(api: PromptManagerAPI, root: Path) -> None:
             "media_image_tags",
             "media_annotation_bytes",
             "media_annotation_files",
-            "image_categories",
             "image_prompt_pairs",
             "prompt_pair_tags",
             "prompt_pairs",

tests/browser/workspace_vocabulary_fixture.py

@@ -72,10 +72,6 @@ CONCEPT_RECIPES = (
         "negative": "oversaturated, flat lighting, watermark, text",
     },
 )
-# #332 D143/D144 (opt-in, ``image_categories``): own image categories, one on
-# images only and one shared with prompts. Stored rows count whether or not the
-# files exist, so the keys name files the fixture never writes.
-IMAGE_CATEGORY_ROWS = (("Landscapes", 2), ("Portraits", 1))
 PAIR_ONLY_TAG = "pair_only_detail"
 ARCHIVED_ONLY_TAG = "archived_pair_detail"
 NEGATIVE_ONLY_TAG = "legacy_negative_detail"
@@ -83,8 +79,6 @@ UNUSED_TAG = "unused_vocabulary"
 MAX_EXTRA_TAGS = 300
 MAX_EXTRA_CATEGORIES = 200
 _TABLES = (
-    "image_collection_items",
-    "image_collections",
     "saved_views",
     "image_favorites",
     "media_review_decisions",
@@ -92,7 +86,6 @@ _TABLES = (
     "media_image_tags",
     "media_annotation_bytes",
     "media_annotation_files",
-    "image_categories",
     "image_prompt_pairs",
     "prompt_pair_tags",
     "prompt_pairs",
@@ -118,26 +111,8 @@ _SNAPSHOT = {
 }
 
 
-def _seed_image_categories(api: PromptManagerAPI) -> dict:
-    """Own image category rows keyed as Images keys them; ``{value: count}``."""
-    from py.api.images import image_category_key
-
-    sources = list(api._get_all_output_dirs())
-    for category, count in IMAGE_CATEGORY_ROWS:
-        keys = [
-            image_category_key(sources, str(Path(sources[0]) / f"{category}_{n}.png"))
-            for n in range(count)
-        ]
-        api.db.set_image_categories(keys, category)
-    return dict(IMAGE_CATEGORY_ROWS)
-
-
 def seed_vocabulary(
-    api: PromptManagerAPI,
-    root: Path,
-    extra_tags: int = 0,
-    extra_categories: int = 0,
-    image_categories: bool = False,
+    api: PromptManagerAPI, root: Path, extra_tags: int = 0, extra_categories: int = 0
 ) -> dict:
     """Replace this server's disposable rows with the concept vocabulary."""
     db = api.db
@@ -191,7 +166,6 @@ def seed_vocabulary(
                 "category": f"bulk_category_{number:04}",
             },
         )
-    images = _seed_image_categories(api) if image_categories else {}
     with db.model.get_connection() as conn:
         tags = [row[0] for row in conn.execute("SELECT name FROM tags ORDER BY id")]
     api.invalidate_gallery_cache()
@@ -205,7 +179,6 @@ def seed_vocabulary(
         "archived_only_tag": ARCHIVED_ONLY_TAG,
         "negative_only_tag": NEGATIVE_ONLY_TAG,
         "unused_tag": UNUSED_TAG,
-        "image_categories": images,
     }
 
 
@@ -226,14 +199,7 @@ def register_vocabulary_commands(
     @routes.post("/__test__/vocabulary/reset")
     async def reset(request: web.Request) -> web.Response:
         data = await request.json() if request.can_read_body else {}
-        if not isinstance(data, dict) or set(data) - {
-            "extra_tags",
-            "extra_categories",
-            "image_categories",
-        }:
-            raise web.HTTPBadRequest()
-        images = data.get("image_categories", False)
-        if not isinstance(images, bool):
+        if not isinstance(data, dict) or set(data) - {"extra_tags", "extra_categories"}:
             raise web.HTTPBadRequest()
         extra = data.get("extra_tags", 0)
         categories = data.get("extra_categories", 0)
@@ -248,7 +214,7 @@ def register_vocabulary_commands(
         if request.query:
             raise web.HTTPBadRequest()
         manifest = await api._run_in_executor(
-            seed_vocabulary, api, root, extra, categories, images
+            seed_vocabulary, api, root, extra, categories
         )
         return web.json_response({"success": True, **manifest})
 

tests/comfyui/execution-text-link.spec.mjs

@@ -11,13 +11,13 @@ import { installHostHooks } from './host-fixture.mjs';
 
 // The worker's owned host must be up before the shared host hooks open the page.
 test.beforeEach(async ({ execution }) => { expect(execution.databasePath).toBeTruthy(); });
-installHostHooks(test, ['PromptManager', 'PromptManagerText', 'PromptManagerFocused', 'PromptManagerPair', 'PMHistoryInputs', 'PMCycledText']);
+installHostHooks(test, ['PromptManager', 'PromptManagerText', 'PromptManagerFocused', 'PromptManagerPair', 'PMHistoryInputs']);
 
 // `primitive`: a core string node the queue-time resolver follows. `legacy`: the frontend's virtual Primitive node,
 // whose value is queued as literal text. `preview`: PrimitiveString -> PreviewAny, the shape of the maintainer's
 // TextGenerate -> PreviewAny chain, whose text is only known when the node runs.
-function build(page, { kind, positive, negative, prefix, saveToLibrary }) {
-    return page.evaluate(async ({ kind, positive, negative, prefix, saveToLibrary }) => {
+function build(page, { kind, positive, negative, prefix }) {
+    return page.evaluate(async ({ kind, positive, negative, prefix }) => {
         const { app } = await import('/scripts/app.js');
         app.graph.clear();
         const add = (type, x, y) => { const node = LiteGraph.createNode(type); app.graph.add(node); node.pos = [x, y]; return node; };
@@ -28,7 +28,6 @@ function build(page, { kind, positive, negative, prefix, saveToLibrary }) {
         const set = (name, value) => { const widget = prompt.widgets.find(item => item.name === name); widget.value = value; if (widget.inputEl) widget.inputEl.value = value; };
         set('text', positive.typed);
         if (negative) set('negative_text', negative.typed);
-        if (saveToLibrary !== undefined) prompt.widgets.find(item => item.name === 'save_to_library').value = saveToLibrary;
         const drive = (name, side, y) => {
             if (!side.via) return;
             if (side.via === 'legacy') {
@@ -38,7 +37,6 @@ function build(page, { kind, positive, negative, prefix, saveToLibrary }) {
                 primitive.widgets[0].value = side.text;
                 return;
             }
-            if (side.via === 'cycled') { connect(add('PMCycledText', 0, y), 0, prompt, name); return; }
             const text = add('PrimitiveString', 0, y);
             text.widgets.find(widget => widget.name === 'value').value = side.text;
             let source = text;
@@ -74,12 +72,12 @@ function build(page, { kind, positive, negative, prefix, saveToLibrary }) {
         await prompt._pmTextSerializerReady;
         const { output, workflow } = await app.graphToPrompt();
         return { output, workflow, promptNode: String(prompt.id) };
-    }, { kind, positive, negative, prefix, saveToLibrary });
+    }, { kind, positive, negative, prefix });
 }
 
-async function run(execution, page, testCase, built) {
+async function run(execution, page, testCase) {
     const prefix = `textlink/${randomUUID()}`;
-    const { output, workflow, promptNode } = built ?? await build(page, { ...testCase, prefix });
+    const { output, workflow, promptNode } = await build(page, { ...testCase, prefix });
     const id = randomUUID();
     const response = await execution.request.post('/prompt', { data: { prompt: output, prompt_id: id, extra_data: { extra_pnginfo: { workflow } } } });
     expect(response.ok(), await response.text()).toBe(true);
@@ -195,205 +193,3 @@ for (const [label, linked, negativeVia] of [['positive', ['text'], 'primitive'],
         await expectImagesLinked(execution, evidence, sides.text.via === 'preview');
     });
 }
-
-// #90: with Save to library off the run still produces its image, but PromptManager saves, counts and links nothing,
-// and the run's history records no prompt text for it.
-for (const kind of ['PromptManager', 'PromptManagerText', 'PromptManagerFocused', 'PromptManagerSplit', 'PromptManagerPair']) {
-    test(`${kind} with Save to library off saves, counts and links nothing (#90)`, async ({ execution, page }) => {
-        test.setTimeout(90000);
-        const text = unique(`Not saved ${kind}`);
-        const negative = kind === 'PromptManagerPair' ? { typed: unique('Not saved negative') } : undefined;
-        const prefix = `notsaved/${randomUUID()}`;
-        const { output, workflow, promptNode } = await build(page, { kind, positive: { typed: text }, negative, prefix, saveToLibrary: false });
-        expect(output[promptNode].inputs.save_to_library).toBe(false);
-        const id = randomUUID();
-        const response = await execution.request.post('/prompt', { data: { prompt: output, prompt_id: id, extra_data: { extra_pnginfo: { workflow } } } });
-        expect(response.ok(), await response.text()).toBe(true);
-        let item;
-        await expect.poll(async () => {
-            item = (await (await execution.request.get(`/history/${id}`)).json())[id];
-            return item?.status?.status_str ?? null;
-        }, { timeout: 20000 }).toBe('success');
-        let result;
-        await expect.poll(async () => {
-            result = await readExecutionRuns(execution.databasePath, id);
-            const run = result.rows[0];
-            return Boolean(run && result.captures[run.run_id]);
-        }, { timeout: 10000, message: 'the run reaches SQLite' }).toBe(true);
-        const run = result.rows[0];
-        for (const context of result.captures[run.run_id].contexts || []) {
-            expect(context.positive_prompt_id ?? null).toBeNull();
-            expect(context.pair_id ?? null).toBeNull();
-        }
-        expect((result.usage[run.run_id] || []).every(entry => entry.run_count === 0)).toBe(true);
-        const files = Object.values(item.outputs).flatMap(value => value.images || []).map(image => image.filename);
-        expect(files.length).toBeGreaterThan(0);
-        await scan(execution);
-        expect(Object.values(await linkedPrompts(execution, files))).toEqual(files.map(() => null));
-        for (const query of [text, negative?.typed].filter(Boolean)) {
-            const found = await (await execution.request.get(`/prompt_manager/search?text=${encodeURIComponent(query)}`)).json();
-            expect(found.results ?? [], query).toEqual([]);
-        }
-    });
-}
-
-// #347: a cached PromptManager node counts every job, as an executing one does. Jobs after the first change only
-// the sampler seed, so ComfyUI serves the PromptManager node (and its PreviewAny source) from its output cache.
-const COUNTS = `import json, sqlite3, sys, pathlib
-db = sqlite3.connect(pathlib.Path(sys.argv[1]).resolve().as_uri() + "?mode=ro", uri=True)
-one = lambda sql, key: (db.execute(sql, (int(key),)).fetchone() or [None])[0] if key != "-" else None
-print(json.dumps({"positive": one("SELECT run_count FROM prompts WHERE id=?", sys.argv[2]),
-    "negative": one("SELECT run_count FROM prompts WHERE id=?", sys.argv[3]),
-    "pair": one("SELECT run_count FROM prompt_pairs WHERE id=?", sys.argv[4])}))`;
-async function runCounts(execution, context) {
-    const key = value => value == null ? '-' : String(value);
-    const { stdout } = await promisify(execFile)(process.env.PM_TEST_PYTHON || 'python',
-        ['-c', COUNTS, execution.databasePath, key(context.positive_prompt_id), key(context.negative_prompt_id), key(context.pair_id)], { timeout: 5000 });
-    return JSON.parse(stdout);
-}
-
-async function setCache(execution, mode) {
-    expect((await execution.request.post('/pm_execution_fixture/cache', { data: { mode } })).ok()).toBe(true);
-}
-
-// Queue an already built workflow again with another sampler seed; returns the job's history item and cached nodes.
-async function queueAgain(execution, first, { seed, edit, targets, status = 'success' } = {}) {
-    const output = structuredClone(first.output);
-    const sampler = Object.values(output).find(node => node.class_type === 'KSampler');
-    sampler.inputs.seed = seed;
-    edit?.(output);
-    const id = randomUUID();
-    const data = { prompt: output, prompt_id: id, extra_data: { extra_pnginfo: { workflow: first.workflow } } };
-    if (targets) data.partial_execution_targets = targets;
-    const response = await execution.request.post('/prompt', { data });
-    expect(response.ok(), await response.text()).toBe(true);
-    let item;
-    await expect.poll(async () => {
-        item = (await (await execution.request.get(`/history/${id}`)).json())[id];
-        return item?.status?.status_str ?? null;
-    }, { timeout: 20000 }).toBe(status);
-    const cached = item.status.messages.find(([event]) => event === 'execution_cached')?.[1]?.nodes ?? [];
-    return { id, item, cached };
-}
-
-// The recorded context of one job, once its capture reached SQLite.
-async function capturedContext(execution, id) {
-    let result;
-    await expect.poll(async () => {
-        result = await readExecutionRuns(execution.databasePath, id);
-        const row = result.rows[0];
-        return row ? result.captures[row.run_id].state : null;
-    }, { timeout: 10000 }).toMatch(/^(complete|partial)$/);
-    return result.captures[result.rows[0].run_id].contexts[0];
-}
-
-async function firstRun(execution, page, testCase) {
-    const prefix = `textlink/${randomUUID()}`;
-    const built = await build(page, { ...testCase, prefix });
-    const evidence = await run(execution, page, testCase, built);
-    return { ...evidence, workflow: built.workflow };
-}
-
-for (const kind of ['PromptManager', 'PromptManagerFocused', 'PromptManagerSplit', 'PromptManagerText', 'PromptManagerPair']) {
-    test(`${kind} counts each cached re-run of text linked from PreviewAny (#347)`, async ({ execution, page }) => {
-        test.setTimeout(90000);
-        await setCache(execution, 'RAM_PRESSURE');
-        const pair = kind === 'PromptManagerPair';
-        const testCase = { kind, positive: { typed: 'Typed under the link', text: unique(`Cached ${kind}`), via: 'preview' },
-            negative: pair ? { typed: unique('Typed negative') } : undefined };
-        const first = await firstRun(execution, page, testCase);
-        for (const seed of [2, 3]) {
-            const again = await queueAgain(execution, first, { seed });
-            expect(again.cached, 'ComfyUI served the PromptManager node from its cache').toContain(first.promptNode);
-        }
-        const counts = await runCounts(execution, first.context);
-        expect(counts.positive).toBe(3);
-        if (pair) expect(counts).toMatchObject({ negative: 0, pair: 3 });
-    });
-}
-
-test.describe('cached runs in one renderer (#347)', () => {
-    // Cache behavior does not depend on the renderer: one project runs these.
-    test.beforeEach(({}, testInfo) => { test.skip(testInfo.project.name !== 'classic-start', 'covered in classic-start'); });
-    const linked = () => ({ kind: 'PromptManager', positive: { typed: 'Typed under the link', text: unique('Cached'), via: 'preview' } });
-
-    for (const mode of ['CLASSIC', 'LRU', 'RAM_PRESSURE', 'NONE']) {
-        test(`counts 3 jobs under the ${mode} cache`, async ({ execution, page }) => {
-            test.setTimeout(90000);
-            await setCache(execution, mode);
-            try {
-                const first = await firstRun(execution, page, linked());
-                for (const seed of [2, 3]) {
-                    const again = await queueAgain(execution, first, { seed });
-                    if (mode === 'NONE') expect(again.cached).not.toContain(first.promptNode);
-                    else expect(again.cached).toContain(first.promptNode);
-                }
-                expect((await runCounts(execution, first.context)).positive).toBe(3);
-            } finally { await setCache(execution, 'RAM_PRESSURE'); }
-        });
-    }
-
-    test('alternating upstream values A, B, A under LRU each count their own prompt', async ({ execution, page }) => {
-        test.setTimeout(90000);
-        await setCache(execution, 'LRU');
-        try {
-            const [a, b] = [unique('Cycled A'), unique('Cycled B')];
-            const cycle = async value => expect((await execution.request.post('/pm_execution_fixture/cycled', { data: { value } })).ok()).toBe(true);
-            await cycle(a);
-            const first = await firstRun(execution, page, { kind: 'PromptManager', positive: { typed: 'Typed under the link', text: a, via: 'cycled' } });
-            expect(first.context.positive.raw).toBe(a);
-            await cycle(b);
-            const second = await queueAgain(execution, first, { seed: 2 });
-            expect(second.cached).not.toContain(first.promptNode);
-            await cycle(a);
-            const third = await queueAgain(execution, first, { seed: 3 });
-            expect(third.cached, 'LRU kept A').toContain(first.promptNode);
-            expect((await runCounts(execution, first.context)).positive).toBe(2);
-            const bContext = await capturedContext(execution, second.id);
-            expect(bContext.positive.raw).toBe(b);
-            expect((await runCounts(execution, bContext)).positive).toBe(1);
-        } finally { await setCache(execution, 'RAM_PRESSURE'); }
-    });
-
-    test('typed text served from the cache still counts once per job', async ({ execution, page }) => {
-        test.setTimeout(90000);
-        await setCache(execution, 'RAM_PRESSURE');
-        const first = await firstRun(execution, page, { kind: 'PromptManager', positive: { typed: unique('Typed cached') } });
-        for (const seed of [2, 3]) expect((await queueAgain(execution, first, { seed })).cached).toContain(first.promptNode);
-        expect((await runCounts(execution, first.context)).positive).toBe(3);
-    });
-
-    test('a job failing downstream of a cached node counts it once; a job that does not need it, never', async ({ execution, page }) => {
-        test.setTimeout(90000);
-        await setCache(execution, 'RAM_PRESSURE');
-        const first = await firstRun(execution, page, linked());
-        const failing = await queueAgain(execution, first, { seed: 2, status: 'error', edit: output => {
-            output.pm_failure = { class_type: 'PMHistoryOutput', inputs: { value: [Object.keys(output).find(id => output[id].class_type === 'KSampler'), 0], mode: 'failure' } };
-        } });
-        expect(failing.cached).toContain(first.promptNode);
-        expect((await runCounts(execution, first.context)).positive).toBe(2);
-        // "Run selected output": only an unrelated output node; ComfyUI still reports the cached PromptManager node
-        const unrelated = await queueAgain(execution, first, { seed: 2, targets: ['pm_unrelated'], edit: output => {
-            output.pm_unrelated = { class_type: 'PMHistoryCached', inputs: { value: unique('unrelated') } };
-        } });
-        expect(unrelated.cached).toContain(first.promptNode);
-        expect((await runCounts(execution, first.context)).positive).toBe(2);
-    });
-
-    test('a cached node rewired to the negative input does not count the positive prompt', async ({ execution, page }) => {
-        test.setTimeout(90000);
-        await setCache(execution, 'RAM_PRESSURE');
-        const first = await firstRun(execution, page, linked());
-        const rewired = await queueAgain(execution, first, { seed: 2, edit: output => {
-            const sampler = Object.values(output).find(node => node.class_type === 'KSampler');
-            [sampler.inputs.positive, sampler.inputs.negative] = [sampler.inputs.negative, sampler.inputs.positive];
-        } });
-        expect(rewired.cached).toContain(first.promptNode);
-        expect((await runCounts(execution, first.context)).positive).toBe(1);
-        // The history capture of a cached job is unchanged: effective text from the cache, no stored-prompt hint
-        const cachedContext = await capturedContext(execution, (await queueAgain(execution, first, { seed: 3 })).id);
-        expect(cachedContext.positive.effective).toBe(first.context.positive.effective);
-        expect(cachedContext.positive_prompt_id).toBeNull();
-        expect((await runCounts(execution, first.context)).positive).toBe(2);
-    });
-});

tests/comfyui/fixtures/ledger_nodes.py

@@ -201,39 +201,6 @@ NODE_CLASS_MAPPINGS.update(
     {"PMHistoryImages": PMHistoryImages, "PMHistoryImageOutput": PMHistoryImageOutput}
 )
 
-# #347: text whose value (and cache signature) follows a value the test sets, so
-# one queued graph can serve A, then B, then A again (each cached under LRU).
-_CYCLED = {"value": "cycled"}
-
-
-class PMCycledText:
-    @classmethod
-    def INPUT_TYPES(cls) -> dict:
-        return {"required": {}}
-
-    RETURN_TYPES = ("STRING",)
-    FUNCTION = "execute"
-    CATEGORY = "testing/execution-history"
-
-    @classmethod
-    def IS_CHANGED(cls, **kwargs: object) -> str:
-        return _CYCLED["value"]
-
-    def execute(self) -> tuple:
-        return (_CYCLED["value"],)
-
-
-NODE_CLASS_MAPPINGS["PMCycledText"] = PMCycledText
-
-
-@PromptServer.instance.routes.post("/pm_execution_fixture/cycled")
-async def cycled_text(request: web.Request) -> web.Response:
-    value = (await request.json())["value"]
-    if type(value) is not str:
-        raise web.HTTPBadRequest()
-    _CYCLED["value"] = value
-    return web.json_response({"value": value})
-
 
 @PromptServer.instance.routes.post("/pm_execution_fixture/metadata")
 async def metadata(request: web.Request) -> web.Response:

tests/comfyui/image-attribution.spec.mjs

@@ -140,26 +140,3 @@ test('an output saved without metadata links once its recorded run names a store
         expect((await request.post('/pm_execution_fixture/metadata', { data: { disabled: false } })).ok()).toBe(true);
     }
 });
-
-// #332 on the real host: the migration ran at startup and the image category routes
-// set, list and remove an own category on a generated output.
-test('an output gets its own image category and loses it again', async ({ execution }, testInfo) => {
-    const request = execution.request;
-    const filename = await saved(request, graph({ text: `category host ${randomUUID()}`, prefix: 'pm332/category' }));
-    let image;
-    await expect.poll(async () => {
-        const listing = await (await request.get('/prompt_manager/images/output?mode=workspace&q=pm332&rescan=1')).json();
-        image = (listing.images || []).find(entry => entry.filename === filename || entry.path?.endsWith(`/${filename}`));
-        return Boolean(image);
-    }, { timeout: 20000, message: `${filename} is listed by Images` }).toBe(true);
-    const items = [{ root_index: image.root_index, root_scope: image.root_scope, path: image.path }];
-    const value = `PM332 host ${testInfo.project.name}`;
-    const set = await request.put('/prompt_manager/images/category', { data: { items, category: value } });
-    expect(set.status()).toBe(200);
-    expect(await set.json()).toEqual({ success: true, category: value, updated: 1, unchanged: 0, not_found: 0 });
-    expect((await (await request.get('/prompt_manager/images/categories')).json()).categories).toContain(value);
-    const cleared = await request.delete('/prompt_manager/images/category', { data: { items } });
-    expect(cleared.status()).toBe(200);
-    expect(await cleared.json()).toEqual({ success: true, cleared: 1 });
-    expect((await (await request.get('/prompt_manager/images/categories')).json()).categories).not.toContain(value);
-});

tests/comfyui/text-link.spec.mjs

@@ -370,7 +370,6 @@ test('workflows saved before #343 load unchanged and their linked text keeps wor
         const nodes = Object.fromEntries(app.graph._nodes.map(node => [node.id, node]));
         const reloaded = app.graph.serialize();
         return {
-            saves: Object.fromEntries(Object.entries(output).filter(([, node]) => node.class_type.startsWith('PromptManager')).map(([id, node]) => [id, node.inputs.save_to_library])),
             values: Object.fromEntries(reloaded.nodes.map(node => [node.id, node.widgets_values])),
             links: Object.fromEntries(Object.entries(output).map(([id, node]) => [id, { text: node.inputs.text, negative_text: node.inputs.negative_text }])),
             widgetBound: Object.fromEntries(Object.values(nodes).filter(node => node.type.startsWith('PromptManager')).map(node => [node.id, node.inputs.filter(input => ['text', 'negative_text'].includes(input.name) && input.widget).map(input => input.name)])),
@@ -378,16 +377,8 @@ test('workflows saved before #343 load unchanged and their linked text keeps wor
     }, workflow);
     for (const node of workflow.nodes) {
         // Every saved widget value comes back as it was saved, except the typed text main lost under a link (null).
-        // #90: the last saved value is the editor's own slot (''), where the Save to library switch is now: it loads on.
-        if (node.widgets_values?.[0] === null) continue;
-        if (!node.type.startsWith('PromptManager')) { expect(result.values[node.id], `${node.type} ${node.id}`).toEqual(node.widgets_values); continue; }
-        const saved = node.widgets_values.length - 1;
-        expect(result.values[node.id].slice(0, saved), `${node.type} ${node.id}`).toEqual(node.widgets_values.slice(0, saved));
-        expect(result.values[node.id][saved], `${node.type} ${node.id} save_to_library`).toBe(true);
+        if (node.widgets_values?.[0] !== null) expect(result.values[node.id], `${node.type} ${node.id}`).toEqual(node.widgets_values);
     }
-    // Every PromptManager node of the old workflow queues with Save to library on.
-    for (const save of Object.values(result.saves)) expect(save).toBe(true);
-    expect(Object.keys(result.saves).length).toBeGreaterThan(0);
     expect(result.links).toMatchObject({
         1: { text: 'Saved PromptManager text' }, 2: { text: 'Saved PromptManagerText text' }, 3: { text: 'Saved PromptManagerFocused text' },
         4: { text: 'Saved PromptManagerSplit text' }, 5: { text: 'Saved PromptManagerPair text', negative_text: 'Saved pair negative' },

tests/disk_waits.py

@@ -1,16 +0,0 @@
-"""Hang guards for waits on disk-bound work (tests only).
-
-A test that waits for a job or handoff whose work is file and SQLite I/O
-(a safety backup with fsync, a restore, hashing and unlinking files) waits
-on that state; the ceiling below only ends a real hang. Hosted Windows
-runners stall disk I/O for tens of seconds at a time: a restore took over
-10 s (merge queue, #382), and on PR #405 every test setup in a 50 s window
-took up to 9 s against 0.1-0.6 s around it while the test bodies stayed
-fast, so a one-file duplicate cleanup missed a 10 s bound (#409).
-
-The ceiling is per wait and stays under the suite's 120 s per-test hang
-watchdog. A test with several such waits in a row can reach the watchdog
-first; either way a real hang fails, the watchdog with every thread's stack.
-"""
-
-DISK_BOUND_SECONDS = 90

tests/fixtures/README.md

@@ -113,19 +113,3 @@ by their own suites. The expectations start as the observed baseline. A change
 that alters an outcome edits the vector in the same commit.
 `tests/js/legacy-metadata-characterization.test.js` pins what
 the legacy viewers show on the same files.
-
-# Legacy contract snapshot
-
-`legacy_contract_snapshot.json` records what the legacy admin and gallery pages
-talk to while System S13 (#330) moves their tools to native System: every
-registered route as `"<METHOD> <path>"` (`routes`) and the key paths of
-`GET /prompt_manager/settings` to depth 2 (`settings_keys`; list items give the
-union of their keys as `name[].key`). `tests/test_legacy_contract_snapshot.py`
-compares a temp-database API against it. Record it again only for an intended
-change, and say why in the PR body:
-
-```sh
-PM_RECORD_LEGACY_SNAPSHOT=1 python3 -m unittest tests.test_legacy_contract_snapshot
-```
-
-Cutover (#334) removes the test and this fixture.

tests/fixtures/legacy_contract_snapshot.json

@@ -1,209 +0,0 @@
-{
-  "routes": [
-    "DELETE /prompt_manager/collections/items",
-    "DELETE /prompt_manager/collections/{collection_id}",
-    "DELETE /prompt_manager/delete/{prompt_id}",
-    "DELETE /prompt_manager/image-annotations/capture/{token}",
-    "DELETE /prompt_manager/images/category",
-    "DELETE /prompt_manager/images/favorite",
-    "DELETE /prompt_manager/images/{image_id}",
-    "DELETE /prompt_manager/pairs/{pair_id}",
-    "DELETE /prompt_manager/prompts/{prompt_id}/tags",
-    "DELETE /prompt_manager/restore/preview/{token}",
-    "DELETE /prompt_manager/saved-views/{view_id}",
-    "DELETE /prompt_manager/tags/{tag_name}",
-    "GET /prompt_manager/admin",
-    "GET /prompt_manager/autotag/models",
-    "GET /prompt_manager/backup",
-    "GET /prompt_manager/backup/status",
-    "GET /prompt_manager/categories",
-    "GET /prompt_manager/collections",
-    "GET /prompt_manager/collections/membership",
-    "GET /prompt_manager/diagnostics",
-    "GET /prompt_manager/export",
-    "GET /prompt_manager/gallery",
-    "GET /prompt_manager/gallery.html",
-    "GET /prompt_manager/gallery/subfolders",
-    "GET /prompt_manager/history/runs/{run_id}",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/inspection",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/media",
-    "GET /prompt_manager/history/runs/{run_id}/output/current/thumbnail",
-    "GET /prompt_manager/history/runs/{run_id}/outputs",
-    "GET /prompt_manager/image-annotations/capture/{token}",
-    "GET /prompt_manager/images/all",
-    "GET /prompt_manager/images/categories",
-    "GET /prompt_manager/images/inspect/{image_path}",
-    "GET /prompt_manager/images/output",
-    "GET /prompt_manager/images/prompt/{image_path}",
-    "GET /prompt_manager/images/recent",
-    "GET /prompt_manager/images/search",
-    "GET /prompt_manager/images/serve/{filepath}",
-    "GET /prompt_manager/images/thumbnails/plan",
-    "GET /prompt_manager/images/thumbnails/status",
-    "GET /prompt_manager/images/{image_id}/file",
-    "GET /prompt_manager/jobs",
-    "GET /prompt_manager/jobs/{job_id}",
-    "GET /prompt_manager/jobs/{job_id}/events",
-    "GET /prompt_manager/jobs/{job_id}/report",
-    "GET /prompt_manager/js/{filepath}",
-    "GET /prompt_manager/lib/{filepath}",
-    "GET /prompt_manager/library",
-    "GET /prompt_manager/library/export",
-    "GET /prompt_manager/library/options",
-    "GET /prompt_manager/library/{positive_id}",
-    "GET /prompt_manager/library/{positive_id}/history",
-    "GET /prompt_manager/library/{positive_id}/history/pairs/{pair_id}/newest",
-    "GET /prompt_manager/library/{positive_id}/images",
-    "GET /prompt_manager/logs",
-    "GET /prompt_manager/logs/config",
-    "GET /prompt_manager/logs/download/{filename}",
-    "GET /prompt_manager/logs/files",
-    "GET /prompt_manager/logs/stats",
-    "GET /prompt_manager/lora/detect",
-    "GET /prompt_manager/lora/status",
-    "GET /prompt_manager/lora/trigger-words",
-    "GET /prompt_manager/maintenance/duplicates/{job_id}",
-    "GET /prompt_manager/pairs",
-    "GET /prompt_manager/pairs/export",
-    "GET /prompt_manager/pairs/{pair_id}",
-    "GET /prompt_manager/prompts/{prompt_id}/images",
-    "GET /prompt_manager/recent",
-    "GET /prompt_manager/review/events",
-    "GET /prompt_manager/review/items",
-    "GET /prompt_manager/review/items/{item_id}",
-    "GET /prompt_manager/saved-views",
-    "GET /prompt_manager/scan/status",
-    "GET /prompt_manager/scan_duplicates",
-    "GET /prompt_manager/scan_duplicates/status",
-    "GET /prompt_manager/scan_output_dir",
-    "GET /prompt_manager/search",
-    "GET /prompt_manager/settings",
-    "GET /prompt_manager/stats",
-    "GET /prompt_manager/subfolders",
-    "GET /prompt_manager/system/diagnostics",
-    "GET /prompt_manager/system/health",
-    "GET /prompt_manager/system/library",
-    "GET /prompt_manager/system/overview",
-    "GET /prompt_manager/system/statistics",
-    "GET /prompt_manager/tags",
-    "GET /prompt_manager/tags/filter",
-    "GET /prompt_manager/tags/stats",
-    "GET /prompt_manager/tags/suggest",
-    "GET /prompt_manager/tags/{tag_name}/prompts",
-    "GET /prompt_manager/test",
-    "GET /prompt_manager/vocabulary/categories",
-    "GET /prompt_manager/vocabulary/tags",
-    "GET /prompt_manager/vocabulary/tags/{tag_id}/impact",
-    "GET /prompt_manager/web",
-    "GET /prompt_manager/workspace",
-    "PATCH /prompt_manager/collections/{collection_id}",
-    "PATCH /prompt_manager/library/{positive_id}",
-    "PATCH /prompt_manager/pairs/{pair_id}",
-    "PATCH /prompt_manager/saved-views/{view_id}",
-    "PATCH /prompt_manager/vocabulary/tags/{tag_id}",
-    "POST /prompt_manager/autotag/apply",
-    "POST /prompt_manager/autotag/batch/preview",
-    "POST /prompt_manager/autotag/download/{model_type}",
-    "POST /prompt_manager/autotag/single",
-    "POST /prompt_manager/autotag/start",
-    "POST /prompt_manager/autotag/unload",
-    "POST /prompt_manager/bulk/category",
-    "POST /prompt_manager/bulk/delete",
-    "POST /prompt_manager/bulk/tags",
-    "POST /prompt_manager/cleanup",
-    "POST /prompt_manager/collections/items",
-    "POST /prompt_manager/delete_duplicate_images",
-    "POST /prompt_manager/diagnostics/test-link",
-    "POST /prompt_manager/gallery/rescan",
-    "POST /prompt_manager/image-annotations/observe",
-    "POST /prompt_manager/image-annotations/suggest",
-    "POST /prompt_manager/images/clear-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails",
-    "POST /prompt_manager/images/generate-thumbnails/progress",
-    "POST /prompt_manager/images/link",
-    "POST /prompt_manager/images/reveal",
-    "POST /prompt_manager/jobs/autotag",
-    "POST /prompt_manager/jobs/duplicates",
-    "POST /prompt_manager/jobs/image-tags",
-    "POST /prompt_manager/jobs/model-download",
-    "POST /prompt_manager/jobs/scan",
-    "POST /prompt_manager/jobs/thumbnails",
-    "POST /prompt_manager/jobs/{job_id}/cancel",
-    "POST /prompt_manager/library",
-    "POST /prompt_manager/library/{positive_id}/variants",
-    "POST /prompt_manager/logs/config",
-    "POST /prompt_manager/logs/truncate",
-    "POST /prompt_manager/lora/enable",
-    "POST /prompt_manager/lora/import/apply",
-    "POST /prompt_manager/lora/import/preview",
-    "POST /prompt_manager/lora/refresh-cache",
-    "POST /prompt_manager/lora/scan",
-    "POST /prompt_manager/maintenance",
-    "POST /prompt_manager/maintenance/apply",
-    "POST /prompt_manager/maintenance/preview",
-    "POST /prompt_manager/pairs",
-    "POST /prompt_manager/prompts/tags",
-    "POST /prompt_manager/prompts/{prompt_id}/tags",
-    "POST /prompt_manager/restore",
-    "POST /prompt_manager/restore/apply",
-    "POST /prompt_manager/restore/preview",
-    "POST /prompt_manager/review/items/{item_id}/decision",
-    "POST /prompt_manager/save",
-    "POST /prompt_manager/saved-views",
-    "POST /prompt_manager/scan",
-    "POST /prompt_manager/scan/cancel",
-    "POST /prompt_manager/scan_duplicates/stream",
-    "POST /prompt_manager/settings",
-    "POST /prompt_manager/settings/validate-source",
-    "POST /prompt_manager/system/health",
-    "POST /prompt_manager/system/library/keep",
-    "POST /prompt_manager/system/library/move",
-    "POST /prompt_manager/tags/merge",
-    "POST /prompt_manager/vocabulary/categories/apply",
-    "POST /prompt_manager/vocabulary/categories/preview",
-    "POST /prompt_manager/vocabulary/tags",
-    "POST /prompt_manager/vocabulary/tags/{tag_id}/delete",
-    "PUT /prompt_manager/image-annotations/tags",
-    "PUT /prompt_manager/images/category",
-    "PUT /prompt_manager/images/favorite",
-    "PUT /prompt_manager/prompts/{prompt_id}",
-    "PUT /prompt_manager/prompts/{prompt_id}/rating",
-    "PUT /prompt_manager/tags/{tag_name}"
-  ],
-  "settings_keys": [
-    "monitor",
-    "monitor.observer_alive",
-    "monitor.present",
-    "monitor.scheduled",
-    "revision",
-    "settings",
-    "settings.autotag_character_threshold",
-    "settings.autotag_existing",
-    "settings.autotag_general_threshold",
-    "settings.autotag_model_type",
-    "settings.autotag_suggestion_limit",
-    "settings.autotag_template",
-    "settings.cpu_count",
-    "settings.gallery_root_path",
-    "settings.gallery_root_paths",
-    "settings.infinite_scroll",
-    "settings.monitored_directories",
-    "settings.monitoring_enabled",
-    "settings.result_timeout",
-    "settings.safety_backup",
-    "settings.thumbnail_edge",
-    "settings.thumbnail_format",
-    "settings.thumbnail_quality",
-    "settings.webui_display_mode",
-    "settings.worker_threads",
-    "sources",
-    "sources.auto_detected",
-    "sources.configured",
-    "sources.effective",
-    "success",
-    "thumbnail_encoders",
-    "thumbnail_encoders.jpeg",
-    "thumbnail_encoders.jxl",
-    "thumbnail_encoders.webp"
-  ]
-}

tests/js/gallery-settings.test.js

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

tests/js/gallery-thumbnails.test.js

@@ -112,12 +112,11 @@ test('saving gallery settings retains the remembered thumbnail dismissal', () =>
 });
 
 // #249 System S5: the stream's work is now an Activity job that outlives the page's connection, so the gallery's
-// Cancel asks the server to stop the job. Since #330 the startup dialog is the gallery's only thumbnail stream (System
-// › Sources & scans generates the rest). The stream's first frame, `job {id, started}`, names the job; the gallery
+// Cancel asks the server to stop the job. The stream's first frame, `job {id, started}`, names the job; the gallery
 // cancels by that id, only a job this stream started, and a Cancel before the id waits for it (review I1).
 const JOB = 'b'.repeat(32);
 
-function streamFixture({ postFails = false } = {}) {
+function streamFixture({ modal = false, postFails = false } = {}) {
     const posts = [];
     const warnings = [];
     const gets = [];
@@ -147,20 +146,18 @@ function streamFixture({ postFails = false } = {}) {
                 return { success: true };
             } } });
     const emit = (type, data) => (listeners[type] || []).forEach(handler => handler({ data: JSON.stringify(data) }));
-    // The dialog's Cancel runs the handler and from then on reads as cancelled, as the startup dialog does.
-    let cancelled = false;
     const ui = { addStatusMessage() {}, progressText: element(), progressPercent: element(), progressBar: element(),
-        progressDetails: element(), progressETA: element(), isCancelled: () => cancelled,
-        onCancel: handler => { ui.cancel = () => { cancelled = true; handler(); }; } };
-    const result = manager.generateThumbnailsWithProgressInModal(ui);
+        progressDetails: element(), progressETA: element(), isCancelled: () => false,
+        onCancel: handler => { ui.cancel = handler; } };
+    const result = modal ? manager.generateThumbnailsWithProgressInModal(ui)
+        : manager.generateThumbnailsWithProgress({ quality: 'medium' });
     const outcome = result.then(value => ({ value }), error => ({ error: error.message }));
-    const cancel = () => ui.cancel();
+    const cancel = () => (modal ? ui.cancel() : elements.cancelThumbnailsBtn.click());
     const settle = () => new Promise(resolve => setImmediate(resolve));
     return { emit, source, posts, gets, warnings, outcome, cancel, settle };
 }
 
 const cancelUrl = id => `/prompt_manager/jobs/${id}/cancel`;
-const CANCELLED = 'Thumbnail generation cancelled; previews already written are kept';
 
 test('Cancel before the job id arrives cancels that job once it does', async () => {
     const f = streamFixture();
@@ -168,8 +165,8 @@ test('Cancel before the job id arrives cancels that job once it does', async ()
     await f.settle();
     assert.deepEqual(f.posts, []);
     assert.equal(f.source.closed, 0); // kept open until the stream names its job
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
-    // The job frame is the stream's first (the dialog closes the stream on any later frame once cancelled).
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
+    f.emit('status', { phase: 'scanning', message: 'Scanning…' });
     f.emit('job', { id: JOB, started: true });
     await f.settle();
     assert.equal(JSON.stringify(f.posts), JSON.stringify([[cancelUrl(JOB), {}]]));
@@ -188,7 +185,7 @@ test('Cancel after the id cancels it at once, and a double Cancel posts once', a
     await f.settle();
     assert.equal(JSON.stringify(f.posts), JSON.stringify([[cancelUrl(JOB), {}]]));
     assert.equal(f.source.closed, 1);
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
     assert.deepEqual(f.gets, []);
 });
 
@@ -219,11 +216,11 @@ test('a cancel post that fails is reported, not thrown', async () => {
     await f.settle();
     assert.equal(f.posts.length, 1);
     assert.equal(f.warnings.length, 1);
-    assert.deepEqual(await f.outcome, { error: CANCELLED });
+    assert.deepEqual(await f.outcome, { error: 'Thumbnail generation cancelled by user' });
 });
 
 test('the startup dialog cancels its own job by id too', async () => {
-    const f = streamFixture();
+    const f = streamFixture({ modal: true });
     f.cancel();
     await f.settle();
     assert.deepEqual(f.posts, []);

tests/js/legacy-refusals.test.js

@@ -65,12 +65,109 @@ function load(file, className, fetchUrl, extra = {}, dom = elements()) {
 
 const BUSY = 'Scan for metadata already running';
 
+test('gallery cache clear reports a refused server clear and never claims success', async () => {
+    const calls = [];
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async url => {
+        calls.push(url);
+        return jsonResponse(409, { success: false, error: BUSY });
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+    dom.getElementById('thumbnailStatus').textContent = 'Generated';
+
+    await page.clearCache();
+
+    assert.deepEqual(calls, ['/prompt_manager/images/clear-thumbnails']);
+    assert.deepEqual(notifications, [['error', `Thumbnails were not cleared: ${BUSY}`]]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Generated');
+    assert.equal(storage.get('gallerySettings'), undefined); // thumbnailsGenerated is not reset
+});
+
+test('gallery cache clear says what it cleared and keeps preferences and other data (#222)', async () => {
+    const calls = [];
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async url => {
+        calls.push(url);
+        return jsonResponse(200, { success: true, cleared_count: 3 });
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+
+    await page.clearCache();
+
+    // The server's thumbnails are cleared by their own explicit call; nothing Prompt Manager owns is cached in this
+    // browser, so no browser entry is removed and the toast says exactly that.
+    assert.deepEqual(calls, ['/prompt_manager/images/clear-thumbnails']);
+    assert.deepEqual(notifications, [['success',
+        "Thumbnails cleared; original images untouched. Nothing of Prompt Manager's is cached in this browser."]]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Not generated');
+    assert.equal(JSON.parse(storage.get('gallerySettings')).thumbnailsGenerated, false);
+    assert.equal(storage.get('userData'), 'keep');
+    assert.equal(storage.get('pm_cached'), '1');
+    assert.equal(storage.get('pm_workspace_theme'), 'light');
+    assert.equal(storage.get('pm_update_notice_dismissed'), '3.3.0');
+});
+
+test("gallery cache clear never deletes another tool's gallery or thumbnail caches (#222)", async () => {
+    const names = new Set(['comfy-gallery', 'thumbnail-cache']);
+    const caches = { keys: async () => [...names], delete: async name => names.delete(name) };
+    const { page, notifications } = load('gallery.js', 'GalleryManager',
+        async () => jsonResponse(200, { success: true }), { caches, window: { caches } });
+    page.getSettings = () => ({});
+
+    await page.clearCache();
+
+    assert.deepEqual([...names], ['comfy-gallery', 'thumbnail-cache']);
+    assert.equal(notifications.at(-1)[0], 'success');
+});
+
+test('gallery cache clear reports a lost server clear instead of success', async () => {
+    const { page, dom, notifications, storage } = load('gallery.js', 'GalleryManager', async () => {
+        throw new TypeError('Failed to fetch');
+    });
+    page.getSettings = () => ({ thumbnailsGenerated: true });
+    dom.getElementById('thumbnailStatus').textContent = 'Generated';
+
+    await page.clearCache();
+
+    assert.deepEqual(notifications, [['error', 'Thumbnails were not cleared: the server could not be reached.']]);
+    assert.equal(dom.nodes.thumbnailStatus.textContent, 'Generated');
+    assert.equal(storage.get('gallerySettings'), undefined);
+});
+
+test('gallery cache clear says so when browser storage is denied', async () => {
+    const denied = { get length() { throw new Error('SecurityError'); }, key() { throw new Error('SecurityError'); },
+        getItem() { throw new Error('SecurityError'); }, setItem() { throw new Error('SecurityError'); },
+        removeItem() { throw new Error('SecurityError'); } };
+    const { page, notifications } = load('gallery.js', 'GalleryManager',
+        async () => jsonResponse(200, { success: true }), { localStorage: denied });
+    page.getSettings = () => ({});
+
+    await page.clearCache();
+
+    assert.deepEqual(notifications, [['warning',
+        'Thumbnails cleared; original images untouched. This browser refused access to its storage, so nothing there was cleared.']]);
+});
+
+test('admin LoRA import shows a refusal frame and closes its modal', async () => {
+    const { page, dom, timers, notifications } = load('admin.js', 'PromptAdmin',
+        async () => sseResponse([{ type: 'error', status: BUSY, progress: 0, message: BUSY }]));
+    page.saveLoraSettings = async () => true;
+    page.loadStatistics = () => assert.fail('a refused import must not reload statistics');
+
+    await page.runLoraImport();
+
+    assert.equal(dom.nodes.loraImportStatus.textContent, `Error: ${BUSY}`);
+    assert.deepEqual(notifications.filter(([type]) => type === 'error'), [['error', `LoRA import failed: ${BUSY}`]]);
+    assert.equal(timers.length, 1);
+    timers[0]();
+    assert.deepEqual(notifications.at(-1), ['hide', 'loraImportModal']);
+});
+
 test('admin settings save shows why config.json refused it', async () => {
     const message = 'config.json cannot be read, so nothing was saved. Fix or remove the file, then save again.';
     const { page, notifications } = load('admin.js', 'PromptAdmin',
         async () => jsonResponse(409, { success: false, persisted: false, code: 'config-unreadable', error: message }));
     page.settings = {};
-    page.setInfiniteScroll = () => assert.fail('nothing changes after a refusal');
+    page._collectScanPaths = () => [];
+    page.saveLoraSettings = async () => assert.fail('nothing else is saved after a refusal');
 
     await page.saveSettings();
 
@@ -81,30 +178,27 @@ test('admin settings save keeps its plain message when the reply has no reason',
     const { page, notifications } = load('admin.js', 'PromptAdmin', async () => ({ ok: false, status: 500,
         json: async () => { throw new SyntaxError('not json'); } }));
     page.settings = {};
+    page._collectScanPaths = () => [];
 
     await page.saveSettings();
 
     assert.deepEqual(notifications, [['error', 'Failed to save settings']]);
 });
 
-// #330 S13-9: the admin page's reduced Page options save sends only the list's scroll default, so a stale legacy form
-// can no longer overwrite scan folders or other settings edited in System.
-test('admin Page options save posts only infinite_scroll', async () => {
-    const sent = [];
-    const { page, dom, notifications } = load('admin.js', 'PromptAdmin', async (url, init) => {
-        sent.push([url, init.method, JSON.parse(init.body)]);
-        return jsonResponse(200, { success: true, restart_required: true });
-    });
-    page.settings = { infiniteScroll: false };
-    const scrolled = [];
-    page.setInfiniteScroll = (on, options) => scrolled.push([on, { ...options }]);
-    dom.getElementById('infiniteScrollDefault').checked = true;
+test('admin maintenance names the job that refused it', async () => {
+    const { page, dom, notifications } = load('admin.js', 'PromptAdmin',
+        async () => jsonResponse(409, { success: false, error: BUSY }), {
+            escapeHtml: text => String(text),
+            document: { readyState: 'loading', addEventListener() {}, getElementById: id => dom.getElementById(id),
+                querySelectorAll: selector => (selector === '.maintenance-option:checked' ? [{ id: 'vacuum' }] : []) },
+        });
 
-    await page.saveSettings();
+    await page.runMaintenance();
 
-    assert.deepEqual(sent, [['/prompt_manager/settings', 'POST', { infinite_scroll: true }]]);
-    assert.deepEqual(scrolled, [[true, { session: false }]]);
-    assert.equal(page.settings.infiniteScroll, true);
-    assert.deepEqual(notifications, [['success', 'Page options saved'], ['hide', 'settingsModal']]);
+    const results = dom.nodes.maintenanceResults.innerHTML;
+    assert.match(results, /Maintenance Failed/);
+    assert.match(results, new RegExp(BUSY));
+    assert.doesNotMatch(results, /HTTP 409/);
+    assert.deepEqual(notifications, [['error', '❌ Maintenance failed']]);
+    assert.equal(dom.nodes.runMaintenanceBtn.disabled, false);
 });
-

tests/js/save-to-library.test.js

@@ -1,68 +0,0 @@
-// #90: the node's save_to_library switch (web/js/save-to-library.js).
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const source = import('../../web/js/save-to-library.js');
-
-function classicNode(saved) {
-    const names = ['text', 'category', 'tags', 'search_text', 'prepend_text', 'append_text', 'save_to_library', 'prompt_manager_search_ui'];
-    const widgets = names.map(name => ({name, value: name === 'save_to_library' ? true : ''}));
-    const node = {widgets, widgets_values: saved ? [...saved] : undefined};
-    // What a host configure does: each saved value goes to the widget at its index.
-    (saved || []).forEach((value, index) => { if (widgets[index]) widgets[index].value = value; });
-    return node;
-}
-
-test('an older workflow stored the editor slot where the switch is now: it loads on', async () => {
-    const {normalizeSaveWidget, savesToLibrary} = await source;
-    const node = classicNode(['a cat', 'c', 't', '', '', '', '']);
-    assert.equal(node.widgets[6].value, '', 'the host put the old DOM slot value into the switch');
-    assert.equal(normalizeSaveWidget(node), true);
-    assert.equal(node.widgets[6].value, true);
-    assert.equal(node.widgets_values[6], true);
-    assert.equal(savesToLibrary(node), true);
-    assert.deepEqual(node.widgets_values.slice(0, 6), ['a cat', 'c', 't', '', '', ''], 'no earlier value moved');
-});
-
-test('null, undefined and missing slots load on; saved booleans are kept', async () => {
-    const {normalizeSaveWidget, savesToLibrary} = await source;
-    for (const value of [null, undefined, 0, 'false']) {
-        const node = classicNode(['a', '', '', '', '', '', value]);
-        normalizeSaveWidget(node);
-        assert.equal(savesToLibrary(node), true, String(value));
-    }
-    const short = classicNode(['a', '', '', '', '', '']);
-    assert.equal(normalizeSaveWidget(short), false);
-    assert.equal(savesToLibrary(short), true);
-    const off = classicNode(['a', '', '', '', '', '', false]);
-    assert.equal(normalizeSaveWidget(off), false);
-    assert.equal(savesToLibrary(off), false);
-});
-
-test('a node without the widget (an older backend) saves', async () => {
-    const {normalizeSaveWidget, savesToLibrary} = await source;
-    assert.equal(savesToLibrary({widgets: [{name: 'text', value: ''}]}), true);
-    assert.equal(normalizeSaveWidget({widgets: []}), false);
-    assert.equal(savesToLibrary(undefined), true);
-});
-
-test('the switch moves after the editor fallbacks so every frontend has one order', async () => {
-    const {placeSaveWidgetLast} = await source;
-    const widgets = ['text', 'category', 'tags', 'search_text', 'save_to_library', 'prepend_text', 'append_text'].map(name => ({name}));
-    const node = {widgets};
-    assert.equal(placeSaveWidgetLast(node), true);
-    assert.deepEqual(node.widgets.map(widget => widget.name), ['text', 'category', 'tags', 'search_text', 'prepend_text', 'append_text', 'save_to_library']);
-    assert.equal(placeSaveWidgetLast(node), false, 'already last');
-    assert.equal(placeSaveWidgetLast({widgets: [{name: 'text'}]}), false);
-});
-
-test('setting the switch updates the widget, its saved value and notifies the host', async () => {
-    const {setSaveToLibrary, savesToLibrary} = await source;
-    const calls = [];
-    const node = classicNode(['a', '', '', '', '', '', true]);
-    node.widgets[6].callback = value => calls.push(value);
-    setSaveToLibrary(node, false);
-    assert.equal(savesToLibrary(node), false);
-    assert.equal(node.widgets_values[6], false);
-    assert.deepEqual(calls, [false]);
-    setSaveToLibrary({widgets: []}, false);
-});

tests/js/workspace-collections.test.js

@@ -1,313 +0,0 @@
-// Collections (#331 D136–D140): the client store, the route hash, the names, every user-facing string and the
-// mapping of the routes' error codes.
-const test = require('node:test');
-const assert = require('node:assert/strict');
-
-const source = import('../../web/js/workspace/collections.mjs');
-
-const FILE = Object.freeze({ root_index: 0, root_scope: 'a'.repeat(64), path: 'grids/one.png' });
-
-function apiError(status, code) {
-    return Object.assign(new Error(code || `HTTP ${status}`), { status, code: code || null });
-}
-
-function fakeApi() {
-    const calls = [];
-    const pending = [];
-    const api = {
-        calls,
-        get(url, options) {
-            calls.push(['GET', url, options?.cache]);
-            if (url.includes('/membership?')) return api.membershipResult ?? Promise.resolve({ success: true, collection_ids: [2] });
-            return new Promise((resolve, reject) => pending.push({ resolve, reject }));
-        },
-        post(url, body) {
-            calls.push(['POST', url, body]);
-            return api.postResult ?? Promise.resolve({ success: true, collection: { id: 5, name: 'Grids' }, created: true,
-                added: body.items.length, already: 0, not_found: 0 });
-        },
-        patch(url, body) {
-            calls.push(['PATCH', url, body]);
-            return api.patchResult ?? Promise.resolve({ success: true, collection: { id: 2, name: body.name } });
-        },
-        del(url, options) {
-            calls.push(['DELETE', url, options?.body]);
-            return api.deleteResult ?? Promise.resolve(options?.body
-                ? { success: true, collection: { id: options.body.collection_id, name: 'Portraits' }, removed: options.body.items.length }
-                : { success: true, deleted: true });
-        },
-    };
-    return { api, pending };
-}
-
-const LISTED = { success: true, collections: [
-    { id: 4, name: 'Experiments', count: 8, missing: 0 },
-    { id: 2, name: 'Landscapes', count: 12, missing: 1 },
-] };
-
-/** A store whose first read answered with `data`; the test's own timer seam replaces the 300 ms count timer. */
-async function readyStore(data = LISTED) {
-    const { createCollections } = await source;
-    const { api, pending } = fakeApi();
-    const timers = [];
-    const controller = new AbortController();
-    const store = createCollections(api, controller.signal, {
-        setTimer: (run, delay) => { timers.push({ run, delay, cleared: false }); return timers.length; },
-        clearTimer: id => { if (timers[id - 1]) timers[id - 1].cleared = true; },
-    });
-    store.load();
-    pending.shift().resolve(data);
-    await store.settled();
-    return { store, api, pending, timers, controller };
-}
-
-test('the route hash, the name rule and the limits', async () => {
-    const { collectionHash, normalizeCollectionName, MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_ITEMS,
-        COLLECTION_COUNT_DELAY_MS } = await source;
-    assert.equal(collectionHash(12), '#/collection/12');
-    assert.throws(() => collectionHash(0), TypeError);
-    assert.throws(() => collectionHash('3'), TypeError);
-    assert.equal(MAX_COLLECTION_NAME_LENGTH, 100);
-    assert.equal(MAX_COLLECTION_ITEMS, 500);
-    assert.equal(COLLECTION_COUNT_DELAY_MS, 300);
-    // Trimmed, each run of whitespace one space, 1 to 100 characters, no control characters (design §1).
-    assert.equal(normalizeCollectionName('  LoRa   testing   grids '), 'LoRa testing grids');
-    assert.equal(normalizeCollectionName('x'.repeat(100)), 'x'.repeat(100));
-    for (const bad of ['', '   ', 'x'.repeat(101), 'bad\u0007name', 7, null, undefined]) {
-        assert.equal(normalizeCollectionName(bad), null, String(bad));
-    }
-    // A tab or newline is whitespace, collapsed rather than refused.
-    assert.equal(normalizeCollectionName('a\tb\nc'), 'a b c');
-});
-
-test('the listing keeps usable rows in the server order, with counts only when they are counts', async () => {
-    const { parseCollections, parseCollection } = await source;
-    assert.deepEqual(parseCollections({ success: true, collections: [
-        { id: 3, name: 'b', count: 2, missing: 0 },
-        { id: 0, name: 'bad id' },
-        { id: 1, name: '  ', count: 1, missing: 0 },
-        { id: 7, name: 'A', count: null, missing: null },
-        { id: 9, name: 'c', count: -1, missing: 1.5 },
-    ] }), [
-        { id: 3, name: 'b', count: 2, missing: 0 },
-        { id: 7, name: 'A', count: null, missing: null },
-        { id: 9, name: 'c', count: null, missing: null },
-    ]);
-    assert.equal(parseCollection(null), null);
-    assert.throws(() => parseCollections({ success: true }), TypeError);
-});
-
-test('every user-facing string of the design (§7.4, §8)', async () => {
-    const c = await source;
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 1, already: 0, notFound: 0 }), 'Added 1 image to “X”.');
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 3, already: 0, notFound: 0 }), 'Added 3 images to “X”.');
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 1, already: 1, notFound: 0 }),
-        'Added 1 image to “X”. 1 was already in it.');
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 2, already: 3, notFound: 1 }),
-        'Added 2 images to “X”. 3 were already in it. 1 could not be found.');
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 1, already: 0, notFound: 2 }),
-        'Added 1 image to “X”. 2 could not be found.');
-    assert.equal(c.addedMessage({ collection: { name: 'X' }, added: 0, already: 4, notFound: 0 }),
-        'All selected images were already in “X”.');
-    assert.equal(c.FILES_NOT_FOUND_TOAST, 'None of the selected images could be found. Refresh the images and try again.');
-    assert.equal(c.SOURCE_CHANGED_TOAST, 'The sources changed. Refresh the images and try again.');
-    assert.equal(c.ADD_FAILED_TOAST, 'The images could not be added. Try again.');
-    assert.equal(c.removedMessage('X', 1), 'Removed 1 image from “X”.');
-    assert.equal(c.removedMessage('X', 4), 'Removed 4 images from “X”.');
-    assert.equal(c.REMOVE_FAILED_TOAST, 'The images could not be removed. Try again.');
-    assert.equal(c.COLLECTION_GONE_TOAST, 'That collection no longer exists.');
-    assert.deepEqual([c.COLLECTION_NOUNS.title, c.COLLECTION_NOUNS.label, c.COLLECTION_NOUNS.deleteTitle],
-        ['Edit collection', 'Collection name', 'Delete collection']);
-    assert.equal(c.COLLECTION_NOUNS.renamed, 'Collection renamed.');
-    assert.equal(c.RENAMED_TOAST, 'Collection renamed.');
-    assert.equal(c.nameTakenMessage('LoRa'), 'A collection named “LoRa” already exists.');
-    assert.equal(c.RENAME_FAILED_TOAST, 'The collection could not be renamed. Try again.');
-    // The stored count: listed members plus missing ones.
-    assert.equal(c.deleteQuestion({ name: 'X', count: 1, missing: 0 }),
-        'Delete “X”? Its 1 image stays where it is; only the collection is removed.');
-    assert.equal(c.deleteQuestion({ name: 'X', count: 3, missing: 1 }),
-        'Delete “X”? Its 4 images stay where they are; only the collection is removed.');
-    assert.equal(c.deleteQuestion({ name: 'X', count: null, missing: null }),
-        'Delete “X”? Its images stay where they are; only the collection is removed.');
-    assert.equal(c.COLLECTION_NOUNS.deleteText({ name: 'X', count: 2, missing: 0 }), c.deleteQuestion({ name: 'X', count: 2, missing: 0 }));
-    assert.equal(c.DELETED_TOAST, 'Collection deleted.');
-    assert.equal(c.DELETE_FAILED_TOAST, 'The collection could not be deleted. Try again.');
-    assert.equal(c.DELETED_PAGE_TEXT, 'This collection no longer exists.');
-    assert.equal(c.OPEN_IMAGES_LINK, 'Open Images');
-    assert.equal(c.VIEW_COLLECTION_DELETED, 'The collection this view uses was deleted.');
-    assert.equal(c.LIST_FAILED_TEXT, 'Collections could not be loaded. Your saved data has not changed.');
-    assert.equal(c.missingNote(1), '1 image in this collection is not in your current sources.');
-    assert.equal(c.missingNote(5), '5 images in this collection are not in your current sources.');
-    for (const none of [0, null, undefined, -1, 1.5]) assert.equal(c.missingNote(none), '');
-    assert.equal(c.TOO_MANY_TOAST, 'Select at most 500 images.');
-    assert.deepEqual([c.ADD_DIALOG_TITLE, c.ADD_DIALOG_LABEL, c.ADD_DIALOG_ACTION],
-        ['Add selected images to collection', 'Collection name', 'Add']);
-    assert.equal(c.COLLECTIONS_UPDATED_TOAST, 'Collections updated.');
-    assert.equal(c.UPDATE_FAILED_TEXT, 'The collections could not be updated. Try again.');
-    assert.equal(c.MEMBERSHIP_LOADING_TEXT, 'Loading collections…');
-    assert.equal(c.MEMBERSHIP_FAILED_TEXT, 'Collections could not be loaded.');
-    assert.equal(c.NO_COLLECTIONS_TEXT, 'No collections yet. Name one below.');
-});
-
-test('a write failure maps the routes\' error codes to their strings', async () => {
-    const { writeFailure, renameFailure, isCollectionGone, COLLECTION_GONE_TOAST, SOURCE_CHANGED_TOAST,
-        FILES_NOT_FOUND_TOAST, ADD_FAILED_TOAST, RENAME_FAILED_TOAST } = await source;
-    assert.equal(writeFailure(apiError(404, 'collection-not-found'), ADD_FAILED_TOAST), COLLECTION_GONE_TOAST);
-    assert.equal(writeFailure(apiError(409, 'source-changed'), ADD_FAILED_TOAST), SOURCE_CHANGED_TOAST);
-    assert.equal(writeFailure(apiError(404, 'files-not-found'), ADD_FAILED_TOAST), FILES_NOT_FOUND_TOAST);
-    for (const other of [apiError(500), apiError(400), apiError(404), new TypeError('x'), null]) {
-        assert.equal(writeFailure(other, ADD_FAILED_TOAST), ADD_FAILED_TOAST);
-    }
-    assert.equal(isCollectionGone(apiError(404, 'collection-not-found')), true);
-    assert.equal(isCollectionGone(apiError(404)), false);
-    // The Edit dialog: a taken name stays in the dialog; a gone collection closes it; anything else keeps it open.
-    assert.deepEqual(renameFailure('LoRa')(apiError(409, 'name-taken')), { field: 'A collection named “LoRa” already exists.' });
-    assert.deepEqual(renameFailure('LoRa')(apiError(404, 'collection-not-found')), { toast: COLLECTION_GONE_TOAST, close: true });
-    assert.deepEqual(renameFailure('LoRa')(apiError(500)), { toast: RENAME_FAILED_TOAST });
-});
-
-test('the store reports loads, keeps the last list after a failed read, and a newer read supersedes', async () => {
-    const { createCollections, COLLECTIONS_URL } = await source;
-    const { api, pending } = fakeApi();
-    const store = createCollections(api);
-    assert.equal(store.status, 'loading');
-    const seen = [];
-    store.subscribe(next => seen.push([next.status, next.collections.map(item => item.id)]));
-    store.load();
-    const settled = store.settled();
-    pending[0].resolve(LISTED);
-    assert.equal((await settled).status, 'ready');
-    assert.deepEqual(api.calls[0], ['GET', COLLECTIONS_URL, 'no-store']);
-    assert.deepEqual(store.find(2), { id: 2, name: 'Landscapes', count: 12, missing: 1 });
-    assert.equal(store.find(3), null);
-    assert.deepEqual(store.collections.map(item => item.name), ['Experiments', 'Landscapes']);
-
-    store.load();
-    pending[1].reject(new Error('offline'));
-    await store.settled();
-    assert.equal(store.status, 'error');
-    assert.deepEqual(store.collections.map(item => item.id), [4, 2]);
-
-    store.load();
-    store.load();
-    pending[3].resolve({ success: true, collections: [{ id: 8, name: 'New', count: 0, missing: 0 }] });
-    pending[2].resolve(LISTED);
-    await store.settled();
-    assert.deepEqual(store.collections.map(item => item.id), [8]);
-    assert.deepEqual(seen.at(-1), ['ready', [8]]);
-    // A malformed listing is a failed read.
-    store.load();
-    pending[4].resolve({ success: true });
-    await store.settled();
-    assert.equal(store.status, 'error');
-});
-
-test('adding by name or id sends only the file identity and re-reads the counts 300 ms after the last change', async () => {
-    const { store, api, pending, timers } = await readyStore();
-    const { COLLECTION_ITEMS_URL } = await source;
-    const result = await store.add({ name: '  Grids  ' }, [{ ...FILE, title: 'ignored', favorite: true }]);
-    assert.deepEqual(api.calls.at(-1), ['POST', COLLECTION_ITEMS_URL, { name: 'Grids', items: [FILE] }]);
-    assert.deepEqual(result, { collection: { id: 5, name: 'Grids' }, created: true, added: 1, already: 0, notFound: 0 });
-    // The new collection is listed at once (its count arrives with the re-read), in name order.
-    assert.deepEqual(store.collections.map(item => [item.id, item.count]), [[4, 8], [5, null], [2, 12]]);
-    api.postResult = Promise.resolve({ success: true, collection: { id: 2, name: 'Landscapes' }, created: false, added: 0,
-        already: 1, not_found: 1 });
-    const again = await store.add({ collectionId: 2 }, [FILE, { ...FILE, path: 'b.png' }]);
-    assert.deepEqual(api.calls.at(-1)[2], { collection_id: 2, items: [FILE, { ...FILE, path: 'b.png' }] });
-    assert.deepEqual(again, { collection: { id: 2, name: 'Landscapes' }, created: false, added: 0, already: 1, notFound: 1 });
-    // One trailing re-read for the run of writes.
-    assert.deepEqual(timers.map(timer => [timer.delay, timer.cleared]), [[300, true], [300, false]]);
-    const reads = api.calls.filter(call => call[0] === 'GET').length;
-    timers.at(-1).run();
-    assert.equal(api.calls.filter(call => call[0] === 'GET').length, reads + 1);
-    pending.shift().resolve(LISTED);
-    await store.settled();
-});
-
-test('a write is refused before sending when its target or files are not valid', async () => {
-    const { store, api } = await readyStore();
-    const sent = api.calls.length;
-    const many = Array.from({ length: 501 }, (_, index) => ({ ...FILE, path: `${index}.png` }));
-    for (const [target, items] of [
-        [{ name: '' }, [FILE]], [{ name: 'x'.repeat(101) }, [FILE]], [{ collectionId: 0 }, [FILE]], [{}, [FILE]],
-        [{ name: 'a', collectionId: 2 }, [FILE]], [{ collectionId: 2 }, []], [{ collectionId: 2 }, many],
-        [{ collectionId: 2 }, [{ ...FILE, root_index: -1 }]], [{ collectionId: 2 }, [{ ...FILE, path: '' }]],
-        [{ collectionId: 2 }, [{ ...FILE, root_scope: 3 }]], [{ collectionId: 2 }, 'a.png'],
-    ]) {
-        await assert.rejects(store.add(target, items), TypeError);
-    }
-    await assert.rejects(store.remove(0, [FILE]), TypeError);
-    await assert.rejects(store.remove(2, []), TypeError);
-    await assert.rejects(store.rename(2, '   '), TypeError);
-    await assert.rejects(store.delete(-1), TypeError);
-    await assert.rejects(store.membership({ root_index: 'x', root_scope: 'a', path: 'p' }), TypeError);
-    assert.equal(api.calls.length, sent);
-});
-
-test('a write to a collection that is gone re-reads the list at once and rejects with the error', async () => {
-    const { store, api, pending } = await readyStore();
-    const { isCollectionGone } = await source;
-    api.postResult = Promise.reject(apiError(404, 'collection-not-found'));
-    const reads = api.calls.filter(call => call[0] === 'GET').length;
-    await assert.rejects(store.add({ collectionId: 2 }, [FILE]), error => isCollectionGone(error));
-    assert.equal(api.calls.filter(call => call[0] === 'GET').length, reads + 1);
-    pending.shift().resolve({ success: true, collections: [LISTED.collections[0]] });
-    await store.settled();
-    assert.equal(store.find(2), null);
-    // Another failure re-reads nothing.
-    api.deleteResult = Promise.reject(apiError(500));
-    await assert.rejects(store.remove(4, [FILE]), error => error.status === 500);
-    assert.equal(api.calls.filter(call => call[0] === 'GET').length, reads + 1);
-});
-
-test('remove sends the collection and files; membership reads one file\'s collections', async () => {
-    const { store, api, timers } = await readyStore();
-    const { COLLECTION_ITEMS_URL, COLLECTION_MEMBERSHIP_URL } = await source;
-    assert.deepEqual(await store.remove(2, [FILE]), { collection: { id: 2, name: 'Portraits' }, removed: 1 });
-    assert.deepEqual(api.calls.at(-1), ['DELETE', COLLECTION_ITEMS_URL, { collection_id: 2, items: [FILE] }]);
-    assert.equal(timers.length, 1);
-    assert.deepEqual(await store.membership(FILE), [2]);
-    const [method, url] = api.calls.at(-1);
-    assert.equal(method, 'GET');
-    const query = new URL(url, 'http://local');
-    assert.equal(query.pathname, COLLECTION_MEMBERSHIP_URL);
-    assert.deepEqual(Object.fromEntries(query.searchParams), { root_index: '0', root_scope: FILE.root_scope, path: FILE.path });
-    api.membershipResult = Promise.resolve({ success: true, collection_ids: [1, 'x'] });
-    await assert.rejects(store.membership(FILE), TypeError);
-});
-
-test('rename and delete change the listed row at once and re-read the counts', async () => {
-    const { store, api, timers } = await readyStore();
-    const { COLLECTIONS_URL } = await source;
-    const renamed = await store.rename(2, '  A  grids ');
-    assert.deepEqual(api.calls.at(-1), ['PATCH', `${COLLECTIONS_URL}/2`, { name: 'A grids' }]);
-    assert.deepEqual(renamed, { id: 2, name: 'A grids' });
-    // The row keeps its counts and moves to its new place in name order.
-    assert.deepEqual(store.collections.map(item => [item.id, item.name, item.count]), [[2, 'A grids', 12], [4, 'Experiments', 8]]);
-    assert.equal(await store.delete(4), 4);
-    assert.deepEqual(api.calls.at(-1), ['DELETE', `${COLLECTIONS_URL}/4`, undefined]);
-    assert.deepEqual(store.collections.map(item => item.id), [2]);
-    // Already gone (another tab): the outcome the user asked for.
-    api.deleteResult = Promise.reject(apiError(404, 'collection-not-found'));
-    assert.equal(await store.delete(2), 2);
-    assert.deepEqual(store.collections, []);
-    api.patchResult = Promise.reject(apiError(409, 'name-taken'));
-    await assert.rejects(store.rename(9, 'Taken'), error => error.code === 'name-taken');
-    assert.equal(timers.filter(timer => !timer.cleared).length, 1);
-});
-
-test('a disposed store stops its count timer, drops a read in flight and reads no more', async () => {
-    const { store, timers, controller, api, pending } = await readyStore();
-    await store.rename(2, 'Kept');
-    const seen = [];
-    store.subscribe(next => seen.push(next));
-    store.load();
-    controller.abort();
-    assert.equal(timers.at(-1).cleared, true);
-    pending.shift().resolve(LISTED);
-    await new Promise(resolve => setImmediate(resolve));
-    assert.equal(seen.filter(next => next.status === 'ready').length, 0);
-    const sent = api.calls.length;
-    await store.load();
-    assert.equal(api.calls.length, sent);
-});

tests/js/workspace-file-inspector.test.js

@@ -185,26 +185,6 @@ test('legacy fill applies to local records', async () => {
     assert.notEqual(zeroed.prompts.positive.text, '');
 });
 
-test('a branch named by recorded run history shows the Recorded run badge', async () => {
-    // #386: the server labels sides whose save node recorded history named; Execution recorded stays stronger.
-    const base = await localRecord(new File([fs.readFileSync(new URL('f09.png', PARITY))], 'f09.png'));
-    const recorded = {...base, prompts:{positive:{...base.prompts.positive, source:'recorded-run'}, negative:{...base.prompts.negative, source:'recorded-run'}}};
-    let view = renderFull(recorded);
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Recorded run']);
-        assert.ok(view.texts(n => n.tagName === 'p').includes('Prompt evidence: recorded run'));
-    } finally { view.done(); }
-    view = renderFull({...recorded, prompts:{...recorded.prompts, negative:{...recorded.prompts.negative, source:'execution'}}});
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Execution recorded']);
-    } finally { view.done(); }
-    // A recorded branch whose negative left out a run-time part is still inferred from the workflow.
-    view = renderFull({...recorded, prompts:{...recorded.prompts, negative:{...recorded.prompts.negative, source:'runtime-parts-omitted'}}});
-    try {
-        assert.deepEqual(view.texts(n => n.className === 'chip blue'), ['Workflow inferred']);
-    } finally { view.done(); }
-});
-
 // #249 PR C Task C3 (D88): one chip row, the file's current image tags first, then D21's linked tags not already shown.
 function tagged(imageTags, library = {status:'linked', tags:['Minimal', 'warm_light', 'editorial'], tags_scope:'positive'}) {
     return {...record(), imageTags, library};
@@ -383,32 +363,3 @@ test('the D117 wrap rule targets only the settings summary button', async () =>
     assert.deepEqual(rules.map(line => line.trim()), ['.ca-tools #viewer-details .settings-summary { white-space: normal; /* D117 */ }']);
     assert.doesNotMatch(css, /#viewer-details > div > button/);
 });
-
-test('category chip names its origin visibly and shows an own category for any link status (#332 D146)', async () => {
-    const base = await localRecord(localPng('a.png'));
-    const chipTexts = record => {
-        const {f, done} = renderFull(record);
-        try {
-            return f.walk(f.container, n => /(^| )chip( |$)/.test(n.className ?? '')).map(n => n.textContent);
-        } finally { done(); }
-    };
-    const cases = [
-        [{status:'none', category:'Scans', category_scope:'image'}, 'Image category: Scans · this image'],
-        [{status:'ambiguous', category:'Scans', category_scope:'image'}, 'Image category: Scans · this image'],
-        [{status:'linked', category:'Portraits', category_scope:'image'}, 'Image category: Portraits · this image'],
-        [{status:'linked', category:'Landscapes', category_scope:'positive'}, 'Positive prompt category: Landscapes · prompt'],
-        [{status:'linked', category:'Recipes', category_scope:'pair'}, 'Recipe category: Recipes · recipe'],
-    ];
-    for (const [library, text] of cases) {
-        const chips = chipTexts({...base, library:{...base.library, tags:[], tags_scope:null, ...library}});
-        assert.ok(chips.includes(text), `${JSON.stringify(library)} -> ${chips}`);
-    }
-    for (const library of [
-        {status:'none', category:'Inherited', category_scope:'positive'},
-        {status:'linked', category:null, category_scope:null},
-        {status:'none', category:null, category_scope:null},
-    ]) {
-        const chips = chipTexts({...base, library:{...base.library, tags:[], tags_scope:null, ...library}});
-        assert.equal(chips.some(chip => /category: /.test(chip)), false, JSON.stringify(library));
-    }
-});

tests/js/workspace-images-category.test.js

@@ -1,61 +1,53 @@
 const test = require('node:test');
 const assert = require('node:assert/strict');
-
-// #332 D140: Set category writes each selected image's own category; Use prompt category removes it.
 const source = import('../../web/js/workspace/images-category.mjs');
 
-test('the dialog keeps the concept\'s simpleInput words and names the routes', async () => {
-    const {CATEGORY_DIALOG, USE_PROMPT_CATEGORY, REMOVE_DIALOG, CATEGORY_URL, IMAGE_CATEGORIES_URL, CATEGORY_FAILED,
-        CATEGORY_MAX_LENGTH, MAX_CATEGORY_IMAGES} = await source;
-    assert.deepEqual({...CATEGORY_DIALOG}, {title:'Categorize selected images', label:'Category', action:'Apply'});
-    assert.equal(USE_PROMPT_CATEGORY, 'Use prompt category');
-    assert.deepEqual({...REMOVE_DIALOG}, {title:'Use prompt category', action:'Remove'});
-    assert.equal(CATEGORY_URL, '/prompt_manager/images/category');
-    assert.equal(IMAGE_CATEGORIES_URL, '/prompt_manager/images/categories');
+const linked = (id, extra = {}) => ({path:`p${id}.png`, linked:{status:'linked', positive_id:id, ...extra}});
+
+test('targets are the distinct linked positives, in selection order, and the rest count as skipped', async () => {
+    const {categoryTargets} = await source;
+    const images = [
+        linked(7), linked(3), linked(7),
+        {path:'u.png', linked:{status:'unlinked', positive_id:null}},
+        {path:'a.png', linked:{status:'ambiguous', positive_id:4}},
+        {path:'v.png', linked:{status:'unavailable', positive_id:null}},
+        {path:'none.png'},
+        {path:'bad.png', linked:{status:'linked', positive_id:'9'}},
+        {path:'zero.png', linked:{status:'linked', positive_id:0}},
+        {path:'frac.png', linked:{status:'linked', positive_id:1.5}},
+        null,
+    ];
+    assert.deepEqual(categoryTargets(images), {promptIds:[7, 3], skipped:8});
+    assert.deepEqual(categoryTargets([]), {promptIds:[], skipped:0});
+    assert.deepEqual(categoryTargets([linked(2)]), {promptIds:[2], skipped:0});
+});
+
+test('the outcome toast counts the prompts and the skipped images', async () => {
+    const {categoryOutcome} = await source;
+    assert.equal(categoryOutcome(3, 0), 'Category set on 3 prompts.');
+    assert.equal(categoryOutcome(1, 0), 'Category set on 1 prompt.');
+    assert.equal(categoryOutcome(2, 4), 'Category set on 2 prompts. 4 selected images had no linked prompt and were skipped.');
+    assert.equal(categoryOutcome(1, 1), 'Category set on 1 prompt. 1 selected image had no linked prompt and was skipped.');
+});
+
+test('the dialog and failure copy is the plan\'s', async () => {
+    const {CATEGORY_DIALOG, CATEGORY_NONE_LINKED, CATEGORY_FAILED} = await source;
+    assert.deepEqual(CATEGORY_DIALOG, {title:'Categorize selected images', label:'Category', action:'Apply'});
+    assert.equal(CATEGORY_NONE_LINKED, "None of the selected images is linked to a saved prompt, so there is no prompt category to set.");
     assert.equal(CATEGORY_FAILED, 'Category could not be set. Try again.');
-    assert.equal(CATEGORY_MAX_LENGTH, 100);
-    assert.equal(MAX_CATEGORY_IMAGES, 500);
+    assert.ok(Object.isFrozen(CATEGORY_DIALOG));
 });
 
-test('a set counts unchanged files as set and names files that could not be found', async () => {
-    const {setOutcome} = await source;
-    assert.equal(setOutcome({updated:1, unchanged:0, not_found:0}, 'Portraits'), 'Category “Portraits” set on 1 image.');
-    assert.equal(setOutcome({updated:1, unchanged:2, not_found:0}, 'Scans'), 'Category “Scans” set on 3 images.');
-    assert.equal(setOutcome({updated:2, unchanged:0, not_found:1}, 'Scans'), 'Category “Scans” set on 2 images. 1 could not be found.');
-    assert.equal(setOutcome({updated:0, unchanged:1, not_found:3}, 'Scans'), 'Category “Scans” set on 1 image. 3 could not be found.');
-    assert.equal(setOutcome({}, 'Scans'), 'Category “Scans” set on 0 images.');
-});
-
-test('a removal says how many lost their own category, or that none had one', async () => {
-    const {clearOutcome, NONE_HAD_OWN} = await source;
-    assert.equal(clearOutcome({cleared:1}), 'Removed the image category from 1 image.');
-    assert.equal(clearOutcome({cleared:4}), 'Removed the image category from 4 images.');
-    assert.equal(clearOutcome({cleared:0}), NONE_HAD_OWN);
-    assert.equal(NONE_HAD_OWN, 'None of the selected images had its own category.');
-});
-
-test('the confirmation states the count', async () => {
-    const {removeQuestion} = await source;
-    assert.equal(removeQuestion(1), "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.');
-    assert.match(removeQuestion(1200), /^Remove the image category from the 1,200 selected images\? /);
-});
-
-test('coded failures have their own sentences, anything else the fixed one', async () => {
-    const {failureMessage, NONE_FOUND, SOURCES_CHANGED, CATEGORY_FAILED} = await source;
-    assert.equal(failureMessage({code:'files-not-found'}), NONE_FOUND);
-    assert.equal(NONE_FOUND, 'None of the selected images could be found. Refresh the images and try again.');
-    assert.equal(failureMessage({code:'source-changed'}), SOURCES_CHANGED);
-    assert.equal(SOURCES_CHANGED, 'The sources changed. Refresh the images and try again.');
-    assert.equal(failureMessage({code:'too-many-images', message:'Select at most 500 images.'}), 'Select at most 500 images.');
-    for (const error of [null, undefined, new Error('x'), {code:'other', message:'secret'}]) {
-        assert.equal(failureMessage(error), CATEGORY_FAILED);
+test('the updated count is the server\'s when it is a count, else the number of prompts posted', async () => {
+    const {updatedCount} = await source;
+    assert.equal(updatedCount({updated_count:0}, 3), 0);
+    assert.equal(updatedCount({updated_count:2}, 3), 2);
+    for (const result of [{}, {updated_count:-1}, {updated_count:1.5}, {updated_count:'2'}, null, undefined]) {
+        assert.equal(updatedCount(result, 3), 3, JSON.stringify(result));
     }
 });
 
-test('the toolbar list merges prompt and image categories once each', async () => {
-    const {mergeCategories} = await source;
-    assert.deepEqual(mergeCategories(['Landscapes', 'Portraits'], ['Scans', 'Landscapes']), ['Landscapes', 'Portraits', 'Scans']);
-    assert.deepEqual(mergeCategories(['A', '', '  ', 7], null), ['A']);
-    assert.deepEqual(mergeCategories(undefined, ['landscapes', 'Landscapes']), ['landscapes', 'Landscapes']);
+test('the category field is limited to the server\'s 100 characters', async () => {
+    const {CATEGORY_MAX_LENGTH} = await source;
+    assert.equal(CATEGORY_MAX_LENGTH, 100);
 });