test(system): compare Auto-tagging with the concept against the real backend

.github/branch-protection.json

@@ -1,6 +1,6 @@
 {
   "required_status_checks": {
-    "strict": false,
+    "strict": true,
     "contexts": [
       "py3.12 on ubuntu-latest",
       "py3.13 on ubuntu-latest",

.github/workflows/code-quality.yml

@@ -4,7 +4,6 @@ permissions:
   contents: read
 
 on:
-  merge_group:
   push:
     branches: [main]
   pull_request:

.github/workflows/test.yml

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

.github/workflows/viewerjs-check.yml

@@ -1,7 +1,6 @@
 name: Viewer.js vendor and compatibility
 
 on:
-  merge_group:
   pull_request:
     branches: [main]
   push:

TESTING.md

@@ -275,77 +275,6 @@ Start fixing as soon as a failed log shows the cause, but push the fix only afte
 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.
 
-## Background threads at exit
-
-PromptManager's own background threads stop through one package teardown,
-`_stop_background_work()` in `__init__.py` (#301, #302). It runs once and
-works against one 10 s deadline. Each step gets the smaller of its own bound
-and the time left. The steps, in order:
-
-1. Refuse new previews (`refuse_auto_thumbnails()`), then detach the
-   monitor's callbacks (Needs review recorder, preview queue, Images listing
-   listener).
-2. `ImageMonitor.stop_monitoring` works against one 5 s deadline. Closing the
-   image handler joins the image worker; watchdog's `observer.stop()` (not
-   bounded here) and the observer join get what is left, which can be 0 s.
-3. `close_auto_thumbnails(final=True)` stops the preview worker (30 s) and
-   kills ffmpeg.
-4. `PromptTracker.shutdown` stops the prompt cleanup thread (2 s).
-
-A failing step, or a second Ctrl+C, is logged with its traceback and does not
-skip the later steps. A clean run logs one INFO line to PromptManager's log:
-`Background work stopped in 0.4 s: monitor=ok thumbnails=ok tracker=ok`. If
-any part is still running, one WARNING goes to the console:
-`Background work not stopped in time (10.0 s): monitor`. A Ctrl+C that lands
-between two steps (each step catches its own) is re-raised after the result is
-stored, with the parts not reached False, and the `atexit` callback is
-removed: the later steps are skipped, no summary line is logged, and a later
-call returns that result and runs nothing.
-
-ComfyUI never runs aiohttp's `on_cleanup` hooks, because it never calls
-`runner.cleanup()`. So `atexit` is the live host's path. It runs on Ctrl+C
-(`main.py` catches `KeyboardInterrupt` and returns) and on a normal exit.
-The teardown is registered after the execution history hook, so at exit
-(newest first) it runs before the history writer's 2 s dispose.
-It also runs from `on_cleanup` on hosts that do run it (our test servers) and
-from the tests' package unload (`cleanup_package`), and it removes its own
-`atexit` callback. Nothing runs when the process is killed: SIGTERM, a
-ComfyUI-Manager restart through `os.execv`, a closed Windows console, or
-ComfyUI Desktop stopping its server. SQLite's WAL journal covers those.
-
-Stop contract: `PromptTracker.shutdown(timeout)`,
-`ImageGenerationHandler.shutdown(timeout)` (restartable),
-`ImageGenerationHandler.close(timeout)` (final: `schedule()` refuses and a
-sealed run's re-check is dropped) and `ImageMonitor.stop_monitoring(timeout)`
-each signal their thread and join it within the bound. They return True only
-when it ended, and log a warning naming the part when it did not. Called on
-their own thread, they only signal.
-
-Test rules:
-
-- Every test that constructs a real `PromptTracker`, `ImageGenerationHandler`
-  or `ImageMonitor` ends with its final stop and an assertion
-  (`tests/background_stops.py`: `close_handler`, `stop_monitor`,
-  `stop_tracker`). The stop comes before the folder and databases are removed.
-  `tearDown` runs before `addCleanup` callbacks, so a class whose `tearDown`
-  removes files stops the thread there.
-- A test waits for a state through an `Event` set by the code under test, or
-  by a wrapper around it, with a 30 s ceiling. It never sleeps or polls for
-  that state.
-- A test that asserts "still running" first waits for an `entered` event
-  inside the held call, then stops with `timeout=0.05`.
-- A test that asserts a history writer's `dispose()`/`close()` is True right
-  after queuing work drains first (`drain_writer`), or holds the write itself
-  (#370).
-- Patch the module attribute of the code under test (for example
-  `utils.prompt_tracker.time`, or the package's `_clock`), or patch with
-  `wraps=`. Never replace a `time` or `atexit` function for the whole
-  process.
-- `tests/test_package_exit.py` runs a child process that imports the
-  package, leaves the image worker alive and returns. Its `atexit` reporter
-  checks the teardown's result. This is the interpreter path ComfyUI takes
-  after Ctrl+C, on all three OS.
-
 ## Performance budgets
 
 A spec performance budget gets two tests:
@@ -3496,9 +3425,7 @@ workflow (README changelog).
 ### LoRA reference import contract (#221, #249 System S10)
 
 The LoRA import is staged (`py/lora_import.py`): discover the LoraManager
-`*.metadata.json` files and fingerprint every scanned one, kept or skipped (path, size,
-modification time and whether it was kept, #362; a skipped sidecar added, removed or edited
-after the review refuses Start with `plan-changed`, `test_start_refused_when_a_skipped_sidecar_changed`); stage each
+`*.metadata.json` files and fingerprint them (path, size, modification time); stage each
 record (CivitAI example images go into the image cache first, best effort, counted in
 `downloaded` / `download_errors`; each image is written to a temp file beside its cache
 entry and moved in place, so a half-written image is never seen as cached); the files are
@@ -3564,67 +3491,25 @@ the kept, readable LoRAs and `skipped` the rest. Media per LoRA, without repeats
 preview (`preview_url`, else LoraManager's `PREVIEW_EXTENSIONS` order), then every file in
 `<example-images root>[/<library>]/<sha256>/` in natural order; a leading video yields to the
 first still. A file counts only with a servable extension and inside the guarded media
-roots. Only an absolute `preview_url` is used; a relative one is skipped with a DEBUG line
-naming the sidecar. A sidecar that is not valid UTF-8 JSON is skipped like any unreadable
-one (#362). CivitAI downloads run only for a LoRA without local media; a record's
-images are linked in reverse order, so its first image (the cover) is the newest link and
-the card image. The folder guard keeps a folder from the settings, and each of ComfyUI's
-default LoRA folders (`models/loras`, `extra_model_paths.yaml`, `folder_paths`), only when
-it exists and is neither a filesystem root (`/`, `C:\`, a UNC share root) nor the home
-folder or a folder that contains it (realpath + `normcase`); a refused default folder that
-exists is listed in the layout's `refused_defaults` and logged as one warning each time the
-refused set changes (`RefusedDefaultsTests`). An unusable layout (no install, unreadable /
-non-JSON / non-object / oversized settings, no `platformdirs`, a missing or refused
-centralized sidecar root, "the sidecar folder is a filesystem root, the home folder or a
-folder that contains it") gives a review without a token ("LoraManager settings: not
-usable: <reason>. Nothing was changed."), a legacy scan error with that reason, the default
-LoRA roots for serving (no example-images root), and trigger words from the default roots
-in alongside mode. A folder discovery cannot list answers the review with 500, code
-`folder-unreadable` ("A LoRA folder could not be listed (...). Nothing was changed.").
-`TriggerWordCache.load` never raises: an `OSError` is a warning, anything else is logged
-with its traceback (#362), both keep the previous map, and a running node retries a failed
-load only after 60 s (`TRIGGER_RETRY_SECONDS`). `tests/run_suite.py` and `tests/browser/server.py` point
+roots. CivitAI downloads run only for a LoRA without local media. The folder guard keeps a
+settings folder only when it exists and is neither a filesystem root (`/`, `C:\`, a UNC
+share root) nor the home folder or one of its ancestors (realpath + `normcase`). An
+unusable layout (no install, unreadable / non-JSON / non-object / oversized settings, no
+`platformdirs`, a missing or refused centralized sidecar root) gives a review without a
+token ("LoraManager settings: not usable: <reason>. Nothing was changed."), a legacy scan
+error with that reason, the default LoRA roots for serving, and trigger words from the
+default roots in alongside mode. `tests/run_suite.py` and `tests/browser/server.py` point
 `LORA_MANAGER_SETTINGS_DIR` at a disposable folder, so no test reads the developer's real
 LoraManager settings; tests that call `load_layout` inject their own folder too.
 
-**Linked-only gate and the layout cache (#362).** While the integration is on, the LoRA
-allow-list (`ImagesMixin._lora_image_dirs`) is the layout's `media_roots` plus the CivitAI
-download cache, and `_media_roots(outputs)` appends it after the output folders for Library
-previews, the Library prompt detail, the per-prompt images page, `serve_output_image` for a
-root past the outputs, `inspect_image` and `reveal_image`. Under such a root only a file the
-database records as a linked image is served, inspected or revealed (`_linked_only_error`,
-by its given and its real path); anything else answers 403. Library responses mark that
-media `linked_only`: no preview file, no favorite, no Tag button. The allow-list's layout
-comes from `py/lora_layout_cache.py` (`tests/test_lora_layout_cache.py`, which injects the
-clocks, `stat` and `ntpath` and never sleeps): one entry keyed by the stripped configured
-path, reused while the plugin settings file's and the settings file's `(st_mtime_ns,
-st_size)` (or "missing") are unchanged, the install and every media root still resolve to
-themselves (a folder swapped for a symlink reloads and the guard runs again), and the entry
-is under `MAX_AGE_SECONDS` (30 s, monotonic clock) old. A load is stored only when no
-watched file was modified within `RACY_SECONDS` (3 s) of the load (git's racy rule: a write
-during the load, LoraManager's in-place write, FAT/HFS+ coarse times), every watched file
-could be checked (any `stat` error but not-found, and an offline Windows share, is "cannot
-validate"), the settings were readable, and no `clear()` ran meanwhile (generation
-counter). Hits take no lock; concurrent misses each load. A finished import (System job or
-legacy scan, both through `replace_lora_imports`) clears it. The integration-off check runs
-before it, and the configured-path rule (a configured path that is not an install under
-`custom_nodes` adds no folders) on its result; a hit also needs the same home folder, which
-the guard compares against. `serve_image` builds the allow-list in the
-executor. The cache writes one INFO line, "LoraManager layout changed: <source> settings,
-<mode> storage, <n> media folders", when a stored layout differs from the last one logged.
-The review, Start, the legacy scan and the trigger cache read the layout fresh. Image route
-tests clear the per-process cache in `ImageRouteCoverageCase.setUp`; `write_settings` in
-`TestLoraManagerMediaServing` back-dates its file 10 s so the first load is stored.
-
 `tests/browser/workspace_integrations_fixture.py` (`/__test__/integrations/*`) makes a fake
 LoraManager install and LoRA folder under the server's temp root, holds or fails the
 import, saves a blocking pair and answers CivitAI downloads with a stub opener, so no
 test reaches the network.
 
 ```sh
-python3 -m unittest tests.test_lora_layout_cache tests.test_lora_manager_layout \
-  tests.test_lora_import tests.test_api_lora tests.test_lora_database tests.test_lora_utils \
-  tests.test_api_images -v
+python3 -m unittest tests.test_lora_manager_layout tests.test_lora_import tests.test_api_lora \
+  tests.test_lora_database tests.test_lora_utils -v
 node --test tests/js/workspace-system-integrations.test.js tests/js/prompt-bridge-adapter.test.js
 npm run --prefix tools/vendor test:workflows -- workspace-system-integrations.spec.mjs \
   system-integrations-concept.spec.mjs \
@@ -3636,8 +3521,7 @@ npm run --prefix tools/vendor test:workflows -- workspace-system-integrations.sp
 System › Auto-tagging (`web/js/workspace/system-tagging.mjs`, D132–D134) edits one
 server-side tagging configuration, `autotag.defaults` in config.json: `model_type`
 (`wd14-swinv2`, `wd14-vit`, `gguf`, `hf`), `existing` (`skip`, `merge`,
-`replace_after_review`), `general_threshold` and `character_threshold` (0–1 in
-steps of 0.05, #369),
+`replace_after_review`), `general_threshold` and `character_threshold` (0–1),
 `template` (non-blank, at most 4,000 characters and 16 KiB) and `suggestion_limit`
 (1–100). They are host drafts (`autotag_model_type`, `autotag_existing`,
 `autotag_general_threshold`, `autotag_character_threshold`, `autotag_template`,
@@ -3648,13 +3532,7 @@ naming the setting by its row label ("General-tag confidence must be between 0 a
 `settingRefusal` in system.mjs only for a save that carried `autotag_*` keys; every
 other section's plain 400 keeps the generic status) and the control is highlighted.
 The template's limit counts code points, as Python's `len` does. A hand-edited bad value
-falls back to its default on load, one key at a time. Every page shows the thresholds in
-steps of 0.05 (the System rows, the Tag image dialogs, the legacy sliders), so a saved
-threshold off that grid is refused ("General-tag confidence must be a multiple of
-0.05.", `validate_saved_threshold`; `draftProblem` holds back Preview tagging review and
-the batch Review with the same sentence) and falls back on load; an accepted one is
-stored exactly on the grid (#369). A per-request threshold keeps its own check: `/image-annotations/suggest` and
-`/jobs/autotag` take 0–1; the legacy `/autotag/single` and `/autotag/start` only require a number. `GET /autotag/models` reports the
+falls back to its default on load, one key at a time. `GET /autotag/models` reports the
 saved values (`wd14_general_threshold`, `wd14_character_threshold`, `suggestion_limit`,
 `default_prompt`, `model_type`, `existing`), so the Tag image and Auto-tag selected
 dialogs start from them; a preset (the bulk review, Preview tagging review) wins.

__init__.py

@@ -22,10 +22,7 @@ Features:
 - Comprehensive logging and diagnostics
 """
 
-import atexit
 import re
-import threading
-import time
 from pathlib import Path
 
 
@@ -75,12 +72,6 @@ NODE_DISPLAY_NAME_MAPPINGS = {
 # are served by our own routes instead (see py/api).
 WEB_DIRECTORY = "web/comfy"
 
-# Parts the package teardown stops (``_stop_background_work``). Each stays None
-# when its start-up block below fails, and the teardown skips it.
-api = None
-_global_prompt_tracker = None
-_global_image_monitor = None
-
 # Add API routes (same pattern as ComfyUI_Assets)
 try:
     # Set extension URI
@@ -98,6 +89,8 @@ try:
     api.add_routes(routes)
     # Temp files of preview writes a crash interrupted (#317), off the
     # import path: the walk may cover a large thumbnails folder.
+    import threading
+
     threading.Thread(
         target=api.sweep_thumbnail_temps,
         name="PromptManagerPreviewTempSweep",
@@ -148,16 +141,29 @@ try:
 
     # The Needs review pass for ambiguous new outputs runs through the API's
     # capture store (the one the scan and the Tag dialog use): a linked output
-    # is never queued and its pending items leave the queue. The package
-    # teardown detaches it before that store is closed at shutdown.
-    if api is not None:
-        _global_image_monitor.set_review_recorder(api.record_review_file)
+    # is never queued and its pending items leave the queue. It stops before
+    # that store is closed at shutdown.
+    _review_api = globals().get("api")
+    if _review_api is not None:
+        _global_image_monitor.set_review_recorder(_review_api.record_review_file)
         # Every settled output's preview is queued for the API's background
         # worker (#249): the workspace never asks to generate thumbnails.
-        _global_image_monitor.set_thumbnail_queue(api.queue_capture_thumbnail)
+        _global_image_monitor.set_thumbnail_queue(_review_api.queue_capture_thumbnail)
         # Every settled output walks its Images listing again (#348): the
         # API hops from the monitor's thread onto the server's loop.
-        _global_image_monitor.set_output_listener(api.notify_output_settled)
+        _global_image_monitor.set_output_listener(_review_api.notify_output_settled)
+        _review_host = getattr(config.server_instance, "app", None)
+        if _review_host is not None and hasattr(_review_host, "on_cleanup"):
+
+            async def _stop_review_recording(
+                app, monitor=_global_image_monitor, api=_review_api
+            ):
+                monitor.set_review_recorder(None)
+                monitor.set_thumbnail_queue(None)
+                monitor.set_output_listener(None)
+                api.close_auto_thumbnails(final=True)
+
+            _review_host.on_cleanup.insert(0, _stop_review_recording)
 
     # Start monitoring
     _global_image_monitor.start_monitoring()
@@ -227,155 +233,6 @@ except Exception:
             "Failed to register execution history"
         )
 
-
-# ── Package teardown (#301, #302) ────────────────────────────────────────────
-# ComfyUI never runs aiohttp's cleanup hooks (it never calls
-# ``runner.cleanup()``), so ``atexit`` is the live host's path: Ctrl+C, and a
-# normal exit. It is registered after the history hook, so at exit (newest
-# first) it runs before the history dispose. Hosts that do run ``on_cleanup``
-# (our test servers) run it there, and the tests' package unload calls it.
-
-TEARDOWN_SECONDS = 10.0
-_clock = time.monotonic
-_background_work_lock = threading.Lock()
-_background_work_result = None
-
-
-def _teardown_step(name, stop, logger):
-    """Run one teardown step; a failure (even Ctrl+C) is logged and is False."""
-    try:
-        return bool(stop())
-    except (Exception, KeyboardInterrupt):
-        logger.error(f"Background work: stopping {name} failed", exc_info=True)
-        return False
-
-
-def _teardown_logger():
-    """PromptManager's init logger; the standard one if that cannot load."""
-    try:
-        from .utils.logging_config import get_logger
-
-        return get_logger("prompt_manager.init")
-    except Exception:
-        import logging
-
-        return logging.getLogger("prompt_manager.init")
-
-
-def _stop_background_work():
-    """Stop the image monitor, the preview worker and the prompt cleanup
-    thread against one TEARDOWN_SECONDS deadline, once.
-
-    Returns ``{"monitor", "thumbnails", "tracker"}`` booleans (True: it
-    stopped), leaving out parts that never started. Later calls return a
-    copy of the first result. A Ctrl+C inside a step is logged and the
-    step is False; one between steps is re-raised after the result (parts
-    not reached are False) is stored and the ``atexit`` entry removed.
-    """
-    global _background_work_result
-    with _background_work_lock:
-        if _background_work_result is not None:
-            return dict(_background_work_result)
-        monitor, thumbnails, tracker = (
-            _global_image_monitor,
-            api,
-            _global_prompt_tracker,
-        )
-        # A part whose global is set has started; False until its step says
-        # otherwise, so an interrupt between steps leaves an honest result.
-        started = (
-            ("monitor", monitor),
-            ("thumbnails", thumbnails),
-            ("tracker", tracker),
-        )
-        result = {name: False for name, part in started if part is not None}
-        try:
-            logger = _teardown_logger()
-            began = _clock()
-            deadline = began + TEARDOWN_SECONDS
-
-            def left(own_bound):
-                return max(0.0, min(own_bound, deadline - _clock()))
-
-            if monitor is not None:
-
-                def stop_monitor():
-                    from .utils.image_monitor import OBSERVER_JOIN_SECONDS
-
-                    # Callbacks first: an image in hand queues no preview into a
-                    # closing preview worker. The worker may have read the queue
-                    # callback already, so the API refuses new previews too (at
-                    # exit, Python 3.12+ refuses to start their worker thread).
-                    if thumbnails is not None:
-                        thumbnails.refuse_auto_thumbnails()
-                    monitor.set_review_recorder(None)
-                    monitor.set_thumbnail_queue(None)
-                    monitor.set_output_listener(None)
-                    return monitor.stop_monitoring(left(OBSERVER_JOIN_SECONDS))
-
-                result["monitor"] = _teardown_step(
-                    "the image monitor", stop_monitor, logger
-                )
-            if thumbnails is not None:
-
-                def close_previews():
-                    from .py.api.thumbnail_auto import CLOSE_WAIT_SECONDS
-
-                    return thumbnails.close_auto_thumbnails(
-                        final=True, timeout=left(CLOSE_WAIT_SECONDS)
-                    )
-
-                result["thumbnails"] = _teardown_step(
-                    "the preview worker", close_previews, logger
-                )
-            if tracker is not None:
-
-                def stop_tracker():
-                    from .utils.prompt_tracker import TRACKER_JOIN_SECONDS
-
-                    return tracker.shutdown(left(TRACKER_JOIN_SECONDS))
-
-                result["tracker"] = _teardown_step(
-                    "the prompt cleanup thread", stop_tracker, logger
-                )
-            elapsed = _clock() - began
-            failed = [name for name, ok in result.items() if not ok]
-            if failed:
-                logger.warning(
-                    f"Background work not stopped in time ({elapsed:.1f} s): "
-                    + ", ".join(failed)
-                )
-            else:
-                parts = " ".join(f"{name}=ok" for name in result)
-                logger.info(f"Background work stopped in {elapsed:.1f} s: {parts}")
-        finally:
-            _background_work_result = result
-            atexit.unregister(_stop_background_work)
-        return dict(result)
-
-
-async def _stop_background_work_on_cleanup(app):
-    """aiohttp ``on_cleanup``: no request is served then, so it runs inline."""
-    _stop_background_work()
-
-
-try:
-    atexit.register(_stop_background_work)
-    from .py.config import server_instance as _teardown_server
-
-    _teardown_host = getattr(_teardown_server, "app", None)
-    if _teardown_host is not None and hasattr(_teardown_host, "on_cleanup"):
-        _teardown_host.on_cleanup.insert(0, _stop_background_work_on_cleanup)
-except Exception as e:
-    try:
-        from .utils.logging_config import get_logger
-
-        get_logger("prompt_manager.init").error(
-            f"Failed to register the background work teardown: {e}"
-        )
-    except Exception:
-        pass
-
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
 
 # Print startup message with loaded tools

py/api/images.py

@@ -2272,8 +2272,7 @@ class ImageRoutesMixin:
                 )
 
             image_path = Path(image["image_path"])
-            lora_dirs = await self._run_in_executor(self._lora_image_dirs)
-            allowed_dirs = list(self._get_all_output_dirs()) + lora_dirs
+            allowed_dirs = list(self._get_all_output_dirs()) + self._lora_image_dirs()
 
             denied = _media_access_error(image_path, allowed_dirs)
             if denied is not None:
@@ -2321,10 +2320,7 @@ class ImageRoutesMixin:
         LoraManager's guarded LoRA roots, sidecar root and example-images
         root (``lora_manager_layout.media_roots``, #355) and PromptManager's
         CivitAI download cache. An unusable LoraManager layout gives the
-        default LoRA roots and the cache. The layout comes from the layout
-        cache (``lora_utils.cached_lora_manager_layout``, #362), which reloads
-        when LoraManager's settings files change; blocking, so the routes
-        call it in the executor.
+        default LoRA roots and the cache.
         """
         try:
             from ..config import IntegrationConfig
@@ -2332,18 +2328,25 @@ class ImageRoutesMixin:
             if not IntegrationConfig.LORA_MANAGER_ENABLED:
                 return []
             from ..lora_utils import (
-                cached_lora_manager_layout,
                 get_lora_image_cache_dir,
+                layout_for_install,
+                lora_manager_layout,
             )
 
-            configured = IntegrationConfig.LORA_MANAGER_PATH or ""
-            install, layout = cached_lora_manager_layout(configured)
-            if configured.strip() and install is None:
+            lora_root = IntegrationConfig.LORA_MANAGER_PATH or ""
+            if lora_root.strip():
                 # A configured path comes from config.json, which can be hand
                 # edited: only a LoraManager install under custom_nodes may
                 # widen the serving allow-list. An empty path keeps the
                 # auto-detection, which itself only scans custom_nodes.
-                return []
+                from ..lora_utils import resolve_lora_manager_path
+
+                lora_root = resolve_lora_manager_path(lora_root)
+                if not lora_root:
+                    return []
+                layout = layout_for_install(lora_root)
+            else:
+                layout = lora_manager_layout("")
 
             dirs = [Path(d) for d in layout.media_roots]
             # Named, not made: listing and serving never create the cache.

py/api/lora_import_routes.py

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

py/api/settings_routes.py

@@ -173,8 +173,8 @@ def _validate_autotag_settings(data):
         EXISTING_POLICIES,
         MAX_SUGGESTION_LIMIT,
         MODEL_TYPES,
-        validate_saved_threshold,
         validate_template,
+        validate_threshold,
     )
 
     updates = {}
@@ -198,7 +198,7 @@ def _validate_autotag_settings(data):
     ):
         if key in data:
             try:
-                value = validate_saved_threshold(label, data[key])
+                value = validate_threshold(label, data[key])
             except ValueError as error:
                 raise ValueError(f"{error}.") from None
             updates[key.upper()] = value

py/api/thumbnail_auto.py

@@ -488,16 +488,10 @@ class AutoThumbnailer:
                 f"Automatic preview failed for {src.name}", exc_info=True
             )
 
-    def close(self, timeout=None):
+    def close(self):
         """Stop the worker at its next file boundary (queued files are
-        dropped), kill a running ffmpeg and wait up to ``timeout`` seconds
-        (None: CLOSE_WAIT_SECONDS, read now); a worker still running after
-        that is logged.
-
-        Returns True when there was no worker or it ended; False when it is
-        still running, or when called on the worker itself (it only signals).
-        """
-        wait = CLOSE_WAIT_SECONDS if timeout is None else timeout
+        dropped), kill a running ffmpeg and wait up to CLOSE_WAIT_SECONDS;
+        a worker still running after that is logged."""
         with self._changed:
             self._closed = True
             self._queue.clear()
@@ -510,18 +504,14 @@ class AutoThumbnailer:
                 process.kill()
             except OSError:
                 pass
-        if worker is None:
-            return True
-        if worker is threading.current_thread():
-            return False
-        worker.join(wait)
+        if worker is None or worker is threading.current_thread():
+            return
+        worker.join(CLOSE_WAIT_SECONDS)
         if worker.is_alive():
             self._logger.warning(
                 "The automatic preview worker is still running after "
-                f"{wait} s; it stops at its next file"
+                f"{CLOSE_WAIT_SECONDS} s; it stops at its next file"
             )
-            return False
-        return True
 
     # ── waits (tests and shutdown; never timers) ──────────────────────
 
@@ -619,19 +609,12 @@ class AutoThumbnailMixin:
                 )
             return self._auto_thumbnailer
 
-    def refuse_auto_thumbnails(self):
-        """Refuse every later capture without stopping the worker yet (the
-        package teardown, before ``close_auto_thumbnails(final=True)``)."""
-        with AutoThumbnailMixin._auto_thumbnailer_lock:
-            self._auto_thumbnails_shut = True
-
-    def close_auto_thumbnails(self, final=False, timeout=None):
+    def close_auto_thumbnails(self, final=False):
         """Stop the capture worker and the view pool, and forget them.
 
-        Bounded by ``timeout`` (see AutoThumbnailer.close). ``final`` (the
-        package teardown) also keeps a late monitor event from starting a
-        worker again; a test reset passes False and the next use starts
-        fresh ones. Returns True when no capture worker is left running.
+        Bounded (see AutoThumbnailer.close). ``final`` (the app's cleanup)
+        also keeps a late monitor event from starting a worker again; a
+        test reset passes False and the next use starts fresh ones.
         """
         with AutoThumbnailMixin._auto_thumbnailer_lock:
             if final:
@@ -639,14 +622,12 @@ class AutoThumbnailMixin:
             thumbnailer, self._auto_thumbnailer = self._auto_thumbnailer, None
             pool, self._preview_pool_obj = self._preview_pool_obj, None
             self._preview_gate_obj = None
-        closed = True
         if thumbnailer is not None:
-            closed = thumbnailer.close(timeout)
+            thumbnailer.close()
         if pool is not None:
             pool.shutdown(wait=False, cancel_futures=True)
         if final:
             shutdown_encoders()  # kill JPEG XL / ffmpeg encoders still running
-        return closed
 
     def _auto_thumbnail_failures(self):
         thumbnailer = self._auto_thumbnailer

py/config.py

@@ -573,7 +573,6 @@ try:
         MAX_INSTRUCTION_CHARS,
         MODEL_TYPES,
         WD14_MODEL_TYPES,
-        validate_saved_threshold,
         validate_template,
         validate_threshold,
     )
@@ -586,7 +585,6 @@ except ImportError:
         MAX_INSTRUCTION_CHARS,
         MODEL_TYPES,
         WD14_MODEL_TYPES,
-        validate_saved_threshold,
         validate_template,
         validate_threshold,
     )
@@ -633,12 +631,12 @@ class AutotagConfig:
         "existing": ("EXISTING", _valid_existing, "skip"),
         "general_threshold": (
             "GENERAL_THRESHOLD",
-            lambda v: validate_saved_threshold("value", v),
+            lambda v: validate_threshold("value", v),
             0.35,
         ),
         "character_threshold": (
             "CHARACTER_THRESHOLD",
-            lambda v: validate_saved_threshold("value", v),
+            lambda v: validate_threshold("value", v),
             0.85,
         ),
         "template": ("TEMPLATE", validate_template, DEFAULT_TAG_TEMPLATE),

py/lora_import.py

@@ -12,10 +12,9 @@ last writes to the database:
    the sidecars (``discover``). In ``alongside`` mode a sidecar beside its
    model is kept when ``<base>.safetensors`` exists; in ``centralized`` mode
    every sidecar under the sidecar root is kept when its ``file_path`` names
-   a model inside a LoRA root. ``fingerprint`` covers every scanned sidecar,
-   kept or skipped (path, size, modification time, kept or not, #362) and the
-   layout; ``preview`` adds the counts a review shows. Nothing is written
-   and nothing is requested.
+   a model inside a LoRA root. ``fingerprint`` covers the kept sidecars (path,
+   size and modification time) and the layout; ``preview`` adds the counts a
+   review shows. Nothing is written and nothing is requested.
 2. **stage**: read each sidecar and build its record. Its LoraManager preview
    and example images are linked where they are (``local_media``); only a
    LoRA without any local image downloads its CivitAI example images into the
@@ -70,10 +69,9 @@ def discover(lora_manager_path: Optional[str]) -> Discovery:
 
 
 def fingerprint(discovery: Discovery) -> str:
-    """What a review saw: the layout, then every scanned sidecar, kept or
-    skipped, with its path, size, modification time and whether it was kept
-    (#362). A LoraManager save that changes unrelated settings leaves it as
-    it was."""
+    """What a review saw: the layout, then each kept sidecar's path, size and
+    modification time (a LoraManager save that changes unrelated settings
+    leaves it as it was)."""
     layout = discovery.layout
     digest = hashlib.sha256()
     for value in (
@@ -89,14 +87,13 @@ def fingerprint(discovery: Discovery) -> str:
         digest.update(f"{value}\n".encode("utf-8", "surrogatepass"))
     for name in discovery.unreadable:
         digest.update(f"unreadable\0{name}\n".encode("utf-8", "surrogatepass"))
-    kept = {str(sidecar.metadata_path) for sidecar in discovery.sidecars}
-    for path in discovery.scanned_files:
-        flag = 1 if str(path) in kept else 0
+    for sidecar in discovery.sidecars:
+        path = sidecar.metadata_path
         try:
             stat = path.stat()
-            entry = f"{path}\0{stat.st_size}\0{stat.st_mtime_ns}\0{flag}\n"
+            entry = f"{path}\0{stat.st_size}\0{stat.st_mtime_ns}\n"
         except OSError:
-            entry = f"{path}\0missing\0{flag}\n"
+            entry = f"{path}\0missing\n"
         digest.update(entry.encode("utf-8", "surrogatepass"))
     return "sha256:" + digest.hexdigest()
 

py/lora_layout_cache.py

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

py/lora_manager_layout.py

@@ -12,10 +12,8 @@ server share one definition:
   plugin file, or the user config folder, in LoraManager's order), keeps only
   the seven keys the import needs, and resolves the LoRA roots, the sidecar
   root (centralized storage), the example-images root and the active
-  LoraManager library. Every folder from the settings, and each of
-  ComfyUI's default LoRA folders, passes the folder guard: it must exist and
-  must not be a filesystem root, the home folder or a folder that contains
-  it. Default folders the guard refuses are listed in ``refused_defaults``.
+  LoraManager library. Every folder from the settings passes the folder
+  guard (exists, not a filesystem root, not the home folder itself).
 - ``discover_sidecars`` finds every sidecar whose model file exists inside a
   LoRA root: beside the models in ``alongside`` mode, under the sidecar root
   (matched to its model by ``file_path``) in ``centralized`` mode.
@@ -27,7 +25,6 @@ it is testable outside ComfyUI.
 """
 
 import json
-import logging
 import os
 import re
 from dataclasses import dataclass, replace
@@ -101,12 +98,7 @@ NOT_OBJECT = "the settings file is not a JSON object"
 TOO_LARGE = "the settings file is larger than 5 MB"
 NO_PLATFORMDIRS = "platformdirs is not available"
 NO_SIDECAR_ROOT = "the sidecar folder does not exist"
-BAD_SIDECAR_ROOT = (
-    "the sidecar folder is a filesystem root, the home folder or a folder "
-    "that contains it"
-)
-
-logger = logging.getLogger("prompt_manager.lora_manager_layout")
+BAD_SIDECAR_ROOT = "the sidecar folder is a filesystem root or the home folder"
 
 
 @dataclass(frozen=True)
@@ -122,9 +114,6 @@ class LoraManagerLayout:
     example_images_root: Optional[str]
     library: str
     media_roots: Tuple[str, ...]
-    # ComfyUI's default LoRA folders that exist but that the folder guard
-    # refused (canonical): the layout cache logs them (#362).
-    refused_defaults: Tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -137,20 +126,13 @@ class Sidecar:
 
 @dataclass(frozen=True)
 class Discovery:
-    """The sidecars kept, every metadata file seen, and those unread."""
+    """The sidecars kept, how many metadata files were seen, and those unread."""
 
     layout: LoraManagerLayout
     sidecars: List[Sidecar]
-    # Every ``*.metadata.json`` seen, kept or skipped: resolved, once each,
-    # sorted by ``str(path)``. The import's fingerprint covers all of them.
-    scanned_files: Tuple[Path, ...]
+    scanned: int
     unreadable: List[str]
 
-    @property
-    def scanned(self) -> int:
-        """How many metadata files were seen."""
-        return len(self.scanned_files)
-
 
 class _SettingsError(Exception):
     """The settings file cannot be used, for the reason it carries."""
@@ -333,23 +315,6 @@ def _guarded(paths, home: str) -> Tuple[str, ...]:
     return tuple(kept)
 
 
-def _refused(paths, home: str) -> Tuple[str, ...]:
-    """The folders in ``paths`` that exist but that the guard refuses."""
-    refused = []
-    for path in paths:
-        absolute = _absolute(path)
-        if not absolute or not os.path.isdir(absolute):
-            continue
-        if _guard_folder(absolute, home) is None:
-            try:
-                canonical = _canonical(absolute)
-            except (OSError, ValueError):
-                continue
-            if canonical not in refused:
-                refused.append(canonical)
-    return tuple(refused)
-
-
 def _example_images_root(
     settings: Mapping, library: str, libraries: int, home: str
 ) -> Optional[str]:
@@ -386,9 +351,7 @@ def load_layout(
     default LoRA roots, so serving and trigger words keep working.
     """
     home = str(Path.home())
-    default_list = list(default_roots())
-    defaults = _guarded(default_list, home)
-    refused_defaults = _refused(default_list, home)
+    defaults = _guarded(default_roots(), home)
     fallback = LoraManagerLayout(
         settings_path=None,
         source=None,
@@ -399,7 +362,6 @@ def load_layout(
         example_images_root=None,
         library="default",
         media_roots=defaults,
-        refused_defaults=refused_defaults,
     )
     if not lora_manager_path:
         return fallback
@@ -415,14 +377,10 @@ def load_layout(
     except _SettingsError as error:
         return replace(fallback, error=str(error))
     settings = _settings_subset(raw or {})
-    return _layout_from_settings(
-        settings, settings_path, source, defaults, home, refused_defaults
-    )
+    return _layout_from_settings(settings, settings_path, source, defaults, home)
 
 
-def _layout_from_settings(
-    settings, settings_path, source, defaults, home, refused_defaults=()
-):
+def _layout_from_settings(settings, settings_path, source, defaults, home):
     library, entry, libraries = _active_library(settings)
     lora_roots = _media_roots(
         defaults,
@@ -442,7 +400,6 @@ def _layout_from_settings(
         example_images_root=example_root,
         library=library,
         media_roots=_media_roots(lora_roots, [example_root]),
-        refused_defaults=refused_defaults,
     )
     if mode != MODE_CENTRALIZED:
         return layout
@@ -525,13 +482,13 @@ def discover_sidecars(layout: LoraManagerLayout) -> Discovery:
     cannot see every folder must not replace the collection with part of it.
     """
     if layout.error is not None:
-        return Discovery(layout, [], (), [])
+        return Discovery(layout, [], 0, [])
     if layout.mode == MODE_CENTRALIZED:
         folders = [layout.sidecar_root]
     else:
         folders = list(layout.lora_roots)
     seen = set()
-    scanned: List[Path] = []
+    scanned = 0
     unreadable: List[str] = []
     sidecars = []
     for folder in folders:
@@ -541,13 +498,12 @@ def discover_sidecars(layout: LoraManagerLayout) -> Discovery:
             if key in seen:
                 continue
             seen.add(key)
-            scanned.append(resolved)
+            scanned += 1
             model = _model_for(resolved, layout, unreadable)
             if model is not None:
                 sidecars.append(Sidecar(resolved, Path(os.path.realpath(model))))
     sidecars.sort(key=lambda sidecar: str(sidecar.metadata_path))
-    scanned.sort(key=str)
-    return Discovery(layout, sidecars, tuple(scanned), unreadable)
+    return Discovery(layout, sidecars, scanned, unreadable)
 
 
 # ── images ──────────────────────────────────────────────────────────
@@ -570,15 +526,8 @@ def _example_files(folder: str) -> List[str]:
 def _preview_candidates(sidecar: Sidecar, metadata: Dict) -> Iterator[str]:
     """The paths a preview is looked for at, in LoraManager's order."""
     url = metadata.get("preview_url")
-    if isinstance(url, str) and url.strip():
-        if os.path.isabs(url.strip()):
-            yield url.strip()
-        else:
-            # LoraManager writes absolute paths; it would resolve a relative
-            # one against its working directory, not the sidecar folder.
-            logger.debug(
-                "Relative preview_url skipped in %s", sidecar.metadata_path.name
-            )
+    if isinstance(url, str) and url.strip() and os.path.isabs(url.strip()):
+        yield url.strip()
     base = sidecar.metadata_path.name[: -len(METADATA_SUFFIX)]
     for suffix in PREVIEW_EXTENSIONS:
         yield str(sidecar.metadata_path.parent / f"{base}{suffix}")

py/lora_utils.py

@@ -30,7 +30,6 @@ except ImportError:
 
 from dataclasses import replace
 
-from .lora_layout_cache import LayoutCache
 from .lora_manager_layout import (
     MODE_ALONGSIDE,
     METADATA_SUFFIX,
@@ -296,35 +295,10 @@ def layout_for_install(install: Optional[str]) -> LoraManagerLayout:
 
 
 def lora_manager_layout(lora_manager_path: Optional[str]) -> LoraManagerLayout:
-    """Where LoraManager keeps its files (``py/lora_manager_layout.py``).
-
-    A fresh read: the import review, Start, the legacy scan and the trigger
-    word cache use it. The image hot paths use ``cached_lora_manager_layout``.
-    """
+    """Where LoraManager keeps its files (``py/lora_manager_layout.py``)."""
     return layout_for_install(lora_manager_install(lora_manager_path))
 
 
-# The image hot paths' layout cache (#362). The lambdas look the functions up
-# when called, so a test that patches them here is seen by the cache.
-_layout_cache = LayoutCache(
-    lambda path: lora_manager_install(path),
-    lambda install: layout_for_install(install),
-)
-
-
-def cached_lora_manager_layout(
-    configured: Optional[str],
-) -> Tuple[Optional[str], LoraManagerLayout]:
-    """``(install, layout)`` for the configured path, from the layout cache
-    while LoraManager's settings files are unchanged (``py/lora_layout_cache.py``)."""
-    return _layout_cache.get(configured or "")
-
-
-def clear_layout_cache() -> None:
-    """Drop the cached layout (after an import linked files in new folders)."""
-    _layout_cache.clear()
-
-
 def _get_extra_lora_paths(comfyui_root: Path) -> List[Path]:
     """Parse extra_model_paths.yaml for additional LoRA directories."""
     results = []
@@ -368,7 +342,7 @@ def read_lora_metadata(metadata_path: Path) -> Optional[Dict]:
     try:
         with open(metadata_path, "r", encoding="utf-8") as f:
             return json.load(f)
-    except (ValueError, OSError) as e:  # JSONDecodeError, UnicodeDecodeError
+    except (json.JSONDecodeError, OSError) as e:
         logger.debug(f"Failed to read {metadata_path}: {e}")
         return None
 
@@ -883,13 +857,11 @@ class TriggerWordCache:
         """
         try:
             new_cache = self._build(lora_manager_path)
-        except OSError as error:
+        except Exception as error:
             logger.warning(f"Trigger word cache not refreshed: {error}")
-            return self._failed()
-        except Exception:
-            # Not a disk error: keep the traceback (#362).
-            logger.exception("Trigger word cache not refreshed")
-            return self._failed()
+            with self._lock:
+                self._failed_at = time.monotonic()
+                return len(self._cache)
 
         with self._lock:
             self._cache = new_cache
@@ -901,12 +873,6 @@ class TriggerWordCache:
         )
         return len(new_cache)
 
-    def _failed(self) -> int:
-        """Keep the previous map and note when this load failed."""
-        with self._lock:
-            self._failed_at = time.monotonic()
-            return len(self._cache)
-
     @staticmethod
     def _build(lora_manager_path: str) -> Dict[str, List[str]]:
         layout = lora_manager_layout(lora_manager_path)

py/tagging_defaults.py

@@ -39,25 +39,6 @@ def validate_threshold(name: str, value: Any) -> float:
     return float(value)
 
 
-# Every page shows the thresholds in steps of 0.05 (the concept's System rows,
-# the Tag image dialogs and the legacy sliders), so a saved one must be on that
-# grid (#369). Per-request thresholds keep their own checks.
-THRESHOLD_STEP = 0.05
-_STEPS_PER_UNIT = round(1 / THRESHOLD_STEP)
-# A computed float can miss the grid by a hair: (0.1 + 0.2) * 20 is 6.000000000000001.
-_STEP_TOLERANCE = 1e-12  # in steps; refuses 0.35000000001
-
-
-def validate_saved_threshold(name: str, value: Any) -> float:
-    """A saved WD14 threshold: in [0, 1] and a multiple of ``THRESHOLD_STEP``,
-    returned exactly on the grid; else ValueError naming ``name``."""
-    value = validate_threshold(name, value)
-    steps = value * _STEPS_PER_UNIT
-    if abs(steps - round(steps)) > _STEP_TOLERANCE:
-        raise ValueError(f"{name} must be a multiple of {THRESHOLD_STEP}")
-    return round(steps) / _STEPS_PER_UNIT
-
-
 def validate_template(value: Any, name: str = "instructions") -> str:
     """Non-empty language-model instructions within the character and byte
     caps, or ValueError naming ``name``."""

tests/background_stops.py

@@ -1,27 +0,0 @@
-"""Final stops for the background threads a test starts (#301, #302).
-
-Every real ``ImageGenerationHandler``, ``ImageMonitor`` or ``PromptTracker``
-a test constructs ends with its final stop and an assertion, before the
-test's folder and databases go: ``close()`` for a handler,
-``stop_monitoring()`` for a monitor, ``shutdown()`` for a tracker.
-"""
-
-from utils.prompt_tracker import PromptTracker
-
-
-def stop_tracker(testcase, tracker):
-    """Shut a real tracker's cleanup thread down; mocks are left alone."""
-    if isinstance(tracker, PromptTracker):
-        testcase.assertTrue(tracker.shutdown(), "prompt cleanup thread still running")
-
-
-def close_handler(testcase, handler):
-    """Close ``handler`` for good, then stop the tracker it was built with."""
-    testcase.assertTrue(handler.close(), "image worker still running")
-    stop_tracker(testcase, getattr(handler, "prompt_tracker", None))
-
-
-def stop_monitor(testcase, monitor):
-    """Stop ``monitor`` (its observer and worker), then its tracker."""
-    testcase.assertTrue(monitor.stop_monitoring(), "image monitor still running")
-    stop_tracker(testcase, getattr(monitor, "prompt_tracker", None))

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

@@ -429,9 +429,7 @@ test('Rebuild all is explicit and the plan line says every preview is regenerate
     await expect(page).toHaveURL(/#\/activity\/[0-9a-f]{32}$/);
     expect(seen.starts).toEqual([{ mode: 'rebuild' }]);
     const id = page.url().split('/').pop();
-    // Rebuild regenerates all 24 previews with real image work: on a busy CI
-    // runner that took over 5 s (12 of 24 done at the default poll budget).
-    await expect.poll(async () => (await serverJson(request, `/prompt_manager/jobs/${id}`)).job.state, { timeout: 30000 }).toBe('finished');
+    await expect.poll(async () => (await serverJson(request, `/prompt_manager/jobs/${id}`)).job.state).toBe('finished');
 });
 
 test('a plan that cannot be read says so; Start still starts', async ({ page }) => {

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

@@ -188,35 +188,6 @@ test('a refused value shows the server\'s message', async ({ page, request }) =>
     await expect(actionOf(page, 'Preview tagging review')).not.toHaveAttribute('aria-disabled', 'true');
 });
 
-test('a value off the 0.05 step is refused and never reaches the Tag image dialog (#369)', async ({ page, request }) => {
-    const before = (await serverJson(request, SETTINGS_URL)).settings;
-    const STEP = 'General-tag confidence must be a multiple of 0.05.';
-    await selectThenOpen(page, FIRST);
-    await page.locator('#threshold-general').fill('0.37');
-    await page.locator('#threshold-general').press('Tab');
-    // Preview tagging review explains instead of opening a dialog whose Generate the browser would block.
-    await expect(actionOf(page, 'Preview tagging review')).toHaveAttribute('aria-disabled', 'true');
-    await actionOf(page, 'Preview tagging review').focus();
-    await page.keyboard.press('Enter');
-    await expect(toast(page)).toHaveText(STEP);
-    await expect(tagDialog(page)).toHaveCount(0);
-    // The server refuses the save with the same sentence and writes nothing.
-    await save(page).click();
-    await expect(status(page)).toHaveText(STEP);
-    expect((await serverJson(request, SETTINGS_URL)).settings.autotag_general_threshold).toBe(before.autotag_general_threshold);
-    // A value on the step opens the dialog, and its Generate passes the browser's own check and sends.
-    await page.locator('#threshold-general').fill('0.4');
-    await page.locator('#threshold-general').press('Tab');
-    await expect(actionOf(page, 'Preview tagging review')).not.toHaveAttribute('aria-disabled', 'true');
-    await actionOf(page, 'Preview tagging review').click();
-    await expect(tagDialog(page).locator('#image-general-threshold')).toHaveValue('0.4');
-    expect(await tagDialog(page).locator('#image-general-threshold').evaluate(input => input.checkValidity())).toBe(true);
-    const suggested = page.waitForResponse(item => item.url().endsWith('/image-annotations/suggest'));
-    await tagDialog(page).getByRole('button', { name: 'Generate suggestions', exact: true }).click();
-    const answer = await suggested;
-    expect(answer.request().postDataJSON().options.general_threshold).toBe(0.4);
-});
-
 test('Download starts the job and Activity shows it without Cancel', async ({ page, request }) => {
     await unavailable(request, ['wd14-vit']);
     await fakeDownload(request, 'hold');

tests/browser/workspace_system_fixture.py

@@ -97,25 +97,15 @@ def register_system_commands(app, routes, api, root: Path):
     real_move = library_move.move_library
     keep = PromptManagerConfig.KEEP_LIBRARY_IN_NODE_FOLDER
     config_bytes = config_path.read_bytes() if config_path.exists() else None
-    from py.api.settings_routes import (
-        _AUTOTAG_SETTINGS,
-        _GALLERY_SETTINGS,
-        _SETTINGS_FILE_KEYS,
+    host_values = (
+        PromptManagerConfig.RESULT_TIMEOUT,
+        PromptManagerConfig.WEBUI_DISPLAY_MODE,
+        PromptManagerConfig.WORKER_THREADS,
+        GalleryConfig.MONITORING_ENABLED,
+        PromptManagerConfig.THUMBNAIL_FORMAT,
+        PromptManagerConfig.THUMBNAIL_QUALITY,
+        PromptManagerConfig.THUMBNAIL_EDGE,
     )
-
-    # Every value POST /settings can change, so a reset restores each one
-    # (a saved safety_backup=false once leaked into a later spec's review).
-    # The tagging settings are the tagging fixture's to reset.
-    host_values = {
-        (GalleryConfig if name in _GALLERY_SETTINGS else PromptManagerConfig, name): (
-            getattr(
-                GalleryConfig if name in _GALLERY_SETTINGS else PromptManagerConfig,
-                name,
-            )
-        )
-        for name in _SETTINGS_FILE_KEYS
-        if name not in _AUTOTAG_SETTINGS
-    }
     from py.api import thumbnail_encode
 
     monitor = getattr(image_monitor, "_monitor_instance", None)
@@ -145,8 +135,15 @@ def register_system_commands(app, routes, api, root: Path):
             unplugged.rmdir()
         GalleryConfig.MONITORING_DIRECTORIES = list(configured)
         api._health_report = None
-        for (owner, name), value in host_values.items():
-            setattr(owner, name, value)
+        (
+            PromptManagerConfig.RESULT_TIMEOUT,
+            PromptManagerConfig.WEBUI_DISPLAY_MODE,
+            PromptManagerConfig.WORKER_THREADS,
+            GalleryConfig.MONITORING_ENABLED,
+            PromptManagerConfig.THUMBNAIL_FORMAT,
+            PromptManagerConfig.THUMBNAIL_QUALITY,
+            PromptManagerConfig.THUMBNAIL_EDGE,
+        ) = host_values
         thumbnail_encode.reset_encoders()
         image_monitor._monitor_instance = monitor
         api.__dict__.pop("_library_resolver", None)

tests/comfyui/fixtures/ledger_nodes.py

@@ -1,6 +1,5 @@
 """Deterministic nodes and queue controls installed only in an owned test host."""
 
-import asyncio
 import os
 import threading
 import time
@@ -292,9 +291,7 @@ async def image_monitor(request: web.Request) -> web.Response:
         config.MONITORING_ENABLED = True
         monitor.start_monitoring([folder_paths.get_output_directory()])
     else:
-        # Joins the image worker and the observer (one shared 5 s deadline),
-        # so it runs on a worker thread, not on the event loop.
-        await asyncio.to_thread(monitor.stop_monitoring)
+        monitor.stop_monitoring()
         config.MONITORING_ENABLED = False
     return web.json_response({"monitoring": monitor.is_monitoring})
 

tests/js/workspace-system-tagging.test.js

@@ -307,16 +307,6 @@ test('Preview tagging review opens the Tag image dialog with the section’s val
     assert.deepEqual(draftProblem({ ...HOST, autotag_general_threshold: 1.5 }),
         { key: 'autotag_general_threshold', message: 'General-tag confidence must be between 0 and 1.' });
     assert.equal(draftProblem({ ...HOST, autotag_character_threshold: '' }).key, 'autotag_character_threshold');
-    // #369: every page shows the thresholds in steps of 0.05, so a value off that grid cannot be saved or previewed.
-    assert.deepEqual(draftProblem({ ...HOST, autotag_general_threshold: 0.37 }),
-        { key: 'autotag_general_threshold', message: 'General-tag confidence must be a multiple of 0.05.' });
-    assert.deepEqual(draftProblem({ ...HOST, autotag_character_threshold: 0.33 }),
-        { key: 'autotag_character_threshold', message: 'Character-tag confidence must be a multiple of 0.05.' });
-    assert.equal(draftProblem({ ...HOST, autotag_general_threshold: 0.15, autotag_character_threshold: 0.95 }), null);
-    assert.equal(draftProblem({ ...HOST, autotag_general_threshold: 0, autotag_character_threshold: 1 }), null);
-    // A computed value a hair off the grid passes and is handed on snapped to it, as the server stores it.
-    assert.equal(draftProblem({ ...HOST, autotag_general_threshold: 0.1 + 0.2 }), null);
-    assert.equal(taggingPreset({ ...HOST, autotag_general_threshold: 0.1 + 0.2 }).options.general_threshold, 0.3);
     assert.equal(draftProblem({ ...HOST, autotag_suggestion_limit: 2.5 }).key, 'autotag_suggestion_limit');
     assert.equal(draftProblem({ ...HOST, autotag_suggestion_limit: 0 }, { limit: false }), null);
     assert.deepEqual(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '  ' }),
@@ -352,11 +342,6 @@ test('Preview tagging review opens the Tag image dialog with the section’s val
         await button('Preview tagging review').dispatch('click');
         assert.deepEqual(calls.toasts, ['General-tag confidence must be between 0 and 1.']);
         assert.equal(calls.opened.length, 1);
-        byId('threshold-general').value = '0.37'; await byId('threshold-general').dispatch('change');
-        assert.equal(button('Preview tagging review').getAttribute('aria-disabled'), 'true');
-        await button('Preview tagging review').dispatch('click');
-        assert.deepEqual(calls.toasts.at(-1), 'General-tag confidence must be a multiple of 0.05.');
-        assert.equal(calls.opened.length, 1);
     } finally { scope.dispose(); dom.restore(); }
 });
 
@@ -376,8 +361,6 @@ test('the batch review grid, body and Cancel-only reasons (D134, CUJ 4–5)', as
     assert.equal(existingLabel('odd'), 'odd');
     assert.deepEqual(batchBody(HOST), { model_type: 'wd14-swinv2', existing: 'skip',
         options: { general_threshold: 0.35, character_threshold: 0.85 } });
-    // #369: a threshold a hair off the grid is sent snapped to it.
-    assert.equal(batchBody({ ...HOST, autotag_character_threshold: 0.1 + 0.2 }).options.character_threshold, 0.3);
     assert.deepEqual(batchBody(llm), { model_type: 'gguf', existing: 'skip', options: { instructions: HOST.autotag_template } });
     assert.equal(batchCloseNote(PLAN), null);
     assert.equal(batchCloseNote({ ...PLAN, review_required: true }), REPLACE_NOTE);

tests/test_api_images.py

@@ -9,11 +9,9 @@ import asyncio
 import json
 import os
 import pathlib
-import shutil
 import sys
 import tempfile
 import threading
-import time
 import types
 import unittest
 from contextlib import ExitStack
@@ -38,8 +36,6 @@ from PIL import Image  # noqa: E402
 from database.operations import PromptDatabase  # noqa: E402
 import py.api.images as images_module
 from py.api import gallery_listing  # noqa: E402
-from py import lora_utils  # noqa: E402
-from py import lora_manager_layout as layout_module  # noqa: E402
 from py.api.thumbnail_settings import ThumbnailSettings  # noqa: E402
 from py.api import PromptManagerAPI  # noqa: E402
 from py.api.prompts import MAX_PAGE_LIMIT  # noqa: E402
@@ -115,25 +111,13 @@ class ImageAPITestCase(AioHTTPTestCase):
         self.assertGreater(image_id, 0, "fixture: image link failed")
         return image_id
 
-    def _make_symlink(self, target, link, target_is_directory=False):
+    def _make_symlink(self, target, link):
         """Create a symlink or skip the test when the platform refuses."""
         try:
-            os.symlink(str(target), str(link), target_is_directory=target_is_directory)
+            os.symlink(str(target), str(link))
         except (OSError, NotImplementedError, AttributeError) as exc:
             self.skipTest(f"symlinks unavailable: {exc}")
 
-    def _spy_executor(self):
-        """Record the __name__ of every callable sent to _run_in_executor."""
-        original = self.api._run_in_executor
-        calls = []
-
-        async def spy(func, *args, **kwargs):
-            calls.append(getattr(func, "__name__", repr(func)))
-            return await original(func, *args, **kwargs)
-
-        self.api._run_in_executor = spy
-        return calls
-
 
 class TestServeOutputImage(ImageAPITestCase):
     """GET /prompt_manager/images/serve/{filepath}"""
@@ -404,6 +388,18 @@ class ThumbnailTestCase(ImageAPITestCase):
 
     PROGRESS_URL = "/prompt_manager/images/generate-thumbnails/progress"
 
+    def _spy_executor(self):
+        """Record the __name__ of every callable sent to _run_in_executor."""
+        original = self.api._run_in_executor
+        calls = []
+
+        async def spy(func, *args, **kwargs):
+            calls.append(getattr(func, "__name__", repr(func)))
+            return await original(func, *args, **kwargs)
+
+        self.api._run_in_executor = spy
+        return calls
+
     def _thumb_path(self, name, suffix=".webp"):
         return self.output_dir / "thumbnails" / f"{name}_thumb{suffix}"
 
@@ -1220,13 +1216,6 @@ def _raise(*_args, **_kwargs):
 class ImageRouteCoverageCase(ImageAPITestCase):
     """Helpers for driving success and failure branches of each route."""
 
-    def setUp(self):
-        # #362: the LoraManager layout cache is per process; every test here
-        # starts and ends with it empty (runs before the subclasses' setUpAsync).
-        super().setUp()
-        lora_utils.clear_layout_cache()
-        self.addCleanup(lora_utils.clear_layout_cache)
-
     def _break_db(self, db_method):
         setattr(self.api.db, db_method, _raise)
 
@@ -1338,9 +1327,6 @@ class TestServeErrorBranches(ImageRouteCoverageCase):
                 )
                 self.assertEqual(resp.status, 200)
 
-            # The cache does not watch default_lora_roots (#362): without a
-            # clear the next request would reuse the folders above.
-            lora_utils.clear_layout_cache()
             with (
                 patch.object(IntegrationConfig, "LORA_MANAGER_ENABLED", True),
                 patch.object(IntegrationConfig, "LORA_MANAGER_PATH", ""),
@@ -1433,39 +1419,32 @@ class TestLoraManagerMediaServing(ImageRouteCoverageCase):
         self.cache = root / "cache"
         for folder in (self.sidecars, self.examples, self.cache):
             folder.mkdir()
-        self.root = root
         self.write_settings(str(self.sidecars))
         self.enabled = patch.object(IntegrationConfig, "LORA_MANAGER_ENABLED", True)
-        self.default_roots = patch("py.lora_utils.default_lora_roots", return_value=[])
         for item in (
             self.enabled,
             patch.object(IntegrationConfig, "LORA_MANAGER_PATH", str(self.lm)),
             patch(
                 "py.lora_utils.custom_nodes_directories", return_value=[custom_nodes]
             ),
-            self.default_roots,
+            patch("py.lora_utils.default_lora_roots", return_value=[]),
             patch("py.lora_utils.get_lora_image_cache_dir", return_value=self.cache),
             patch.dict(os.environ, {"LORA_MANAGER_SETTINGS_DIR": str(self.settings)}),
         ):
             item.start()
             self.addCleanup(item.stop)
 
-    def write_settings(self, sidecar_root, examples=None):
-        path = self.settings / "settings.json"
-        path.write_text(
+    def write_settings(self, sidecar_root):
+        (self.settings / "settings.json").write_text(
             json.dumps(
                 {
                     "sidecar_storage_mode": "centralized",
                     "sidecar_storage_path": sidecar_root,
-                    "example_images_path": str(examples or self.examples),
+                    "example_images_path": str(self.examples),
                     "civitai_api_key": "never-served",
                 }
             )
         )
-        # Ten seconds old, so the layout cache (real clock here) stores the
-        # first load instead of treating the file as being written (#362).
-        stamp = time.time_ns() - 10 * 10**9
-        os.utime(path, ns=(stamp, stamp))
 
     async def _status(self, image_id):
         resp = await self.client.request(
@@ -1485,65 +1464,11 @@ class TestLoraManagerMediaServing(ImageRouteCoverageCase):
 
         for image_id in ids:
             self.assertEqual(await self._status(image_id), 200)
-        # A warm layout cache does not outlive the integration (#362).
-        self.assertIsNotNone(lora_utils._layout_cache._entry)
         self.enabled.stop()
         for image_id in ids:
             self.assertEqual(await self._status(image_id), 403)
         self.enabled.start()
 
-    def _example(self, folder=None, name="1.mp4"):
-        path = (folder or self.examples) / "ab12" / name
-        path.parent.mkdir(exist_ok=True)
-        path.write_bytes(b"video")
-        return path
-
-    async def test_unchanged_settings_reuse_the_cached_layout(self):
-        image_id = self._link_image(self._example())
-        self.assertEqual(await self._status(image_id), 200)
-        self.assertIsNotNone(lora_utils._layout_cache._entry)
-        self.assertEqual(await self._status(image_id), 200)
-        self.assertEqual(lora_utils.default_lora_roots.call_count, 1)
-
-    async def test_a_settings_change_is_seen_without_a_clear(self):
-        image_id = self._link_image(self._example())
-        self.assertEqual(await self._status(image_id), 200)
-        self.assertIsNotNone(lora_utils._layout_cache._entry)
-        moved = self.root / "examples-moved"
-        moved.mkdir()
-        self.write_settings(str(self.sidecars), examples=moved)
-        self.assertEqual(await self._status(image_id), 403)
-
-    async def test_a_cached_folder_swapped_for_a_symlink_to_home_is_refused(self):
-        # CUJ 7: the example-images folder becomes a symlink to a folder that
-        # holds the home folder; the same recorded file is refused.
-        outer = self.root / "outer"
-        (outer / "home").mkdir(parents=True)
-        self._example(outer)
-        image_id = self._link_image(self._example())
-        with patch.object(layout_module.Path, "home", return_value=outer / "home"):
-            self.assertEqual(await self._status(image_id), 200)
-            self.assertIsNotNone(lora_utils._layout_cache._entry)
-            # A skip after the rmtree is safe: setUp builds a fresh tree.
-            shutil.rmtree(self.examples)
-            self._make_symlink(outer, self.examples, target_is_directory=True)
-            self.assertEqual(await self._status(image_id), 403)
-
-    async def test_a_configured_path_outside_custom_nodes_adds_nothing(self):
-        from py.config import IntegrationConfig
-
-        self.assertEqual(await self._status(self._link_image(self._example())), 200)
-        self.assertIsNotNone(lora_utils._layout_cache._entry)
-        with patch.object(IntegrationConfig, "LORA_MANAGER_PATH", str(self.sidecars)):
-            self.assertEqual(self.api._lora_image_dirs(), [])
-        # The warm entry for the real install was never handed out for it.
-        self.assertIsNone(lora_utils.cached_lora_manager_layout(str(self.sidecars))[0])
-
-    async def test_serve_image_builds_the_allow_list_in_the_executor(self):
-        calls = self._spy_executor()
-        self.assertEqual(await self._status(self._link_image(self._example())), 200)
-        self.assertIn("_lora_image_dirs", calls)
-
     async def test_a_filesystem_root_as_sidecar_folder_adds_nothing(self):
         self.write_settings(os.path.abspath(os.sep))
         dirs = self.api._lora_image_dirs()

tests/test_api_lora.py

@@ -876,18 +876,6 @@ class TestLoraScanRoute(LoraAPITestCase):
         resp = await self.client.request("POST", "/prompt_manager/lora/scan")
         self.assertEqual(resp.status, 400)
 
-    async def test_a_finished_scan_clears_the_layout_cache(self):
-        # #362: the legacy scan replaces through the same method.
-        self._enable()
-        loras = self.tmp_root / "loras"
-        loras.mkdir()
-        _write_metadata(loras, "plain")
-        (loras / "plain.png").write_bytes(_png_bytes())
-        with patch("py.lora_utils.clear_layout_cache") as clear:
-            resp, events, _calls = await self._scan(loras)
-        self.assertEqual(events[-1]["type"], "complete", events)
-        clear.assert_called_once_with()
-
     async def test_scan_imports_loras_with_images_and_links_existing(self):
         self._enable()
         loras = self.tmp_root / "loras"

tests/test_config.py

@@ -516,9 +516,8 @@ class TestAutotagConfig(unittest.TestCase):
         bad_values = {
             "model_type": ["wd14-convnext", 3, None],
             "existing": ["replace", "", True],
-            # #369: a saved threshold off the 0.05 step no page can show.
-            "general_threshold": [1.5, -0.1, float("nan"), "0.4", True, 0.37],
-            "character_threshold": [2, float("inf"), None, 0.33],
+            "general_threshold": [1.5, -0.1, float("nan"), "0.4", True],
+            "character_threshold": [2, float("inf"), None],
             # 4000 characters are at most 16,000 UTF-8 bytes, so the 16 KiB
             # byte cap can only be met past the character cap.
             "template": ["", "   ", "x" * 4001, "\U0001f600" * 4097, "\ud800", 7],
@@ -568,27 +567,6 @@ class TestAutotagConfig(unittest.TestCase):
             config_module.MODEL_TYPES, {"gguf", "hf", "wd14-swinv2", "wd14-vit"}
         )
 
-    def test_saved_threshold_is_a_multiple_of_the_step(self):
-        """#369: every page shows the thresholds in steps of 0.05, so a saved
-        one must be on that grid; it is stored exactly on it."""
-        from py.tagging_defaults import validate_saved_threshold as validate
-
-        for value in (0, 0.05, 0.15, 0.35, 0.85, 1):
-            with self.subTest(value=value):
-                self.assertEqual(validate("x", value), value)
-        self.assertEqual(validate("x", 0.1 + 0.2), 0.3)
-        for value, message in (
-            (0.37, "x must be a multiple of 0.05"),
-            (0.351, "x must be a multiple of 0.05"),
-            (0.35000000001, "x must be a multiple of 0.05"),
-            (1.5, "x must be between 0 and 1"),
-            ("0.4", "x must be a finite number"),
-        ):
-            with self.subTest(value=value):
-                with self.assertRaises(ValueError) as caught:
-                    validate("x", value)
-                self.assertEqual(str(caught.exception), message)
-
     def test_suggestion_limit_setting_validated_on_load(self):
         for value in (0, 101, "10", float("nan"), 2.5, True, None, [10]):
             with self.subTest(value=value):

tests/test_execution_history_hooks.py

@@ -28,8 +28,6 @@ except ImportError:
 
 Status = namedtuple("ExecutionStatus", "status_str completed messages")
 JOB = "a0c26da3-eb26-405c-b143-c662a84c3112"
-# A cross-thread wait or a duration check fails only past this (#370).
-CEILING_SECONDS = 30.0
 
 
 class HostQueue:
@@ -211,9 +209,6 @@ class HistoryHooksTests(unittest.TestCase):
         self.queue.get = unrelated_after
         self.dequeue(0)
         self.queue.task_done(0, {}, status())
-        # The writer drains first: this test checks wrappers and the session,
-        # not the 2 s bound, which a slow runner can spend on the write (#370).
-        self.drain(first)
         self.assertTrue(first.dispose())
         self.assertTrue(first.dispose())
         self.assertIs(self.queue.get, unrelated_after)
@@ -344,20 +339,16 @@ class HistoryHooksTests(unittest.TestCase):
         with patch.object(self.db, "write_execution_start", blocked):
             registration = self.register()
             self.dequeue(0)
-            # Ceilings, not tight wall clocks (#370): the return values show
-            # the bound; a ceiling still fails a call that waits unbounded.
-            self.assertTrue(entered.wait(CEILING_SECONDS))
+            self.assertTrue(entered.wait(1))
             began = time.monotonic()
             self.queue.task_done(0, {}, status())
             self.dequeue(1)
-            self.assertLess(time.monotonic() - began, CEILING_SECONDS)
+            self.assertLess(time.monotonic() - began, 0.2)
             began = time.monotonic()
             self.assertFalse(registration.dispose())
             self.assertGreaterEqual(time.monotonic() - began, 1.8)
-            self.assertLess(time.monotonic() - began, CEILING_SECONDS)
+            self.assertLess(time.monotonic() - began, 2.3)
             release.set()
-            # Drain first: the 2 s bound is not under test here (#370).
-            self.drain(registration)
             self.assertTrue(registration.dispose(2))
 
     def test_restore_disables_capture_and_clears_handles_before_fresh_epoch(self):

tests/test_execution_history_writer.py

@@ -642,8 +642,6 @@ class HistoryWriterTests(unittest.TestCase):
                 == "succeeded"
             )
             self.assertTrue(writer.submit(self.start_command(2)))
-            # Drain first: the 2 s bound is not under test here (#370).
-            drain_writer(writer)
             self.assertTrue(writer.close(2))
         self.assertEqual(len(set(threads)), 1)
         self.assertNotEqual(threads[0], threading.get_ident())

tests/test_execution_output_hooks.py

@@ -245,8 +245,6 @@ class OutputHooksTests(fixtures.unittest.TestCase):
         registration = self.register()
         self.dequeue(0)
         late = registration._task_done
-        # Drain first: the 2 s bound is not under test here (#370).
-        self.drain(registration)
         self.assertTrue(registration.dispose())
         thread = threading.Thread(
             target=lambda: late((0, history(), fixtures.status()), {})
@@ -399,10 +397,6 @@ class OutputHooksTests(fixtures.unittest.TestCase):
             self.queue.task_done(1, history("rejected.png"), fixtures.status())
             registration.writer.invalidate()
             release.set()
-            # Let the writer work through the 1,024 queued commands first
-            # (#370's pattern): on a busy Windows runner that took longer
-            # than dispose's 2 s bound (merge queue, #382).
-            self.drain(registration)
             self.assertTrue(registration.dispose(2))
         self.assertEqual(self.outputs(0)["state"], "not_captured")
         self.assertEqual(len(self.rows()), 1)

tests/test_execution_output_writer.py

@@ -17,7 +17,6 @@ from utils.execution_contexts import MAX_ATTEMPT_BYTES
 from utils.execution_output_capture import seal_outputs
 from utils.execution_outputs import snapshot_output_roots
 from utils.execution_history_writer import HistoryWriter
-from tests.history_waits import drain_writer
 
 try:
     from tests import test_execution_history_writer as fixtures
@@ -28,11 +27,6 @@ except ImportError:
 # Upper bound a blocked fake write waits for its release. Tests prove ordering
 # with events, so this only caps a failing run and never decides a pass.
 BLOCK_SECONDS = 10
-# A restore is a full verify/migrate/backup/replace cycle and is bound by the
-# disk: a busy Windows runner took over 10 s (merge queue, #382). Waits that
-# span a restore use this ceiling, which stays under the runner's 120 s hang
-# watchdog, so a real hang still fails with the thread dump.
-RESTORE_SECONDS = 90
 
 
 class OutputWriterTests(fixtures.unittest.TestCase):
@@ -167,8 +161,6 @@ class OutputWriterTests(fixtures.unittest.TestCase):
         start = replace(self.start_command(), run_id=str(fixtures.uuid4()))
         self.assertTrue(writer.submit(start))
         self.finalization(writer, start)
-        # Drain first: the 2 s bound is not under test here (#370).
-        drain_writer(writer)
         self.assertTrue(writer.close(2))
         self.assertEqual(
             self.db.get_execution_run(start.run_id)["outcome"], "succeeded"
@@ -322,8 +314,8 @@ class OutputWriterTests(fixtures.unittest.TestCase):
 
         Returns the patch and an event set once that rotation has returned on
         the worker. A restore is a full verify/migrate/backup/replace cycle, so
-        the handoff waits on this event with the ``RESTORE_SECONDS`` ceiling
-        instead of the short worker-behavior deadline (TESTING.md,
+        the handoff waits on this event with the generous ``BLOCK_SECONDS``
+        ceiling instead of the short worker-behavior deadline (TESTING.md,
         Windows portability preflight).
         """
         backup = os.path.join(self.directory.name, f"restore-{start.run_id}.db")
@@ -366,7 +358,7 @@ class OutputWriterTests(fixtures.unittest.TestCase):
                         )
                         with rotation:
                             self.finalization(writer, start)
-                            self.assertTrue(rotated.wait(RESTORE_SECONDS))
+                            self.assertTrue(rotated.wait(BLOCK_SECONDS))
                             self.wait_for(lambda: writer.status().pending == 0)
                         self.assertEqual(
                             self.db.get_execution_outputs(start.run_id)["state"],
@@ -408,7 +400,7 @@ class OutputWriterTests(fixtures.unittest.TestCase):
             self.assertEqual(writer.status().pending, 1)
             self.assertEqual(writer.context_budget.charged_bytes, charge)
             release.set()
-            self.assertTrue(rotated.wait(RESTORE_SECONDS))
+            self.assertTrue(rotated.wait(BLOCK_SECONDS))
             self.wait_for(lambda: writer.status().pending == 0)
         self.assertEqual(writer.context_budget.charged_bytes, 0)
         self.assertFalse(writer.status().accepting)
@@ -572,8 +564,6 @@ class OutputWriterTests(fixtures.unittest.TestCase):
                 self.assertIs(replacement.context_budget, writer.context_budget)
                 self.assertIsNone(replacement.context_budget.reserve(8388608))
                 release.set()
-                # Drain first: the 2 s bound is not under test here (#370).
-                drain_writer(writer)
                 self.assertTrue(writer.close(2))
         finally:
             release.set()
@@ -615,8 +605,6 @@ class OutputWriterTests(fixtures.unittest.TestCase):
             writer.invalidate()
             self.assertEqual(writer.context_budget.charged_bytes, 0)
             release.set()
-        # Drain first: the 2 s bound is not under test here (#370).
-        drain_writer(writer)
         self.assertTrue(writer.close(2))
 
     def test_malformed_context_omission_preserves_independent_valid_output(self):
@@ -707,8 +695,6 @@ class OutputWriterTests(fixtures.unittest.TestCase):
                 release.set()
                 invalidator.join(BLOCK_SECONDS)
             self.assertFalse(invalidator.is_alive())
-            # Drain first: the 2 s bound is not under test here (#370).
-            drain_writer(writer)
             self.assertTrue(writer.close(2))
         self.assertEqual(
             self.db.get_execution_outputs(start.run_id)["state"], "complete"

tests/test_hashing.py

@@ -12,7 +12,6 @@ import unittest
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from tests.background_stops import stop_tracker  # noqa: E402
 from utils.hashing import (
     generate_prompt_hash,
     is_duplicate_prompt,
@@ -50,7 +49,6 @@ class TestSingleHashImplementation(unittest.TestCase):
         db = mock.Mock()
         db.get_prompt_by_hash.return_value = {"id": 42}
         tracker = PromptTracker(db)
-        self.addCleanup(stop_tracker, self, tracker)
         tracker.set_current_prompt("  Hello World  ")
         db.get_prompt_by_hash.assert_called_once_with(
             generate_prompt_hash("  Hello World  ")

tests/test_image_linking.py

@@ -8,7 +8,6 @@ import unittest.mock as mock
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from tests.background_stops import close_handler  # noqa: E402
 from database.operations import PromptDatabase
 from utils.hashing import generate_prompt_hash
 from utils.image_monitor import ImageGenerationHandler
@@ -53,7 +52,6 @@ class LinkingTestCase(unittest.TestCase):
         )
 
     def tearDown(self):
-        close_handler(self, self.handler)  # and the tracker's cleanup thread
         self.db.close_all()  # Windows cannot unlink an open database file
         for path in (
             self.image,

tests/test_image_monitor_singleton.py

@@ -136,21 +136,13 @@ class TestMonitorSingletonLifecycle(unittest.TestCase):
 
 
 class FakeObserver:
-    """Records what the monitor does with the watchdog observer.
+    """Records what the monitor does with the watchdog observer."""
 
-    ``calls`` lists ``stop`` and ``join`` in order (shared with a test's own
-    recorders when given); ``stay_alive`` keeps it alive after ``join``;
-    ``stop_error`` makes ``stop`` raise.
-    """
-
-    def __init__(self, calls=None, stay_alive=False, stop_error=None):
+    def __init__(self):
         self.scheduled = []
         self.started = False
         self.stopped = False
         self.joined = False
-        self.calls = calls if calls is not None else []
-        self.stay_alive = stay_alive
-        self.stop_error = stop_error
 
     def schedule(self, handler, path, recursive=False):
         self.scheduled.append((handler, path, recursive))
@@ -159,18 +151,12 @@ class FakeObserver:
         self.started = True
 
     def stop(self):
-        self.calls.append(("stop",))
-        if self.stop_error is not None:
-            raise self.stop_error
         self.stopped = True
 
     def join(self, timeout=None):
-        self.calls.append(("join", timeout))
         self.joined = True
 
     def is_alive(self):
-        if self.stay_alive:
-            return self.started
         return self.started and not self.stopped
 
 
@@ -185,8 +171,6 @@ class TestStartStop(unittest.TestCase):
         self.missing = os.path.join(self.tmp.name, "does-not-exist")
 
     def tearDown(self):
-        # Before the folder is removed (addCleanup runs after tearDown).
-        self.assertTrue(self.monitor.stop_monitoring())
         im_mod._monitor_instance = None
 
     def test_only_nonexistent_directories_leaves_monitoring_off(self):
@@ -241,8 +225,9 @@ class TestStartStop(unittest.TestCase):
         worker = handler._worker
         self.assertTrue(worker.is_alive())
 
-        self.assertTrue(self.monitor.stop_monitoring())
+        self.monitor.stop_monitoring()
 
+        worker.join(timeout=2)
         self.assertFalse(worker.is_alive())
         self.assertEqual(handler.pending_count(), 0)
         # A restart gets a fresh handler and observer
@@ -318,89 +303,6 @@ class TestStartStop(unittest.TestCase):
         self.assertEqual(self.monitor.monitored_directories, [self.tmp.name])
         self.monitor.stop_monitoring()
 
-    def _start_with(self, fake):
-        with patch.object(im_mod, "Observer", return_value=fake):
-            self.monitor.start_monitoring([self.tmp.name])
-        handler = self.monitor.handler
-        real_close = handler.close
-
-        def close(timeout=im_mod.WORKER_JOIN_SECONDS):
-            fake.calls.append(("close",))
-            return real_close(timeout)
-
-        handler.close = close
-        return handler
-
-    def test_stop_monitoring_joins_observer_and_worker(self):
-        fake = FakeObserver()
-        handler = self._start_with(fake)
-
-        self.assertTrue(self.monitor.stop_monitoring(timeout=3.0))
-
-        self.assertEqual([c[0] for c in fake.calls], ["close", "stop", "join"])
-        join_timeout = fake.calls[2][1]
-        self.assertIsNotNone(join_timeout)
-        self.assertLessEqual(join_timeout, 3.0)
-        self.assertTrue(handler._closed)
-
-    def test_stop_monitoring_reports_an_observer_still_running(self):
-        fake = FakeObserver(stay_alive=True)
-        self._start_with(fake)
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs:
-            self.assertFalse(self.monitor.stop_monitoring(timeout=0.05))
-        self.assertIn("watchdog observer still running", "\n".join(logs.output))
-        self.assertFalse(self.monitor.is_monitoring)
-        fake.stay_alive = False  # it ends; tearDown's stop waits for it
-
-    def test_a_second_stop_monitoring_waits_for_the_observer(self):
-        fake = FakeObserver(stay_alive=True)
-        self._start_with(fake)
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING"):
-            self.assertFalse(self.monitor.stop_monitoring(timeout=0.05))
-            self.assertFalse(self.monitor.stop_monitoring(timeout=0.05))
-        fake.stay_alive = False
-        self.assertTrue(self.monitor.stop_monitoring())
-        self.assertFalse(self.monitor._unfinished)
-
-    def test_stop_monitoring_reports_an_observer_stop_that_raised(self):
-        fake = FakeObserver(stop_error=OSError("descriptor gone"))
-        self._start_with(fake)
-        fake.stopped = True  # its thread has ended; stop() still raises
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs:
-            self.assertFalse(self.monitor.stop_monitoring())
-        text = "\n".join(logs.output)
-        self.assertIn("Error while stopping image monitoring", text)
-        self.assertNotIn("watchdog observer still running", text)
-        fake.stop_error = None  # tearDown's stop calls stop() again
-
-    def test_the_still_running_warning_names_the_time_the_join_got(self):
-        fake = FakeObserver(stay_alive=True)
-        handler = self._start_with(fake)
-        now = [100.0]
-        recorded_close = handler.close
-
-        def close_that_uses_the_deadline(timeout=im_mod.WORKER_JOIN_SECONDS):
-            ok = recorded_close(timeout)
-            now[0] += 5.0  # a busy worker took the whole deadline
-            return ok
-
-        handler.close = close_that_uses_the_deadline
-        with (
-            patch.object(
-                im_mod, "time", types.SimpleNamespace(monotonic=lambda: now[0])
-            ),
-            self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs,
-        ):
-            self.assertFalse(self.monitor.stop_monitoring(timeout=5.0))
-        self.assertEqual(fake.calls[-1], ("join", 0.0))
-        self.assertIn(
-            "watchdog observer still running after 0.0 s", "\n".join(logs.output)
-        )
-        fake.stay_alive = False  # it ends; tearDown's stop waits for it
-
-    def test_stop_monitoring_without_an_observer_returns_true(self):
-        self.assertTrue(self.monitor.stop_monitoring())
-
 
 class FakeEvent:
     def __init__(self, path, is_directory=False):
@@ -433,10 +335,6 @@ class TestHandlerScheduling(unittest.TestCase):
             self.processed.append((path, prompt_snapshot))
         )
 
-    def tearDown(self):
-        # Before the folder is removed (addCleanup runs after tearDown).
-        self.assertTrue(self.handler.close())
-
     def _image(self, name, content=b"x" * 16):
         path = os.path.join(self.tmp.name, name)
         with open(path, "wb") as f:
@@ -501,127 +399,23 @@ class TestHandlerScheduling(unittest.TestCase):
         empty = self._image("empty.png", content=b"")
         self.assertFalse(self.handler.wait_until_settled(empty))
 
-    def test_shutdown_joins_the_worker_within_the_bound(self):
+    def test_shutdown_stops_the_worker_and_clears_pending(self):
         self.handler.processing_delay = 10  # keep the first image waiting
         self.handler.schedule(self._image("s1.png"))
         self.handler.schedule(self._image("s2.png"))
         worker = self.handler._worker
         self.assertTrue(worker.is_alive())
 
-        self.assertTrue(self.handler.shutdown())
+        self.handler.shutdown()
 
+        worker.join(timeout=2)
         self.assertFalse(worker.is_alive())
         self.assertEqual(self.handler.pending_count(), 0)
 
-    def test_shutdown_reports_a_worker_still_busy(self):
-        entered, release = threading.Event(), threading.Event()
-
-        def busy(path, prompt_snapshot=None):
-            entered.set()
-            release.wait(30)
-
-        self.handler.process_new_image = busy
-        self.handler.schedule(self._image("busy.png"))
-        worker = self.handler._worker
-        self.addCleanup(worker.join, 30)
-        self.addCleanup(release.set)
-        self.assertTrue(entered.wait(30), "the worker never took the image")
-
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs:
-            self.assertFalse(self.handler.shutdown(timeout=0.05))
-        self.assertIn("image worker still running", "\n".join(logs.output))
-
-        release.set()
-        worker.join(30)
-        self.assertFalse(worker.is_alive())
-
-    def test_a_second_stop_waits_for_a_worker_still_finishing(self):
-        entered, release = threading.Event(), threading.Event()
-
-        def busy(path, prompt_snapshot=None):
-            entered.set()
-            release.wait(30)
-
-        self.handler.process_new_image = busy
-        self.handler.schedule(self._image("twice.png"))
-        worker = self.handler._worker
-        self.addCleanup(worker.join, 30)
-        self.addCleanup(release.set)
-        self.assertTrue(entered.wait(30), "the worker never took the image")
-
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING"):
-            self.assertFalse(self.handler.close(timeout=0.05))
-            self.assertFalse(self.handler.close(timeout=0.05))
-        release.set()
-        self.assertTrue(self.handler.close(timeout=30))
-        self.assertFalse(worker.is_alive())
-
-    def test_shutdown_on_the_worker_itself_only_signals(self):
-        entered, result = threading.Event(), {}
-
-        def stop_from_inside(path, prompt_snapshot=None):
-            result["value"] = self.handler.shutdown()
-            entered.set()
-
-        self.handler.process_new_image = stop_from_inside
-        self.handler.schedule(self._image("self.png"))
-        worker = self.handler._worker
-        self.assertTrue(entered.wait(30), "the worker never took the image")
-        worker.join(30)
-        self.assertFalse(result["value"])
-        self.assertFalse(worker.is_alive())
-
-    def _live_workers(self):
-        return {
-            t for t in threading.enumerate() if t.name == "PromptManagerImageWorker"
-        }
-
-    def _seal(self, handler, name):
-        handler._await_history(os.path.join(self.tmp.name, name))
-        handler._on_outputs_sealed(
-            "run-1",
-            [{"folder_type": "output", "subfolder": "", "filename": name}],
-        )
-
-    def test_close_refuses_new_work(self):
-        path = self._image("late.png")
-        with patch.object(im_mod, "host_output_directory", return_value=self.tmp.name):
-            self.assertTrue(self.handler.close())
-            before = self._live_workers()
-            self.assertFalse(self.handler.schedule(path))
-            # The image in hand can still ask for a history re-check and its
-            # run can be sealed afterwards, on the history writer's thread.
-            self.handler._await_history(path)
-            self.assertEqual(self.handler.awaiting_history(), [])
-            self._seal(self.handler, "late.png")
-            self.handler._schedule_recheck(path)
-        self.assertIsNone(self.handler._worker)
-        self.assertEqual(list(self.handler._history_due), [])
-        self.assertEqual(self._live_workers() - before, set())
-
-    def test_a_sealed_run_starts_a_worker_on_an_open_handler(self):
-        self._image("open.png")
-        with patch.object(im_mod, "host_output_directory", return_value=self.tmp.name):
-            self._seal(self.handler, "open.png")
-        self.assertIsNotNone(self.handler._worker)
-        self.assertTrue(self.handler.close())
-
-    def test_close_is_idempotent(self):
-        self.handler.schedule(self._image("c1.png"))
-        self.assertTrue(self.handler.close())
-        self.assertTrue(self.handler.close())
-
-    def test_on_created_after_close_takes_no_lock(self):
-        self.assertTrue(self.handler.close())
-        self.handler.on_created(FakeEvent(self._image("after.png")))
-        self.tracker.keyed_snapshot.assert_not_called()
-        self.assertEqual(self.handler.pending_count(), 0)
-
     def test_shutdown_is_idempotent_and_safe_before_start(self):
         fresh = im_mod.ImageGenerationHandler(MagicMock(), self.tracker)
-        self.assertTrue(fresh.shutdown())
-        self.assertTrue(fresh.shutdown())
-        self.assertTrue(fresh.close())
+        fresh.shutdown()
+        fresh.shutdown()
         self.handler.schedule(self._image("s3.png"))
         self.assertTrue(wait_for(lambda: self.handler.pending_count() == 0))
         self.handler.shutdown()
@@ -640,7 +434,7 @@ class TestHandlerScheduling(unittest.TestCase):
         self.assertTrue(wait_for(lambda: self.handler.pending_count() == 0))
         self.assertIn(path, [p for p, _ in self.processed])
         self.assertIsNot(self.handler._worker, old_worker)
-        self.assertTrue(self.handler.close())
+        self.handler.shutdown()
 
     def test_processing_errors_do_not_kill_the_worker(self):
         def explode(path, prompt_snapshot=None):
@@ -655,47 +449,6 @@ class TestHandlerScheduling(unittest.TestCase):
         self.assertEqual(self.processed, [first, second])
 
 
-class TestCloseReleasesHandles(unittest.TestCase):
-    """``close`` joins the worker, so the test folder can be removed (#302)."""
-
-    def test_close_releases_handles(self):
-        from PIL import Image
-
-        from database.operations import PromptDatabase
-        from tests.open_handles import assert_closed
-        from utils.prompt_tracker import PromptTracker
-
-        with tempfile.TemporaryDirectory() as folder:
-            db = PromptDatabase(os.path.join(folder, "prompts.db"))
-            tracker = PromptTracker(db)
-            handler = im_mod.ImageGenerationHandler(db, tracker)
-            handler.processing_delay = 0
-            handler.settle_interval = 0.01
-            done = threading.Event()
-            real_process = handler.process_new_image
-
-            def process(path, prompt_snapshot=None):
-                try:
-                    real_process(path, prompt_snapshot=prompt_snapshot)
-                finally:
-                    done.set()
-
-            handler.process_new_image = process
-            path = os.path.join(folder, "real.png")
-            Image.new("RGB", (8, 8), "red").save(path)
-            try:
-                self.assertTrue(handler.schedule(path))
-                worker = handler._worker
-                self.assertTrue(done.wait(30), "the worker never processed the image")
-            finally:
-                closed, shut = handler.close(), tracker.shutdown()
-                db.model.close_all()
-            self.assertTrue(closed)
-            self.assertTrue(shut)
-            self.assertFalse(worker.is_alive())
-            assert_closed(self, folder)
-
-
 class TestOutputListener(unittest.TestCase):
     """Every settled output is reported to the Images listing (#348, PR 2)."""
 
@@ -703,7 +456,7 @@ class TestOutputListener(unittest.TestCase):
         self.tmp = tempfile.TemporaryDirectory()
         self.addCleanup(self.tmp.cleanup)
         self.handler = im_mod.ImageGenerationHandler(MagicMock(), MagicMock())
-        self.addCleanup(lambda: self.assertTrue(self.handler.close()))
+        self.addCleanup(self.handler.shutdown)
         self.handler.processing_delay = 0
         self.handler.settle_interval = 0.01
         self.handler.process_new_image = lambda path, prompt_snapshot=None: None
@@ -796,7 +549,7 @@ class TestOutputListener(unittest.TestCase):
             self.assertIsNone(monitor.output_listener)
             self.assertIsNone(monitor.handler.output_listener)
         finally:
-            self.assertTrue(monitor.stop_monitoring())
+            monitor.stop_monitoring()
 
 
 class TestModuleIsolation(unittest.TestCase):

tests/test_init_package.py

@@ -4,8 +4,6 @@ The package is loaded the way ComfyUI loads it (``__init__`` with relative
 imports) with ComfyUI's ``server`` and ``folder_paths`` modules stubbed.
 """
 
-import asyncio
-import atexit
 import contextlib
 import importlib.util
 import io
@@ -18,7 +16,6 @@ import threading
 import types
 import unittest
 import unittest.mock as mock
-from pathlib import Path
 
 from aiohttp import web
 
@@ -43,20 +40,13 @@ class FakePromptQueue:
         return self.results.pop(0) if self.results else None
 
 
-def fake_server_module(app=None, queue_task_done=False):
-    """A ``server`` module whose PromptServer.instance accepts routes and hooks.
-
-    ``app`` replaces the default app (one without aiohttp hooks);
-    ``queue_task_done`` gives the queue a ``task_done``, so history registers.
-    """
-    queue = FakePromptQueue()
-    if queue_task_done:
-        queue.task_done = lambda *a, **k: None
+def fake_server_module():
+    """A ``server`` module whose PromptServer.instance accepts routes and hooks."""
     instance = types.SimpleNamespace(
         routes=web.RouteTableDef(),
-        prompt_queue=queue,
+        prompt_queue=FakePromptQueue(),
         handlers=[],
-        app=app if app is not None else types.SimpleNamespace(middlewares=[]),
+        app=types.SimpleNamespace(middlewares=[]),
     )
     instance.add_on_prompt_handler = instance.handlers.append
     module = types.ModuleType("server")
@@ -102,7 +92,7 @@ def _import_package(name, db_path, output_dir, server=None):
             try:
                 spec.loader.exec_module(package)
             except BaseException:
-                cleanup_package(package, require_stopped=False)
+                cleanup_package(package)
                 raise
     finally:
         for key, module in saved.items():
@@ -113,34 +103,20 @@ def _import_package(name, db_path, output_dir, server=None):
     return package, server.PromptServer.instance
 
 
-def cleanup_package(package, require_stopped=True):
-    """Stop fixture-owned workers before releasing its other resources.
-
-    The package's own teardown runs first (the reload case of #301); with
-    ``require_stopped`` every part it reports must have stopped. The direct
-    stops after it also cover an import that failed before the teardown
-    existed, and a test that made a teardown step fail on purpose.
-    """
-    teardown = getattr(package, "_stop_background_work", None)
-    if callable(teardown):
-        result = teardown()
-        if require_stopped:
-            assert all(result.values()), f"package teardown left work running: {result}"
-    monitor = getattr(package, "_global_image_monitor", None)
-    if monitor is not None:
-        assert monitor.stop_monitoring(), "package image monitor still running"
-    tracker = getattr(package, "_global_prompt_tracker", None)
-    if tracker is not None:
-        assert tracker.shutdown(), "package prompt cleanup thread still running"
+def cleanup_package(package):
+    """Stop fixture-owned workers before releasing its other resources."""
     registration = getattr(package, "_history_registration", None)
     if registration is not None:
         assert registration.dispose(3), "package history worker leaked"
+    monitor = getattr(package, "_global_image_monitor", None)
+    if monitor is not None:
+        monitor.stop_monitoring()
     close_every_database()
     sys.modules.pop(package.__name__, None)
 
 
 @contextlib.contextmanager
-def load_package(name, db_path, output_dir, server=None, require_stopped=True):
+def load_package(name, db_path, output_dir, server=None):
     """Dispose package workers before closing its isolated logging handlers."""
     root_logger = logging.getLogger("prompt_manager")
     loggers = [root_logger] + [
@@ -168,7 +144,7 @@ def load_package(name, db_path, output_dir, server=None, require_stopped=True):
         try:
             yield package, instance
         finally:
-            cleanup_package(package, require_stopped=require_stopped)
+            cleanup_package(package)
     finally:
         current_loggers = [root_logger] + [
             logger
@@ -580,406 +556,3 @@ class TestPackageLoggerIsolation(unittest.TestCase):
         self.assert_logging_restored(
             captured["handlers"], captured["package"]._history_registration
         )
-
-
-PACKAGE_THREAD_NAMES = ("PromptManagerPromptCleanup", "PromptManagerImageWorker")
-
-
-def package_threads():
-    """Live threads this design owns: the tracker, the image worker, and the
-    watchdog observer and emitters (which have no name of their own)."""
-    from watchdog.utils import BaseThread
-
-    return {
-        thread
-        for thread in threading.enumerate()
-        if thread.name in PACKAGE_THREAD_NAMES or isinstance(thread, BaseThread)
-    }
-
-
-def hooked_app():
-    return types.SimpleNamespace(
-        middlewares=[], on_cleanup=[], on_startup=[], on_shutdown=[]
-    )
-
-
-WAIT_SECONDS = 30  # ceiling for every Event wait (TESTING.md test rules)
-
-
-def start_busy_worker(package, folder, name="busy.png"):
-    """The image worker alive in its processing delay."""
-    handler = package._global_image_monitor.handler
-    if handler is None:
-        raise AssertionError("the package's monitor did not start")
-    handler.processing_delay = 3600
-    # Outside the watched folder, so the observer does not schedule it first.
-    path = os.path.join(folder, name)
-    with open(path, "wb") as image:
-        image.write(b"x" * 16)
-    if not handler.schedule(path) or not handler._worker.is_alive():
-        raise AssertionError("the image worker did not start")
-    return handler._worker
-
-
-class PackageTeardownCase(unittest.TestCase):
-    """Each test loads its own package (#301): the teardown runs once."""
-
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.addCleanup(lambda: self.assertEqual(open_handles_under(self.tmp.name), []))
-        self.output_dir = os.path.join(self.tmp.name, "output")
-        os.makedirs(self.output_dir)
-        self.db_path = os.path.join(self.tmp.name, "prompts.db")
-
-    def load(self, server=None, require_stopped=True, suffix=""):
-        name = f"pm_teardown_{self._testMethodName}{suffix}"
-        stack = contextlib.ExitStack()
-        self.addCleanup(stack.close)
-        stack.enter_context(contextlib.redirect_stdout(io.StringIO()))
-        package, _ = stack.enter_context(
-            load_package(
-                name,
-                self.db_path,
-                self.output_dir,
-                server,
-                require_stopped=require_stopped,
-            )
-        )
-        return package
-
-    def busy_worker(self, package, name="busy.png"):
-        return start_busy_worker(package, self.tmp.name, name)
-
-    def hold_a_preview(self, package, *, advance, kill_releases):
-        """A preview worker held inside a fake encode that tracks a fake
-        ffmpeg, and a package clock that the monitor step moves by
-        ``advance`` seconds. Cleanups release the encode first."""
-        # Not the watched folder. Real path for both the file and the root:
-        # macOS /var vs /private/var, Windows short names.
-        previews = os.path.realpath(os.path.join(self.tmp.name, "previews"))
-        os.makedirs(previews)
-        from PIL import Image
-
-        image = os.path.join(previews, "held.png")
-        Image.new("RGB", (8, 8), "red").save(image)
-        held = types.SimpleNamespace(
-            entered=threading.Event(),
-            release=threading.Event(),
-            killed=threading.Event(),
-            stop_seen=[],
-            timeouts=[],
-            now=[100.0],
-        )
-
-        class FakeFfmpeg:
-            def poll(self):  # _track keeps only processes still running
-                return None
-
-            def kill(self):
-                held.killed.set()
-                if kill_releases:
-                    held.release.set()
-
-        def held_encode(src, dst, settings, is_video, *, stop, guard, track):
-            track(FakeFfmpeg())
-            held.entered.set()
-            held.release.wait(WAIT_SECONDS)
-            held.stop_seen.append(stop())
-            return {"action": "skipped"}
-
-        api = package.api
-        monitor = package._global_image_monitor
-        real_stop = monitor.stop_monitoring
-        real_close = api.close_auto_thumbnails
-
-        def stop_then_advance(timeout):
-            ok = real_stop(timeout)
-            held.now[0] += advance
-            return ok
-
-        def recorded_close(final=False, timeout=None):
-            held.timeouts.append(timeout)
-            return real_close(final=final, timeout=timeout)
-
-        for target, name, value in (
-            (api, "_get_all_output_dirs", lambda: [Path(previews)]),
-            (api, "_generate_one", held_encode),
-            (api, "close_auto_thumbnails", recorded_close),
-            (monitor, "stop_monitoring", stop_then_advance),
-            (package, "_clock", lambda: held.now[0]),
-        ):
-            patcher = mock.patch.object(target, name, value)
-            patcher.start()
-            self.addCleanup(patcher.stop)
-        self.assertEqual(api.queue_capture_thumbnail(image), "queued")
-        self.addCleanup(held.release.set)
-        self.assertTrue(held.entered.wait(WAIT_SECONDS), "the encode never started")
-        held.thumbnailer = api._auto_thumbnailer  # the teardown drops the API's
-        held.worker = held.thumbnailer._worker
-        # Cleanups run newest first: release the encode, then join the worker
-        # (even when an assertion failed first), then end the patches.
-        self.addCleanup(held.worker.join, WAIT_SECONDS)
-        self.addCleanup(held.release.set)
-        self.assertTrue(held.worker.is_alive())
-        return held
-
-
-class TestPackageTeardown(PackageTeardownCase):
-    def test_an_image_in_hand_queues_no_preview_during_teardown(self):
-        package = self.load()
-        monitor = package._global_image_monitor
-        real_stop = monitor.stop_monitoring
-        image = os.path.join(self.output_dir, "in_hand.png")
-        from PIL import Image
-
-        Image.new("RGB", (8, 8), "red").save(image)
-        seen = {}
-
-        def stop_with_an_image_in_hand(timeout):
-            # The worker read ``thumbnail_queue`` before the detach and now
-            # hands its finished image over (at exit, Python 3.12+ refuses a
-            # new thread here and logs a traceback).
-            seen["queued"] = package.api.queue_capture_thumbnail(image)
-            seen["worker"] = package.api._auto_thumbnailer
-            return real_stop(timeout)
-
-        with (
-            mock.patch.object(
-                package.api,
-                "_get_all_output_dirs",
-                return_value=[Path(os.path.realpath(self.output_dir))],
-            ),
-            mock.patch.object(
-                monitor, "stop_monitoring", side_effect=stop_with_an_image_in_hand
-            ),
-        ):
-            result = package._stop_background_work()
-        self.assertEqual(seen["queued"], "skipped")
-        self.assertIsNone(seen["worker"])
-        self.assertTrue(all(result.values()), result)
-
-    def test_teardown_kills_ffmpeg_and_stops_the_preview_worker(self):
-        package = self.load()
-        held = self.hold_a_preview(package, advance=4.0, kill_releases=True)
-
-        result = package._stop_background_work()
-
-        self.assertTrue(held.killed.is_set())
-        self.assertEqual(held.timeouts, [6.0])  # min(30, 10 - 4)
-        self.assertTrue(result["thumbnails"], result)
-        self.assertFalse(held.worker.is_alive())
-        self.assertEqual(held.stop_seen, [True])
-
-    def test_on_cleanup_runs_the_teardown(self):
-        app = hooked_app()
-        package = self.load(fake_server_module(app=app))
-        self.assertIs(app.on_cleanup[0], package._stop_background_work_on_cleanup)
-        self.assertIsNone(package._background_work_result)
-
-        async def run_cleanup():
-            for callback in list(app.on_cleanup):
-                await callback(app)
-
-        asyncio.run(run_cleanup())
-        self.assertEqual(
-            package._background_work_result,
-            {"monitor": True, "thumbnails": True, "tracker": True},
-        )
-
-    def test_teardown_runs_before_history_dispose_at_exit(self):
-        with mock.patch("atexit.register", wraps=atexit.register) as register:
-            package = self.load(fake_server_module(queue_task_done=True))
-        registered = [call.args[0] for call in register.call_args_list]
-        registration = package._history_registration
-        self.assertIsNotNone(registration, "history did not register")
-        self.assertIn(registration.dispose, registered)
-        self.assertIn(package._stop_background_work, registered)
-        # atexit runs newest first: the teardown before the history dispose.
-        self.assertGreater(
-            registered.index(package._stop_background_work),
-            registered.index(registration.dispose),
-        )
-
-
-class ListHandler(logging.Handler):
-    def __init__(self):
-        super().__init__(logging.INFO)
-        self.lines = []
-
-    def emit(self, record):
-        self.lines.append(f"{record.levelname}:{record.getMessage()}")
-
-
-class TestPackageTeardownOnce(PackageTestCase):
-    """The tests that only observe one plain teardown share one package.
-
-    The teardown runs once, so it runs here in ``setUpClass`` (per-test
-    ``assertLogs`` cannot wrap it); the tests read what it recorded.
-    """
-
-    package_name = "pm_teardown_once"
-
-    @classmethod
-    def setUpClass(cls):
-        with contextlib.redirect_stdout(io.StringIO()):
-            super().setUpClass()
-        package = cls.package
-        cls.monitor = package._global_image_monitor
-        cls.observer = cls.monitor.observer
-        cls.tracker_thread = package._global_prompt_tracker.cleanup_thread
-        cls.worker = start_busy_worker(package, cls.tmp.name)
-        cls.recorder_before = cls.monitor.review_recorder
-        logger = logging.getLogger("prompt_manager.init")
-        handler, level = ListHandler(), logger.level
-        logger.addHandler(handler)
-        logger.setLevel(logging.INFO)  # otherwise set by the config
-        try:
-            with mock.patch("atexit.unregister", wraps=atexit.unregister) as unregister:
-                cls.result = package._stop_background_work()
-        finally:
-            logger.removeHandler(handler)
-            logger.setLevel(level)
-        cls.log = "\n".join(handler.lines)
-        cls.unregister_calls = unregister.call_args_list
-
-    def test_teardown_stops_every_part_once(self):
-        expected = {"monitor": True, "thumbnails": True, "tracker": True}
-        self.assertEqual(self.result, expected)
-        self.assertEqual(list(self.result), ["monitor", "thumbnails", "tracker"])
-        self.assertIn("Background work stopped in", self.log)
-        self.assertIn("monitor=ok thumbnails=ok tracker=ok", self.log)
-        self.assertFalse(self.worker.is_alive())
-        self.assertFalse(self.observer.is_alive())
-        self.assertFalse(self.tracker_thread.is_alive())
-        copy = self.package._stop_background_work()
-        copy["monitor"] = False  # a copy: the stored result is unchanged
-        with mock.patch.object(self.monitor, "stop_monitoring") as again:
-            self.assertEqual(self.package._stop_background_work(), expected)
-        again.assert_not_called()
-
-    def test_teardown_detaches_the_monitor_callbacks(self):
-        self.assertIsNotNone(self.recorder_before)
-        self.assertIsNone(self.monitor.review_recorder)
-        self.assertIsNone(self.monitor.thumbnail_queue)
-        self.assertIsNone(self.monitor.output_listener)
-
-    def test_teardown_removes_its_atexit_callback(self):
-        self.assertEqual(
-            self.unregister_calls, [mock.call(self.package._stop_background_work)]
-        )
-
-
-class TestPackageTeardownFailures(PackageTeardownCase):
-    """A failing step never skips the later ones (design D14, R2)."""
-
-    def assert_tracker_stops_after(self, error):
-        package = self.load(require_stopped=False)
-        monitor = package._global_image_monitor
-        tracker_thread = package._global_prompt_tracker.cleanup_thread
-        with (
-            mock.patch.object(monitor, "stop_monitoring", side_effect=error),
-            self.assertLogs("prompt_manager.init", "WARNING") as logs,
-        ):
-            result = package._stop_background_work()
-        self.assertFalse(result["monitor"])
-        self.assertTrue(result["tracker"])
-        self.assertFalse(tracker_thread.is_alive())
-        text = "\n".join(logs.output)
-        self.assertIn("Background work not stopped in time", text)
-        self.assertRegex(text, r"not stopped in time \([0-9.]+ s\): monitor$")
-        self.assertIn("Traceback", text)
-
-    def test_teardown_step_failure_does_not_skip_later_steps(self):
-        self.assert_tracker_stops_after(RuntimeError("stop failed"))
-
-    def test_second_interrupt_does_not_skip_the_tracker(self):
-        self.assert_tracker_stops_after(KeyboardInterrupt())
-
-    def test_an_interrupt_between_steps_still_records_the_teardown(self):
-        package = self.load(require_stopped=False)
-        real_step = package._teardown_step
-
-        def interrupted_before_the_previews(name, stop, logger):
-            if name == "the preview worker":
-                raise KeyboardInterrupt  # outside the step's own try
-            return real_step(name, stop, logger)
-
-        with (
-            mock.patch.object(
-                package, "_teardown_step", interrupted_before_the_previews
-            ),
-            mock.patch("atexit.unregister", wraps=atexit.unregister) as unregister,
-            self.assertRaises(KeyboardInterrupt),
-        ):
-            package._stop_background_work()
-        expected = {"monitor": True, "thumbnails": False, "tracker": False}
-        self.assertEqual(package._background_work_result, expected)
-        unregister.assert_called_once_with(package._stop_background_work)
-        with mock.patch.object(
-            package._global_image_monitor, "stop_monitoring"
-        ) as again:
-            self.assertEqual(package._stop_background_work(), expected)
-        again.assert_not_called()
-
-    def test_teardown_reports_a_preview_worker_still_held(self):
-        package = self.load(require_stopped=False)
-        held = self.hold_a_preview(package, advance=9.95, kill_releases=False)
-
-        with self.assertLogs("prompt_manager.init", "WARNING") as logs:
-            result = package._stop_background_work()
-
-        self.assertTrue(held.killed.is_set())
-        self.assertEqual(len(held.timeouts), 1)
-        self.assertAlmostEqual(held.timeouts[0], 0.05, places=6)
-        self.assertTrue(held.thumbnailer.closed)
-        self.assertFalse(result["thumbnails"], result)
-        self.assertRegex("\n".join(logs.output), r"not stopped in time .*thumbnails")
-        held.release.set()
-        held.worker.join(WAIT_SECONDS)
-        self.assertFalse(held.worker.is_alive())
-        self.assertEqual(held.stop_seen, [True])
-
-    def test_teardown_shares_one_deadline(self):
-        package = self.load(require_stopped=False)
-        now = [100.0]
-        seen = []
-
-        def step(timeout, **_):
-            seen.append(timeout)
-            now[0] += 6.0
-            return True
-
-        with (
-            mock.patch.object(package, "_clock", lambda: now[0]),
-            mock.patch.object(
-                package._global_image_monitor, "stop_monitoring", side_effect=step
-            ),
-            mock.patch.object(
-                package.api,
-                "close_auto_thumbnails",
-                side_effect=lambda final=False, timeout=None: step(timeout),
-            ),
-            mock.patch.object(
-                package._global_prompt_tracker, "shutdown", side_effect=step
-            ),
-        ):
-            package._stop_background_work()
-        self.assertEqual(seen, [5.0, 4.0, 0.0])
-
-
-class TestRepeatedLoads(PackageTeardownCase):
-    def test_repeated_loads_leave_no_threads(self):
-        for round_ in range(3):
-            before = package_threads()
-            with contextlib.redirect_stdout(io.StringIO()):
-                with load_package(
-                    f"pm_teardown_repeat_{round_}",
-                    self.db_path,
-                    self.output_dir,
-                ) as (package, _):
-                    self.busy_worker(package, f"busy_{round_}.png")
-                    started = package_threads() - before
-                    self.assertTrue(started, "the package started no thread")
-            left = {t for t in package_threads() - before if t.is_alive()}
-            self.assertEqual(left, set(), f"round {round_}")

tests/test_library_move_review.py

@@ -29,7 +29,6 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from database import library_move as lm  # noqa: E402
 from database import models  # noqa: E402
 from database.operations import PromptDatabase  # noqa: E402
-from tests.background_stops import close_handler  # noqa: E402
 from tests.open_handles import assert_closed  # noqa: E402
 from utils import library_location as ll  # noqa: E402
 from utils import usage_tracking  # noqa: E402
@@ -205,7 +204,6 @@ class TestBackgroundWritesSurviveTheSwitch(_MoveCase):
         image = os.path.join(self.comfy, "output", "late.png")
         writer_db = PromptDatabase(self.old_db)
         handler = ImageGenerationHandler(writer_db, mock.MagicMock())
-        self.addCleanup(close_handler, self, handler)
         started = threading.Event()
         probe = _CrossThreadCloseProbe()
         outcome = {}
@@ -258,7 +256,6 @@ class TestBackgroundWritesSurviveTheSwitch(_MoveCase):
 
         db = PromptDatabase(self.old_db)
         handler = ImageGenerationHandler(db, mock.MagicMock())
-        self.addCleanup(close_handler, self, handler)
         image = os.path.join(self.comfy, "output", "orphan.png")
         with mock.patch.object(handler, "logger") as log:
             handler.link_image_to_prompt(image, {"id": 99999}, {})

tests/test_lora_import.py

@@ -529,16 +529,6 @@ class LoraImportRouteTests(LoraImportAPITestCase):
         resp, body = await self._post(APPLY, {"token": plan["token"]})
         self.assertEqual((resp.status, body["code"]), (409, "plan-used"))
 
-    async def test_a_finished_import_clears_the_layout_cache(self):
-        # #362: the import may link files under a folder LoraManager created
-        # after the image routes cached its layout.
-        self._two_loras()
-        with patch("py.lora_utils.clear_layout_cache") as clear:
-            _plan, job = await self._apply_reviewed()
-            await job.task
-        self.assertEqual(job.state, "finished", job.log)
-        clear.assert_called_once_with()
-
     async def test_discovery_failure_keeps_previous_imports(self):
         self._two_loras()
         before = _snapshot(self.api.db)
@@ -946,35 +936,6 @@ class LoraImportRefusalTests(LoraImportAPITestCase):
         self.assertEqual((job.state, job.scope["failure"]), ("failed", "plan-changed"))
         self.assertEqual(_snapshot(self.api.db), before)
 
-    async def test_a_refused_import_keeps_the_layout_cache(self):
-        self._two_loras()
-        resp, plan = await self._post(PREVIEW)
-        self.api.db.save_prompt(
-            text="late", category=CATEGORY, prompt_hash=generate_prompt_hash("late")
-        )
-        with patch("py.lora_utils.clear_layout_cache") as clear:
-            resp, body = await self._post(APPLY, {"token": plan["token"]})
-            job = self.api._jobs.get(body["job"]["id"])
-            await job.task
-        self.assertEqual(job.scope["failure"], "plan-changed")
-        clear.assert_not_called()
-
-    async def test_start_refused_when_a_skipped_sidecar_changed(self):
-        # #362 CUJ 4: the review counted the orphan as skipped.
-        self._two_loras()
-        orphan = self.loras / "orphan.metadata.json"
-        orphan.write_text(json.dumps({"model_name": "orphan"}))
-        resp, plan = await self._post(PREVIEW)
-        self.assertEqual(resp.status, 200, plan)
-        self.assertEqual((plan["lora_files"], plan["skipped"]), (3, 1))
-        before = _snapshot(self.api.db)
-        orphan.write_text(orphan.read_text() + "  ")
-        resp, body = await self._post(APPLY, {"token": plan["token"]})
-        self.assertEqual(resp.status, 409, body)
-        self.assertEqual(body["code"], "plan-changed")
-        self.assertEqual(self.api._jobs.list(), [])
-        self.assertEqual(_snapshot(self.api.db), before)
-
     async def test_a_pair_saved_after_the_review_blocks_the_job(self):
         self._two_loras()
         resp, plan = await self._post(PREVIEW)
@@ -1226,62 +1187,6 @@ class LoraImportStageTests(unittest.TestCase):
         )
         self.assertNotEqual(lora_import.fingerprint(self.discover()), first)
 
-    # #362: a skipped sidecar is part of what the review counted.
-
-    def _assert_fingerprint_follows(self, change):
-        first = lora_import.fingerprint(self.discover())
-        self.assertEqual(lora_import.fingerprint(self.discover()), first)
-        change()
-        self.assertNotEqual(lora_import.fingerprint(self.discover()), first)
-
-    def _assert_add_edit_remove_change_it(self, path, text):
-        self._assert_fingerprint_follows(lambda: path.write_text(text))
-        self._assert_fingerprint_follows(
-            lambda: path.write_text(path.read_text() + "  ")
-        )
-        self._assert_fingerprint_follows(path.unlink)
-
-    def _centralized(self):
-        sidecars = self.tmp / "sidecars"
-        sidecars.mkdir()
-        self.settings_file(
-            {
-                "sidecar_storage_mode": "centralized",
-                "sidecar_storage_path": str(sidecars),
-            }
-        )
-        model = self.loras / "kept.safetensors"
-        model.write_bytes(b"m")
-        (sidecars / "kept.metadata.json").write_text(
-            json.dumps({"file_path": str(model)})
-        )
-        return sidecars
-
-    def test_fingerprint_follows_a_centralized_sidecar_whose_model_is_missing(self):
-        sidecars = self._centralized()
-        gone = self.loras / "gone.safetensors"
-        self._assert_add_edit_remove_change_it(
-            sidecars / "gone.metadata.json", json.dumps({"file_path": str(gone)})
-        )
-        self.assertEqual(len(self.discover().sidecars), 1)
-
-    def test_fingerprint_follows_a_checkpoint_sidecar_outside_the_lora_roots(self):
-        sidecars = self._centralized()
-        checkpoints = self.tmp / "checkpoints"
-        checkpoints.mkdir()
-        ckpt = checkpoints / "base.safetensors"
-        ckpt.write_bytes(b"c")
-        self._assert_add_edit_remove_change_it(
-            sidecars / "base.metadata.json", json.dumps({"file_path": str(ckpt)})
-        )
-
-    def test_fingerprint_follows_an_alongside_sidecar_without_its_model(self):
-        _write_metadata(self.loras, "kept")
-        self._assert_add_edit_remove_change_it(
-            self.loras / "orphan.metadata.json", json.dumps({"model_name": "orphan"})
-        )
-        self.assertEqual(len(self.discover().sidecars), 1)
-
     def test_fingerprint_follows_a_missing_file_between_stat_calls(self):
         meta = _write_metadata(self.loras, "one")
         discovery = self.discover()

tests/test_lora_layout_cache.py

@@ -1,590 +0,0 @@
-"""The LoraManager layout cache for the image hot paths (#362).
-
-``py/lora_layout_cache.py``. Every test injects the install resolver, the
-layout loader (both counting calls), the wall clock, the monotonic clock and,
-where needed, ``stat`` and ``pathmod``, over a temporary folder. No test
-sleeps: modification times are set with ``os.utime`` and the clocks are
-plain attributes the test moves.
-"""
-
-import ntpath
-import os
-import shutil
-import sys
-import tempfile
-import threading
-import time
-import unittest
-from dataclasses import replace
-from pathlib import Path, PureWindowsPath
-from types import SimpleNamespace
-from unittest.mock import patch
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from py import lora_layout_cache as cache_module
-from py.lora_layout_cache import (
-    MAX_AGE_SECONDS,
-    MISSING,
-    RACY_SECONDS,
-    LayoutCache,
-)
-from py.lora_manager_layout import UNREADABLE, LoraManagerLayout, _canonical
-
-SECOND_NS = 10**9
-# NTFS keeps modification times in 100 ns steps and FAT in 2 s steps: every
-# time a test sets is a whole millisecond, and a test whose file system rounds
-# it anyway skips (``set_mtime``).
-TICK_NS = 10**6
-
-
-def make_layout(settings_path=None, media_roots=(), error=None, source="user config"):
-    return LoraManagerLayout(
-        settings_path=settings_path,
-        source=source,
-        error=error,
-        mode="alongside",
-        lora_roots=tuple(media_roots),
-        sidecar_root=None,
-        example_images_root=None,
-        library="default",
-        media_roots=tuple(media_roots),
-    )
-
-
-class CacheTestCase(unittest.TestCase):
-    """An install, its plugin settings file, a settings file and a LoRA root."""
-
-    def setUp(self):
-        self.tmp = Path(tempfile.mkdtemp()).resolve()
-        self.addCleanup(shutil.rmtree, self.tmp)
-        self.install_dir = self.tmp / "custom_nodes" / "ComfyUI-Lora-Manager"
-        self.install_dir.mkdir(parents=True)
-        self.plugin_settings = self.install_dir / "settings.json"
-        self.settings = self.tmp / "user-config" / "settings.json"
-        self.settings.parent.mkdir()
-        self.root_dir = self.tmp / "loras"
-        self.root_dir.mkdir()
-        # Files are written ten minutes before the injected wall clock, so
-        # nothing is racy unless a test sets a recent modification time.
-        self.now_ns = time.time_ns() // TICK_NS * TICK_NS
-        self.mono = 1000.0
-        self.resolved = []
-        self.loaded = []
-        self.install = _canonical(str(self.install_dir))
-        self.layout = make_layout(
-            settings_path=self.settings,
-            media_roots=(_canonical(str(self.root_dir)),),
-        )
-        self.write(self.settings, "{}")
-
-    def write(self, path, text, mtime_ns=None):
-        Path(path).write_text(text, encoding="utf-8")
-        stamp = mtime_ns if mtime_ns is not None else self.now_ns - 600 * SECOND_NS
-        self.set_mtime(path, stamp)
-
-    def set_mtime(self, path, stamp):
-        os.utime(path, ns=(stamp, stamp))
-        if os.stat(path).st_mtime_ns != stamp:
-            self.skipTest("this file system rounds modification times")
-
-    def resolve(self, key):
-        self.resolved.append(key)
-        return self.install
-
-    def load(self, install):
-        self.loaded.append(install)
-        return self.layout
-
-    def cache(self, **kwargs):
-        kwargs.setdefault("wall_ns", lambda: self.now_ns)
-        kwargs.setdefault("monotonic", lambda: self.mono)
-        return LayoutCache(
-            kwargs.pop("resolve", self.resolve), kwargs.pop("load", self.load), **kwargs
-        )
-
-
-class ValidationTests(CacheTestCase):
-    def test_hit_reuses_the_entry_without_resolving_or_loading(self):
-        cache = self.cache()
-        first = cache.get("")
-        second = cache.get("")
-        self.assertEqual(len(self.resolved), 1)
-        self.assertEqual(len(self.loaded), 1)
-        self.assertIs(first[1], second[1])
-        self.assertIs(first[0], second[0])
-        self.assertEqual(first, (self.install, self.layout))
-
-    def test_settings_size_change_reloads_once(self):
-        cache = self.cache()
-        cache.get("")
-        stamp = self.settings.stat().st_mtime_ns
-        self.write(self.settings, '{"a": 1}', mtime_ns=stamp)
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_settings_mtime_change_reloads_once(self):
-        cache = self.cache()
-        cache.get("")
-        self.set_mtime(self.settings, self.settings.stat().st_mtime_ns + TICK_NS)
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_settings_deletion_reloads_once(self):
-        cache = self.cache()
-        cache.get("")
-        self.settings.unlink()
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_settings_creation_reloads_once(self):
-        self.settings.unlink()
-        cache = self.cache()
-        cache.get("")
-        self.write(self.settings, "{}")
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_plugin_settings_change_reloads_once(self):
-        cache = self.cache()
-        cache.get("")
-        self.write(self.plugin_settings, '{"use_portable_settings": true}')
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_a_different_configured_path_reloads(self):
-        cache = self.cache()
-        cache.get("")
-        cache.get("other")
-        self.assertEqual(self.resolved, ["", "other"])
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_a_different_home_folder_reloads(self):
-        # The folder guard compares against the home folder: a cached layout
-        # must not outlive a change of it.
-        home = {"value": str(self.tmp / "home-a")}
-        cache = self.cache(home=lambda: home["value"])
-        cache.get("")
-        cache.get("")
-        home["value"] = str(self.tmp / "home-b")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_configured_path_is_stripped_for_the_key_and_the_resolver(self):
-        cache = self.cache()
-        cache.get("  x ")
-        cache.get("x")
-        self.assertEqual(self.resolved, ["x"])
-        self.assertEqual(len(self.loaded), 1)
-
-    def test_a_recently_modified_file_is_not_stored(self):
-        self.write(self.settings, "{}", mtime_ns=self.now_ns - SECOND_NS)
-        cache = self.cache()
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-        self.assertIsNone(cache._entry)
-        self.now_ns += RACY_SECONDS * SECOND_NS
-        cache.get("")
-        self.assertIsNotNone(cache._entry)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 3)
-
-    def test_racy_boundary(self):
-        # Exactly RACY_SECONDS old is trusted; anything newer is not.
-        boundary = self.now_ns - RACY_SECONDS * SECOND_NS
-        self.write(self.settings, "{}", mtime_ns=boundary + TICK_NS)
-        cache = self.cache()
-        cache.get("")
-        self.assertIsNone(cache._entry)
-        self.set_mtime(self.settings, boundary)
-        cache.get("")
-        self.assertIsNotNone(cache._entry)
-
-    def test_a_modification_time_in_the_future_is_racy(self):
-        self.write(self.plugin_settings, "{}", mtime_ns=self.now_ns + 60 * SECOND_NS)
-        cache = self.cache()
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-        self.assertIsNone(cache._entry)
-
-    def test_a_missing_file_is_not_racy(self):
-        self.assertFalse(self.plugin_settings.exists())
-        self.settings.unlink()
-        cache = self.cache()
-        cache.get("")
-        self.assertIsNotNone(cache._entry)
-        signatures = dict(cache._entry.signatures)
-        self.assertTrue(all(value is MISSING for value in signatures.values()))
-        self.assertEqual(len(signatures), 2)
-
-    def test_entry_is_reused_below_the_maximum_age_and_reloaded_at_it(self):
-        cache = self.cache()
-        cache.get("")
-        stored_at = self.mono
-        self.mono = stored_at + MAX_AGE_SECONDS - 0.5
-        cache.get("")
-        self.assertEqual(len(self.loaded), 1)
-        self.mono = stored_at + MAX_AGE_SECONDS
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_a_wall_clock_moved_backward_does_not_extend_the_age(self):
-        cache = self.cache()
-        cache.get("")
-        self.now_ns -= 3600 * SECOND_NS
-        self.mono += MAX_AGE_SECONDS
-        # The old entry is too old; the new load sees files "from the future"
-        # (racy) and is not stored, but it does load.
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_stat_failure_on_a_hit_reloads(self):
-        failing = {"on": False}
-
-        def stat(path):
-            if failing["on"]:
-                raise PermissionError(13, "sharing violation", path)
-            return os.stat(path)
-
-        cache = self.cache(stat=stat)
-        cache.get("")
-        failing["on"] = True
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-        self.assertIsNone(cache._entry)
-
-    def test_stat_failure_on_a_miss_leaves_the_layout_unstored(self):
-        def stat(path):
-            raise PermissionError(13, "sharing violation", path)
-
-        cache = self.cache(stat=stat)
-        self.assertEqual(cache.get(""), (self.install, self.layout))
-        self.assertIsNone(cache._entry)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_an_unreadable_settings_layout_is_not_stored(self):
-        self.layout = make_layout(settings_path=self.settings, error=UNREADABLE)
-        cache = self.cache()
-        self.assertEqual(cache.get("")[1].error, UNREADABLE)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-        self.assertIsNone(cache._entry)
-
-    def test_other_layout_errors_are_stored(self):
-        self.layout = make_layout(
-            settings_path=self.settings, error="the settings file is not valid JSON"
-        )
-        cache = self.cache()
-        cache.get("")
-        cache.get("")
-        self.assertEqual(len(self.loaded), 1)
-
-    def _symlink(self, link, target):
-        try:
-            os.symlink(target, link, target_is_directory=True)
-        except (OSError, NotImplementedError) as error:
-            self.skipTest(f"symlinks are not available here: {error}")
-
-    def test_a_media_root_swapped_for_a_symlink_reloads(self):
-        elsewhere = self.tmp / "elsewhere"
-        elsewhere.mkdir()
-        cache = self.cache()
-        cache.get("")
-        shutil.rmtree(self.root_dir)
-        self._symlink(self.root_dir, elsewhere)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_an_install_swapped_for_a_symlink_reloads(self):
-        elsewhere = self.tmp / "elsewhere-lm"
-        elsewhere.mkdir()
-        cache = self.cache()
-        cache.get("")
-        moved = self.tmp / "moved-lm"
-        self.install_dir.rename(moved)
-        self._symlink(self.install_dir, elsewhere)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_a_root_whose_realpath_fails_reloads(self):
-        cache = self.cache()
-        cache.get("")
-        with patch.object(
-            cache_module, "_canonical", side_effect=OSError("realpath failed")
-        ):
-            cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_a_stat_value_error_cannot_validate(self):
-        def stat(path):
-            raise ValueError("embedded null character in path")
-
-        cache = self.cache(stat=stat)
-        cache.get("")
-        self.assertIsNone(cache._entry)
-
-    def test_not_a_directory_is_missing(self):
-        def stat(path):
-            raise NotADirectoryError(20, "Not a directory", path)
-
-        cache = self.cache(stat=stat)
-        cache.get("")
-        self.assertTrue(
-            all(value is MISSING for _path, value in cache._entry.signatures)
-        )
-        cache.get("")
-        self.assertEqual(len(self.loaded), 1)
-
-    def test_an_offline_windows_share_cannot_validate(self):
-        def stat(path):
-            error = FileNotFoundError(2, "The network path was not found", path)
-            error.winerror = 53
-            raise error
-
-        cache = self.cache(stat=stat)
-        cache.get("")
-        self.assertIsNone(cache._entry)
-
-    def test_a_failed_reload_leaves_no_stale_entry(self):
-        failing = {"on": False}
-
-        def load(install):
-            self.loaded.append(install)
-            if failing["on"]:
-                raise RuntimeError("boom")
-            return self.layout
-
-        cache = self.cache(load=load)
-        cache.get("")
-        self.mono += MAX_AGE_SECONDS
-        failing["on"] = True
-        with self.assertRaises(RuntimeError):
-            cache.get("")
-        self.assertIsNone(cache._entry)
-
-    def test_a_resolve_failure_propagates_and_stores_nothing(self):
-        def resolve(key):
-            raise RuntimeError("boom")
-
-        cache = self.cache(resolve=resolve)
-        with self.assertRaises(RuntimeError):
-            cache.get("")
-        self.assertIsNone(cache._entry)
-
-    def test_without_a_settings_path_only_the_plugin_file_is_watched(self):
-        self.layout = make_layout(media_roots=self.layout.media_roots)
-        cache = self.cache()
-        cache.get("")
-        self.assertEqual(
-            [path for path, _sig in cache._entry.signatures],
-            [os.path.join(self.install, "settings.json")],
-        )
-
-    def test_portable_settings_are_watched_once(self):
-        self.layout = make_layout(settings_path=self.install_dir / "settings.json")
-        cache = self.cache()
-        cache.get("")
-        self.assertEqual(len(cache._entry.signatures), 1)
-
-    def test_a_load_failure_propagates_and_stores_nothing(self):
-        calls = []
-
-        def load(install):
-            calls.append(install)
-            if len(calls) == 1:
-                raise RuntimeError("boom")
-            return self.layout
-
-        cache = self.cache(load=load)
-        with self.assertRaises(RuntimeError):
-            cache.get("")
-        self.assertIsNone(cache._entry)
-        self.assertEqual(cache.get(""), (self.install, self.layout))
-        self.assertEqual(len(calls), 2)
-
-    def test_without_an_install_nothing_is_watched_and_the_entry_ages_out(self):
-        stats = []
-
-        def stat(path):
-            stats.append(path)
-            return os.stat(path)
-
-        self.layout = make_layout(media_roots=self.layout.media_roots, source=None)
-        cache = self.cache(resolve=lambda key: self.resolved.append(key), stat=stat)
-        self.assertEqual(cache.get(""), (None, self.layout))
-        self.assertEqual(cache._entry.signatures, ())
-        cache.get("")
-        self.assertEqual(len(self.loaded), 1)
-        self.assertEqual(stats, [])
-        self.mono += MAX_AGE_SECONDS
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-    def test_windows_paths_differing_only_in_case_are_watched_once(self):
-        stats = []
-
-        def stat(path):
-            stats.append(path)
-            return SimpleNamespace(st_mtime_ns=self.now_ns - 600 * SECOND_NS, st_size=2)
-
-        install = _canonical("C:\\ComfyUI\\custom_nodes\\LM", ntpath)
-        # The hit check needs ntpath's realpath to be idempotent here.
-        self.assertEqual(install, _canonical(install, ntpath))
-        self.layout = make_layout(
-            settings_path=PureWindowsPath(
-                "C:\\ComfyUI\\custom_nodes\\lm\\SETTINGS.JSON"
-            )
-        )
-        cache = self.cache(resolve=lambda key: install, stat=stat, pathmod=ntpath)
-        cache.get("")
-        self.assertEqual(len(cache._entry.signatures), 1)
-        self.assertEqual(len(stats), 1)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 1)
-        self.assertEqual(len(stats), 2)
-
-
-class ConcurrencyTests(CacheTestCase):
-    def test_a_load_that_started_before_clear_stores_nothing(self):
-        started = threading.Event()
-        release = threading.Event()
-
-        def load(install):
-            self.loaded.append(install)
-            if len(self.loaded) == 1:
-                started.set()
-                self.assertTrue(release.wait(10))
-            return self.layout
-
-        cache = self.cache(load=load)
-        results = []
-        worker = threading.Thread(target=lambda: results.append(cache.get("")))
-        worker.start()
-        self.assertTrue(started.wait(10))
-        cache.clear()
-        release.set()
-        worker.join(10)
-        self.assertFalse(worker.is_alive())
-        self.assertEqual(results, [(self.install, self.layout)])
-        self.assertIsNone(cache._entry)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-        self.assertIsNotNone(cache._entry)
-
-    def test_concurrent_misses_all_get_a_layout_and_one_entry_is_stored(self):
-        cache = self.cache()
-        count = 6
-        barrier = threading.Barrier(count)
-        results = []
-        lock = threading.Lock()
-
-        def worker():
-            barrier.wait(10)
-            result = cache.get("")
-            with lock:
-                results.append(result)
-
-        threads = [threading.Thread(target=worker) for _ in range(count)]
-        for thread in threads:
-            thread.start()
-        for thread in threads:
-            thread.join(10)
-        self.assertEqual(results, [(self.install, self.layout)] * count)
-        self.assertIsNotNone(cache._entry)
-        loads = len(self.loaded)
-        cache.get("")
-        self.assertEqual(len(self.loaded), loads)
-
-    def test_a_valid_hit_takes_no_lock(self):
-        cache = self.cache()
-        cache.get("")
-        results = []
-        with cache._lock:
-            worker = threading.Thread(target=lambda: results.append(cache.get("")))
-            worker.start()
-            worker.join(10)
-            alive = worker.is_alive()
-        worker.join(10)
-        self.assertFalse(alive)
-        self.assertEqual(results, [(self.install, self.layout)])
-
-    def test_clear_forces_a_reload(self):
-        cache = self.cache()
-        cache.get("")
-        cache.clear()
-        self.assertIsNone(cache._entry)
-        cache.get("")
-        self.assertEqual(len(self.loaded), 2)
-
-
-class LoggingTests(CacheTestCase):
-    LOGGER = "prompt_manager.lora_layout_cache"
-
-    def get(self, cache):
-        with self.assertLogs(self.LOGGER, "DEBUG") as logs:
-            cache.get("")
-            # assertLogs needs one record; this marker is not counted.
-            cache_module.logger.debug("marker")
-        return [r for r in logs.records if r.getMessage() != "marker"]
-
-    def test_a_new_layout_logs_one_info_line(self):
-        cache = self.cache()
-        records = self.get(cache)
-        self.assertEqual([r.levelname for r in records], ["INFO"])
-        self.assertEqual(
-            records[0].getMessage(),
-            "LoraManager layout changed: user config settings, alongside storage, "
-            "1 media folders",
-        )
-        self.mono += MAX_AGE_SECONDS
-        self.assertEqual(self.get(cache), [])  # an equal layout, reloaded
-        cache.clear()
-        self.assertEqual(self.get(cache), [])
-        self.layout = replace(self.layout, media_roots=(), lora_roots=())
-        self.mono += MAX_AGE_SECONDS
-        self.assertEqual(len(self.get(cache)), 1)
-
-    def test_no_settings_source_prints_no(self):
-        self.layout = replace(self.layout, source=None)
-        records = self.get(self.cache())
-        self.assertIn("layout changed: no settings,", records[0].getMessage())
-
-    def test_an_unstored_load_logs_no_info_line(self):
-        self.write(self.settings, "{}", mtime_ns=self.now_ns)
-        self.assertEqual(
-            [r for r in self.get(self.cache()) if r.levelname == "INFO"], []
-        )
-
-    def test_a_newly_refused_default_folder_logs_one_warning(self):
-        self.layout = replace(self.layout, refused_defaults=("/home",))
-        cache = self.cache()
-        records = self.get(cache)
-        warnings = [r for r in records if r.levelname == "WARNING"]
-        self.assertEqual(len(warnings), 1)
-        self.assertIn("/home", warnings[0].getMessage())
-        self.mono += MAX_AGE_SECONDS
-        self.assertEqual(self.get(cache), [])
-        cache.clear()
-        self.assertEqual(self.get(cache), [])
-        self.layout = replace(self.layout, refused_defaults=("/home", "/"))
-        self.mono += MAX_AGE_SECONDS
-        warnings = [r for r in self.get(cache) if r.levelname == "WARNING"]
-        self.assertEqual([w.getMessage().count("'/'") for w in warnings], [1])
-
-
-class ModuleTests(unittest.TestCase):
-    def test_constants(self):
-        self.assertEqual(cache_module.RACY_SECONDS, 3)
-        self.assertEqual(cache_module.MAX_AGE_SECONDS, 30)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_lora_manager_layout.py

@@ -33,10 +33,6 @@ MEDIA = frozenset(
     {".png", ".jpg", ".jpeg", ".webp", ".gif", ".mp4", ".webm", ".mov", ".bmp"}
 )
 MARKER = "marker-from-unkept-settings-0123"
-BAD_SIDECAR_REASON = (
-    "the sidecar folder is a filesystem root, the home folder or a folder "
-    "that contains it"
-)
 
 
 class LayoutTestCase(unittest.TestCase):
@@ -265,25 +261,10 @@ class UnusableLayoutTests(LayoutTestCase):
             {"sidecar_storage_mode": "centralized", "sidecar_storage_path": "/"},
         )
         layout = self.load()
-        self.assertEqual(layout.error, BAD_SIDECAR_REASON)
-        self.assertNotIn(os.path.normcase(os.path.realpath("/")), layout.media_roots)
-
-    def test_a_centralized_sidecar_root_that_contains_home(self):
-        home = self.tmp / "outer" / "me"
-        home.mkdir(parents=True)
-        self.write_settings(
-            self.user_config,
-            {
-                "sidecar_storage_mode": "centralized",
-                "sidecar_storage_path": str(self.tmp / "outer"),
-            },
-        )
-        with patch.object(layout_module.Path, "home", return_value=home):
-            layout = self.load()
-        self.assertEqual(layout.error, BAD_SIDECAR_REASON)
         self.assertEqual(
-            layout.media_roots, (os.path.normcase(str(self.default_loras)),)
+            layout.error, "the sidecar folder is a filesystem root or the home folder"
         )
+        self.assertNotIn(os.path.normcase(os.path.realpath("/")), layout.media_roots)
 
 
 class SecretTests(LayoutTestCase):
@@ -520,31 +501,6 @@ class CentralizedDiscoveryTests(LayoutTestCase):
         self.assertEqual(discovery.scanned, 3)
         self.assertEqual(discovery.sidecars, [])
 
-    def test_every_scanned_file_is_listed_resolved_and_sorted(self):
-        # #362: the fingerprint covers every scanned sidecar, kept or skipped.
-        ckpt = self.model(self.checkpoints, "base")
-        alpha = self.model(self.loras, "alpha")
-        self.sidecar(self.sidecars / "z", "base", {"file_path": str(ckpt)})
-        self.sidecar(self.sidecars / "a", "alpha", {"file_path": str(alpha)})
-        self.sidecar(self.sidecars / "m", "nopath", {"model_name": "x"})
-        discovery = discover_sidecars(self.load())
-        files = discovery.scanned_files
-        self.assertIsInstance(files, tuple)
-        self.assertEqual(len(files), 3)
-        self.assertEqual(discovery.scanned, len(files))
-        self.assertEqual([str(f) for f in files], sorted(str(f) for f in files))
-        self.assertEqual(
-            [f.name for f in files],
-            [
-                f"alpha{METADATA_SUFFIX}",
-                f"nopath{METADATA_SUFFIX}",
-                f"base{METADATA_SUFFIX}",
-            ],
-        )
-        for path in files:
-            self.assertEqual(str(path), os.path.realpath(path))
-        self.assertEqual(len(discovery.sidecars), 1)
-
     def test_leftover_sidecars_beside_models_are_not_scanned(self):
         model = self.model(self.loras, "alpha")
         self.sidecar(self.loras, "alpha", {"file_path": str(model)})
@@ -655,16 +611,6 @@ class LocalMediaTests(LayoutTestCase):
         self.touch(self.default_loras / "alpha.webp")
         self.assertEqual(self.media({"preview_url": preview}), [preview])
 
-    def test_a_relative_preview_url_is_logged_and_skipped(self):
-        fallback = self.touch(self.default_loras / "alpha.webp")
-        self.touch(self.default_loras / "relative.png")
-        with self.assertLogs("prompt_manager.lora_manager_layout", "DEBUG") as logs:
-            media = self.media({"preview_url": "relative.png"})
-        self.assertEqual(media, [fallback])
-        self.assertEqual(len(logs.records), 1)
-        self.assertEqual(logs.records[0].levelname, "DEBUG")
-        self.assertIn(self.meta.name, logs.output[0])
-
     def test_preview_url_outside_media_roots_or_not_servable_is_ignored(self):
         outside = self.touch(self.tmp / "elsewhere" / "p.png")
         avif = self.touch(self.default_loras / "p.avif")
@@ -864,63 +810,6 @@ class FolderGuardTests(unittest.TestCase):
         self.assertFalse(layout_module._inside(str(self.tmp / "other.png"), (root,)))
 
 
-class RefusedDefaultsTests(LayoutTestCase):
-    """#362: ComfyUI's default LoRA folders pass the same guard; the refused
-    ones that exist are listed so the layout cache can warn about them."""
-
-    def setUp(self):
-        super().setUp()
-        self.outer = self.tmp / "outer"
-        self.home = self.outer / "me"
-        self.home.mkdir(parents=True)
-        self.fs_root = os.path.abspath(os.sep)
-        self.defaults = [
-            str(self.home),
-            str(self.outer),
-            self.fs_root,
-            str(self.tmp / "missing"),
-            str(self.default_loras),
-        ]
-        self.expected = (
-            layout_module._canonical(str(self.home)),
-            layout_module._canonical(str(self.outer)),
-            layout_module._canonical(self.fs_root),
-        )
-        home_patch = patch.object(layout_module.Path, "home", return_value=self.home)
-        home_patch.start()
-        self.addCleanup(home_patch.stop)
-
-    def load_defaults(self, path="__plugin__"):
-        return self.load(path, default_roots=lambda: list(self.defaults))
-
-    def test_refused_existing_defaults_are_listed_on_a_usable_layout(self):
-        self.write_settings(self.user_config, {})
-        layout = self.load_defaults()
-        self.assertIsNone(layout.error)
-        self.assertEqual(layout.refused_defaults, self.expected)
-        self.assertEqual(
-            layout.lora_roots, (os.path.normcase(str(self.default_loras)),)
-        )
-
-    def test_they_are_listed_on_an_unusable_centralized_layout(self):
-        self.write_settings(
-            self.user_config,
-            {"sidecar_storage_mode": "centralized", "sidecar_storage_path": "/"},
-        )
-        layout = self.load_defaults()
-        self.assertEqual(layout.error, BAD_SIDECAR_REASON)
-        self.assertEqual(layout.refused_defaults, self.expected)
-
-    def test_they_are_listed_without_an_install(self):
-        layout = self.load_defaults(None)
-        self.assertEqual(layout.error, "no LoraManager install found")
-        self.assertEqual(layout.refused_defaults, self.expected)
-
-    def test_nothing_is_listed_when_every_default_is_accepted(self):
-        self.write_settings(self.user_config, {})
-        self.assertEqual(self.load().refused_defaults, ())
-
-
 class SummaryTests(LayoutTestCase):
 
     def test_summary_names_what_the_import_read(self):

tests/test_lora_utils.py

@@ -224,14 +224,6 @@ class TestReadLoraMetadata(unittest.TestCase):
         result = read_lora_metadata(Path("/nonexistent/file.metadata.json"))
         self.assertIsNone(result)
 
-    def test_returns_none_for_a_file_that_is_not_utf8(self):
-        # #362: one malformed sidecar is skipped; it must not fail the whole
-        # trigger-word load (now logged with a traceback) or the review.
-        with tempfile.TemporaryDirectory() as folder:
-            path = Path(folder) / "bad.metadata.json"
-            path.write_bytes(b'{"model_name": "\xff\xfe"}')
-            self.assertIsNone(read_lora_metadata(path))
-
 
 class TestGetLoraImageCacheDir(unittest.TestCase):
     """Test get_lora_image_cache_dir — returns and creates cache path."""
@@ -1799,34 +1791,6 @@ class TestTriggerWordCacheLayout(unittest.TestCase):
         self.assertTrue(cache.is_loaded)
         self.assertTrue(cache.retry_due())
 
-    def test_an_os_error_is_a_warning_without_a_traceback(self):
-        cache = TriggerWordCache()
-        cache._cache = {"old": ["word"]}
-        with (
-            patch.object(TriggerWordCache, "_build", side_effect=OSError("denied")),
-            self.assertLogs("prompt_manager.lora_utils", level="WARNING") as logs,
-        ):
-            self.assertEqual(cache.load(str(self.lm)), 1)
-        self.assertEqual([r.levelname for r in logs.records], ["WARNING"])
-        self.assertIsNone(logs.records[0].exc_info)
-        self.assertEqual(cache.get_trigger_words("old"), ["word"])
-        self.assertFalse(cache.retry_due())
-
-    def test_an_unexpected_failure_logs_its_traceback(self):
-        # #362: a programming error must not look like a disk error.
-        cache = TriggerWordCache()
-        cache._cache = {"old": ["word"]}
-        with (
-            patch.object(TriggerWordCache, "_build", side_effect=ValueError("bug")),
-            self.assertLogs("prompt_manager.lora_utils", level="WARNING") as logs,
-        ):
-            self.assertEqual(cache.load(str(self.lm)), 1)
-        self.assertEqual(len(logs.records), 1)
-        self.assertIsNotNone(logs.records[0].exc_info)
-        self.assertIs(logs.records[0].exc_info[0], ValueError)
-        self.assertEqual(cache.get_trigger_words("old"), ["word"])
-        self.assertFalse(cache.retry_due())
-
     def test_any_other_failure_never_raises(self):
         cache = TriggerWordCache()
         with (

tests/test_nonfinite_metadata.py

@@ -24,7 +24,6 @@ from unittest.mock import patch
 from PIL import Image, PngImagePlugin
 
 from database.operations import PromptDatabase
-from tests.background_stops import close_handler
 from tests.history_waits import drain_writer
 from tests.test_api_admin import AdminAPITestCase
 from tests.test_api_images import ImageAPITestCase
@@ -225,7 +224,6 @@ class TestMonitorIngestsNonFiniteMetadata(StrictRows, unittest.TestCase):
         self.handler.logger.disabled = True
 
     def tearDown(self):
-        close_handler(self, self.handler)
         self.db.close_all()
         assert_closed(self, self.temp.name)
         self.temp.cleanup()

tests/test_package_exit.py

@@ -1,142 +0,0 @@
-"""The package teardown runs at a normal interpreter exit (#301, #302).
-
-ComfyUI catches Ctrl+C in ``main.py`` and returns, so its exit is a normal
-return: ``atexit`` callbacks then run, newest first. A child process imports
-the package with ComfyUI stubbed, leaves the image worker alive in its
-processing delay and returns. Its own ``atexit`` reporter, registered before
-the package, runs after the teardown and prints the result as one JSON line.
-"""
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import textwrap
-import unittest
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-# The parent never waits longer than this for the child (the hang watchdog
-# allows 120 s per test).
-CHILD_CEILING_SECONDS = 60
-REPORT_PREFIX = "PM_EXIT_REPORT "
-
-CHILD = textwrap.dedent("""
-    import atexit
-    import contextlib
-    import io
-    import json
-    import os
-    import sys
-    import threading
-
-    root, tmp = sys.argv[1], sys.argv[2]
-    sys.path.insert(0, root)
-    state = {}
-
-    def report():
-        from watchdog.utils import BaseThread
-
-        package = state.get("package")
-        result = getattr(package, "_background_work_result", None)
-        # The image worker, the tracker, and watchdog's observer and emitters.
-        alive = sorted(
-            t.name
-            for t in threading.enumerate()
-            if t.name in ("PromptManagerImageWorker", "PromptManagerPromptCleanup")
-            or isinstance(t, BaseThread)
-        )
-        print("PM_EXIT_REPORT " + json.dumps({"result": result, "alive": alive}))
-        sys.stdout.flush()
-
-    # First registered, so it runs last: after the package's teardown and
-    # after the history dispose.
-    atexit.register(report)
-
-    from tests.test_init_package import _import_package, fake_server_module
-
-    output = os.path.join(tmp, "output")
-    with contextlib.redirect_stdout(io.StringIO()):
-        package, _ = _import_package(
-            "pm_exit_child",
-            os.path.join(tmp, "prompts.db"),
-            output,
-            fake_server_module(queue_task_done=True),
-        )
-    state["package"] = package
-    monitor = package._global_image_monitor
-    handler = monitor.handler if monitor is not None else None
-    if handler is None:
-        sys.exit(3)
-    handler.processing_delay = 3600
-    path = os.path.join(tmp, "busy.png")  # outside the watched folder
-    with open(path, "wb") as image:
-        image.write(b"x" * 16)
-    if not handler.schedule(path) or not handler._worker.is_alive():
-        sys.exit(4)
-    # Return normally with the worker alive, as ComfyUI does after Ctrl+C.
-    """)
-
-
-class TestPackageExit(unittest.TestCase):
-    def test_teardown_runs_at_a_normal_exit_with_the_worker_alive(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            os.makedirs(os.path.join(tmp, "output"))
-            script = os.path.join(tmp, "child.py")
-            with open(script, "w", encoding="utf-8") as handle:
-                handle.write(CHILD)
-            env = dict(os.environ)
-            env.pop("PROMPT_MANAGER_CONFIG_PATH", None)
-            # The child's library and log file live in its own folder, never
-            # in the checkout's logs/ (which this runner may hold open) or a
-            # data folder the caller set.
-            env["PROMPT_MANAGER_DATA_DIR"] = tmp
-            env["PYTHONIOENCODING"] = "utf-8"
-            try:
-                completed = subprocess.run(
-                    [sys.executable, script, ROOT, tmp],
-                    cwd=ROOT,
-                    env=env,
-                    capture_output=True,
-                    timeout=CHILD_CEILING_SECONDS,
-                    encoding="utf-8",
-                    errors="replace",
-                )
-            except subprocess.TimeoutExpired as hung:
-                self.fail(
-                    f"the child did not exit within {CHILD_CEILING_SECONDS} s\n"
-                    f"stdout:\n{hung.stdout}\nstderr:\n{hung.stderr}"
-                )
-            # Leaving the block removes the folder: on Windows that fails
-            # if the child left a handle open, which it cannot once it exited,
-            # so the check here is that the child exited at all.
-        detail = f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
-        self.assertEqual(completed.returncode, 0, detail)
-        reports = [
-            line[len(REPORT_PREFIX) :]
-            for line in completed.stdout.splitlines()
-            if line.startswith(REPORT_PREFIX)
-        ]
-        self.assertEqual(len(reports), 1, detail)
-        report = json.loads(reports[0])
-        # "thumbnails" is True here because no preview worker started; its
-        # close result is tested in test_thumbnail_auto and test_init_package.
-        self.assertEqual(
-            report["result"],
-            {"monitor": True, "thumbnails": True, "tracker": True},
-            detail,
-        )
-        self.assertEqual(report["alive"], [], detail)
-        # The teardown's own warnings. Import-time warnings (the API's
-        # output-folder search finds no ComfyUI here) are not about exit.
-        for text in (
-            "Traceback",
-            "Background work not stopped in time",
-            "still running after",
-            "Error while stopping",
-        ):
-            self.assertNotIn(text, completed.stderr, detail)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_prompt_attribution.py

@@ -23,7 +23,6 @@ try:
 except ImportError:  # discovered with tests/ as the top-level directory
     from open_handles import assert_closed
 
-from tests.background_stops import close_handler  # noqa: E402
 from database.operations import PromptDatabase
 from prompt_manager import PromptManager
 from prompt_manager_pair import PromptManagerPair
@@ -279,7 +278,6 @@ class MonitorCase(DatabaseCase):
         fd, self.image = tempfile.mkstemp(suffix=".png", dir=self.tmp.name)
         os.close(fd)
         self.handler = ImageGenerationHandler(self.db, self.tracker)
-        self.addCleanup(close_handler, self, self.handler)
         self.linked = []
         self.handler.link_image_to_prompt = lambda path, prompt, meta: (
             self.linked.append(prompt["id"])

tests/test_prompt_tracker.py

@@ -5,12 +5,10 @@ Tests PromptTracker, PromptExecutionContext, and the singleton
 get_prompt_tracker. Uses a mock db_manager to avoid database deps.
 """
 
-import logging
 import os
 import sys
 import time
 import threading
-import types
 import unittest
 from unittest.mock import MagicMock, patch
 
@@ -314,93 +312,5 @@ class TestPromptQueue(unittest.TestCase):
         self.assertEqual(popped_ids, ids)
 
 
-def _real_tracker():
-    """A PromptTracker built by its own ``__init__``, so its cleanup thread runs."""
-    mock_db = MagicMock()
-    mock_db.get_prompt_by_hash.return_value = None
-    return PromptTracker(mock_db)
-
-
-class TestTrackerShutdown(unittest.TestCase):
-    """The cleanup thread stops on a signal and is joined within a bound (#301)."""
-
-    def test_shutdown_stops_the_cleanup_thread_within_the_bound(self):
-        tracker = _real_tracker()
-        thread = tracker.cleanup_thread
-        self.assertTrue(thread.is_alive())
-        self.assertEqual(thread.name, "PromptManagerPromptCleanup")
-
-        self.assertTrue(tracker.shutdown())
-        self.assertFalse(thread.is_alive())
-
-    def test_shutdown_is_idempotent(self):
-        tracker = _real_tracker()
-        self.assertTrue(tracker.shutdown())
-        self.assertTrue(tracker.shutdown())
-
-    def test_cleanup_error_wait_is_interruptible(self):
-        import utils.prompt_tracker as tracker_mod
-
-        real_time = time.time
-        calls = {"n": 0}
-
-        def failing_once():
-            calls["n"] += 1
-            if calls["n"] == 1:
-                raise RuntimeError("clock unavailable")
-            return real_time()
-
-        stub = types.SimpleNamespace(
-            time=failing_once, sleep=time.sleep, monotonic=time.monotonic
-        )
-        logged = threading.Event()
-        logger = logging.getLogger("prompt_manager.prompt_tracker")
-        real_error = logger.error
-
-        def error(*args, **kwargs):
-            real_error(*args, **kwargs)
-            logged.set()
-
-        with (
-            patch.object(tracker_mod, "time", stub),
-            patch.object(logger, "error", side_effect=error),
-        ):
-            tracker = _real_tracker()
-            self.addCleanup(tracker.shutdown)
-            self.assertTrue(logged.wait(30), "the cleanup error was never logged")
-            # The thread is now in its 60 s error wait.
-            self.assertTrue(tracker.shutdown())
-        self.assertFalse(tracker.cleanup_thread.is_alive())
-
-    def test_tracker_works_after_shutdown(self):
-        tracker = _real_tracker()
-        self.assertTrue(tracker.shutdown())
-        tracker.set_current_prompt("still tracked", {"prompt_id": 9})
-        self.assertEqual(tracker.pop_next_prompt()["id"], 9)
-
-    def test_shutdown_of_a_tracker_built_without_init(self):
-        self.assertTrue(_make_tracker().shutdown())
-
-    def test_shutdown_on_the_cleanup_thread_only_signals(self):
-        tracker = _real_tracker()
-        self.addCleanup(lambda: self.assertTrue(tracker.shutdown()))
-        result = {}
-        with patch.object(tracker, "cleanup_thread", threading.current_thread()):
-            result["value"] = tracker.shutdown()
-        self.assertFalse(result["value"])
-        self.assertTrue(tracker._stop.is_set())
-
-    def test_shutdown_reports_a_thread_still_running(self):
-        tracker = _real_tracker()
-        self.assertTrue(tracker.shutdown())
-        busy = MagicMock()
-        busy.is_alive.return_value = True
-        tracker.cleanup_thread = busy
-        with self.assertLogs("prompt_manager.prompt_tracker", "WARNING") as logs:
-            self.assertFalse(tracker.shutdown(timeout=0.05))
-        busy.join.assert_called_once_with(0.05)
-        self.assertIn("prompt cleanup thread still running", "\n".join(logs.output))
-
-
 if __name__ == "__main__":
     unittest.main()

tests/test_review.py

@@ -27,7 +27,6 @@ except ImportError:  # discovered with tests/ as the top-level directory
 
 from PIL import Image, PngImagePlugin
 
-from tests.background_stops import close_handler, stop_monitor
 from database.operations import PromptDatabase
 from database.review_schema import canonical_evidence, evidence_digest
 from py.api import PromptManagerAPI
@@ -791,7 +790,6 @@ class TestReviewEdges(ReviewTestCase):
 class TestMonitorRecording(ReviewTestCase):
     def _handler(self):
         handler = ImageGenerationHandler(self.api.db, PromptTracker(self.api.db))
-        self.addCleanup(close_handler, self, handler)
         return handler
 
     def _linked_prompt(self, path):
@@ -955,7 +953,7 @@ class TestMonitorRecording(ReviewTestCase):
             monitor.set_review_recorder(None)
             self.assertIsNone(monitor.handler.review_recorder)
         finally:
-            stop_monitor(self, monitor)
+            monitor.stop_monitoring()
 
 
 if __name__ == "__main__":
@@ -1094,7 +1092,6 @@ class TestCaptureStoreShutdown(ReviewTestCase):
                 self._scan_record(path)
             # The monitor's pass records nothing, so it needs no store.
             handler = ImageGenerationHandler(self.api.db, PromptTracker(self.api.db))
-            self.addCleanup(close_handler, self, handler)
             handler.review_recorder = self.api.record_review_file
             handler._record_review(str(path))
             self.assertEqual(self.api.record_review_file(str(path)), "skipped")

tests/test_review_image_links_tool.py

@@ -17,7 +17,6 @@ except ImportError:  # discovered with tests/ as the top-level directory
     from open_handles import assert_closed
 
 from database.operations import PromptDatabase
-from tests.background_stops import close_handler
 from tests.test_api_images import ImageAPITestCase
 from tests.test_prompt_attribution import issue_graph, pair_evidence
 from tools import review_image_links as tool
@@ -159,8 +158,8 @@ class ReviewToolTests(ToolFixture):
 
     def test_conflicting_sources_are_left_to_the_maintainer(self):
         db = PromptDatabase(self.db_path)
-        handler = tool.ImageGenerationHandler(db, None)
         try:
+            handler = tool.ImageGenerationHandler(db, None)
             row = {
                 "id": 1,
                 "prompt_id": self.coffee,
@@ -171,7 +170,6 @@ class ReviewToolTests(ToolFixture):
             ):
                 verdict = tool.judge(db, handler, row, self.output)
         finally:
-            close_handler(self, handler)
             db.close_all()
         self.assertEqual(verdict["verdict"], "conflict")
 

tests/test_review_inspection.py

@@ -28,7 +28,6 @@ except ImportError:  # discovered with tests/ as the top-level directory
     from test_api_review import ReviewRoutesTestCase
     from test_review import unlinkable_graph, write_png
 
-from tests.background_stops import close_handler
 from utils import inspection_semantics, review_capture
 from utils.hashing import generate_prompt_hash
 from utils.image_monitor import ImageGenerationHandler
@@ -438,7 +437,6 @@ class TestApplyInspectionCandidate(InspectionTestCase):
 class TestMonitorNeverQueues(InspectionTestCase):
     def _handler(self):
         handler = ImageGenerationHandler(self.api.db, PromptTracker(self.api.db))
-        self.addCleanup(close_handler, self, handler)
         handler.review_recorder = self.api.record_review_file
         return handler
 
@@ -762,7 +760,6 @@ class TestRecordingEdges(InspectionTestCase):
             text="latest", prompt_hash=generate_prompt_hash("latest")
         )
         handler = ImageGenerationHandler(self.api.db, PromptTracker(self.api.db))
-        self.addCleanup(close_handler, self, handler)
         handler.link_image_to_prompt(
             str(path),
             {"id": prompt_id, "text": "latest", "fallback": True},

tests/test_review_outcome.py

@@ -38,7 +38,6 @@ except ImportError:  # discovered with tests/ as the top-level directory
         write_png,
     )
 
-from tests.background_stops import close_handler
 from utils.hashing import generate_prompt_hash
 from utils.image_monitor import ImageGenerationHandler
 from utils.prompt_tracker import PromptTracker
@@ -300,7 +299,6 @@ class TestQueueSelfHeals(OutcomeTestCase):
 class TestMonitorRule(OutcomeTestCase):
     def _handler(self):
         handler = ImageGenerationHandler(self.api.db, PromptTracker(self.api.db))
-        self.addCleanup(close_handler, self, handler)
         handler.review_recorder = self.api.record_review_file
         return handler
 

tests/test_run_attribution.py

@@ -11,7 +11,6 @@ from unittest import mock
 
 from database.run_attribution import stored_run_prompt
 from tests import test_execution_history_database as history_tests
-from tests.background_stops import close_handler
 from tests.test_api_admin import AdminAPITestCase
 from tests.test_execution_context_database import snapshot
 from tests.test_prompt_attribution import issue_graph, llm_text_graph, make_tracker
@@ -152,7 +151,6 @@ class TestStoredRunPrompt(RecordedRuns, unittest.TestCase):
         prompt_id = self.save(LLM_TEXT)
         self.record_run(self.db, self.output, [("sub", "img_00001_.png")], [LLM_TEXT])
         handler = ImageGenerationHandler(self.db, make_tracker(self.db))
-        self.addCleanup(close_handler, self, handler)
         linked = []
         handler.link_image_to_prompt = lambda path, prompt, meta: linked.append(
             prompt["id"]
@@ -334,7 +332,7 @@ class TestMonitorHistoryRecheck(RecordedRuns, unittest.TestCase):
         self.handler = ImageGenerationHandler(self.db, make_tracker(self.db))
         self.handler.processing_delay = 0
         self.handler.settle_interval = 0.01
-        self.addCleanup(close_handler, self, self.handler)
+        self.addCleanup(self.handler.shutdown)
         self.linked = []
         self.handler.link_image_to_prompt = lambda path, prompt, meta: (
             self.linked.append((os.path.basename(path), prompt["id"]))
@@ -652,7 +650,7 @@ class TestLinkedOutputRoot(RecordedRuns, unittest.TestCase):
         handler = ImageGenerationHandler(db, make_tracker(db))
         handler.processing_delay = 0
         handler.settle_interval = 0.01
-        self.addCleanup(close_handler, self, handler)
+        self.addCleanup(handler.shutdown)
         linked = []
         handler.link_image_to_prompt = lambda path, prompt, meta: linked.append(
             prompt["id"]

tests/test_settings_sources.py

@@ -1037,23 +1037,6 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
         settings = (await self._get())["settings"]
         self.assertEqual({key: settings[key] for key in self.SAVED}, self.SAVED)
 
-    async def test_threshold_near_the_grid_is_saved_on_it(self):
-        """#369: a computed value a hair off the 0.05 grid is stored on it, so
-        every page's step check accepts what /settings and the file return."""
-        revision = (await self._get())["revision"]
-        status, data = await self._post(
-            "/prompt_manager/settings",
-            {"expected_revision": revision, "autotag_general_threshold": 0.1 + 0.2},
-        )
-        self.assertEqual(status, 200, data)
-        self.assertEqual(
-            repr(self._read_config()["autotag"]["defaults"]["general_threshold"]),
-            "0.3",
-        )
-        self.assertEqual(
-            repr((await self._get())["settings"]["autotag_general_threshold"]), "0.3"
-        )
-
     async def test_stale_revision_changes_no_default(self):
         revision = (await self._get())["revision"]
         self._write_config({"custom": {"edited": "elsewhere"}})
@@ -1072,16 +1055,6 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
                 1.5,
                 "General-tag confidence must be between 0 and 1.",
             ),
-            (
-                "autotag_general_threshold",
-                0.37,
-                "General-tag confidence must be a multiple of 0.05.",
-            ),
-            (
-                "autotag_character_threshold",
-                0.33,
-                "Character-tag confidence must be a multiple of 0.05.",
-            ),
             (
                 "autotag_character_threshold",
                 "0.8",

tests/test_thumbnail_auto.py

@@ -32,7 +32,6 @@ from PIL import Image  # noqa: E402
 
 import py.api.images as images_module  # noqa: E402
 import py.api.thumbnail_auto as auto  # noqa: E402
-from tests.background_stops import close_handler, stop_monitor  # noqa: E402
 from py.api.jobs import THUMBNAILS_JOB_KIND  # noqa: E402
 
 SERVE = "/prompt_manager/images/serve/"
@@ -738,27 +737,11 @@ class TestShutdown(AutoThumbnailCase):
             patch.object(auto, "CLOSE_WAIT_SECONDS", 0),
             self.assertLogs("prompt_manager.api", "WARNING") as logs,
         ):
-            self.assertFalse(self.api.close_auto_thumbnails())
+            self.api.close_auto_thumbnails()
         process.kill.assert_called_once()
         self.assertIn("still running", "\n".join(logs.output))
         release.set()
 
-    async def test_close_reports_an_ended_worker(self):
-        path = make_png(self.output_dir / "a.png", size=(64, 64))
-        self.api.queue_capture_thumbnail(str(path))
-        worker = self.api._auto_thumbnails()._worker
-        await self._idle()
-        loop = asyncio.get_running_loop()
-        closed = await loop.run_in_executor(
-            None, lambda: self.api.close_auto_thumbnails(timeout=WAIT)
-        )
-        self.assertTrue(closed)
-        self.assertFalse(worker.is_alive())
-
-    def test_close_without_a_thumbnailer_returns_true(self):
-        self.assertIsNone(self.api._auto_thumbnailer)
-        self.assertTrue(self.api.close_auto_thumbnails())
-
 
 class TestHistorySharesTheAdmission(AutoThumbnailCase):
     async def _shared_flight(self, name, is_video, first):
@@ -997,7 +980,6 @@ class TestMonitorQueuesThumbnails(AutoThumbnailCase):
         from utils.image_monitor import ImageGenerationHandler
 
         handler = ImageGenerationHandler(self.api.db, unittest.mock.MagicMock())
-        self.addCleanup(close_handler, self, handler)
         handler.processing_delay = 0
         handler.settle_interval = 0
         return handler
@@ -1040,7 +1022,7 @@ class TestMonitorQueuesThumbnails(AutoThumbnailCase):
             monitor.set_thumbnail_queue(None)
             self.assertIsNone(monitor.handler.thumbnail_queue)
         finally:
-            stop_monitor(self, monitor)
+            monitor.stop_monitoring()
 
 
 class TestScanHandsOffThumbnails(AutoThumbnailCase):

tests/test_usage_tracking.py

@@ -16,7 +16,6 @@ import uuid
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from tests.background_stops import stop_tracker  # noqa: E402
 from database.operations import PromptDatabase
 from prompt_manager_base import PromptManagerBase
 from utils.hashing import generate_prompt_hash
@@ -597,7 +596,6 @@ class TestNodeRoles(DbTestCase):
 class TestTrackerQueueFlag(unittest.TestCase):
     def setUp(self):
         self.tracker = PromptTracker(mock.Mock())
-        self.addCleanup(stop_tracker, self, self.tracker)
 
     def test_push_to_queue_false_keeps_the_batch_queue_empty(self):
         self.tracker.set_current_prompt("a cat", {"prompt_id": 1}, push_to_queue=False)

tests/vendor/browser-image.test.mjs

@@ -28,24 +28,3 @@ for (const name of ['frontend-coverage', 'browser-workflows']) {
         assert.match(body, /node --version \| grep -q '\^v24\\\.'/, 'the image Node is the Node 24 the project requires');
     });
 }
-
-// The real-host job drives Chromium against a managed ComfyUI. `playwright install --with-deps` pulled the browser's
-// system packages from Ubuntu's apt mirror on every run, and three runs (#349, #378, #382) crawled at ~26 kB/s until
-// the job hit its limit after every test had passed. The pinned image ships Chromium and its libraries, so the job runs
-// there; the image Python must be the reviewed host Python from tools/vendor/comfyui-runtime.json.
-test('real ComfyUI compatibility runs in the pinned Playwright image on the reviewed host Python', () => {
-    const testWorkflow = readFileSync(new URL('../../.github/workflows/test.yml', import.meta.url), 'utf8');
-    const runtime = JSON.parse(readFileSync(new URL('../../tools/vendor/comfyui-runtime.json', import.meta.url), 'utf8'));
-    const match = testWorkflow.match(/^ {2}comfyui:\n([\s\S]*?)(?=^ {2}[a-z][a-z-]*:\n|(?![\s\S]))/m);
-    assert.ok(match, 'comfyui job exists');
-    const body = match[1];
-    assert.match(body, new RegExp(`^    container:\\n      image: mcr\\.microsoft\\.com/playwright:v${version.replaceAll('.', '\\.')}-noble$`, 'm'));
-    assert.doesNotMatch(body, /playwright install/, 'Chromium and its system libraries come from the image, not apt');
-    assert.doesNotMatch(body, /apt-get|actions\/setup-(python|node)@/);
-    assert.match(body, /python3 -m venv --without-pip /, 'a user-space venv on the image Python');
-    assert.match(body, /sha256sum -c/, 'the pip wheel that bootstraps the venv is checksum-pinned');
-    assert.match(body, /node --version \| grep -q '\^v24\\\.'/, 'the image Node is Node 24');
-    // The image Python is checked against the pin at run time, so a pin or image bump that disagrees fails loudly.
-    assert.match(body, /steps\.runtime\.outputs\.pythonVersion/, 'the job compares the image Python with the reviewed pin');
-    assert.match(runtime.pythonVersion, /^3\.12$/, 'the reviewed host Python is the image Python (3.12 on noble)');
-});

utils/image_monitor.py

@@ -70,11 +70,6 @@ MAX_AWAITING_HISTORY = 1000
 AWAIT_HISTORY_SECONDS = 3600
 # ``schedule`` snapshot meaning "history-only re-check" (not a new image)
 HISTORY_ONLY = object()
-# How long a stop waits for the image worker, and for the watchdog observer
-# after its stop (#302). Every wait before the image in hand is interrupted
-# at once, so a bound is reached only while one image is still being linked.
-WORKER_JOIN_SECONDS = 5.0
-OBSERVER_JOIN_SECONDS = 5.0
 
 
 class ImageGenerationHandler(FileSystemEventHandler):
@@ -148,11 +143,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
         self._history_due: "OrderedDict[str, None]" = OrderedDict()
         self._awaiting_lock = threading.Lock()
         self._sealed_subscribed = False
-        # Set by ``close``: no new work, no new worker, ever (#302).
-        self._closed = False
-        # Workers a stop signalled that had not ended yet: every later stop
-        # waits for them again, so it never reports True too early.
-        self._finishing: List[threading.Thread] = []
 
     def on_created(self, event):
         """Handle filesystem creation events.
@@ -167,10 +157,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
         Args:
             event: FileSystemEvent object containing event details
         """
-        # Closed: return before any log or tracker lock, so watchdog's
-        # ``observer.stop()`` never waits on this dispatch.
-        if self._closed:
-            return
         if event.is_directory or not self.is_image_file(event.src_path):
             return
         self.logger.info(f"New image detected: {event.src_path}")
@@ -194,12 +180,9 @@ class ImageGenerationHandler(FileSystemEventHandler):
         and once its size has stopped changing.
 
         Returns:
-            False when the path is already pending, the pending set is full or
-            the handler is closed
+            False when the path is already pending or the pending set is full
         """
         with self._pending_lock:
-            if self._closed:
-                return False
             if image_path in self._pending:
                 self.logger.debug(f"Already pending, not rescheduled: {image_path}")
                 return False
@@ -220,19 +203,12 @@ class ImageGenerationHandler(FileSystemEventHandler):
         with self._pending_lock:
             return len(self._pending)
 
-    def shutdown(self, timeout: float = WORKER_JOIN_SECONDS) -> bool:
-        """Stop the worker thread, drop every image still waiting, and wait
-        for the worker within ``timeout`` seconds.
+    def shutdown(self) -> None:
+        """Stop the worker thread and drop every image still waiting.
 
-        The worker wakes from any delay or settle wait, finishes at most the
-        image in hand and exits; the next ``schedule`` starts a fresh worker
-        with its own queue (use ``close`` for a final stop). Safe to call
-        repeatedly and before anything was scheduled.
-
-        Returns:
-            True when no worker is left running. False when the worker is
-            still finishing its image after ``timeout`` (a warning is
-            logged), or when called on the worker itself (it only signals).
+        The worker wakes from any delay or settle wait, finishes nothing more
+        and exits; the next ``schedule`` starts a fresh worker with its own
+        queue. Safe to call repeatedly and before anything was scheduled.
         """
         with self._awaiting_lock:
             self._awaiting.clear()
@@ -242,40 +218,9 @@ class ImageGenerationHandler(FileSystemEventHandler):
             worker, self._worker = self._worker, None
             work, self._work = self._work, queue.Queue()
             stop, self._stop = self._stop, threading.Event()
-            if worker is not None:
-                self._finishing.append(worker)
-            finishing = [w for w in self._finishing if w.is_alive()]
-            self._finishing = finishing
         stop.set()
         if worker is not None and worker.is_alive():
             work.put(None)  # sentinel: wake a worker idle on an empty queue
-        if threading.current_thread() in finishing:
-            self.logger.debug("shutdown called on the image worker itself")
-            return False
-        deadline = time.monotonic() + timeout
-        for thread in finishing:
-            thread.join(max(0.0, deadline - time.monotonic()))
-        with self._pending_lock:
-            self._finishing = [w for w in self._finishing if w.is_alive()]
-            still_running = bool(self._finishing)
-        if still_running:
-            self.logger.warning(
-                f"image worker still running after {timeout} s; "
-                "it stops after the image in hand"
-            )
-            return False
-        return True
-
-    def close(self, timeout: float = WORKER_JOIN_SECONDS) -> bool:
-        """Final stop: ``shutdown`` and refuse every later ``schedule``.
-
-        After ``close`` no worker starts again, not even from a sealed run's
-        history re-check on the history writer's thread. Returns what
-        ``shutdown`` returns.
-        """
-        with self._pending_lock:
-            self._closed = True
-        return self.shutdown(timeout)
 
     def _ensure_worker(self) -> None:
         """Start the single daemon worker thread if it isn't running.
@@ -576,12 +521,7 @@ class ImageGenerationHandler(FileSystemEventHandler):
             self._awaiting.popitem(last=False)
 
     def _await_history(self, image_path: str) -> None:
-        """Re-check ``image_path`` once, history only, when its run is sealed.
-
-        A closed handler re-checks nothing.
-        """
-        if self._closed:
-            return
+        """Re-check ``image_path`` once, history only, when its run is sealed."""
         if not self._sealed_subscribed:
             subscribe_outputs_sealed(self._on_outputs_sealed)
             self._sealed_subscribed = True
@@ -630,19 +570,10 @@ class ImageGenerationHandler(FileSystemEventHandler):
             self._schedule_recheck(image_path)
 
     def _schedule_recheck(self, image_path: str) -> None:
-        """Schedule the history-only re-check, or keep it due for later.
-
-        A closed handler drops it.
-        """
-        if self._closed:
-            return
+        """Schedule the history-only re-check, or keep it due for later."""
         if self.schedule(image_path, HISTORY_ONLY):
             return
         with self._awaiting_lock:
-            # ``close`` sets the flag before ``shutdown`` clears this set, so
-            # a close that raced the refusal above is seen here.
-            if self._closed:
-                return
             self._history_due.pop(image_path, None)
             self._history_due[image_path] = None
             while len(self._history_due) > MAX_AWAITING_HISTORY:
@@ -941,9 +872,6 @@ class ImageMonitor:
         self.observer = None
         self.handler = None
         self.monitored_directories = []
-        # (observer, handler) pairs a stop left running: the next stop waits
-        # for them again instead of reporting True.
-        self._unfinished: List[Tuple[Any, Any]] = []
         self.logger = get_logger("prompt_manager.image_monitor")
         self.review_recorder: Optional[Callable[[str], str]] = None
         self.thumbnail_queue: Optional[Callable[[str], str]] = None
@@ -1071,73 +999,29 @@ class ImageMonitor:
         """Whether a filesystem observer is running."""
         return self.observer is not None
 
-    def stop_monitoring(self, timeout: float = OBSERVER_JOIN_SECONDS) -> bool:
-        """Stop the image monitoring system within one ``timeout`` deadline.
+    def stop_monitoring(self):
+        """Stop the image monitoring system.
 
-        Closes the handler first (its worker is joined and its dispatch
-        returns at once), then stops the watchdog observer and joins it. The
-        worker and the observer share the one deadline: the observer's join
-        gets what the worker left, possibly 0 s.
-        watchdog's ``observer.stop()`` joins its emitters without a limit;
-        it counts against the deadline but is not bounded here. A part an
-        earlier call left running is waited for again. Safe to call when
-        monitoring never started and more than once.
-
-        Returns:
-            True when every worker and observer it stopped has ended.
+        Cleanly shuts down the filesystem watcher and clears all monitoring state.
+        This method should be called before program exit to ensure proper cleanup.
+        Safe to call when monitoring never started.
         """
-        deadline = time.monotonic() + timeout
         observer, self.observer = self.observer, None
         handler, self.handler = self.handler, None
         self.monitored_directories = []
-        pairs, self._unfinished = self._unfinished, []
-        if observer is not None:
-            pairs.append((observer, handler))
-        if not pairs:
-            return True
-
-        def remaining() -> float:
-            return max(0.0, deadline - time.monotonic())
-
-        for pair_observer, pair_handler in pairs:
-            handler_ok = self._close_handler(pair_handler, remaining())
-            observer_ok = self._stop_observer(pair_observer, remaining())
-            if not (handler_ok and observer_ok):
-                self._unfinished.append(
-                    (
-                        None if observer_ok else pair_observer,
-                        None if handler_ok else pair_handler,
-                    )
-                )
-        self.logger.debug("Image monitoring stopped")
-        return not self._unfinished
-
-    def _close_handler(self, handler, timeout: float) -> bool:
-        if handler is None:
-            return True
-        try:
-            return handler.close(timeout)
-        except Exception as e:
-            self.logger.warning(f"Error while stopping the image worker: {e}")
-            return False
-
-    def _stop_observer(self, observer, timeout: float) -> bool:
-        """``observer.stop()`` (safe to repeat), then a join of ``timeout``
-        seconds; a join that times out is logged with the time it got."""
         if observer is None:
-            return True
+            return
         try:
             observer.stop()
-            observer.join(timeout)
+            observer.join()
         except Exception as e:
             self.logger.warning(f"Error while stopping image monitoring: {e}")
-            return False
-        if observer.is_alive():
-            self.logger.warning(
-                f"watchdog observer still running after {timeout:.1f} s"
-            )
-            return False
-        return True
+        if handler is not None:
+            try:
+                handler.shutdown()
+            except Exception as e:
+                self.logger.warning(f"Error while stopping the image worker: {e}")
+        self.logger.debug("Image monitoring stopped")
 
     def detect_comfyui_output_dirs(self) -> list:
         """Auto-detect ComfyUI output directories.

utils/prompt_tracker.py

@@ -44,9 +44,6 @@ except ImportError:
     from utils.hashing import generate_prompt_hash
     from utils.logging_config import get_logger
 
-# How long ``PromptTracker.shutdown`` waits for the cleanup thread (#301).
-TRACKER_JOIN_SECONDS = 2.0
-
 
 class PromptTracker:
     """Thread-safe tracking of current prompt executions.
@@ -95,12 +92,9 @@ class PromptTracker:
             self.cleanup_interval = 300  # 5 minutes
             self.prompt_timeout = 600  # 10 minutes
 
-        # Start cleanup thread; ``shutdown`` sets ``_stop`` to end it.
-        self._stop = threading.Event()
+        # Start cleanup thread
         self.cleanup_thread = threading.Thread(
-            target=self._cleanup_expired_prompts,
-            name="PromptManagerPromptCleanup",
-            daemon=True,
+            target=self._cleanup_expired_prompts, daemon=True
         )
         self.cleanup_thread.start()
         self.logger.debug("PromptTracker initialization completed")
@@ -470,10 +464,9 @@ class PromptTracker:
 
         Runs continuously as a daemon thread, periodically removing expired
         prompt contexts from the global tracking dictionary. This prevents
-        memory leaks from accumulating old prompt data. Every wait ends at
-        once when ``shutdown`` sets the stop event.
+        memory leaks from accumulating old prompt data.
         """
-        while not self._stop.is_set():
+        while True:
             try:
                 current_time = time.time()
                 expired_ids = []
@@ -504,37 +497,11 @@ class PromptTracker:
                     if pruned:
                         self.logger.debug(f"Pruned {pruned} expired queue entries")
 
-                if self._stop.wait(self.cleanup_interval):
-                    break
+                time.sleep(self.cleanup_interval)
 
             except Exception as e:
                 self.logger.error(f"Error in cleanup thread: {e}")
-                if self._stop.wait(60):  # Wait a minute before retrying
-                    break
-
-    def shutdown(self, timeout: float = TRACKER_JOIN_SECONDS) -> bool:
-        """Stop the cleanup thread and wait for it within ``timeout`` seconds.
-
-        Returns True when the thread has ended (or never existed). The tracker
-        keeps working afterwards; only the background pruning of expired
-        entries stops. Safe to call more than once. Called on the cleanup
-        thread itself it only signals and returns False.
-        """
-        stop = getattr(self, "_stop", None)
-        thread = getattr(self, "cleanup_thread", None)
-        if stop is None or thread is None:
-            return True  # built without __init__: no thread was started
-        stop.set()
-        if thread is threading.current_thread():
-            self.logger.debug("shutdown called on the prompt cleanup thread")
-            return False
-        thread.join(timeout)
-        if thread.is_alive():
-            self.logger.warning(
-                f"prompt cleanup thread still running after {timeout} s"
-            )
-            return False
-        return True
+                time.sleep(60)  # Wait a minute before retrying
 
     def get_active_prompts(self) -> Dict[str, Dict[str, Any]]:
         """

web/js/workspace/system-tagging.mjs

@@ -85,9 +85,6 @@ export const STATUS_COPY = Object.freeze({
 export const SETTING_PROBLEMS = Object.freeze({
     autotag_general_threshold: 'General-tag confidence must be between 0 and 1.',
     autotag_character_threshold: 'Character-tag confidence must be between 0 and 1.',
-    // #369: every page shows the thresholds in steps of 0.05, so the server saves only values on that grid.
-    autotag_general_threshold_step: 'General-tag confidence must be a multiple of 0.05.',
-    autotag_character_threshold_step: 'Character-tag confidence must be a multiple of 0.05.',
     autotag_suggestion_limit: 'Suggestions per image must be a whole number from 1 to 100.',
     // The server's two template sentences (`validate_template`), blank first.
     autotag_template: 'LLM tag template must be non-empty text.',
@@ -174,15 +171,10 @@ export function draftValue(key, text) {
 }
 
 const unit = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
-// A multiple of 0.05 within the server's tolerance (`validate_saved_threshold`): (0.1 + 0.2) * 20 is 6.000000000000001.
-const onStep = value => Math.abs(value * 20 - Math.round(value * 20)) <= 1e-12;
-// A threshold on the grid, handed on exactly as the server stores it (anything else is left for draftProblem to refuse).
-const snapped = value => (unit(value) && onStep(value) ? Math.round(value * 20) / 20 : value);
 
 /**
  * The first setting the chosen model would use that the section cannot send, as `{key, message}`, else null: WD14
- * reads both thresholds (0 to 1 in steps of 0.05, #369), the language models the template; Generate also reads the
- * suggestion count (`limit`).
+ * reads both thresholds, the language models the template; Generate also reads the suggestion count (`limit`).
  */
 export function draftProblem(values, { limit = true } = {}) {
     const model = values.autotag_model_type;
@@ -197,7 +189,6 @@ export function draftProblem(values, { limit = true } = {}) {
         }
         const valid = key === 'autotag_suggestion_limit' ? Number.isInteger(value) && value >= 1 && value <= 100 : unit(value);
         if (!valid) return { key, message: SETTING_PROBLEMS[key] };
-        if (key !== 'autotag_suggestion_limit' && !onStep(value)) return { key, message: SETTING_PROBLEMS[`${key}_step`] };
     }
     return null;
 }
@@ -206,8 +197,7 @@ export function draftProblem(values, { limit = true } = {}) {
 export function taggingPreset(values) {
     const model = values.autotag_model_type;
     const options = CLASSIFIERS.has(model)
-        ? { general_threshold: snapped(values.autotag_general_threshold),
-            character_threshold: snapped(values.autotag_character_threshold) }
+        ? { general_threshold: values.autotag_general_threshold, character_threshold: values.autotag_character_threshold }
         : { instructions: values.autotag_template };
     return { model, options: { ...options, suggestion_limit: values.autotag_suggestion_limit } };
 }
@@ -216,8 +206,7 @@ export function taggingPreset(values) {
 export function batchBody(values) {
     const model = values.autotag_model_type;
     const options = CLASSIFIERS.has(model)
-        ? { general_threshold: snapped(values.autotag_general_threshold),
-            character_threshold: snapped(values.autotag_character_threshold) }
+        ? { general_threshold: values.autotag_general_threshold, character_threshold: values.autotag_character_threshold }
         : { instructions: values.autotag_template };
     return { model_type: model, existing: values.autotag_existing, options };
 }