Merge remote-tracking branch 'origin/main' into ci/356-python-311-314

ComfyUI recommends 3.13, names 3.12 as the fallback and 3.14 as working
(its README); PromptManager supports exactly those. requires-python is
>=3.12, the test matrix and the required checks drop 3.11, and bandit
runs on 3.12.

TESTING.md

@@ -1504,8 +1504,8 @@ targets of the longest legal path (1024 code points, even escaped as `\uXXXX`) f
   Its fields show the server's defaults (`GET /prompt_manager/autotag/models`, the
   D91 Suggestions count included) once that read lands; Start waits for it. A model
   the status lists as not downloaded keeps Start `aria-disabled` and
-  `#tag-generation-status` says "<model> is not downloaded. Download it in System ›
-  Auto-tagging." (the server's own sentence), so no job starts only to fail.
+  `#tag-generation-status` says "<model> is not downloaded. Download it from the
+  legacy Auto-tag page." (the server's own sentence), so no job starts only to fail.
   Start validates the fields as Generate does (native validity; nothing is sent).
   The concept comparison (`images-concept.spec.mjs`) uses the concept page itself as
   the oracle, with Add to collection and Remove links… removed and a copy of its Add
@@ -2587,7 +2587,7 @@ the connection's `total_changes` is 0 at close and the data reads back unchanged
 `-shm` bytes are not compared: every WAL reader rewrites its read marks there, so no
 reader can keep it byte-identical (`test_health_check_never_writes`).
 
-Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107 and D111–D114; D121–D134 assigned):
+Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107 and D111–D114; D121–D131 assigned):
 
 - **D92** (shell): no "Sample configuration" chip. The Save status is truthful: "No
   unsaved changes.", "Unsaved changes.", "Saved in this browser." / "Saved to the server
@@ -2621,8 +2621,7 @@ Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107 and D111–
   output folder is used." when that is the case.
 - **D94** (all sections): a section not delivered yet shows the hand-off panel "Your
   current tools are ready" with a link to each legacy tool that still owns it (the
-  plan's legacy coverage table); retired section by section, gone after S12. Since S11
-  (#328) only Diagnostics & logs hands off (`SECTION_HANDOFFS`, to the admin page).
+  plan's legacy coverage table); retired section by section, gone after S12.
 - **D95** (health report): the concept's `health-check` dialog titled "Health report",
   with no sample note. It lists every check in the server's order: Integrity check,
   Foreign keys & pair references, Canonical hashes, Pair uniqueness (added), Missing
@@ -2998,59 +2997,6 @@ Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107 and D111–
   dialog on that scope. Pinned by the thumbnail dialog comparison (mapped) and its
   mutation check (system-concept.spec) and `the thumbnail row counts outdated previews`
   (workspace-system.spec).
-- **D132** (Auto-tagging, S11, #328, OQ1/OQ5/OQ6/OQ10): "Tagging model" (`#tag-model`)
-  lists the four real engines in the concept's order, each `<label> · <size_label>` from
-  `GET /prompt_manager/autotag/models` ("WD14 SwinV2 · ~400 MB", "WD14 ViT · ~400 MB",
-  "GGUF JoyCaption · ~4.5 GB", "HuggingFace JoyCaption · ~16 GB"; GGUF takes the
-  concept's "Ollama" slot, as D61 does). Its description is the chosen engine's live
-  status instead of the concept's design note: "Loading model status…" (the select is
-  disabled until the read answers), "Model status could not be read.", "Not downloaded.
-  Download size <size>.", "Downloaded. Not loaded.", "Downloaded and loaded." or "Partly
-  downloaded. Download again to finish." (GGUF with one of its two files). The concept's
-  two simulated job buttons are "Download" ("Download again" for an engine on disk),
-  which starts the `model_download` Activity job and opens it, and "Unload", a direct
-  `POST /autotag/unload` with a toast ("<label> unloaded.") and a fresh status read,
-  enabled only while a model is loaded; a busy model's refusal reads "The tagging model
-  is busy: <operation>. Try again when it finishes.". "Preview tagging review" opens the
-  Tag image dialog for the image selected in Images with the section's current model and
-  values; it is `aria-disabled` without a selection (the D115 sentence "Select an image
-  in Images first.") or with an invalid value (the toast names the setting); a saved
-  engine the section does not know reads "The saved tagging model is not one of these
-  engines. Choose one and save preferences.". A part-downloaded GGUF offers "Download
-  again"; an Unload that found nothing loaded only reads the status again. At phone width
-  the concept's 120px select cap cuts every engine label, so `#tag-model` alone keeps its
-  natural width there and its row wraps the select under the text (`workspace.css`
-  `/* D132 */`); Existing tags stays as the concept draws it, cut at 390 as there. The
-  comparison maps `selectsFit` only for the engine select and measures each row's
-  `flexWrap` and whether its control sits under the text. Pinned by `auto-tagging matches
-  the concept` (both themes and sizes), `auto-tagging at 390 wraps only the engine row`,
-  `auto-tagging engine select fits at 320 wide` and the mutation check (it includes a
-  wrapped row) (system-tagging-concept.spec), and the model, Download, Unload and Preview
-  tests of workspace-system-tagging.spec.
-- **D133** (Auto-tagging, S11): a "Suggestions per image" row (`#tag-suggestions`,
-  number 1–100, host key `autotag_suggestion_limit`) follows the two confidence rows:
-  the persisted count the Tag image dialog's Suggestions field (D91) starts from. Pinned
-  by the comparison's mapping (it inserts the row) and `defaults save through Save
-  preferences and the Tag image dialog uses them`.
-- **D134** (Auto-tagging, S11, OQ2/OQ3/OQ7/OQ8): an `.operation` "Tag output images"
-  with "Review" follows `.row-actions`: the legacy prompt-tag batch. Review is
-  `aria-disabled` (the press explains) while the chosen engine is not downloaded or a
-  value it uses is invalid; otherwise it posts `/autotag/batch/preview` with the drafted
-  engine and policy (read-only) and opens "Review tag output images" in the concept's
-  record-changing review (its `maintenancePlan` shell): `h3` "Tag output images", the
-  `dl.meta-grid` Model, Existing tags, Images linked, Prompts, Already tagged, Prompts
-  to tag ("up to N"), Settings ("General <g> · Character <c>" or "Template of N
-  characters") and Backup, the upper-bound sentence in the `p.small`, the D55 backup box
-  and Cancel / "Start tagging", which starts the cancellable `autotag` job and opens it.
-  Replace after review, a model not on disk, a short disk, no linked image and nothing to
-  tag each show the rows with only Cancel and the reason ("Replacing tags needs a review
-  of each image. Use Preview tagging review, or choose Skip or Merge for a batch run.",
-  "Every prompt with an output image is already tagged.", "Not enough free disk space:
-  the safety backup needs about X MB and Y MB is free. Nothing is written until there is
-  room.") in the close-only review Integrations shares (`openCloseOnlyReview`). Pinned by
-  `tag output images review matches the concept`, its mutation check and `the
-  Cancel-only review matches the concept review shell` (system-tagging-concept.spec) and
-  the batch tests of workspace-system-tagging.spec.
 - **D124** (inspector): with "Load metadata on selection" off, the Images panel and
   the viewer's details show "Metadata loads when you ask for it." and a "Load metadata"
   button instead of reading the file. The concept has no such state, so no concept
@@ -3516,69 +3462,6 @@ npm run --prefix tools/vendor test:workflows -- workspace-system-integrations.sp
   --project chromium --project touch --project firefox --project webkit
 ```
 
-### Auto-tagging contract (#328, #249 System S11)
-
-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),
-`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`,
-`autotag_suggestion_limit`) saved by the one Save row through `POST
-/prompt_manager/settings` with `expected_revision`; a bad value is refused with a 400
-naming the setting by its row label ("General-tag confidence must be between 0 and
-1."), nothing is written, the Save row shows that sentence (`invalid-setting`, set by
-`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. `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.
-
-`GET /prompt_manager/autotag/models` reads the disk in the executor, never loads or
-downloads a model and carries no absolute path: per engine `name`, `label`,
-`size_label`, `description`, `size`, `downloaded`, `loaded` (GGUF also `model_exists`,
-`mmproj_exists`), plus `model_loaded` and `loaded_model_type`. Opening the section
-makes exactly one such read per mount (`entering the section makes no model call
-besides status`).
-
-One model gate (`py/model_gate.py`) covers download, unload, both batches, the legacy
-single-image tag, Generate suggestions and Auto-tag selected. A refusal is `409
-model-busy` with `operation`, the holder's label: the download job's title, "Tag output
-images", "Tag output images (legacy page)", "Tagging one image (legacy page)",
-"Unloading the tagging model", "Auto-tag selected images", "Generate suggestions", else
-"Another tagging operation". `ApiError.operation` keeps it (only on `model-busy`).
-
-- **Download**: `POST /prompt_manager/jobs/model-download {model_type}` starts the
-  `model_download` job (202), title "Tagging model download · <label>", admission
-  `read`, not cancellable, indeterminate (Activity's generic held view: no Cancel, a
-  `<progress>` without a value), holding the gate until it ends. A second download is
-  `409 busy`; the legacy SSE route attaches to the same job and keeps its frames.
-- **Unload**: `POST /prompt_manager/autotag/unload` answers `{success, message}` or
-  `409 model-busy`.
-- **Tag output images**: `POST /prompt_manager/autotag/batch/preview {model_type,
-  existing}` writes nothing and opens no file; it answers `images`, `prompts`,
-  `already_tagged`, `to_tag` (an upper bound), `model {type, label, size_label,
-  downloaded}`, `existing`, `review_required`, `backup {policy}` and `disk`. `POST
-  /prompt_manager/jobs/autotag {model_type, existing, options}` (WD14: both thresholds;
-  GGUF/HF: `instructions`, the template) starts the cancellable `autotag` job (202),
-  title "Tag output images", admission `records`, a safety backup by the policy first.
-  Refusals: `400 review-required` (Replace after review never runs as a batch), `409
-  model-unavailable` ("<label> is not downloaded. Download it in System ›
-  Auto-tagging."), `507 insufficient-space`, `409 busy`, `409 model-busy`. The section
-  toasts `model-busy` with its operation, the other three with the server's sentence,
-  `busy` with the running job (D57), anything else "<what> could not start. Try again.".
-  Outcomes: Tagged / Unchanged / Skipped / Errors (the `image-tags` descriptor, D111).
-
-No browser test downloads or runs a model: the injected `TestModel` answers, its
-`download_model` raises unless `/__test__/tagging/download {mode: hold | succeed |
-fail}` installs a fake that waits on a fixture event, and every tagging reset releases
-it. Every workspace-system-tagging test asserts no `/autotag/download/` request.
-Changing the routes or `py/config.py` needs a ComfyUI restart; the section itself is
-HTML, CSS and JS only.
-
 ### Browser cache ownership (#222)
 
 The legacy gallery's Clear cache used to delete every localStorage key starting `pm_` or

database/operations.py

@@ -1808,37 +1808,6 @@ class PromptDatabase(
             reader = DocumentReader(conn)
             return [self._image_row_to_dict(row, reader) for row in cursor]
 
-    def autotag_batch_candidates(self) -> List[Dict[str, Any]]:
-        """The images a Tag output images batch looks at (#328).
-
-        ``{id, image_path, prompt_id, prompt_tags}`` for every image with a
-        stored path that is linked to a prompt, newest first (the
-        ``get_all_images`` order, ties newest row first). Never reads
-        ``workflow_data`` or the other documents: a batch needs none of them.
-        """
-        sql = (
-            "SELECT gi.id, gi.image_path, gi.prompt_id, "
-            "(SELECT GROUP_CONCAT(t.name, '|||') FROM prompt_tags pt "
-            "JOIN tags t ON pt.tag_id = t.id WHERE pt.prompt_id = gi.prompt_id) "
-            "AS prompt_tags "
-            "FROM generated_images gi "
-            "INNER JOIN prompts p ON gi.prompt_id = p.id "
-            "WHERE gi.image_path IS NOT NULL AND gi.image_path != '' "
-            "ORDER BY gi.generation_time DESC, gi.id DESC"
-        )
-        with self.model.get_connection() as conn:
-            return [
-                {
-                    "id": row["id"],
-                    "image_path": row["image_path"],
-                    "prompt_id": row["prompt_id"],
-                    "prompt_tags": (
-                        row["prompt_tags"].split("|||") if row["prompt_tags"] else []
-                    ),
-                }
-                for row in conn.execute(sql)
-            ]
-
     def get_all_images(
         self,
         limit: int = 0,

py/api/annotation_suggest.py

@@ -10,15 +10,12 @@ filesystem or the database.
 
 import math
 
-from ..tagging_defaults import (  # noqa: F401 - re-exported for the route
-    LLM_MODEL_TYPES as LLM_MODELS,
-    MAX_INSTRUCTION_BYTES,
-    MAX_INSTRUCTION_CHARS,
-    MODEL_TYPES,
-    WD14_MODEL_TYPES as WD14_MODELS,
-    validate_template,
-    validate_threshold,
-)
+WD14_MODELS = frozenset({"wd14-swinv2", "wd14-vit"})
+LLM_MODELS = frozenset({"gguf", "hf"})
+MODEL_TYPES = WD14_MODELS | LLM_MODELS
+
+MAX_INSTRUCTION_CHARS = 4000
+MAX_INSTRUCTION_BYTES = 16 * 1024
 
 SUGGEST_FIELDS = frozenset(
     {"target", "capture_token", "expected_epoch", "model_type", "options"}
@@ -27,7 +24,7 @@ _COMMON = frozenset({"suggestion_limit", "use_gpu"})
 _WD14_REQUIRED = frozenset({"general_threshold", "character_threshold"})
 _LLM_REQUIRED = frozenset({"instructions"})
 
-UNAVAILABLE_HINT = "Download it in System › Auto-tagging."
+UNAVAILABLE_HINT = "Download it from the legacy Auto-tag page."
 
 
 class OptionError(ValueError):
@@ -35,17 +32,27 @@ class OptionError(ValueError):
 
 
 def _threshold(name: str, value) -> float:
-    try:
-        return validate_threshold(name, value)
-    except ValueError as error:
-        raise OptionError(str(error)) from None
+    if type(value) not in (int, float) or not math.isfinite(value):
+        raise OptionError(f"{name} must be a finite number")
+    if not 0 <= value <= 1:
+        raise OptionError(f"{name} must be between 0 and 1")
+    return float(value)
 
 
 def _instructions(value) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise OptionError("instructions must be non-empty text")
+    if len(value) > MAX_INSTRUCTION_CHARS:
+        raise OptionError(
+            f"instructions must be at most {MAX_INSTRUCTION_CHARS} characters"
+        )
     try:
-        return validate_template(value)
-    except ValueError as error:
-        raise OptionError(str(error)) from None
+        encoded = value.encode("utf-8")
+    except UnicodeEncodeError:
+        raise OptionError("instructions must be valid Unicode text") from None
+    if len(encoded) > MAX_INSTRUCTION_BYTES:
+        raise OptionError("instructions are too long")
+    return value
 
 
 def validate_options(model_type, options, *, default_limit: int, max_limit: int):

py/api/autotag_routes.py

@@ -1,26 +1,14 @@
 """AutoTag API routes for PromptManager."""
 
 import asyncio
-import contextlib
-import functools
 import json
 import os
-import re
 import threading
-import time
 from pathlib import Path
 from typing import Optional
 from urllib.parse import quote
 
-from .job_routes import busy_response
-from .jobs import (
-    AUTOTAG_BATCH_JOB_KIND,
-    AUTOTAG_GROUP_NAMES,
-    MODEL_DOWNLOAD_JOB_KIND,
-    JobBusy,
-)
-from .admin import _plural, _scan_location, _scan_roots
-from .maintenance import disk_plan, short_space_message
+from .jobs import AUTOTAG_BATCH_JOB_KIND
 from .prompts import thumbnail_url_for
 from . import thumbnail_settings
 from .. import model_gate
@@ -28,104 +16,20 @@ from .. import model_gate
 from aiohttp import web
 
 _INTERNAL_ERROR = "An internal error occurred. Check server logs for details."
-
-# Tag output images (#328): the native prompt-tag batch.
-AUTOTAG_JOB_TITLE = "Tag output images"
-AUTOTAG_PREVIEW_LEASE = "Tag output images review"
-AUTOTAG_OWNER_KIND = "autotag-job"
-BATCH_PREVIEW_BODY_MAX = 1024
-BATCH_JOB_BODY_MAX = 32 * 1024
-REVIEW_REQUIRED = (
-    "Replacing tags needs a review of each image. Use Preview tagging review, "
-    "or choose Skip or Merge for a batch run."
-)
-BATCH_CANCELLED = "Cancelled. Tags already added were kept."
 _BUSY_ERROR = "Auto-tagging is already running"
 MODEL_BUSY_ERROR = (
     "A tagging model is busy with another operation. Try again when it finishes."
 )
 
 
-# Who holds the model gate, as a 409 model-busy names it (``operation``). An
-# owner is ``"<kind>:<uuid>"`` (``model_gate.new_owner``); a download names
-# its own job, whose title says which model.
-MODEL_DOWNLOAD_OWNER_KIND = "model-download"
-OWNER_LABELS = {
-    "autotag-job": "Tag output images",
-    "legacy-batch": "Tag output images (legacy page)",
-    "legacy-single": "Tagging one image (legacy page)",
-    "legacy-unload": "Unloading the tagging model",
-    "image-tag-job": "Auto-tag selected images",
-    "image-annotations": "Generate suggestions",
-}
-ANOTHER_OPERATION = "Another tagging operation"
-_DOWNLOAD_FAILED = "The download failed. Check server logs for details."
-# POST /jobs/model-download carries only {model_type}.
-MODEL_DOWNLOAD_BODY_MAX = 1024
-# The running download's gate owner and job title. Only one download runs at a
-# time and each needs the gate, so a new start replaces the entry.
-_download_titles = {}
-
-
-def _holder_label(holder: Optional[str]) -> str:
-    if not holder:
-        return ANOTHER_OPERATION
-    kind = holder.split(":", 1)[0]
-    if kind == MODEL_DOWNLOAD_OWNER_KIND:
-        return _download_titles.get(holder, ANOTHER_OPERATION)
-    return OWNER_LABELS.get(kind, ANOTHER_OPERATION)
-
-
 def model_busy_response() -> web.Response:
-    """``409 model-busy``: another operation holds the shared model gate.
-
-    ``operation`` names the holder (``OWNER_LABELS``), or "Another tagging
-    operation" when the gate was freed meanwhile or the kind is unknown.
-    """
+    """``409 model-busy``: another operation holds the shared model gate."""
     return web.json_response(
-        {
-            "success": False,
-            "code": "model-busy",
-            "error": MODEL_BUSY_ERROR,
-            "operation": _holder_label(model_gate.holder()),
-        },
+        {"success": False, "code": "model-busy", "error": MODEL_BUSY_ERROR},
         status=409,
     )
 
 
-_SIZE = re.compile(r"^(~?[0-9.]+)\s*([KMGT]?B)$")
-
-
-def size_label(size: str) -> str:
-    """The engine table's size with a space before the unit (``~400 MB``)."""
-    match = _SIZE.match(str(size or "").strip())
-    return f"{match.group(1)} {match.group(2)}" if match else str(size or "")
-
-
-def public_models(status: dict, loaded_type: Optional[str]) -> dict:
-    """Each engine model's public entry: names and sizes from ``MODELS``, the
-    flags from ``status``; never a path (``model_path`` is dropped)."""
-    from ..autotag import MODELS
-
-    models = {}
-    for model_type, config in MODELS.items():
-        flags = status.get(model_type) or {}
-        entry = {
-            "name": config["name"],
-            "label": config["label"],
-            "description": config["description"],
-            "size": config["size"],
-            "size_label": size_label(config["size"]),
-            "downloaded": bool(flags.get("downloaded")),
-            "loaded": loaded_type == model_type,
-        }
-        for key in ("model_exists", "mmproj_exists"):
-            if key in flags:
-                entry[key] = bool(flags[key])
-        models[model_type] = entry
-    return models
-
-
 # Only these may be handed to the tagging engine or listed by the scanner.
 _MEDIA_EXTENSIONS = frozenset(
     {".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp", ".tiff", ".tif"}
@@ -161,39 +65,6 @@ def path_is_within(candidate, root) -> bool:
     return child != parent and child.is_relative_to(parent)
 
 
-def _thresholds_or_saved(general, character):
-    """The request's WD14 thresholds as floats; one it omits is the saved
-    default (``autotag.defaults``, OQ4). Raises ValueError/TypeError."""
-    from ..config import AutotagConfig
-
-    return (
-        AutotagConfig.GENERAL_THRESHOLD if general is None else float(general),
-        AutotagConfig.CHARACTER_THRESHOLD if character is None else float(character),
-    )
-
-
-async def _single(event):
-    """A stream of one event."""
-    yield event
-
-
-_monotonic = time.monotonic  # the legacy frames' throttle clock (patched in tests)
-
-# What one image came to in a batch (``on_item``): fixed strings, never an
-# exception's text.
-SKIP_DETAILS = {
-    "unlinked": "File not found",
-    "prompt already processed": "Prompt handled by another image",
-    "outside allowed directories": "Outside the output folders",
-    "file missing": "File not found",
-    "already tagged": "Prompt already tagged",
-}
-
-
-def _added(count):
-    return f"Added {count} tag" if count == 1 else f"Added {count} tags"
-
-
 async def _refusal(title):
     """The single error event of an auto-tag batch refused by another job."""
     message = f"{title} already running"
@@ -212,10 +83,6 @@ class AutotagRoutesMixin:
         async def download_autotag_model_route(request):
             return await self.download_autotag_model(request)
 
-        @routes.post("/prompt_manager/autotag/batch/preview")
-        async def preview_autotag_batch_route(request):
-            return await self.preview_autotag_batch(request)
-
         @routes.post("/prompt_manager/autotag/start")
         async def start_autotag_route(request):
             return await self.start_autotag(request)
@@ -243,24 +110,18 @@ class AutotagRoutesMixin:
             from ..config import AutotagConfig
 
             service = get_autotag_service()
-            # Off the loop: the HuggingFace check walks the whole HF cache.
-            status = await self._run_in_executor(service.get_models_status)
-            loaded = service.is_model_loaded()
-            loaded_type = service.get_loaded_model_type() if loaded else None
+            models_status = service.get_models_status()
 
             return web.json_response(
                 {
                     "success": True,
-                    "models": public_models(status, loaded_type),
-                    # The saved tagging defaults (#328, System › Auto-tagging).
-                    "default_prompt": AutotagConfig.TEMPLATE,
-                    "model_loaded": loaded,
-                    "loaded_model_type": loaded_type,
-                    "wd14_general_threshold": AutotagConfig.GENERAL_THRESHOLD,
-                    "wd14_character_threshold": AutotagConfig.CHARACTER_THRESHOLD,
+                    "models": models_status,
+                    "default_prompt": service.default_prompt,
+                    "model_loaded": service.is_model_loaded(),
+                    "loaded_model_type": service.get_loaded_model_type(),
+                    "wd14_general_threshold": service.wd14_general_threshold,
+                    "wd14_character_threshold": service.wd14_character_threshold,
                     "suggestion_limit": AutotagConfig.suggestion_limit(),
-                    "model_type": AutotagConfig.MODEL_TYPE,
-                    "existing": AutotagConfig.EXISTING,
                 }
             )
 
@@ -298,156 +159,55 @@ class AutotagRoutesMixin:
         return response
 
     async def download_autotag_model(self, request):
-        """Download a tagging model, streaming the legacy events (POST only).
-
-        The download is the model_download Activity job: this request
-        attaches to a running download of the same model or starts one, and
-        streams the legacy frames until the job ends. A client disconnect
-        ends only the stream; the download goes on. A running download of
-        another model answers 409 model-busy (it holds the gate).
-        """
-        from ..autotag import MODELS, get_autotag_service
-
+        """Download an AutoTag model with streaming progress (POST only)."""
         model_type = request.match_info.get("model_type")
-        if model_type not in MODELS:
-            invalid = {"type": "error", "message": f"Invalid model type: {model_type}"}
-            return await self._stream_sse(request, _single(invalid))
-        try:
-            job = self._jobs.active(MODEL_DOWNLOAD_JOB_KIND)
-            if job is not None and job.scope.get("model_type") != model_type:
-                return model_busy_response()
-            if job is None:
-                job, refusal = self._start_model_download(
-                    model_type, get_autotag_service()
+        owner = model_gate.new_owner("legacy-download")
+
+        async def events():
+            try:
+                from ..autotag import get_autotag_service
+
+                service = get_autotag_service()
+                if model_type not in service.models_config:
+                    yield {
+                        "type": "error",
+                        "message": f"Invalid model type: {model_type}",
+                    }
+                    return
+
+                yield {
+                    "type": "progress",
+                    "progress": 0,
+                    "status": "Starting download...",
+                }
+
+                def progress_callback(status: str, progress: float):
+                    pass
+
+                success = await model_gate.run(
+                    owner, service.download_model, model_type, progress_callback
                 )
-                if refusal is not None:
-                    return refusal
-        except Exception:
-            self.logger.exception("Download model error")
-            failed = {"type": "error", "message": _INTERNAL_ERROR}
-            return await self._stream_sse(request, _single(failed))
-        return await self._stream_sse(request, self._download_frames(job))
+                if success:
+                    yield {
+                        "type": "complete",
+                        "progress": 100,
+                        "status": "Download complete",
+                    }
+                else:
+                    yield {"type": "error", "message": "Download failed"}
+            except Exception:
+                self.logger.exception("Download model error")
+                yield {
+                    "type": "error",
+                    "message": _INTERNAL_ERROR,
+                }
 
-    @staticmethod
-    async def _download_frames(job):
-        """The legacy download frames for job: start, then its end."""
-        yield {"type": "progress", "progress": 0, "status": "Starting download..."}
-        async with contextlib.aclosing(job.events()) as events:
-            async for _payload in events:
-                pass
-        if job.state == "finished":
-            yield {"type": "complete", "progress": 100, "status": "Download complete"}
-        else:
-            yield {"type": "error", "message": "Download failed"}
-
-    # ── model download job (#328) ───────────────────────────────────────
-
-    async def start_model_download_job(self, request):
-        """``POST /jobs/model-download {model_type}``: 202 with the job.
-
-        400 for a bad body, 409 ``busy`` while a download (or an exclusive
-        job) runs, 409 ``model-busy`` while another operation holds the gate.
-        """
-        data, error = await self._read_json_body(
-            request, max_bytes=MODEL_DOWNLOAD_BODY_MAX
-        )
-        if error is not None:
-            return error
-        if set(data) != {"model_type"}:
-            return self._bad_request("The body must be exactly {model_type}")
-        from ..autotag import MODELS, get_autotag_service
-
-        model_type = data["model_type"]
-        if not isinstance(model_type, str) or model_type not in MODELS:
-            return self._bad_request(
-                "model_type must be one of " + ", ".join(sorted(MODELS))
-            )
-        try:
-            job, refusal = self._start_model_download(model_type, get_autotag_service())
-        except Exception as e:
-            self.logger.exception("Model download start error")
-            return web.json_response(
-                {"success": False, "error": self._public_error(e)}, status=500
-            )
-        if refusal is not None:
-            return refusal
-        return web.json_response({"success": True, "job": job.summary()}, status=202)
-
-    def _start_model_download(self, model_type, service):
-        """Register the download job: ``(job, None)`` or ``(None, refusal)``.
-
-        Synchronous (no await between the checks and the start). The gate is
-        taken before the job registers and released when the runner ends,
-        also when the task is cancelled before the runner ever starts.
-        """
-        from ..autotag import MODELS
-
-        busy = self._jobs.blocker(MODEL_DOWNLOAD_JOB_KIND, admission="read")
-        if busy is not None:
-            return None, busy_response(JobBusy(busy))
-        owner = model_gate.new_owner(MODEL_DOWNLOAD_OWNER_KIND)
         if not model_gate.try_acquire(owner):
-            return None, model_busy_response()
-        config = MODELS[model_type]
-        label = config["label"]
-        title = f"Tagging model download · {label}"
-        _download_titles.clear()
-        _download_titles[owner] = title
+            return model_busy_response()
         try:
-            job = self._jobs.start(
-                MODEL_DOWNLOAD_JOB_KIND,
-                title,
-                admission="read",
-                cancellable=False,
-                scope={
-                    "model_type": model_type,
-                    "label": label,
-                    "size_label": size_label(config["size"]),
-                },
-                runner=functools.partial(
-                    self._run_model_download, service, model_type, owner
-                ),
-            )
-        except BaseException as refused:
-            # JobBusy, or anything else the registry raised: give the gate back.
-            model_gate.release(owner)
-            _download_titles.pop(owner, None)
-            if isinstance(refused, JobBusy):
-                return None, busy_response(refused)
-            raise
-
-        def ended(_task):
-            model_gate.release(owner)
-            if model_gate.holder() != owner:  # not while a thread still runs
-                _download_titles.pop(owner, None)
-
-        job.task.add_done_callback(ended)
-        return job, None
-
-    async def _run_model_download(self, service, model_type, owner, job):
-        label = job.scope["label"]
-        job.update(status_line=f"Downloading {label} ({job.scope['size_label']})")
-        job.log_line(f"Download started: {label}")
-        job.publish({"type": "status", "status": job.status_line})
-        try:
-            ok = await model_gate.run(owner, service.download_model, model_type, None)
-        except Exception:
-            self.logger.exception(f"Tagging model download failed: {model_type}")
-            ok = False
+            return await self._stream_sse(request, events())
         finally:
-            # Before the job ends, so a reader that sees the end finds the
-            # gate free (a running download thread defers the release).
             model_gate.release(owner)
-        if ok:
-            job.update(status_line=f"Downloaded {label}")
-            job.log_line(f"Download finished: {label}")
-            job.publish({"type": "status", "status": job.status_line})
-            job.finish("finished")
-            return
-        job.update(status_line=_DOWNLOAD_FAILED)
-        job.log_line(f"Download failed: {label}")
-        job.publish({"type": "status", "status": job.status_line})
-        job.finish("failed")
 
     async def _read_start_params(self, request) -> Optional[dict]:
         """Merge query-string and optional JSON-body parameters for autotag/start.
@@ -478,48 +238,35 @@ class AutotagRoutesMixin:
             and not t.startswith("append:")
         ]
 
-    async def _apply_tags_to_prompt(self, prompt_id, tags) -> int:
-        """Merge ``tags`` into the prompt; how many new tags were added."""
+    async def _apply_tags_to_prompt(self, prompt_id, tags) -> bool:
+        """Merge ``tags`` into the prompt; True when something new was added."""
         existing_prompt = await self._run_in_executor(
             self.db.get_prompt_by_id, prompt_id
         )
         if not existing_prompt:
-            return 0
+            return False
         existing_tags = existing_prompt.get("tags", [])
         if isinstance(existing_tags, str):
             existing_tags = [t.strip() for t in existing_tags.split(",") if t.strip()]
-        new_tags = list(dict.fromkeys(t for t in tags if t not in existing_tags))
+        new_tags = [t for t in tags if t not in existing_tags]
         if not new_tags:
-            return 0
+            return False
         await self._run_in_executor(
             self.db.update_prompt_metadata, prompt_id, tags=existing_tags + new_tags
         )
-        return len(new_tags)
+        return True
 
     async def _autotag_batch_events(self, service, opts: dict):
-        """Yield SSE progress dicts while tagging every image linked to a prompt.
+        """Yield SSE progress dicts while tagging every image linked to a prompt."""
+        import time as _time
 
-        Both batches run here: the legacy page's (its frames unchanged) and
-        the ``autotag`` job's. ``opts``: ``model_type``, ``keep_in_memory``,
-        ``existing`` (``skip`` leaves prompts with real tags alone, ``merge``
-        adds to them), the two thresholds, and optionally ``gate_owner``,
-        ``prompt`` (the template, passed to each call; the legacy page sets
-        ``custom_prompt`` instead), ``cancelled`` (checked before each image:
-        a cancelled run returns without a ``complete`` frame) and
-        ``on_item(index, total, group, image_path, detail)`` (one outcome per
-        image, ``SKIP_DETAILS`` for the skips).
-        """
         model_type = opts["model_type"]
         keep_in_memory = opts["keep_in_memory"]
-        cancelled = opts.get("cancelled") or (lambda: False)
-        on_item = opts.get("on_item") or (lambda *_args: None)
-        status = await self._run_in_executor(service.get_models_status)
+        status = service.get_models_status()
         if not status.get(model_type, {}).get("downloaded"):
             yield {"type": "error", "message": f"Model {model_type} not downloaded"}
             return
 
-        if cancelled():
-            return
         yield {"type": "progress", "progress": 0, "status": "Loading model..."}
         run = self._gated_runner(opts.get("gate_owner"))
         try:
@@ -532,21 +279,15 @@ class AutotagRoutesMixin:
             }
             return
 
-        if opts.get("custom_prompt"):
+        if opts["custom_prompt"]:
             service.custom_prompt = opts["custom_prompt"]
-        tag_kwargs = {
-            "general_threshold": opts["general_threshold"],
-            "character_threshold": opts["character_threshold"],
-        }
-        if opts.get("prompt"):
-            tag_kwargs["prompt"] = opts["prompt"]
 
         yield {
             "type": "progress",
             "progress": 5,
             "status": "Model loaded. Fetching all images from database...",
         }
-        images = await self._run_in_executor(self.db.autotag_batch_candidates)
+        images = await self._run_in_executor(self.db.get_all_images)
         total = len(images)
         if total == 0:
             yield {
@@ -558,8 +299,7 @@ class AutotagRoutesMixin:
                 "skipped_outside_roots": 0,
                 "status": "No images with linked prompts found",
             }
-            if not keep_in_memory:
-                service.unload_model()
+            service.unload_model()
             return
 
         yield {
@@ -576,7 +316,7 @@ class AutotagRoutesMixin:
             "skipped_outside_roots": 0,
         }
         tagged_prompt_ids = set()
-        last_update = _monotonic()
+        last_update = _time.monotonic()
         finished = False
 
         def progress_event(i, message):
@@ -592,8 +332,6 @@ class AutotagRoutesMixin:
 
         try:
             for i, image_data in enumerate(images):
-                if cancelled():
-                    return
                 image_path = image_data.get("image_path")
                 prompt_id = image_data.get("prompt_id")
                 skip_reason = None
@@ -612,7 +350,7 @@ class AutotagRoutesMixin:
                             counts["skipped_outside_roots"] += 1
                         else:
                             skip_reason = "file missing"
-                    elif opts["existing"] == "skip" and self._real_tags(
+                    elif opts["skip_tagged"] and self._real_tags(
                         image_data.get("prompt_tags", [])
                     ):
                         tagged_prompt_ids.add(prompt_id)
@@ -620,8 +358,7 @@ class AutotagRoutesMixin:
 
                 if skip_reason is not None:
                     counts["skipped"] += 1
-                    on_item(i, total, "skipped", image_path, SKIP_DETAILS[skip_reason])
-                    now = _monotonic()
+                    now = _time.monotonic()
                     if (now - last_update) >= 0.5 or i == total - 1:
                         yield progress_event(
                             i, f"Skipping {i + 1}/{total} ({skip_reason})..."
@@ -631,17 +368,17 @@ class AutotagRoutesMixin:
                     continue
 
                 try:
-                    tags = await run(service.generate_tags, allowed_path, **tag_kwargs)
+                    tags = await run(
+                        service.generate_tags,
+                        allowed_path,
+                        general_threshold=opts["general_threshold"],
+                        character_threshold=opts["character_threshold"],
+                    )
                     counts["processed"] += 1
-                    added = 0
-                    if tags:
-                        added = await self._apply_tags_to_prompt(prompt_id, tags)
-                    if added:
+                    if tags and await self._apply_tags_to_prompt(prompt_id, tags):
                         counts["tagged"] += 1
-                        on_item(i, total, "tagged", image_path, _added(added))
                     else:
                         counts["skipped"] += 1
-                        on_item(i, total, "unchanged", image_path, "No new tags")
                     tagged_prompt_ids.add(prompt_id)
                 except Exception as img_err:
                     self.logger.error(
@@ -650,11 +387,10 @@ class AutotagRoutesMixin:
                     )
                     counts["errors"] += 1
                     counts["processed"] += 1
-                    on_item(i, total, "errors", image_path, "Tagging failed")
 
                 yield progress_event(i, f"Processing {i + 1}/{total}...")
                 await asyncio.sleep(0.01)
-                last_update = _monotonic()
+                last_update = _time.monotonic()
 
             finished = True
             if not keep_in_memory:
@@ -682,22 +418,16 @@ class AutotagRoutesMixin:
         opts = {
             "model_type": params.get("model_type", "gguf"),
             "custom_prompt": params.get("prompt", ""),
-            "existing": (
-                "skip"
-                if str(params.get("skip_tagged", "true")).lower() == "true"
-                else "merge"
-            ),
+            "skip_tagged": str(params.get("skip_tagged", "true")).lower() == "true",
             "keep_in_memory": str(params.get("keep_in_memory", "true")).lower()
             == "true",
             "general_threshold": params.get("general_threshold"),
             "character_threshold": params.get("character_threshold"),
         }
         try:
-            opts["general_threshold"], opts["character_threshold"] = (
-                _thresholds_or_saved(
-                    opts["general_threshold"], opts["character_threshold"]
-                )
-            )
+            for key in ("general_threshold", "character_threshold"):
+                if opts[key] is not None:
+                    opts[key] = float(opts[key])
         except (ValueError, TypeError):
             return self._bad_request(
                 "general_threshold and character_threshold must be numeric"
@@ -727,9 +457,7 @@ class AutotagRoutesMixin:
         # never runs beside a scan, restore or the workspace tagging job.
         busy = self._jobs.blocker(AUTOTAG_BATCH_JOB_KIND, admission="records")
         if busy is not None:
-            # A second legacy batch keeps its JSON 409; the workspace's Tag
-            # output images job is named in a stream frame.
-            if busy.kind == AUTOTAG_BATCH_JOB_KIND and busy.title != AUTOTAG_JOB_TITLE:
+            if busy.kind == AUTOTAG_BATCH_JOB_KIND:  # unchanged payload
                 return web.json_response(
                     {"success": False, "error": _BUSY_ERROR}, status=409
                 )
@@ -739,7 +467,7 @@ class AutotagRoutesMixin:
             return await self._stream_sse(request, _refusal(busy.title))
         async with self._jobs.hold(
             AUTOTAG_BATCH_JOB_KIND,
-            OWNER_LABELS["legacy-batch"],
+            "Auto-tag images (legacy page)",
             admission="records",
         ) as job:
             response = await self._start_autotag_batch(request, opts, events)
@@ -763,278 +491,6 @@ class AutotagRoutesMixin:
         finally:
             _autotag_batch_lock.release()
 
-    # ── Tag output images (#328) ────────────────────────────────────────
-
-    async def _batch_body(self, request, keys, max_bytes):
-        """``(data, None)`` for a JSON object with exactly ``keys``."""
-        data, error = await self._read_json_body(request, max_bytes=max_bytes)
-        if error is not None:
-            return None, error
-        if set(data) != set(keys):
-            return None, self._bad_request(
-                "The body must be exactly {" + ", ".join(keys) + "}"
-            )
-        return data, None
-
-    @staticmethod
-    def _batch_choice(data):
-        """The model's engine entry and the policy, or a 400 message."""
-        from ..autotag import MODELS
-        from ..config import EXISTING_POLICIES
-
-        model_type, existing = data.get("model_type"), data.get("existing")
-        if not isinstance(model_type, str) or model_type not in MODELS:
-            return None, "model_type must be one of " + ", ".join(sorted(MODELS))
-        if not isinstance(existing, str) or existing not in EXISTING_POLICIES:
-            return None, "existing must be one of " + ", ".join(EXISTING_POLICIES)
-        return MODELS[model_type], None
-
-    async def preview_autotag_batch(self, request):
-        """Review Tag output images: counts, model, backup and disk; no write.
-
-        Opens no image file. Refused (409 ``busy``) while an exclusive job runs.
-        """
-        try:
-            async with self._jobs.lease(AUTOTAG_PREVIEW_LEASE):
-                return await self._preview_autotag_batch(request)
-        except JobBusy as busy:
-            return busy_response(busy)
-
-    async def _preview_autotag_batch(self, request):
-        from ..autotag import get_autotag_service
-
-        data, error = await self._batch_body(
-            request, ("model_type", "existing"), BATCH_PREVIEW_BODY_MAX
-        )
-        if error is not None:
-            return error
-        config, message = self._batch_choice(data)
-        if message:
-            return self._bad_request(message)
-        model_type, existing = data["model_type"], data["existing"]
-        policy = self._safety_backup_policy()
-        try:
-            candidates = await self._run_in_executor(self.db.autotag_batch_candidates)
-            status = await self._run_in_executor(
-                get_autotag_service().get_models_status
-            )
-            disk, _short, _size = await self._run_in_executor(
-                functools.partial(
-                    disk_plan,
-                    self.db.model.db_path,
-                    backup=policy != "off",
-                    vacuum=False,
-                )
-            )
-        except Exception as e:
-            self.logger.exception("Tag output images could not be reviewed")
-            return web.json_response(
-                {"success": False, "error": self._public_error(e)}, status=500
-            )
-        prompts = {row["prompt_id"]: row["prompt_tags"] for row in candidates}
-        tagged = sum(1 for tags in prompts.values() if self._real_tags(tags))
-        to_tag = len(prompts) - tagged if existing == "skip" else len(prompts)
-        return web.json_response(
-            {
-                "success": True,
-                "images": len(candidates),
-                "prompts": len(prompts),
-                "already_tagged": tagged,
-                "to_tag": to_tag,
-                "model": {
-                    "type": model_type,
-                    "label": config["label"],
-                    "size_label": size_label(config["size"]),
-                    "downloaded": bool(
-                        (status.get(model_type) or {}).get("downloaded")
-                    ),
-                },
-                "existing": existing,
-                "review_required": existing == "replace_after_review",
-                "backup": {"policy": policy},
-                "disk": disk,
-            }
-        )
-
-    async def start_autotag_job(self, request):
-        """``POST /jobs/autotag``: start Tag output images (202), or refuse.
-
-        In order: 400 body or options, 400 ``review-required``; 409
-        ``model-unavailable``; 507 ``insufficient-space``; 409 ``busy``
-        (another records job, the legacy batch's hold included); 409
-        ``model-busy``. No await follows the busy check.
-        """
-        from ..autotag import get_autotag_service
-        from ..config import MAX_SUGGESTION_LIMIT, AutotagConfig
-        from .annotation_suggest import OptionError, validate_options
-
-        data, error = await self._batch_body(
-            request, ("model_type", "existing", "options"), BATCH_JOB_BODY_MAX
-        )
-        if error is not None:
-            return error
-        config, message = self._batch_choice(data)
-        if message:
-            return self._bad_request(message)
-        model_type, existing, options = (
-            data["model_type"],
-            data["existing"],
-            data["options"],
-        )
-        if isinstance(options, dict) and {"suggestion_limit", "use_gpu"} & set(options):
-            return self._bad_request("options take no suggestion_limit or use_gpu")
-        try:
-            _model, options = validate_options(
-                model_type,
-                options,
-                default_limit=AutotagConfig.suggestion_limit(),
-                max_limit=MAX_SUGGESTION_LIMIT,
-            )
-        except OptionError as error:
-            return self._bad_request(str(error))
-        if existing == "replace_after_review":
-            return web.json_response(
-                {"success": False, "code": "review-required", "error": REVIEW_REQUIRED},
-                status=400,
-            )
-        service = get_autotag_service()
-        backup_on = self._safety_backup_policy() == "on"
-        try:
-            status = await self._run_in_executor(service.get_models_status)
-            candidates = await self._run_in_executor(self.db.autotag_batch_candidates)
-            _disk, short, _size = await self._run_in_executor(
-                functools.partial(
-                    disk_plan, self.db.model.db_path, backup=backup_on, vacuum=False
-                )
-            )
-        except Exception as e:
-            self.logger.exception("Tag output images could not start")
-            return web.json_response(
-                {"success": False, "error": self._public_error(e)}, status=500
-            )
-        if not (status.get(model_type) or {}).get("downloaded"):
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": "model-unavailable",
-                    "error": f"{config['label']} is not downloaded. "
-                    "Download it in System › Auto-tagging.",
-                },
-                status=409,
-            )
-        if backup_on and short is not None:
-            return web.json_response(
-                {
-                    "success": False,
-                    "code": "insufficient-space",
-                    "error": short_space_message(short),
-                },
-                status=507,
-            )
-        busy = self._jobs.blocker(AUTOTAG_BATCH_JOB_KIND, admission="records")
-        if busy is not None:
-            return busy_response(JobBusy(busy))
-        owner = model_gate.new_owner(AUTOTAG_OWNER_KIND)
-        if not model_gate.try_acquire(owner):
-            return model_busy_response()
-        opts = {
-            "model_type": model_type,
-            "existing": existing,
-            "keep_in_memory": True,
-            "gate_owner": owner,
-            "general_threshold": options.get("general_threshold"),
-            "character_threshold": options.get("character_threshold"),
-            "prompt": options.get("instructions"),
-        }
-        try:
-            job = self._jobs.start(
-                AUTOTAG_BATCH_JOB_KIND,
-                AUTOTAG_JOB_TITLE,
-                admission="records",
-                cancellable=True,
-                scope={
-                    "model_type": model_type,
-                    "existing": existing,
-                    "images": len(candidates),
-                    "label": config["label"],
-                },
-                groups=AUTOTAG_GROUP_NAMES,
-                runner=functools.partial(
-                    self._run_autotag_job, service, opts, backup_on
-                ),
-            )
-        except BaseException as refused:
-            model_gate.release(owner)
-            if isinstance(refused, JobBusy):
-                return busy_response(refused)
-            raise
-        job.task.add_done_callback(lambda _task: model_gate.release(owner))
-        return web.json_response({"success": True, "job": job.summary()}, status=202)
-
-    async def _run_autotag_job(self, service, opts, backup_on, job):
-        ok, _backup = await self._safety_backup_step(job, self.db, backup_on)
-        if not ok:
-            return
-        try:
-            await self._tag_output_images(service, opts, job)
-        except Exception:
-            self.logger.exception("Tag output images failed")
-            job.update(status_line=_INTERNAL_ERROR)
-            job.log_line(f"Tagging failed · {_INTERNAL_ERROR}")
-            job.finish("failed")
-        finally:
-            if backup_on:
-                await self._prune_backup_pool(job, self.db)
-
-    async def _tag_output_images(self, service, opts, job):
-        roots = _scan_roots(self._get_all_output_dirs())
-        job.log_line(
-            f"Tagging started · {job.scope['label']} · "
-            + ("skip prompts already tagged" if opts["existing"] == "skip" else "merge")
-        )
-        job.update(status_line="Loading the tagging model")
-
-        def on_item(index, total, group, image_path, detail):
-            path, root, root_index = _scan_location(image_path or "", roots)
-            job.update(
-                processed=index + 1,
-                total=total,
-                progress=100 * (index + 1) // total,
-                status_line=f"Tagging {index + 1} of {total}",
-            )
-            job.record(
-                group,
-                {
-                    "path": path,
-                    "root": root,
-                    "root_index": root_index,
-                    "detail": detail,
-                },
-                f"{path}: {detail}",
-            )
-            job.publish({"type": "progress", "progress": job.progress})
-
-        final = None
-        async for event in self._autotag_batch_events(
-            service,
-            {**opts, "cancelled": lambda: job.cancelled, "on_item": on_item},
-        ):
-            if event.get("type") in ("complete", "error"):
-                final = event
-        if final is not None and final["type"] == "error":
-            job.update(status_line=final["message"])
-            job.log_line(f"Tagging failed · {final['message']}")
-            job.finish("failed")
-        elif job.cancelled:  # a cancel wins over a run that then completed
-            job.update(status_line=BATCH_CANCELLED)
-            job.log_line(BATCH_CANCELLED)
-            job.finish("cancelled")
-        else:
-            done = f"Tagged {_plural(job.counters.get('tagged', 0), 'prompt')}"
-            job.update(status_line=done, progress=100)
-            job.log_line(done)
-            job.finish("finished")
-
     def _gated_runner(self, owner):
         """Executor calls under the model gate *owner* holds (plain when None)."""
         if owner is None:
@@ -1151,9 +607,10 @@ class AutotagRoutesMixin:
             general_threshold = data.get("general_threshold")
             character_threshold = data.get("character_threshold")
             try:
-                general_threshold, character_threshold = _thresholds_or_saved(
-                    general_threshold, character_threshold
-                )
+                if general_threshold is not None:
+                    general_threshold = float(general_threshold)
+                if character_threshold is not None:
+                    character_threshold = float(character_threshold)
             except (ValueError, TypeError):
                 return self._bad_request(
                     "general_threshold and character_threshold must be numeric"

py/api/job_routes.py

@@ -130,14 +130,6 @@ class JobRoutesMixin:
         async def start_image_tag_job_route(request):
             return await self.start_image_tag_job(request)
 
-        @routes.post("/prompt_manager/jobs/model-download")
-        async def start_model_download_job_route(request):
-            return await self.start_model_download_job(request)
-
-        @routes.post("/prompt_manager/jobs/autotag")
-        async def start_autotag_job_route(request):
-            return await self.start_autotag_job(request)
-
         @routes.post("/prompt_manager/jobs/thumbnails")
         async def start_thumbnail_job_route(request):
             return await self.start_thumbnail_job(request)

py/api/jobs.py

@@ -87,8 +87,6 @@ SCAN_GROUPS = {
 # Record-changing: it writes image tag sets and new vocabulary names.
 IMAGE_TAG_JOB_KIND = "image-tags"
 IMAGE_TAG_GROUP_NAMES = ("tagged", "unchanged", "skipped", "errors")
-# Tag output images (#328) counts its prompts the same way.
-AUTOTAG_GROUP_NAMES = IMAGE_TAG_GROUP_NAMES
 
 # Thumbnail generation (#249 System S5): previews written, already fresh, failed.
 THUMBNAIL_GROUP_NAMES = ("generated", "skipped", "errors")
@@ -111,8 +109,6 @@ DUPLICATE_CLEANUP_JOB_KIND = "duplicate_cleanup"
 THUMBNAILS_JOB_KIND = "thumbnails"
 LORA_IMPORT_JOB_KIND = "lora_import"
 AUTOTAG_BATCH_JOB_KIND = "autotag"
-# A tagging model download (#328): read admission, not cancellable.
-MODEL_DOWNLOAD_JOB_KIND = "model_download"
 # Duplicate image files (#249 System S6, py/api/duplicate_files.py): the
 # find is a cancellable ``read`` job; the reviewed removal is ``records``.
 DUPLICATES_JOB_KIND = "duplicates"

py/api/settings_routes.py

@@ -47,23 +47,11 @@ _SETTINGS_FILE_KEYS = {
     "THUMBNAIL_FORMAT": ("thumbnails", "format"),
     "THUMBNAIL_QUALITY": ("thumbnails", "quality"),
     "THUMBNAIL_EDGE": ("thumbnails", "edge"),
-    # The one tagging configuration (#328), published to AutotagConfig.
-    "AUTOTAG_MODEL_TYPE": ("autotag", "defaults", "model_type"),
-    "AUTOTAG_EXISTING": ("autotag", "defaults", "existing"),
-    "AUTOTAG_GENERAL_THRESHOLD": ("autotag", "defaults", "general_threshold"),
-    "AUTOTAG_CHARACTER_THRESHOLD": ("autotag", "defaults", "character_threshold"),
-    "AUTOTAG_TEMPLATE": ("autotag", "defaults", "template"),
-    "AUTOTAG_SUGGESTION_LIMIT": ("autotag", "defaults", "suggestion_limit"),
 }
 # The thumbnail settings a running Convert outdated job fixes (#317).
 _THUMBNAIL_SETTINGS = ("THUMBNAIL_FORMAT", "THUMBNAIL_QUALITY", "THUMBNAIL_EDGE")
 # Attributes that live on GalleryConfig; the others on PromptManagerConfig.
 _GALLERY_SETTINGS = frozenset({"MONITORING_ENABLED"})
-# Attributes that live on AutotagConfig, named without the AUTOTAG_ prefix.
-_AUTOTAG_SETTINGS = frozenset(
-    name for name in _SETTINGS_FILE_KEYS if name.startswith("AUTOTAG_")
-)
-_AUTOTAG_PREFIX = "AUTOTAG_"
 SOURCE_CHANGE_JOB_KIND = "source_change"
 SOURCE_CHANGE_JOB_TITLE = "Source change"
 
@@ -163,63 +151,6 @@ def _set_nested(config, sections, key, value):
     config[sections[0]] = merged
 
 
-def _validate_autotag_settings(data):
-    """The ``autotag_*`` settings as ``{AUTOTAG_ATTR: value}``.
-
-    The first bad value raises ValueError with a message that names the
-    setting by its label in System › Auto-tagging.
-    """
-    from ..config import (
-        EXISTING_POLICIES,
-        MAX_SUGGESTION_LIMIT,
-        MODEL_TYPES,
-        validate_template,
-        validate_threshold,
-    )
-
-    updates = {}
-    if "autotag_model_type" in data:
-        value = data["autotag_model_type"]
-        if not isinstance(value, str) or value not in MODEL_TYPES:
-            raise ValueError(
-                "Tagging model must be one of " + ", ".join(sorted(MODEL_TYPES)) + "."
-            )
-        updates["AUTOTAG_MODEL_TYPE"] = value
-    if "autotag_existing" in data:
-        value = data["autotag_existing"]
-        if not isinstance(value, str) or value not in EXISTING_POLICIES:
-            raise ValueError(
-                "Existing tags must be skip, merge or replace_after_review."
-            )
-        updates["AUTOTAG_EXISTING"] = value
-    for key, label in (
-        ("autotag_general_threshold", "General-tag confidence"),
-        ("autotag_character_threshold", "Character-tag confidence"),
-    ):
-        if key in data:
-            try:
-                value = validate_threshold(label, data[key])
-            except ValueError as error:
-                raise ValueError(f"{error}.") from None
-            updates[key.upper()] = value
-    if "autotag_template" in data:
-        try:
-            updates["AUTOTAG_TEMPLATE"] = validate_template(
-                data["autotag_template"], "LLM tag template"
-            )
-        except ValueError as error:
-            raise ValueError(f"{error}.") from None
-    if "autotag_suggestion_limit" in data:
-        value = data["autotag_suggestion_limit"]
-        if type(value) is not int or not 1 <= value <= MAX_SUGGESTION_LIMIT:
-            raise ValueError(
-                "Suggestions per image must be a whole number from 1 to "
-                f"{MAX_SUGGESTION_LIMIT}."
-            )
-        updates["AUTOTAG_SUGGESTION_LIMIT"] = value
-    return updates
-
-
 async def _read_json(request):
     """Parse a JSON object body through the package's capped reader."""
     from . import _read_json_body
@@ -246,7 +177,7 @@ class SettingsRoutesMixin:
     async def get_settings(self, request):
         """Get current settings."""
         try:
-            from ..config import AutotagConfig, PromptManagerConfig, GalleryConfig
+            from ..config import PromptManagerConfig, GalleryConfig
 
             root_paths = [
                 self._public_path(d) for d in GalleryConfig.MONITORING_DIRECTORIES
@@ -272,14 +203,6 @@ class SettingsRoutesMixin:
                         "thumbnail_format": PromptManagerConfig.THUMBNAIL_FORMAT,
                         "thumbnail_quality": PromptManagerConfig.THUMBNAIL_QUALITY,
                         "thumbnail_edge": PromptManagerConfig.THUMBNAIL_EDGE,
-                        "autotag_model_type": AutotagConfig.MODEL_TYPE,
-                        "autotag_existing": AutotagConfig.EXISTING,
-                        "autotag_general_threshold": AutotagConfig.GENERAL_THRESHOLD,
-                        "autotag_character_threshold": (
-                            AutotagConfig.CHARACTER_THRESHOLD
-                        ),
-                        "autotag_template": AutotagConfig.TEMPLATE,
-                        "autotag_suggestion_limit": AutotagConfig.SUGGESTION_LIMIT,
                         "cpu_count": PromptManagerConfig.max_worker_threads(),
                         "gallery_root_paths": root_paths,
                         "gallery_root_path": root_paths[0] if root_paths else "",
@@ -502,12 +425,7 @@ class SettingsRoutesMixin:
         """
         from ..config import GalleryConfig, PromptManagerConfig
 
-        from ..config import AutotagConfig
-
         for name, value in updates.items():
-            if name in _AUTOTAG_SETTINGS:
-                setattr(AutotagConfig, name[len(_AUTOTAG_PREFIX) :], value)
-                continue
             owner = GalleryConfig if name in _GALLERY_SETTINGS else PromptManagerConfig
             setattr(owner, name, value)
         restart_fields = []
@@ -646,7 +564,6 @@ class SettingsRoutesMixin:
             updates["THUMBNAIL_EDGE"] = thumbnail_settings.validate_edge(
                 data["thumbnail_edge"]
             )
-        updates.update(_validate_autotag_settings(data))
         return updates
 
     def _parse_gallery_roots(self, data):

py/autotag.py

@@ -25,23 +25,6 @@ except ImportError:
     from database.annotations import MAX_IMAGE_TAGS
     from database.vocabulary import validate_vocabulary_tag_name
 
-# The tag template and thresholds live with the saved tagging defaults
-# (#328), so config.py never imports PIL.
-try:
-    from .tagging_defaults import DEFAULT_TAG_TEMPLATE
-except ImportError:
-    from py.tagging_defaults import DEFAULT_TAG_TEMPLATE
-
-
-def _autotag_config():
-    """The saved defaults; imported late, as config needs ComfyUI's server."""
-    try:
-        from .config import AutotagConfig
-    except ImportError:
-        from py.config import AutotagConfig
-    return AutotagConfig
-
-
 # Try to import logging from utils, fallback to standard logging
 try:
     from ..utils.logging_config import get_logger
@@ -62,12 +45,10 @@ except ImportError:
         return logger
 
 
-# Model configurations - same as standalone_tagger.py. ``label`` is the short
-# name System, Activity and a 409 model-busy show (#328).
+# Model configurations - same as standalone_tagger.py
 MODELS = {
     "gguf": {
         "name": "GGUF (Recommended)",
-        "label": "GGUF JoyCaption",
         "description": "Quantized model, ~4.5GB, faster loading",
         "size": "~4.5GB",
         "repo": "mradermacher/llama-joycaption-beta-one-hf-llava-GGUF",
@@ -78,7 +59,6 @@ MODELS = {
     },
     "hf": {
         "name": "HuggingFace",
-        "label": "HuggingFace JoyCaption",
         "description": "Full precision model, ~16GB, higher quality",
         "size": "~16GB",
         "repo": "fancyfeast/llama-joycaption-beta-one-hf-llava",
@@ -86,7 +66,6 @@ MODELS = {
     },
     "wd14-swinv2": {
         "name": "WD14 SwinV2",
-        "label": "WD14 SwinV2",
         "description": "Fast classifier tagger, ~400MB, no prompt needed",
         "size": "~400MB",
         "repo": "SmilingWolf/wd-swinv2-tagger-v3",
@@ -96,7 +75,6 @@ MODELS = {
     },
     "wd14-vit": {
         "name": "WD14 ViT",
-        "label": "WD14 ViT",
         "description": "Fast classifier tagger, ~400MB, ViT architecture",
         "size": "~400MB",
         "repo": "SmilingWolf/wd-vit-tagger-v3",
@@ -107,7 +85,17 @@ MODELS = {
 }
 
 # Default prompts
-DEFAULT_PROMPT = DEFAULT_TAG_TEMPLATE
+DEFAULT_PROMPT = (
+    "Generate only comma-separated Danbooru tags (lowercase_underscores, no spaces).\n"
+    "Include: subject_count (1girl/1boy/etc), gender, ethnicity (asian, caucasian, "
+    "etc), age_approx (teen, young_woman), body_attributes, face_features, "
+    "hairstyle, appearance, clothing, accessories, pose, expression, action, "
+    "camera_angle, camera_shot, scene_composition (wide_shot, long_shot, "
+    "dutch_angle), environment, background_elements, lighting, mood.\n"
+    "Prioritize visual accuracy.\n"
+    "No sentences, no commentary, no captions. Only tags. Keep length short but "
+    "descriptive."
+)
 
 # Upper bound of one suggestion request: the image tag set cap.
 MAX_SUGGESTION_LIMIT = MAX_IMAGE_TAGS
@@ -191,6 +179,10 @@ class AutoTagService:
         self._current_model_type: Optional[str] = None
         self._custom_prompt: str = DEFAULT_PROMPT
 
+        # WD14 threshold defaults
+        self._wd14_general_threshold: float = 0.35
+        self._wd14_character_threshold: float = 0.85
+
     @property
     def models_config(self) -> Dict[str, Dict[str, Any]]:
         """Get the models configuration dictionary."""
@@ -213,13 +205,19 @@ class AutoTagService:
 
     @property
     def wd14_general_threshold(self) -> float:
-        """The saved General-tag confidence (``autotag.defaults``)."""
-        return _autotag_config().GENERAL_THRESHOLD
+        return self._wd14_general_threshold
+
+    @wd14_general_threshold.setter
+    def wd14_general_threshold(self, value: float):
+        self._wd14_general_threshold = max(0.0, min(1.0, value))
 
     @property
     def wd14_character_threshold(self) -> float:
-        """The saved Character-tag confidence (``autotag.defaults``)."""
-        return _autotag_config().CHARACTER_THRESHOLD
+        return self._wd14_character_threshold
+
+    @wd14_character_threshold.setter
+    def wd14_character_threshold(self, value: float):
+        self._wd14_character_threshold = max(0.0, min(1.0, value))
 
     def get_models_status(self) -> Dict[str, Dict[str, Any]]:
         """Get availability status for all model types.
@@ -862,12 +860,12 @@ class AutoTagService:
             gen_thresh = (
                 general_threshold
                 if general_threshold is not None
-                else _autotag_config().GENERAL_THRESHOLD
+                else self._wd14_general_threshold
             )
             char_thresh = (
                 character_threshold
                 if character_threshold is not None
-                else _autotag_config().CHARACTER_THRESHOLD
+                else self._wd14_character_threshold
             )
             return self._generate_wd14(
                 session, tags_list, image, gen_thresh, char_thresh

py/config.py

@@ -563,90 +563,18 @@ class IntegrationConfig:
 DEFAULT_SUGGESTION_LIMIT = 10
 MAX_SUGGESTION_LIMIT = 100  # pinned to MAX_IMAGE_TAGS by tests/test_config.py
 
-# The tagging engines, options, template and validators (server-free, #328).
-try:
-    from .tagging_defaults import (  # noqa: F401 - re-exported
-        DEFAULT_TAG_TEMPLATE,
-        EXISTING_POLICIES,
-        LLM_MODEL_TYPES,
-        MAX_INSTRUCTION_BYTES,
-        MAX_INSTRUCTION_CHARS,
-        MODEL_TYPES,
-        WD14_MODEL_TYPES,
-        validate_template,
-        validate_threshold,
-    )
-except ImportError:
-    from py.tagging_defaults import (  # noqa: F401 - re-exported
-        DEFAULT_TAG_TEMPLATE,
-        EXISTING_POLICIES,
-        LLM_MODEL_TYPES,
-        MAX_INSTRUCTION_BYTES,
-        MAX_INSTRUCTION_CHARS,
-        MODEL_TYPES,
-        WD14_MODEL_TYPES,
-        validate_template,
-        validate_threshold,
-    )
-
-
-def _valid_model_type(value: Any) -> str:
-    if not isinstance(value, str) or value not in MODEL_TYPES:
-        raise ValueError("must be one of " + ", ".join(sorted(MODEL_TYPES)))
-    return value
-
-
-def _valid_existing(value: Any) -> str:
-    if not isinstance(value, str) or value not in EXISTING_POLICIES:
-        raise ValueError("must be one of " + ", ".join(EXISTING_POLICIES))
-    return value
-
-
-def _valid_suggestion_limit(value: Any) -> int:
-    if type(value) is not int or not 1 <= value <= MAX_SUGGESTION_LIMIT:
-        raise ValueError(f"must be an integer from 1 to {MAX_SUGGESTION_LIMIT}")
-    return value
-
 
 class AutotagConfig:
     """Persisted tagging defaults under ``autotag.defaults`` in config.json.
 
-    One tagging configuration (#328): the model, what a batch does with
-    prompts already tagged, the two WD14 thresholds, the language-model
-    template and how many suggestions Generate returns. Each key is checked
-    alone on load; a hand-edited value that fails its check falls back to
-    its default with one warning rather than failing the load.
+    ``suggestion_limit`` is how many suggestions Generate returns (the top N
+    by score), an integer in ``1..MAX_SUGGESTION_LIMIT``. A hand-edited value
+    outside that range, or of another type, falls back to the default with a
+    warning rather than failing the load.
     """
 
-    MODEL_TYPE = "wd14-swinv2"
-    EXISTING = "skip"
-    GENERAL_THRESHOLD = 0.35
-    CHARACTER_THRESHOLD = 0.85
-    TEMPLATE = DEFAULT_TAG_TEMPLATE
     SUGGESTION_LIMIT = DEFAULT_SUGGESTION_LIMIT
 
-    # config.json key -> (attribute, validator, default)
-    _KEYS = {
-        "model_type": ("MODEL_TYPE", _valid_model_type, "wd14-swinv2"),
-        "existing": ("EXISTING", _valid_existing, "skip"),
-        "general_threshold": (
-            "GENERAL_THRESHOLD",
-            lambda v: validate_threshold("value", v),
-            0.35,
-        ),
-        "character_threshold": (
-            "CHARACTER_THRESHOLD",
-            lambda v: validate_threshold("value", v),
-            0.85,
-        ),
-        "template": ("TEMPLATE", validate_template, DEFAULT_TAG_TEMPLATE),
-        "suggestion_limit": (
-            "SUGGESTION_LIMIT",
-            _valid_suggestion_limit,
-            DEFAULT_SUGGESTION_LIMIT,
-        ),
-    }
-
     @classmethod
     def suggestion_limit(cls) -> int:
         return cls.SUGGESTION_LIMIT
@@ -659,14 +587,7 @@ class AutotagConfig:
 
     @classmethod
     def get_config(cls) -> Dict[str, Any]:
-        """The saved defaults; the template only when it is not the built-in
-        one, so a later built-in template still reaches who never set one."""
-        defaults = {
-            key: getattr(cls, attr) for key, (attr, _v, _d) in cls._KEYS.items()
-        }
-        if defaults["template"] == DEFAULT_TAG_TEMPLATE:
-            del defaults["template"]
-        return {"defaults": defaults}
+        return {"defaults": {"suggestion_limit": cls.SUGGESTION_LIMIT}}
 
     @classmethod
     def update_config(cls, new_config: Any) -> None:
@@ -677,18 +598,17 @@ class AutotagConfig:
         if not isinstance(defaults, dict):
             config_logger.warning("Ignoring autotag.defaults that is not an object")
             return
-        for key, (attr, validate, default) in cls._KEYS.items():
-            if key not in defaults:
-                continue
-            try:
-                setattr(cls, attr, validate(defaults[key]))
-            except ValueError as error:
-                config_logger.warning(
-                    f"autotag.defaults.{key} {error}; using {default!r}"
-                    if key != "template"
-                    else f"autotag.defaults.template {error}; using the built-in one"
-                )
-                setattr(cls, attr, default)
+        if "suggestion_limit" not in defaults:
+            return
+        value = defaults["suggestion_limit"]
+        if cls.valid_suggestion_limit(value):
+            cls.SUGGESTION_LIMIT = value
+            return
+        config_logger.warning(
+            "autotag.defaults.suggestion_limit must be an integer from 1 to "
+            f"{MAX_SUGGESTION_LIMIT}; using {DEFAULT_SUGGESTION_LIMIT}"
+        )
+        cls.SUGGESTION_LIMIT = DEFAULT_SUGGESTION_LIMIT
 
 
 class PromptManagerConfig:

py/tagging_defaults.py

@@ -1,55 +0,0 @@
-"""The tagging configuration's constants and validators (#328).
-
-Server-free on purpose: ``py.api`` must import without ComfyUI's ``server``
-module, which ``py/config.py`` needs; config re-exports all of this.
-"""
-
-import math
-from typing import Any
-
-# The tagging engines (``py/autotag.py`` MODELS) and the options they take.
-WD14_MODEL_TYPES = frozenset({"wd14-swinv2", "wd14-vit"})
-LLM_MODEL_TYPES = frozenset({"gguf", "hf"})
-MODEL_TYPES = WD14_MODEL_TYPES | LLM_MODEL_TYPES
-MAX_INSTRUCTION_CHARS = 4000
-MAX_INSTRUCTION_BYTES = 16 * 1024
-# What a batch does with a prompt that already has tags (#328).
-EXISTING_POLICIES = ("skip", "merge", "replace_after_review")
-
-# The language-model tag template every page starts from until one is saved.
-DEFAULT_TAG_TEMPLATE = (
-    "Generate only comma-separated Danbooru tags (lowercase_underscores, no spaces).\n"
-    "Include: subject_count (1girl/1boy/etc), gender, ethnicity (asian, caucasian, "
-    "etc), age_approx (teen, young_woman), body_attributes, face_features, "
-    "hairstyle, appearance, clothing, accessories, pose, expression, action, "
-    "camera_angle, camera_shot, scene_composition (wide_shot, long_shot, "
-    "dutch_angle), environment, background_elements, lighting, mood.\n"
-    "Prioritize visual accuracy.\n"
-    "No sentences, no commentary, no captions. Only tags. Keep length short but "
-    "descriptive."
-)
-
-
-def validate_threshold(name: str, value: Any) -> float:
-    """A WD14 confidence threshold in [0, 1], or ValueError naming ``name``."""
-    if type(value) not in (int, float) or not math.isfinite(value):
-        raise ValueError(f"{name} must be a finite number")
-    if not 0 <= value <= 1:
-        raise ValueError(f"{name} must be between 0 and 1")
-    return float(value)
-
-
-def validate_template(value: Any, name: str = "instructions") -> str:
-    """Non-empty language-model instructions within the character and byte
-    caps, or ValueError naming ``name``."""
-    if not isinstance(value, str) or not value.strip():
-        raise ValueError(f"{name} must be non-empty text")
-    if len(value) > MAX_INSTRUCTION_CHARS:
-        raise ValueError(f"{name} must be at most {MAX_INSTRUCTION_CHARS} characters")
-    try:
-        encoded = value.encode("utf-8")
-    except UnicodeEncodeError:
-        raise ValueError(f"{name} must be valid Unicode text") from None
-    if len(encoded) > MAX_INSTRUCTION_BYTES:
-        raise ValueError(f"{name} {'are' if name == 'instructions' else 'is'} too long")
-    return value

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/legacy-autotag.spec.mjs

@@ -1,152 +0,0 @@
-// #328: the legacy admin and gallery auto-tag tools keep working beside System › Auto-tagging. The model download is
-// the `model_download` Activity job; the pages' stream attaches to it. No model is ever downloaded: the fixture's
-// fake download waits until the test releases it (`/__test__/tagging/download`).
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-const TITLE = 'Tagging model download · WD14 ViT';
-
-async function post(request, url, data) {
-    await expect(await request.post(url, data === undefined ? {} : { data })).toBeOK();
-}
-
-async function downloads(request) {
-    const response = await request.get('/prompt_manager/jobs');
-    await expect(response).toBeOK();
-    return (await response.json()).jobs.filter(job => job.kind === 'model_download');
-}
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    // The 3.2.0 update notice would cover the admin page's toolbar.
-    await page.addInitScript(() => { localStorage.setItem('pm_update_notice_dismissed', '3.2.0'); });
-    await post(request, '/__test__/jobs/restart');
-    await post(request, '/__test__/tagging/reset');
-    await post(request, '/__test__/tagging/models', { unavailable: ['wd14-vit'] });
-    await post(request, '/__test__/tagging/download', { mode: 'hold' });
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    // Releases a download a failed test left held, and puts the raising default back.
-    await post(request, '/__test__/tagging/reset');
-    await post(request, '/__test__/jobs/restart');
-});
-
-async function startDownload(page, request) {
-    await page.locator('#autoTagBtn').click();
-    const status = page.locator('#wd14VitModelStatus');
-    await status.getByRole('button', { name: 'Download', exact: true }).click();
-    const modal = page.locator('#autoTagDownloadModal');
-    await expect(modal).toBeVisible();
-    await expect(page.locator('#downloadStatus')).toHaveText('Downloading…');
-    await expect(page.locator('#downloadProgressBar')).toHaveClass(/animate-pulse/);
-    await expect(modal).toContainText('The download continues in Activity.');
-    await expect(page.locator('#cancelDownloadBtn')).toHaveText('Close');
-    const running = (await downloads(request)).filter(job => job.state === 'running');
-    expect(running.map(job => [job.title, job.cancellable])).toEqual([[TITLE, false]]);
-    return { modal, status };
-}
-
-test('admin download modal closes on complete and Activity lists the job without Cancel', async ({ page, request }) => {
-    await page.goto('/prompt_manager/admin');
-    const { modal, status } = await startDownload(page, request);
-
-    await page.goto('/prompt_manager/workspace#/activity');
-    const item = page.locator('#workspace-main section.surface > .activity-item')
-        .filter({ has: page.getByRole('link', { name: new RegExp(`${TITLE}$`) }) });
-    await expect(item.locator('.chip')).toHaveText('Running');
-    await expect(item.locator('progress')).not.toHaveAttribute('value');
-    await expect(item.getByRole('button', { name: 'Cancel job', exact: true })).toHaveCount(0);
-
-    // Back on the admin page a second download of the same model attaches to the running job.
-    await page.goto('/prompt_manager/admin');
-    await startDownload(page, request);
-    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
-    await expect(modal).toBeHidden();
-    await expect(status).toContainText('Downloaded');
-    expect((await downloads(request)).map(job => [job.title, job.state])).toEqual([[TITLE, 'finished']]);
-});
-
-test('gallery download modal closes on complete', async ({ page, request }) => {
-    await page.goto('/prompt_manager/gallery');
-    const { modal, status } = await startDownload(page, request);
-    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
-    await expect(modal).toBeHidden();
-    await expect(page.locator('#autoTagModal')).toBeVisible();
-    await expect(status).toContainText('Downloaded');
-    expect((await downloads(request)).map(job => job.state)).toEqual(['finished']);
-});
-
-test('a failed download closes the modal and says so', async ({ page, request }) => {
-    await page.goto('/prompt_manager/gallery');
-    const { modal, status } = await startDownload(page, request);
-    await post(request, '/__test__/tagging/download', { mode: 'fail' });
-    await expect(modal).toBeHidden();
-    await expect(page.getByText('Download failed: Download failed')).toBeVisible();
-    await expect(status.getByRole('button', { name: 'Download', exact: true })).toBeVisible();
-    expect((await downloads(request)).map(job => job.state)).toEqual(['failed']);
-});
-
-// (wd14-vit is not downloaded in these tests: beforeEach marks it so the download tests can offer it.)
-// The gallery's batch reader keyed on `data.status` values the server never sends, so its modal never moved or
-// closed (#328 Problem 5). It now reads `type` frames as the admin page does.
-async function watchProgress(page) {
-    await page.evaluate(() => {
-        window.progressSeen = [];
-        const node = document.getElementById('autoTagProgressPercent');
-        new MutationObserver(() => window.progressSeen.push(node.textContent))
-            .observe(node, { childList: true, characterData: true, subtree: true });
-    });
-}
-
-async function runGalleryBatch(page) {
-    await page.locator('#autoTagBtn').click();
-    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
-    await watchProgress(page);
-    const done = page.waitForResponse(response => response.url().includes('/prompt_manager/autotag/start'));
-    await page.locator('#startAutoTagBtn').click();
-    await done;
-    await expect(page.locator('#autoTagProgressModal')).toBeHidden();
-    await expect(page.getByText(/^Auto tagging complete! Applied tags to \d+ prompts\.$/)).toBeVisible();
-}
-
-test('gallery batch modal counts progress and closes on complete', async ({ page, request }) => {
-    await page.goto('/prompt_manager/gallery');
-    await runGalleryBatch(page);
-    const seen = await page.evaluate(() => window.progressSeen);
-    // The fixture's prompts are already tagged, so the batch skips them; its progress frames still move the bar.
-    expect(seen).toContain('95%');
-    expect((await downloads(request)).length).toBe(0);
-});
-
-test('admin review opens the first image', async ({ page }) => {
-    await page.goto('/prompt_manager/admin');
-    await page.locator('#autoTagBtn').click();
-    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
-    await page.locator('#startReviewBtn').click();
-    // The first image's prompt is already tagged: confirm a new pass, then the review opens on that image.
-    await page.locator('#retagConfirmBtn').click();
-    await expect(page.locator('#autoTagReviewModal')).toBeVisible();
-    await expect(page.locator('#reviewImageName')).not.toHaveText(/^(image_name\.png|Unknown|)$/);
-    await expect(page.getByText('Failed to start review mode')).toHaveCount(0);
-});
-
-test('gallery unload works and is refused while the gate is held', async ({ page, request }) => {
-    await page.goto('/prompt_manager/gallery');
-    await runGalleryBatch(page); // keeps the model in memory
-    await page.locator('#autoTagBtn').click();
-    const unload = page.locator('#unloadModelBtn');
-    await expect(unload).toBeVisible();
-
-    // A held download owns the model gate: Unload is refused with the server's error.
-    const held = await request.post('/prompt_manager/jobs/model-download', { data: { model_type: 'gguf' } });
-    expect(held.status()).toBe(202);
-    await unload.click();
-    await expect(page.getByText(/^Failed to unload model: A tagging model is busy/)).toBeVisible();
-
-    await post(request, '/__test__/tagging/download', { mode: 'succeed' });
-    await expect.poll(async () => (await downloads(request)).map(job => job.state)).toEqual(['finished']);
-    await unload.click();
-    await expect(page.getByText('WD14-SWINV2 model unloaded successfully')).toBeVisible();
-});

tests/browser/server.py

@@ -72,8 +72,6 @@ class TestModel:
     # Scored names the concept comparisons answer instead of the fixed list
     # (``/__test__/tagging/suggestions``); None keeps the fixed list.
     suggestions: list | None = None
-    # The engine's model table (``py/autotag.py`` MODELS), set at startup.
-    models_config: dict = {}
 
     def get_models_status(self) -> dict:
         return {
@@ -81,7 +79,7 @@ class TestModel:
                 "downloaded": name not in self.unavailable,
                 "loaded": self.loaded == name,
             }
-            for name in self.models_config
+            for name in ("gguf", "hf", "wd14-vit", "wd14-convnext", "wd14-swinv2")
         }
 
     def is_model_loaded(self) -> bool:
@@ -209,7 +207,6 @@ def create_app(root: Path) -> web.Application:
     from py import autotag
     from utils.hashing import generate_prompt_hash
 
-    TestModel.models_config = autotag.MODELS
     model = TestModel()
     autotag.get_autotag_service = lambda: model
     api = PromptManagerAPI()

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

@@ -1,385 +0,0 @@
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-import { SIZES, THEMES, seedConcept, openConcept, openProduction, diffInventory, mutate } from './concept-inventory.mjs';
-
-// #328 System S11 Task 8: System › Auto-tagging (app.js renderSystem 685–686) and the Tag output images review against
-// the immutable concept, on the concept-shaped fixture with the fake tagging model (every engine downloaded, none
-// loaded). Each concept measurement is mapped only by the recorded deviations (D132, D133, D134), each commented where
-// it applies; after that the difference must be empty, and a mutated label, option, order, class, select width or
-// token must be noticed. The concept has no batch review, so the Tag output images review is compared with the
-// concept's own record-changing review, `maintenancePlan` (953–958), whose shell, grid, note and actions it shares.
-test.use({ locale: 'en-US', timezoneId: 'UTC' });
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    // The tagging reset restores the fake model (nothing loaded, every engine on disk) and the saved tagging defaults;
-    // the concept fixture then replaces its rows and files.
-    await expect(await request.post('/__test__/tagging/reset', { data: {} })).toBeOK();
-    await seedConcept(request);
-    await expect(await request.post('/__test__/system/reset')).toBeOK();
-    await expect(await request.post('/__test__/jobs/restart')).toBeOK();
-    page.conceptErrors = [];
-    page.on('pageerror', error => page.conceptErrors.push(error.message));
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    await request.post('/__test__/jobs/restart');
-    await request.post('/__test__/system/reset');
-    await request.post('/__test__/tagging/reset', { data: {} });
-    expect(page.conceptErrors).toEqual([]);
-});
-
-const PREVIEW_URL = '/prompt_manager/autotag/batch/preview';
-const MODEL_OPTIONS = ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB'];
-const SUGGESTIONS = 'From 1 to 100: the most suggestions Generate shows for one image.';
-const BATCH = 'Add tags to each prompt from its linked output images with the model above. Review the scope first.';
-
-/** Runs in the page: Auto-tagging's surface under `mainSelector`: rows, field, actions, operation, geometry and tokens. */
-function measureTagging(mainSelector) {
-    const layout = document.querySelector(`${mainSelector} .settings-layout`);
-    const css = (node, ...keys) => node ? Object.fromEntries(keys.map(key => [key, getComputedStyle(node)[key]])) : null;
-    const name = node => [node.localName, ...[...node.classList].sort()].join('.');
-    const text = node => node?.textContent.trim() ?? null;
-    const control = row => {
-        const select = row.querySelector(':scope > select');
-        if (select) return { kind: 'select', id: select.id, options: [...select.options].map(option => [option.textContent, option.disabled]),
-            selected: select.selectedOptions[0]?.textContent ?? null, disabled: select.disabled };
-        const input = row.querySelector(':scope > input');
-        return input ? { kind: `input.${input.type}`, id: input.id, value: input.value, disabled: input.disabled } : null;
-    };
-    const surface = layout.querySelector(':scope > section.surface');
-    const firstRow = surface.querySelector('.setting-row');
-    const field = surface.querySelector(':scope > .field');
-    const actions = surface.querySelector(':scope > .row-actions');
-    return {
-        layout: [...layout.children].map(name),
-        tree: [...surface.children].map(name),
-        heading: text(surface.querySelector(':scope > h2')),
-        intro: text(surface.querySelector(':scope > p')),
-        // Per row: whether it may wrap, and whether its control sits under the text (a wrapped row) or beside it.
-        rows: [...surface.querySelectorAll(':scope > .setting-row')].map(row => ({ tree: [...row.children].map(name),
-            text: [...row.firstElementChild.children].map(node => [name(node), text(node), node.localName === 'label' ? node.htmlFor : null]),
-            control: control(row), flexWrap: getComputedStyle(row).flexWrap,
-            controlBelow: row.lastElementChild.getBoundingClientRect().top >= row.firstElementChild.getBoundingClientRect().bottom - 0.5 })),
-        field: { tree: [...field.children].map(name), label: [text(field.querySelector('label')), field.querySelector('label').htmlFor],
-            textarea: { id: field.querySelector('textarea').id, value: field.querySelector('textarea').value,
-                ...css(field.querySelector('textarea'), 'fontSize', 'minHeight', 'backgroundColor', 'color', 'borderTopColor') },
-            ...css(field, 'display', 'rowGap', 'fontSize', 'marginTop', 'marginBottom') },
-        actions: { buttons: [...actions.children].map(item => [text(item), item.className]),
-            ...css(actions, 'display', 'flexWrap', 'columnGap', 'justifyContent'),
-            primary: css(actions.querySelector('.ca-primary'), 'backgroundColor', 'color', 'fontSize', 'paddingTop', 'paddingLeft'),
-            plain: css(actions.querySelector('button:not(.ca-primary)'), 'backgroundColor', 'color', 'fontSize', 'borderTopColor') },
-        operations: [...surface.querySelectorAll(':scope > .operation')].map(row => ({ tree: [...row.children].map(name),
-            title: text(row.querySelector('h3')), description: text(row.querySelector('p')),
-            actions: [...row.querySelectorAll('.row-actions > button')].map(item => [text(item), item.className]) })),
-        surface: css(surface, 'paddingTop', 'paddingLeft', 'backgroundColor', 'borderTopWidth', 'borderTopColor', 'borderTopLeftRadius'),
-        row: css(firstRow, 'display', 'alignItems', 'justifyContent', 'columnGap', 'paddingTop', 'paddingBottom', 'borderTopWidth',
-            'borderTopColor', 'marginTop'),
-        label: css(firstRow.querySelector('label'), 'fontSize', 'fontWeight', 'color'),
-        description: css(firstRow.querySelector('p'), 'fontSize', 'color', 'marginTop', 'maxWidth'),
-        select: css(firstRow.querySelector('select'), 'fontSize', 'minWidth', 'backgroundColor', 'color', 'borderTopColor'),
-        number: css(surface.querySelector('.setting-row input[type="number"]'), 'fontSize', 'minWidth', 'maxWidth', 'backgroundColor',
-            'color', 'borderTopColor'),
-        // Whether each select is as wide as the browser lays out a copy holding only its chosen option, i.e. it shows
-        // that option whole (the browser's own select sizing, arrow included).
-        selectsFit: [...surface.querySelectorAll('.setting-row > select')].map(select => {
-            const copy = select.cloneNode(false);
-            copy.removeAttribute('id');
-            copy.append(new Option(select.selectedOptions[0]?.textContent ?? ''));
-            // Important inline values: the phone cap is an !important rule (concept.css), which a plain inline style loses to.
-            for (const [key, value] of [['position', 'absolute'], ['visibility', 'hidden'], ['width', 'max-content'], ['min-width', '0'],
-                ['max-width', 'none'], ['flex', 'none']]) copy.style.setProperty(key, value, 'important');
-            select.parentElement.append(copy);
-            const needed = copy.getBoundingClientRect().width;
-            copy.remove();
-            return select.getBoundingClientRect().width + 0.5 >= needed;
-        }),
-        pageScroll: document.documentElement.scrollWidth > document.documentElement.clientWidth,
-    };
-}
-
-/**
- * The concept's Auto-tagging with the recorded deviations applied, for the fixture (all engines on disk, none loaded).
- * `phone` is a viewport at the concept's 700px breakpoint or below.
- */
-function mapTaggingConcept(reference, { template, phone }) {
-    const [model, existing, general, character] = reference.rows;
-    const [preview] = reference.actions.buttons;
-    return {
-        ...reference,
-        // D133 adds a row after the thresholds; D134 adds the operation after the actions.
-        tree: [...reference.tree.slice(0, 6), 'div.setting-row', ...reference.tree.slice(6), 'div.operation'],
-        rows: [
-            // D132 (OQ5, OQ6): the four real engines with their download size, and the chosen one's live status.
-            { ...model, text: [model.text[0], ['p', 'Downloaded. Not loaded.', null]],
-                control: { ...model.control, options: MODEL_OPTIONS.map(label => [label, false]), selected: MODEL_OPTIONS[0] },
-                // D132: at phone width the row wraps, so the engine select sits whole under its text.
-                ...(phone ? { flexWrap: 'wrap', controlBelow: true } : {}) },
-            existing, general, character,
-            // D133: the persisted suggestion count, on the concept's number row.
-            { ...general, text: [['label', 'Suggestions per image', 'tag-suggestions'], ['p', SUGGESTIONS, null]],
-                control: { ...general.control, id: 'tag-suggestions', value: '10' } },
-        ],
-        // The saved template (the server's default until one is saved) replaces the concept's sample text.
-        field: { ...reference.field, textarea: { ...reference.field.textarea, value: template } },
-        // D132: Download (for an engine already on disk, "Download again") and Unload replace the two simulated jobs.
-        actions: { ...reference.actions, buttons: [preview, ['Download again', ''], ['Unload', '']] },
-        // D134: the prompt-tag batch, reviewed first.
-        operations: [{ tree: ['div', 'div.row-actions'], title: 'Tag output images', description: BATCH, actions: [['Review', '']] }],
-        // D132: the engine select shows its whole chosen option at every width (at 390 the concept's 120px cap cuts it;
-        // `#tag-model` alone may grow there). Existing tags keeps the concept's own fit, cut or not.
-        selectsFit: reference.selectsFit.map((fit, index) => (index === 0 ? true : fit)),
-    };
-}
-
-async function conceptTagging(page, theme) {
-    await openConcept(page, 'system', theme);
-    await page.locator('#main .section-nav').getByRole('button', { name: 'Auto-tagging', exact: true }).click();
-    await expect(page.locator('#main #tag-template')).toBeVisible();
-    await page.mouse.move(0, 0);
-    return page.evaluate(measureTagging, '#main');
-}
-
-async function productionTagging(page, theme) {
-    await openProduction(page, 'system/tagging', theme);
-    // Compare once the settings and the model status answered.
-    await expect(page.locator('#workspace-main #tag-model')).toBeEnabled();
-    await expect(page.locator('#workspace-main .setting-row').first().locator('p')).toHaveText('Downloaded. Not loaded.');
-    await page.mouse.move(0, 0);
-    return page.evaluate(measureTagging, '#workspace-main');
-}
-
-async function savedTemplate(request, page) {
-    const response = await request.get('/prompt_manager/settings');
-    await expect(response).toBeOK();
-    return { template: (await response.json()).settings.autotag_template, phone: page.viewportSize().width <= 700 };
-}
-
-for (const theme of THEMES) for (const [width, height] of SIZES) {
-    test(`auto-tagging matches the concept ${theme} ${width}x${height}`, async ({ page, request }, testInfo) => {
-        await page.setViewportSize({ width, height });
-        const concept = await conceptTagging(page, theme);
-        await page.screenshot({ path: testInfo.outputPath(`concept-tagging-${theme}-${width}.png`), fullPage: true });
-        const production = await productionTagging(page, theme);
-        await page.screenshot({ path: testInfo.outputPath(`production-tagging-${theme}-${width}.png`), fullPage: true });
-        expect(diffInventory(mapTaggingConcept(concept, await savedTemplate(request, page)), production)).toEqual([]);
-        expect(production.pageScroll).toBe(false);
-    });
-}
-
-// D132 below the concept's smallest size: on a 320px phone the engine select still shows its whole option.
-for (const theme of THEMES) test(`auto-tagging engine select fits at 320 wide ${theme}`, async ({ page }) => {
-    await page.setViewportSize({ width: 320, height: 700 });
-    const production = await productionTagging(page, theme);
-    for (const model of ['hf', 'gguf', 'wd14-swinv2']) {
-        await page.locator('#workspace-main #tag-model').selectOption(model);
-        expect((await page.evaluate(measureTagging, '#workspace-main')).selectsFit[0], model).toBe(true);
-    }
-    expect(production.pageScroll).toBe(false);
-});
-
-test('auto-tagging comparison detects mutations', async ({ page, request }) => {
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    const concept = await conceptTagging(page, 'dark');
-    const saved = await savedTemplate(request, page);
-    const expected = mapTaggingConcept(concept, saved);
-    const production = await productionTagging(page, 'dark');
-    expect(diffInventory(expected, production)).toEqual([]);
-    // Unmapped, the section differs only where D132, D133 and D134 are recorded (and the saved template's text).
-    expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 3).join('.'))
-        .filter((path, index, all) => all.indexOf(path) === index).sort()).toEqual([
-        'actions.buttons.1', 'actions.buttons.2', 'field.textarea.value', 'operations.0.actions', 'operations.0.description',
-        'operations.0.title', 'operations.0.tree', 'operations.length', 'rows.0.control', 'rows.0.text', 'rows.4.control', 'rows.4.controlBelow',
-        'rows.4.flexWrap', 'rows.4.text', 'rows.4.tree', 'rows.length', 'tree.6', 'tree.7', 'tree.8', 'tree.9', 'tree.length'].sort());
-    const measure = () => page.evaluate(measureTagging, '#workspace-main');
-    const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
-    // A removed row.
-    const undoRow = await mutate(page, { remove: ['#workspace-main section.surface > .setting-row:nth-of-type(2)'] });
-    expect(await paths()).toEqual(expect.arrayContaining(['rows.length', 'tree.length']));
-    await undoRow();
-    // A renamed label.
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="tag-existing"]').textContent = 'Existing'; });
-    expect(await paths()).toEqual(['rows.1.text.0.1']);
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="tag-existing"]').textContent = 'Existing tags'; });
-    // A reordered option.
-    await page.evaluate(() => { const select = document.querySelector('#workspace-main #tag-existing'); select.append(select.options[0]); });
-    expect(await paths()).toEqual(expect.arrayContaining(['rows.1.control.options.0.0']));
-    await page.evaluate(() => { const select = document.querySelector('#workspace-main #tag-existing'); select.prepend(select.options[2]); });
-    // ca-primary moved to another action.
-    await page.evaluate(() => {
-        const [first, second] = document.querySelectorAll('#workspace-main section.surface > .row-actions > button');
-        first.classList.remove('ca-primary');
-        second.classList.add('ca-primary');
-    });
-    expect(await paths()).toEqual(expect.arrayContaining(['actions.buttons.0.1', 'actions.buttons.1.1']));
-    await page.evaluate(() => {
-        const [first, second] = document.querySelectorAll('#workspace-main section.surface > .row-actions > button');
-        second.classList.remove('ca-primary');
-        first.classList.add('ca-primary');
-    });
-    // A select squeezed until its chosen option is cut.
-    const undoSqueeze = await mutate(page, { css: '#workspace-main #tag-model { max-width: 60px !important; min-width: 0 !important; }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['selectsFit.0']));
-    await undoSqueeze();
-    // A row that wraps where the concept's does not.
-    const undoWrap = await mutate(page, { css: '#workspace-main .setting-row:has(> #tag-existing) { flex-wrap: wrap; }' });
-    expect(await paths()).toEqual(['rows.1.flexWrap']);
-    await undoWrap();
-    // A swapped token.
-    const undoToken = await mutate(page, { css: '#workspace-main .settings-layout { --line: rgb(255, 0, 0); }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['row.borderTopColor']));
-    await undoToken();
-    expect(diffInventory(expected, await measure())).toEqual([]);
-});
-
-// D132 at phone width, unmapped: only the engine row wraps; Existing tags keeps the concept's cut select.
-test('auto-tagging at 390 wraps only the engine row', async ({ page, request }) => {
-    await page.setViewportSize({ width: 390, height: 844 });
-    const concept = await conceptTagging(page, 'dark');
-    const production = await productionTagging(page, 'dark');
-    expect(diffInventory(mapTaggingConcept(concept, await savedTemplate(request, page)), production)).toEqual([]);
-    expect(production.rows.map(row => row.flexWrap)).toEqual(['wrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap']);
-    expect(production.selectsFit[1]).toBe(concept.selectsFit[1]);
-});
-
-/** Runs in the page: the open review dialog: its title, body and the concept's tokens. */
-function measureReview() {
-    const dialog = document.querySelector('dialog#modal[open]');
-    const css = (node, ...keys) => node ? Object.fromEntries(keys.map(key => [key, getComputedStyle(node)[key]])) : null;
-    const name = node => [node.localName, ...[...node.classList].sort()].join('.');
-    const text = node => node?.textContent.trim() ?? null;
-    const body = dialog.querySelector('#modal-body');
-    const grid = body.querySelector(':scope > dl.meta-grid');
-    const note = [...body.querySelectorAll(':scope > p.small')].at(-1);
-    const actions = body.querySelector(':scope > .dialog-actions');
-    return {
-        title: text(dialog.querySelector('#modal-title')),
-        tree: [...body.children].map(name),
-        heading: { text: text(body.querySelector(':scope > h3')),
-            ...css(body.querySelector(':scope > h3'), 'fontSize', 'fontWeight', 'color', 'marginBottom') },
-        grid: { rows: [...grid.children].map(row => [text(row.querySelector('dt')), text(row.querySelector('dd'))]),
-            ...css(grid, 'display', 'gridTemplateColumns', 'columnGap', 'rowGap'),
-            dt: css(grid.querySelector('dt'), 'fontSize', 'color', 'textTransform'), dd: css(grid.querySelector('dd'), 'fontSize', 'color') },
-        backup: body.querySelector(':scope > .notice') && { tree: [...body.querySelector(':scope > .notice').children].map(name),
-            text: [...body.querySelectorAll(':scope > .notice > div:first-child > *')].map(node => [node.localName, text(node)]),
-            buttons: [...body.querySelectorAll(':scope > .notice button')].map(text) },
-        note: { text: text(note), ...css(note, 'fontSize', 'color', 'marginTop') },
-        actions: { tree: [...actions.children].map(name), ...css(actions, 'display', 'justifyContent', 'columnGap', 'marginTop'),
-            buttons: [...actions.children].map(item => ({ text: text(item), className: item.className,
-                ...css(item, 'backgroundColor', 'color', 'fontSize', 'paddingTop', 'paddingLeft', 'borderTopColor') })) },
-    };
-}
-
-const number = value => value.toLocaleString('en-US');
-
-/**
- * D134: the server's batch preview in the concept's review: "Review tag output images" with "Tag output images" as its
- * `h3`, the model, policy, counts and settings in the concept's `dl.meta-grid` (Backup in the concept's wording), the
- * upper-bound sentence in the concept's `p.small`, the D55 backup box and Cancel / "Start tagging".
- */
-function mapBatchConcept(reference, plan) {
-    const [cancel, start] = reference.actions.buttons;
-    return {
-        ...reference,
-        title: 'Review tag output images',
-        tree: ['h3', 'dl.meta-grid', 'p.small', 'div.notice', 'div.dialog-actions'],
-        heading: { ...reference.heading, text: 'Tag output images' },
-        grid: { ...reference.grid, rows: [['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Merge with existing'],
-            ['Images linked', number(plan.images)], ['Prompts', number(plan.prompts)], ['Already tagged', number(plan.already_tagged)],
-            ['Prompts to tag', `up to ${number(plan.to_tag)}`], ['Settings', 'General 0.35 · Character 0.85'],
-            ['Backup', 'Create and verify before changes']] },
-        backup: { tree: ['div', 'div.row-actions'], text: [['h3', 'Back up the database first (recommended)'],
-            ['p', 'Downloads a copy of the prompts database before this operation changes any records.']], buttons: ['Back up now'] },
-        note: { ...reference.note, text: 'Nothing is written until you start. Missing files and files outside the output folders '
-            + 'are counted, so the prompts to tag are an upper bound; Activity reports what was tagged.' },
-        actions: { ...reference.actions, buttons: [cancel, { ...start, text: 'Start tagging' }] },
-    };
-}
-
-async function conceptReview(page, theme) {
-    await openConcept(page, 'system', theme);
-    await page.locator('#main .section-nav').getByRole('button', { name: 'Maintenance', exact: true }).click();
-    await page.locator('#main [data-plan="duplicate prompts"]').click();
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Review maintenance plan');
-    await page.mouse.move(0, 0);
-    return page.evaluate(measureReview);
-}
-
-async function productionReview(page, theme) {
-    await productionTagging(page, theme);
-    // Every concept-fixture prompt with an image is already tagged, so under the saved Skip there is nothing to start
-    // (the Cancel-only review). Merge reviews a batch with work: the full review the concept's shell is compared with.
-    await page.locator('#workspace-main #tag-existing').selectOption('merge');
-    const answer = page.waitForResponse(response => response.url().endsWith(PREVIEW_URL));
-    await page.locator('#workspace-main .operation').getByRole('button', { name: 'Review', exact: true }).click();
-    const plan = await (await answer).json();
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Review tag output images');
-    await page.mouse.move(0, 0);
-    return { plan, production: await page.evaluate(measureReview) };
-}
-
-for (const theme of THEMES) for (const [width, height] of SIZES) {
-    test(`tag output images review matches the concept ${theme} ${width}x${height}`, async ({ page }, testInfo) => {
-        await page.setViewportSize({ width, height });
-        const concept = await conceptReview(page, theme);
-        expect(concept.tree).toEqual(['p.demo-note', 'h3', 'dl.meta-grid', 'p.small', 'div.dialog-actions']);
-        await page.screenshot({ path: testInfo.outputPath(`concept-plan-review-${theme}-${width}.png`) });
-        const { plan, production } = await productionReview(page, theme);
-        // Under Merge every prompt with a linked image is tagged again: the batch has work to review.
-        expect(plan.to_tag).toBeGreaterThan(0);
-        await page.screenshot({ path: testInfo.outputPath(`production-tagging-review-${theme}-${width}.png`) });
-        expect(diffInventory(mapBatchConcept(concept, plan), production)).toEqual([]);
-    });
-}
-
-/**
- * D134 (CUJ 5): Replace after review never runs as a batch: the same review shell with the counts, the reason as its
- * `p.small`, no backup box and only Cancel (the shared close-only review Integrations also uses).
- */
-function mapCancelOnlyConcept(reference, plan) {
-    const [cancel] = reference.actions.buttons;
-    const mapped = mapBatchConcept(reference, plan);
-    return {
-        ...mapped,
-        tree: ['h3', 'dl.meta-grid', 'p.small', 'div.dialog-actions'],
-        grid: { ...mapped.grid, rows: mapped.grid.rows.map(([term, value]) => [term, term === 'Existing tags' ? 'Replace after review' : value]) },
-        backup: null,
-        note: { ...reference.note, text: 'Replacing tags needs a review of each image. Use Preview tagging review, or choose Skip or '
-            + 'Merge for a batch run.' },
-        actions: { ...reference.actions, tree: [reference.actions.tree[0]], buttons: [cancel] },
-    };
-}
-
-test('the Cancel-only review matches the concept review shell', async ({ page }) => {
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    const concept = await conceptReview(page, 'dark');
-    await productionTagging(page, 'dark');
-    await page.locator('#workspace-main #tag-existing').selectOption('replace_after_review');
-    const answer = page.waitForResponse(response => response.url().endsWith(PREVIEW_URL));
-    await page.locator('#workspace-main .operation').getByRole('button', { name: 'Review', exact: true }).click();
-    const plan = await (await answer).json();
-    expect(plan.review_required).toBe(true);
-    await expect(page.locator('dialog#modal[open] #modal-title')).toHaveText('Review tag output images');
-    await page.mouse.move(0, 0);
-    expect(diffInventory(mapCancelOnlyConcept(concept, plan), await page.evaluate(measureReview))).toEqual([]);
-});
-
-test('tag output images review comparison detects mutations', async ({ page }) => {
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    const concept = await conceptReview(page, 'dark');
-    const { plan } = await productionReview(page, 'dark');
-    const expected = mapBatchConcept(concept, plan);
-    const paths = async () => diffInventory(expected, await page.evaluate(measureReview)).map(item => item.path);
-    expect(await paths()).toEqual([]);
-    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[5].textContent = 'To tag'; });
-    expect(await paths()).toEqual(['grid.rows.5.0']);
-    await page.evaluate(() => { document.querySelectorAll('dialog#modal[open] dl.meta-grid dt')[5].textContent = 'Prompts to tag'; });
-    const undoGrid = await mutate(page, { css: 'dialog#modal dl.meta-grid { column-gap: 3px; }' });
-    expect(await paths()).toEqual(expect.arrayContaining(['grid.columnGap']));
-    await undoGrid();
-    const undoBox = await mutate(page, { remove: ['dialog#modal[open] #modal-body > .notice'] });
-    expect(await paths()).toEqual(expect.arrayContaining(['backup', 'tree.length']));
-    await undoBox();
-    expect(await paths()).toEqual([]);
-});

tests/browser/tagging-concept.spec.mjs

@@ -236,7 +236,7 @@ test('paired Tag dialog captures', async ({ page, request }, testInfo) => {
     await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-swinv2'] } })).toBeOK();
     await openTagDialog(page, 'production', 'dark');
     await generateWith(page, 'production').catch(() => {});
-    await expect(status()).toHaveText('WD14 SwinV2 is not downloaded. Download it in System › Auto-tagging.');
+    await expect(status()).toHaveText('WD14 SwinV2 is not downloaded. Download it from the legacy Auto-tag page.');
     await shot('production-unavailable');
     await expect(await request.post('/__test__/tagging/models', { data: { unavailable: [] } })).toBeOK();
 

tests/browser/workspace-activity.spec.mjs

@@ -1088,36 +1088,6 @@ test('a held legacy job and the health check show no tiles, no Results and no ma
     await expect(toast(page)).toHaveText('Health check finished.');
 });
 
-// #328: a tagging model download is a job of its own kind with no byte progress and no Cancel; Activity shows it
-// through the generic held view (its title, status line and an indeterminate bar), then its end toast.
-test('a held model download shows its title, an indeterminate bar and no Cancel; its end toast follows', async ({ page, request }) => {
-    await page.setViewportSize({ width: 1600, height: 1100 });
-    const title = 'Tagging model download · WD14 ViT';
-    await expect(await request.post('/__test__/tagging/reset')).toBeOK();
-    await expect(await request.post('/__test__/tagging/download', { data: { mode: 'hold' } })).toBeOK();
-    try {
-        const response = await request.post('/prompt_manager/jobs/model-download', { data: { model_type: 'wd14-vit' } });
-        expect(response.status()).toBe(202);
-        const job = (await response.json()).job;
-        expect([job.kind, job.title, job.cancellable]).toEqual(['model_download', title, false]);
-        await page.goto(`${workspace}#/activity`);
-        const item = items(page).filter({ has: page.getByRole('link', { name: new RegExp(`${title}$`) }) });
-        await expect(item.locator('progress')).not.toHaveAttribute('value');
-        await expect(item.getByRole('button', { name: 'Cancel job', exact: true })).toHaveCount(0);
-        await item.getByRole('link').click();
-        await expect(heading(page).locator('h1')).toHaveText(title);
-        await expect(progressSection(page).locator('.panel-heading > span.small')).toHaveText('Downloading WD14 ViT (~400 MB)');
-        await expect(progressSection(page).locator('progress')).not.toHaveAttribute('value');
-        await expect(progressSection(page).locator('dl.stat-row')).toHaveCount(0);
-        await expect(heading(page).getByRole('button', { name: /^Cancel/ })).toHaveCount(0);
-        await expect(await request.post('/__test__/tagging/download', { data: { mode: 'succeed' } })).toBeOK();
-        await expect(toast(page)).toHaveText(`${title} finished.`);
-        await expect(heading(page).locator('p.muted')).toHaveText(/^Finished \d\d:\d\d$/);
-    } finally {
-        await request.post('/__test__/tagging/reset');
-    }
-});
-
 // S5 review I3: a thumbnail job with nothing to generate ends on the server's final line ("No previews to generate · N
 // already up to date"), never on a stale "Processing file 0 of 0" under the Completed chip.
 test('a finished thumbnail job with nothing to do says so', async ({ page, request }) => {

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

@@ -1,356 +0,0 @@
-import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
-import { test, expect } from './fixtures.mjs';
-
-// System › Auto-tagging (#328, System S11 Tasks 6–7) on the tagging fixture (workspace_tagging_fixture.py) with the
-// injected fake model: no model file exists and nothing is downloaded or run for real. The fake download waits on the
-// fixture (`/__test__/tagging/download {mode}`), and every reset releases it. Every test asserts that no legacy
-// download stream (`/autotag/download/`) was requested: the section downloads only through the Activity job.
-const workspace = '/prompt_manager/workspace';
-const MODELS_URL = '/prompt_manager/autotag/models';
-const PREVIEW_URL = '/prompt_manager/autotag/batch/preview';
-const SETTINGS_URL = '/prompt_manager/settings';
-const MODEL_LABELS = ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB'];
-const FIRST = 'tagging/dunes_00001.png';
-const SECOND = 'tagging/dunes_00002.png';
-
-test.beforeEach(async ({ page, request, browserName }) => {
-    await startCoverage(page, browserName);
-    await expect(await request.post('/__test__/tagging/reset', { data: {} })).toBeOK();
-    await expect(await request.post('/__test__/system/reset')).toBeOK();
-    await expect(await request.post('/__test__/jobs/restart')).toBeOK();
-    page.systemErrors = [];
-    page.on('pageerror', error => page.systemErrors.push(error.message));
-    page.downloads = [];
-    page.modelCalls = [];
-    page.on('request', item => {
-        const { pathname } = new URL(item.url());
-        if (pathname.includes('/autotag/download/')) page.downloads.push(pathname);
-        if (pathname.startsWith('/prompt_manager/autotag/') || pathname.startsWith('/prompt_manager/image-annotations/suggest')
-            || pathname.startsWith('/prompt_manager/jobs/model-download')) page.modelCalls.push(`${item.method()} ${pathname}`);
-    });
-});
-
-test.afterEach(async ({ page, request, browserName }) => {
-    await saveCoverage(page, browserName);
-    // The reset releases a held fake download, so no runner outlives the test.
-    await request.post('/__test__/tagging/reset', { data: {} });
-    await request.post('/__test__/jobs/restart');
-    await request.post('/__test__/system/reset');
-    expect(page.systemErrors).toEqual([]);
-    expect(page.downloads).toEqual([]);
-});
-
-const toast = page => page.locator('#workspace-toast');
-const layoutOf = page => page.locator('#workspace-main .settings-layout');
-const dialog = page => page.locator('dialog#modal[open]');
-const status = page => page.locator('#settings-status');
-const save = page => page.getByRole('button', { name: 'Save preferences', exact: true });
-const surface = page => layoutOf(page).locator(':scope > section.surface');
-const settingOf = (page, label) => layoutOf(page).locator('.setting-row').filter({ has: page.locator(`label:text-is("${label}")`) });
-const modelRow = page => settingOf(page, 'Tagging model');
-const actionOf = (page, name) => surface(page).locator(':scope > .row-actions').getByRole('button', { name, exact: true });
-const reviewButton = page => surface(page).locator('.operation').getByRole('button', { name: 'Review', exact: true });
-const card = (page, path) => page.locator(`article[data-image-key="0:${path}"]`);
-const tagDialog = page => page.getByRole('dialog', { name: 'Tag image', exact: true });
-const gridOf = page => dialog(page).locator('dl.meta-grid > div').evaluateAll(items => items.map(item =>
-    [item.querySelector('dt').textContent, item.querySelector('dd').textContent]));
-
-async function serverJson(request, url) {
-    const response = await request.get(url);
-    await expect(response).toBeOK();
-    return response.json();
-}
-
-async function fakeDownload(request, mode) {
-    await expect(await request.post('/__test__/tagging/download', { data: { mode } })).toBeOK();
-}
-
-async function unavailable(request, models) {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: models } })).toBeOK();
-}
-
-async function ended(request, id) {
-    await expect.poll(async () => (await serverJson(request, `/prompt_manager/jobs/${id}`)).job.state).not.toBe('running');
-    return (await serverJson(request, `/prompt_manager/jobs/${id}`)).job;
-}
-
-/** System › Auto-tagging on a fresh page (the drafts live for the page session, Q10), settled on the model status. */
-async function openTagging(page) {
-    if (page.url().endsWith('#/system/tagging')) await page.reload();
-    else await page.goto(`${workspace}#/system/tagging`);
-    await expect(surface(page)).toHaveCount(1);
-    await expect(page.locator('#tag-model')).toBeEnabled();
-    await expect(modelRow(page).locator('p').first()).not.toHaveText('Loading model status…');
-}
-
-/** Select `path` in Images (the concept's `state.selectedImage`), then open System › Auto-tagging from the sidebar. */
-async function selectThenOpen(page, path) {
-    await page.goto(`${workspace}#/images`);
-    await card(page, path).getByRole('button', { name: `Inspect ${path.split('/').pop()}`, exact: true }).click();
-    await expect(card(page, path)).toHaveClass(/\bselected\b/);
-    await page.locator('aside.sidebar a[href="#/system"]').click();
-    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Auto-tagging', exact: true }).click();
-    await expect(page.locator('#tag-model')).toBeEnabled();
-    await expect(modelRow(page).locator('p').first()).not.toHaveText('Loading model status…');
-}
-
-test('model options are the four real engines with size and the description shows live status', async ({ page, request }) => {
-    await unavailable(request, ['wd14-vit', 'hf']);
-    await openTagging(page);
-    expect(await surface(page).locator(':scope > h2').textContent()).toBe('Auto-tagging');
-    expect(await page.locator('#tag-model option').allTextContents()).toEqual(MODEL_LABELS);
-    await expect(page.locator('#tag-model')).toHaveValue('wd14-swinv2');
-    const line = modelRow(page).locator('p').first();
-    await expect(line).toHaveText('Downloaded. Not loaded.');
-    await expect(actionOf(page, 'Download again')).toBeVisible();
-    // Choosing another engine drafts it and tells its own status; nothing is downloaded or loaded.
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    await expect(line).toHaveText('Not downloaded. Download size ~400 MB.');
-    await expect(actionOf(page, 'Download')).toBeVisible();
-    await page.locator('#tag-model').selectOption('hf');
-    await expect(line).toHaveText('Not downloaded. Download size ~16 GB.');
-    await expect(status(page)).toHaveText('Unsaved changes.');
-    // The other rows keep the concept's copy and the saved values (D133 adds Suggestions per image).
-    expect(await surface(page).locator(':scope > .setting-row label').allTextContents()).toEqual(['Tagging model', 'Existing tags',
-        'General-tag confidence', 'Character-tag confidence', 'Suggestions per image']);
-    await expect(page.locator('#tag-existing')).toHaveValue('skip');
-    await expect(page.locator('#threshold-general')).toHaveValue('0.35');
-    await expect(page.locator('#threshold-character')).toHaveValue('0.85');
-    await expect(page.locator('#tag-suggestions')).toHaveValue('10');
-    const settings = await serverJson(request, SETTINGS_URL);
-    await expect(page.locator('#tag-template')).toHaveValue(settings.settings.autotag_template);
-    // Unload is offered only while a model is loaded (none is).
-    await expect(actionOf(page, 'Unload')).toBeDisabled();
-});
-
-test('entering the section makes no model call besides status', async ({ page }) => {
-    await openTagging(page);
-    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Integrations', exact: true }).click();
-    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Auto-tagging', exact: true }).click();
-    await expect(page.locator('#tag-model')).toBeEnabled();
-    await expect(modelRow(page).locator('p').first()).toHaveText('Downloaded. Not loaded.');
-    // One status read per mount (two mounts), and nothing else that could load, run or download a model.
-    expect(page.modelCalls).toEqual([`GET ${MODELS_URL}`, `GET ${MODELS_URL}`]);
-    const models = await (await page.request.get(MODELS_URL)).json();
-    expect(models.model_loaded).toBe(false);
-});
-
-test('defaults save through Save preferences and the Tag image dialog uses them', async ({ page, request }) => {
-    await openTagging(page);
-    await page.locator('#tag-existing').selectOption('merge');
-    await page.locator('#threshold-general').fill('0.4');
-    await page.locator('#threshold-general').press('Tab');
-    await page.locator('#tag-suggestions').fill('15');
-    await page.locator('#tag-suggestions').press('Tab');
-    const posted = page.waitForRequest(item => item.method() === 'POST' && new URL(item.url()).pathname === SETTINGS_URL);
-    await save(page).click();
-    const body = (await posted).postDataJSON();
-    expect(body).toMatchObject({ autotag_existing: 'merge', autotag_general_threshold: 0.4, autotag_suggestion_limit: 15 });
-    expect(typeof body.expected_revision).toBe('string');
-    await expect(status(page)).toHaveText('Saved to the server configuration.');
-    const saved = (await serverJson(request, SETTINGS_URL)).settings;
-    expect([saved.autotag_existing, saved.autotag_general_threshold, saved.autotag_character_threshold, saved.autotag_suggestion_limit])
-        .toEqual(['merge', 0.4, 0.85, 15]);
-    const models = await serverJson(request, MODELS_URL);
-    expect([models.existing, models.wd14_general_threshold, models.suggestion_limit]).toEqual(['merge', 0.4, 15]);
-    // The Tag image dialog in a fresh page starts from them.
-    await page.goto(`${workspace}#/images`);
-    await card(page, FIRST).getByRole('button', { name: `Tag or auto-tag ${FIRST.split('/').pop()}`, exact: true }).click();
-    await expect(tagDialog(page)).toBeVisible();
-    await expect(tagDialog(page).locator('#image-general-threshold')).toHaveValue('0.4');
-    await expect(tagDialog(page).locator('#image-character-threshold')).toHaveValue('0.85');
-    await expect(tagDialog(page).locator('#image-suggestion-limit')).toHaveValue('15');
-});
-
-test('a refused value shows the server\'s message', async ({ page, request }) => {
-    const before = (await serverJson(request, SETTINGS_URL)).settings;
-    // An image is selected, so Preview tagging review is held back only by the invalid value below.
-    await selectThenOpen(page, FIRST);
-    await page.locator('#threshold-general').fill('1.5');
-    await page.locator('#threshold-general').press('Tab');
-    await save(page).click();
-    await expect(status(page)).toHaveText('General-tag confidence must be between 0 and 1.');
-    await expect(page.locator('#threshold-general')).toHaveAttribute('aria-invalid', 'true');
-    // Nothing was written; the draft is kept for the next Save.
-    expect((await serverJson(request, SETTINGS_URL)).settings.autotag_general_threshold).toBe(before.autotag_general_threshold);
-    await expect(page.locator('#threshold-general')).toHaveValue('1.5');
-    // While the value is invalid, Preview tagging review is aria-disabled and explains instead of opening (Playwright
-    // waits on an aria-disabled control, so it is pressed from the keyboard, as a user can).
-    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('General-tag confidence must be between 0 and 1.');
-    await expect(tagDialog(page)).toHaveCount(0);
-    await page.locator('#threshold-general').fill('0.5');
-    await page.locator('#threshold-general').press('Tab');
-    await expect(page.locator('#threshold-general')).not.toHaveAttribute('aria-invalid', 'true');
-    await expect(status(page)).toHaveText('Unsaved changes.');
-    await expect(actionOf(page, 'Preview tagging review')).not.toHaveAttribute('aria-disabled', 'true');
-});
-
-test('Download starts the job and Activity shows it without Cancel', async ({ page, request }) => {
-    await unavailable(request, ['wd14-vit']);
-    await fakeDownload(request, 'hold');
-    await openTagging(page);
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    const started = page.waitForResponse(item => new URL(item.url()).pathname === '/prompt_manager/jobs/model-download');
-    await actionOf(page, 'Download').click();
-    const answer = await started;
-    expect(answer.status()).toBe(202);
-    expect(answer.request().postDataJSON()).toEqual({ model_type: 'wd14-vit' });
-    const { job } = await answer.json();
-    expect(job.title).toBe('Tagging model download · WD14 ViT');
-    await expect(toast(page)).toHaveText('Tagging model download · WD14 ViT started.');
-    await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    const main = page.locator('#workspace-main');
-    await expect(main.locator('h1')).toHaveText('Tagging model download · WD14 ViT');
-    await expect(main.getByRole('button', { name: /^Cancel/ })).toHaveCount(0);
-    // Indeterminate: the server knows no byte progress.
-    await expect(main.locator('progress').first()).toBeVisible();
-    expect(await main.locator('progress').first().evaluate(node => node.hasAttribute('value'))).toBe(false);
-    await fakeDownload(request, 'succeed');
-    expect((await ended(request, job.id)).state).toBe('finished');
-    await expect(toast(page)).toHaveText('Tagging model download · WD14 ViT finished.');
-    // Back in the section, the engine reads as on disk (the fake marks it downloaded on success).
-    await page.goto(`${workspace}#/system/tagging`);
-    await expect(page.locator('#tag-model')).toBeEnabled();
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    await expect(modelRow(page).locator('p').first()).toHaveText('Downloaded. Not loaded.');
-    expect(page.modelCalls.filter(call => call.startsWith('POST'))).toEqual(['POST /prompt_manager/jobs/model-download']);
-});
-
-test('Unload is enabled only while a model is loaded, and a held gate\'s refusal names the operation', async ({ page, request }) => {
-    await openTagging(page);
-    await expect(actionOf(page, 'Unload')).toBeDisabled();
-    // Load WD14 SwinV2 the way a user does: Generate suggestions in the Tag image dialog.
-    await page.goto(`${workspace}#/images`);
-    await card(page, FIRST).getByRole('button', { name: `Tag or auto-tag ${FIRST.split('/').pop()}`, exact: true }).click();
-    await expect(tagDialog(page)).toBeVisible();
-    const suggested = page.waitForResponse(item => item.url().endsWith('/image-annotations/suggest'));
-    await tagDialog(page).getByRole('button', { name: 'Generate suggestions', exact: true }).click();
-    expect((await suggested).status()).toBe(200);
-    await tagDialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await openTagging(page);
-    await expect(modelRow(page).locator('p').first()).toHaveText('Downloaded and loaded.');
-    await expect(actionOf(page, 'Unload')).toBeEnabled();
-    // A download holds the model gate: Unload is refused and the toast names it; nothing is unloaded.
-    await unavailable(request, ['wd14-vit']);
-    await fakeDownload(request, 'hold');
-    const held = await request.post('/prompt_manager/jobs/model-download', { data: { model_type: 'wd14-vit' } });
-    expect(held.status()).toBe(202);
-    const { job } = await held.json();
-    const refused = page.waitForResponse(item => item.url().endsWith('/autotag/unload'));
-    await actionOf(page, 'Unload').click();
-    const refusal = await refused;
-    expect(refusal.status()).toBe(409);
-    expect(await refusal.json()).toMatchObject({ code: 'model-busy', operation: 'Tagging model download · WD14 ViT' });
-    await expect(toast(page)).toHaveText('The tagging model is busy: Tagging model download · WD14 ViT. Try again when it finishes.');
-    expect((await serverJson(request, MODELS_URL)).loaded_model_type).toBe('wd14-swinv2');
-    await expect(actionOf(page, 'Unload')).toBeEnabled();
-    // Once the download ended, Unload works, says so and the row follows.
-    await fakeDownload(request, 'succeed');
-    await ended(request, job.id);
-    await actionOf(page, 'Unload').click();
-    await expect(toast(page)).toHaveText('WD14 SwinV2 unloaded.');
-    await expect(modelRow(page).locator('p').first()).toHaveText('Downloaded. Not loaded.');
-    await expect(actionOf(page, 'Unload')).toBeDisabled();
-});
-
-test('Preview tagging review opens the Tag image dialog for the selected image', async ({ page }) => {
-    await selectThenOpen(page, SECOND);
-    // The section's current (unsaved) values are what the dialog starts from.
-    await page.locator('#threshold-character').fill('0.6');
-    await page.locator('#threshold-character').press('Tab');
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    const preview = actionOf(page, 'Preview tagging review');
-    await expect(preview).toHaveClass(/ca-primary/);
-    await expect(preview).not.toHaveAttribute('aria-disabled', 'true');
-    const observed = page.waitForResponse(item => item.url().endsWith('/image-annotations/observe'));
-    await preview.click();
-    expect((await observed).status()).toBe(200);
-    await expect(tagDialog(page)).toBeVisible();
-    await expect(tagDialog(page).locator('.tag-image-heading p.small')).toHaveText('dunes_00002.png');
-    await expect(tagDialog(page).getByRole('combobox', { name: 'Tagging model', exact: true })).toHaveValue('wd14-vit');
-    await expect(tagDialog(page).locator('#image-character-threshold')).toHaveValue('0.6');
-    await expect(tagDialog(page).locator('#image-general-threshold')).toHaveValue('0.35');
-});
-
-test('Preview tagging review without a selection toasts the D115 sentence', async ({ page }) => {
-    await openTagging(page);
-    const preview = actionOf(page, 'Preview tagging review');
-    await expect(preview).toHaveAttribute('aria-disabled', 'true');
-    // An aria-disabled control still takes a press; it only explains.
-    await preview.focus();
-    await page.keyboard.press('Enter');
-    await expect(toast(page)).toHaveText('Select an image in Images first.');
-    await expect(tagDialog(page)).toHaveCount(0);
-});
-
-test('Tag output images reviews the scope and starts a batch job', async ({ page, request }) => {
-    const before = await serverJson(request, '/__test__/tagging/snapshot');
-    await openTagging(page);
-    // The fixture's one prompt is already tagged: under Merge it is tagged again with what its images give.
-    await page.locator('#tag-existing').selectOption('merge');
-    const previewed = page.waitForResponse(item => new URL(item.url()).pathname === PREVIEW_URL);
-    await reviewButton(page).click();
-    const answer = await previewed;
-    expect(answer.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'merge' });
-    const plan = await answer.json();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Review tag output images');
-    await expect(dialog(page).locator('#modal-body > h3')).toHaveText('Tag output images');
-    expect(await gridOf(page)).toEqual([['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Merge with existing'],
-        ['Images linked', String(plan.images)], ['Prompts', String(plan.prompts)], ['Already tagged', String(plan.already_tagged)],
-        ['Prompts to tag', `up to ${plan.to_tag}`], ['Settings', 'General 0.35 · Character 0.85'],
-        ['Backup', 'Create and verify before changes']]);
-    await expect(dialog(page).locator('#modal-body > .notice h3')).toHaveText('Back up the database first (recommended)');
-    // The review wrote nothing.
-    expect(await serverJson(request, '/__test__/tagging/snapshot')).toEqual(before);
-    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel', 'Start tagging']);
-    const started = page.waitForResponse(item => new URL(item.url()).pathname === '/prompt_manager/jobs/autotag');
-    await dialog(page).getByRole('button', { name: 'Start tagging', exact: true }).click();
-    const start = await started;
-    expect(start.request().postDataJSON()).toEqual({ model_type: 'wd14-swinv2', existing: 'merge',
-        options: { general_threshold: 0.35, character_threshold: 0.85 } });
-    const { job } = await start.json();
-    await expect(page).toHaveURL(`${workspace}#/activity/${job.id}`);
-    await expect(page.locator('#workspace-main h1')).toHaveText('Tag output images');
-    const finished = await ended(request, job.id);
-    expect(finished.state).toBe('finished');
-    const after = await serverJson(request, '/__test__/tagging/snapshot');
-    expect(after.prompt_tags.length).toBeGreaterThan(before.prompt_tags.length);
-});
-
-test('Replace after review shows only Cancel with the reason', async ({ page, request }) => {
-    const before = await serverJson(request, '/__test__/tagging/snapshot');
-    await openTagging(page);
-    await page.locator('#tag-existing').selectOption('replace_after_review');
-    await reviewButton(page).click();
-    await expect(dialog(page).locator('#modal-title')).toHaveText('Review tag output images');
-    expect((await gridOf(page)).map(([term]) => term)).toEqual(['Model', 'Existing tags', 'Images linked', 'Prompts', 'Already tagged',
-        'Prompts to tag', 'Settings', 'Backup']);
-    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Replacing tags needs a review of each image. '
-        + 'Use Preview tagging review, or choose Skip or Merge for a batch run.');
-    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel']);
-    await dialog(page).getByRole('button', { name: 'Cancel', exact: true }).click();
-    await expect(dialog(page)).toHaveCount(0);
-    // Under Skip the fixture's only prompt is already tagged: nothing to start either.
-    await page.locator('#tag-existing').selectOption('skip');
-    await reviewButton(page).click();
-    await expect(dialog(page).locator('#modal-body > p.small')).toHaveText('Every prompt with an output image is already tagged.');
-    await expect(dialog(page).locator('.dialog-actions button')).toHaveText(['Cancel']);
-    expect(await serverJson(request, '/__test__/tagging/snapshot')).toEqual(before);
-    expect((await serverJson(request, '/prompt_manager/jobs')).jobs.filter(item => item.kind === 'autotag')).toEqual([]);
-});
-
-test('a model that is not downloaded cannot be reviewed for a batch; the button says why', async ({ page, request }) => {
-    await unavailable(request, ['gguf']);
-    await openTagging(page);
-    await page.locator('#tag-model').selectOption('gguf');
-    await expect(reviewButton(page)).toHaveAttribute('aria-disabled', 'true');
-    // Playwright waits on an aria-disabled control: press it from the keyboard, as a user can.
-    await reviewButton(page).focus();
-    await page.keyboard.press('Enter');
-    await expect(toast(page)).toHaveText('GGUF JoyCaption is not downloaded. Download it first.');
-    await expect(dialog(page)).toHaveCount(0);
-    expect(page.modelCalls.filter(call => call.includes('/batch/preview'))).toEqual([]);
-});

tests/browser/workspace-system.spec.mjs

@@ -412,11 +412,11 @@ test('out-of-order overview responses never repaint a newer section', async ({ p
     await nav.getByRole('button', { name: 'Appearance', exact: true }).click();
     await nav.getByRole('button', { name: 'Overview', exact: true }).click();
     await expect.poll(held).toBe(2);
-    // Diagnostics still hands off (S12), so its body is one known panel.
-    await nav.getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
+    // Auto-tagging still hands off (S11), so its body is one known panel.
+    await nav.getByRole('button', { name: 'Auto-tagging', exact: true }).click();
     await expect(await request.post('/__test__/release')).toBeOK();
     await expect.poll(held).toBe(0);
-    // Both late answers reached a section that had left: Diagnostics keeps its own body.
+    // Both late answers reached a section that had left: Auto-tagging keeps its own body.
     await expect(layout.locator(':scope > section.handoff')).toBeVisible();
     await page.evaluate(() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve))));
     await expect(layout.locator('.summary-metrics')).toHaveCount(0);

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

@@ -17,7 +17,7 @@ const chips = page => modal(page).locator('#tag-suggestions .chip.tag-suggestion
 const actionButtons = page => modal(page).locator('.dialog-actions button');
 const panel = page => page.getByRole('complementary', { name: 'Selected image details', exact: true });
 const tagRow = page => panel(page).locator('.detail-inner > .tags').last();
-const NOT_DOWNLOADED = 'WD14 SwinV2 is not downloaded. Download it in System › Auto-tagging.';
+const NOT_DOWNLOADED = 'WD14 SwinV2 is not downloaded. Download it from the legacy Auto-tag page.';
 
 test.beforeEach(async ({ page, request, browserName }) => {
     await startCoverage(page, browserName);

tests/browser/workspace-tagging.spec.mjs

@@ -246,7 +246,7 @@ test('unavailable model shows inline status and never downloads', async ({ page,
     await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-swinv2'] } })).toBeOK();
     await openTag(page);
     expect((await generated(page)).status()).toBe(409);
-    await expect(status(page)).toHaveText('WD14 SwinV2 is not downloaded. Download it in System › Auto-tagging.');
+    await expect(status(page)).toHaveText('WD14 SwinV2 is not downloaded. Download it from the legacy Auto-tag page.');
     await expect(chips(page)).toHaveCount(0);
     await expect(dialog(page).locator('#suggestion-count')).toHaveText('Not generated');
     // D116: Retry leads the actions while the controller allows it, and generates again.

tests/browser/workspace.spec.mjs

@@ -413,7 +413,7 @@ for (const width of [1600, 390]) test(`overview and handoff render with concept
 
     await sidebarLink(page, 'System').click();
     // System's Overview is native (S2 Task 6); a section not delivered yet still hands off (D94).
-    await main.locator('.section-nav').getByRole('button', { name: 'Diagnostics & logs', exact: true }).click();
+    await main.locator('.section-nav').getByRole('button', { name: 'Auto-tagging', exact: true }).click();
     const handoff = main.locator('section.handoff');
     await expect(handoff).toHaveClass(/\bsurface\b/);
     expect(await handoff.evaluate(surfaceStyle)).toMatchObject(SURFACE);
@@ -465,9 +465,8 @@ test('System is native: the concept shell, section navigation, sections, hand-of
         // S2 Task 6: Overview is native (workspace-system.spec.mjs), and so are Appearance (S3 Task 8) and Sources & scans
         // (S4 Task 11, workspace-system-sources.spec.mjs, its update notice shown in a fresh browser), Integrations (S10
         // Task 27, workspace-system-integrations.spec.mjs), Maintenance (S7 Task 19,
-        // workspace-system-maintenance.spec.mjs), Backup & export (S9 Task 24, workspace-system-backups.spec.mjs) and
-        // Auto-tagging (S11 Task 6, workspace-system-tagging.spec.mjs); every other section hands off.
-        if (hash === 'tagging') await expect(layout.locator('#tag-model')).toBeVisible();
+        // workspace-system-maintenance.spec.mjs) and Backup & export (S9 Task 24, workspace-system-backups.spec.mjs);
+        // every other section hands off.
         if (hash === 'overview') await expect(layout.locator(':scope > .summary-metrics')).toBeVisible();
         if (hash === 'sources') await expect(layout.locator('#source-list .operation')).toHaveCount(2);
         expect(await layout.evaluate(node => [...node.children].map(child => `${child.localName}.${child.className}`)))
@@ -475,10 +474,9 @@ test('System is native: the concept shell, section navigation, sections, hand-of
                 sources: ['div.notice', 'section.surface', 'div.save-row'],
                 integrations: ['section.surface', 'section.surface', 'div.save-row'],
                 maintenance: ['div.notice', 'section.surface', 'section.surface', 'div.save-row'],
-                backups: ['div.two-col', 'section.surface', 'div.save-row'],
-                tagging: ['section.surface', 'div.save-row'] }[hash]
+                backups: ['div.two-col', 'section.surface', 'div.save-row'] }[hash]
                 ?? ['section.surface handoff', 'div.save-row']);
-        if (['overview', 'appearance', 'sources', 'integrations', 'tagging', 'maintenance', 'backups'].includes(hash)) continue;
+        if (['overview', 'appearance', 'sources', 'integrations', 'maintenance', 'backups'].includes(hash)) continue;
         const handoff = layout.locator('section.handoff');
         await expect(handoff.locator('h2')).toHaveText('Your current tools are ready');
         expect(await handoff.locator('a.workspace-link').evaluateAll(links => links.map(link => link.getAttribute('href'))))

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/browser/workspace_tagging_fixture.py

@@ -12,7 +12,6 @@ import json
 import os
 from pathlib import Path
 import shutil
-import threading
 import time
 from typing import TYPE_CHECKING
 
@@ -182,28 +181,6 @@ def register_tagging_commands(
     routes: web.RouteTableDef, api: PromptManagerAPI, root: Path, model
 ) -> None:
     """Register fixed seed, snapshot and fake-model commands; no paths or SQL input."""
-    # The fake download (``/__test__/tagging/download``): waits on ``event``,
-    # then answers ``result``. Every reset sets the event and puts back the
-    # model's raising default, so no test can leave a worker hanging.
-    # ``generation`` grows on every reset: a download a reset released (or one
-    # that timed out) fails without touching the next test's model state.
-    download = {"event": threading.Event(), "result": True, "generation": 0}
-
-    def restore_download() -> None:
-        download["generation"] += 1
-        download["event"].set()
-        model.__dict__.pop("download_model", None)
-
-    def fake_download(model_type: str, progress_callback=None) -> bool:
-        event, generation = download["event"], download["generation"]
-        released = event.wait(DOWNLOAD_HOLD_LIMIT_S)
-        if not released or download["generation"] != generation:
-            return False
-        if download["result"]:
-            model.unavailable = model.unavailable - {model_type}
-        return download["result"]
-
-    _set_defaults(model, DEFAULTS)  # the server starts on the standard ones
 
     @routes.post("/__test__/tagging/reset")
     async def reset(request: web.Request) -> web.Response:
@@ -218,7 +195,6 @@ def register_tagging_commands(
         model.unavailable = set()
         model.suggestions = None
         model.loaded = None
-        restore_download()
         _set_defaults(model, DEFAULTS)
         # A test that ends with the dialog open leaves its capture behind; drop
         # every capture so the next test starts below the store's limits.
@@ -247,33 +223,6 @@ def register_tagging_commands(
         model.unavailable = set(data["unavailable"])
         return web.json_response({"success": True})
 
-    @routes.post("/__test__/tagging/download")
-    async def download_mode(request: web.Request) -> web.Response:
-        """Switch the model's download to a fake (never a real download).
-
-        ``{"mode": "hold"}``: the next download waits until a later
-        ``succeed`` or ``fail`` (or a reset) releases it. ``succeed`` and
-        ``fail`` release a held download with that result and answer every
-        later one at once. A successful fake marks the model downloaded.
-        """
-        data = await request.json() if request.can_read_body else None
-        if (
-            request.query
-            or not isinstance(data, dict)
-            or set(data) != {"mode"}
-            or data["mode"] not in ("hold", "succeed", "fail")
-        ):
-            raise web.HTTPBadRequest()
-        if data["mode"] == "hold":
-            download["event"].set()
-            download["event"] = threading.Event()
-            download["result"] = True
-        else:
-            download["result"] = data["mode"] == "succeed"
-            download["event"].set()
-        model.download_model = fake_download
-        return web.json_response({"success": True})
-
     @routes.post("/__test__/tagging/suggestions")
     async def suggestions(request: web.Request) -> web.Response:
         """Answer Generate with fixed scored names (the concept's own sample).
@@ -324,28 +273,18 @@ def register_tagging_commands(
         return web.json_response({"captures": count})
 
 
-# A held fake download gives up after this long, whatever the test does.
-DOWNLOAD_HOLD_LIMIT_S = 60
-
 # The standard tagging defaults: WD14 general and character thresholds, and
 # the suggestion count (``AutotagConfig``).
 DEFAULTS = (0.35, 0.85, 10)
 
 
 def _set_defaults(model, values) -> None:
-    """Set the saved tagging defaults (``AutotagConfig``, #328); a reset also
-    puts back the saved model, batch policy and template (the fake model's
-    short instructions, which the concept comparisons show)."""
     from py.config import AutotagConfig
 
     general, character, limit = values
-    AutotagConfig.GENERAL_THRESHOLD = general
-    AutotagConfig.CHARACTER_THRESHOLD = character
+    model.wd14_general_threshold = general
+    model.wd14_character_threshold = character
     AutotagConfig.SUGGESTION_LIMIT = limit
-    if values == DEFAULTS:
-        AutotagConfig.MODEL_TYPE = "wd14-swinv2"
-        AutotagConfig.EXISTING = "skip"
-        AutotagConfig.TEMPLATE = model.default_prompt
 
 
 def _valid_defaults(data: object) -> bool:

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,8 +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 (up to 5 s each): off the 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/api-client.test.js

@@ -388,16 +388,6 @@ test("ApiError keeps a validated running job on busy and a validated source on i
     assert.deepEqual([new ApiError(409, "old caller").running, new ApiError(409, "old caller").source], [null, null]);
 });
 
-test("ApiError keeps a validated operation on model-busy only (#328)", () => {
-    const body = { operation: "Tagging model download · WD14 ViT" };
-    assert.equal(new ApiError(409, "busy", "model-busy", null, body).operation, "Tagging model download · WD14 ViT");
-    assert.equal(new ApiError(409, "busy", "busy", null, body).operation, null);
-    for (const operation of [null, 7, "", "x".repeat(201)]) {
-        assert.equal(new ApiError(409, "busy", "model-busy", null, { operation }).operation, null);
-    }
-    assert.equal(new ApiError(409, "busy", "model-busy").operation, null);
-});
-
 test("ApiError says whether the server itself refused (a parsed success:false body; S7 review I1)", () => {
     assert.equal(new ApiError(400, "bad", null, null, { success: false, error: "bad" }).refused, true);
     assert.equal(new ApiError(409, "busy", "busy", null, { success: false, code: "busy" }).refused, true);

tests/js/workspace-activity-kinds.test.js

@@ -225,26 +225,3 @@ test('a failed duplicate cleanup says the server reason (S7 review M3)', async (
     assert.equal(finishToast(failed), `Duplicate cleanup failed · ${reason}`);
     assert.equal(finishToast({ ...failed, status_line: '' }), 'Duplicate cleanup failed · 0 removed · 1 error');
 });
-
-// #328: Tag output images (`autotag`) reuses the image tagging view: Tagged / Unchanged / Skipped / Errors and Cancel.
-// The legacy page's hold of the same kind counts nothing and is not cancellable, so it keeps the generic held view.
-test('autotag gets Tagged / Unchanged / Skipped / Errors and Cancel; its legacy hold keeps the generic view', async () => {
-    const { kindOf, viewOf, canCancel } = await source;
-    const { startToast, finishToast } = await store;
-    const counters = { tagged: 3, unchanged: 1, skipped: 2, errors: 0 };
-    const batch = job({ kind: 'autotag', title: 'Tag output images', counters, scope: { images: 6 } });
-    const view = viewOf(batch);
-    assert.deepEqual(view.tiles.map(([group, label]) => [group, label]),
-        [['tagged', 'Tagged'], ['unchanged', 'Unchanged'], ['skipped', 'Skipped'], ['errors', 'Errors']]);
-    assert.equal(kindOf('autotag').pillVerb, 'Tagging');
-    assert.equal(kindOf('autotag').cancelLabel, 'Cancel tagging');
-    assert.equal(canCancel(batch), true);
-    assert.equal(startToast(batch), 'Tag output images started.');
-    assert.match(finishToast({ ...batch, state: 'finished', finished_at: 2 }), /^Tag output images finished/);
-
-    const held = job({ kind: 'autotag', title: 'Tag output images (legacy page)', counters: {}, cancellable: false,
-        progress: 0, processed: 0, total: 0 });
-    const legacy = viewOf(held);
-    assert.deepEqual([legacy.tiles, legacy.outcomes, [...legacy.openable]], [[], [], []]);
-    assert.equal(canCancel(held), false);
-});

tests/js/workspace-image-tagging-state.test.js

@@ -197,52 +197,6 @@ test('instructions default to the server prompt', async () => {
     assert.equal(c.state.options.suggestion_limit, 7, 'the suggestion count survives a model change');
 });
 
-// #328: one tagging configuration. The dialogs start on the model saved in System › Auto-tagging, unless a preset
-// (a review session's choice) or the user already picked one; an unknown saved model keeps the first option.
-test('dialog starts on the saved model unless a preset or the user chose one', async () => {
-    const saved = { [`GET ${MODELS}`]: () => response(200, models({ model_type: 'gguf' })) };
-    const { c } = await opened(saved);
-    assert.equal(c.state.model, 'gguf');
-    assert.equal(c.state.options.instructions, DEFAULT_PROMPT);
-
-    const { c: preset } = await opened(saved, { preset: { model: 'wd14-vit', options: {} } });
-    assert.equal(preset.state.model, 'wd14-vit');
-
-    const { createImageTaggingController, createTaggingOptionsController } = await load();
-    const h = harness(defaultRoutes(saved));
-    const picked = createImageTaggingController({ api: h.api, target: TARGET, source: 'images' });
-    picked.setModel('hf');
-    await picked.open();
-    await settle();
-    assert.equal(picked.state.model, 'hf', 'the user picked a model before the read landed');
-
-    // A pick made while the models read is still in flight wins over the saved model that lands after it.
-    const gate = deferred();
-    const late = harness(defaultRoutes({ [`GET ${MODELS}`]: () => gate.promise }));
-    const racing = createImageTaggingController({ api: late.api, target: TARGET, source: 'images' });
-    const opening = racing.open();
-    await settle();
-    assert.equal(racing.state.phase, 'observing');
-    racing.setModel('wd14-vit');
-    gate.resolve(response(200, models({ model_type: 'gguf' })));
-    await opening;
-    await settle();
-    assert.equal(racing.state.model, 'wd14-vit');
-    racing.dispose();
-
-    const { c: unknown } = await opened({ [`GET ${MODELS}`]: () => response(200, models({ model_type: 'wd14-convnext' })) });
-    assert.equal(unknown.state.model, 'wd14-swinv2');
-
-    const options = createTaggingOptionsController({ api: harness(defaultRoutes(saved)).api });
-    await options.open();
-    assert.equal(options.state.model, 'gguf');
-    const chosen = createTaggingOptionsController({ api: harness(defaultRoutes(saved)).api });
-    chosen.setModel('wd14-vit');
-    await chosen.open();
-    assert.equal(chosen.state.model, 'wd14-vit');
-    for (const controller of [c, preset, picked, unknown, options, chosen]) controller.dispose();
-});
-
 test('an unreadable or malformed models read falls back to the documented defaults', async () => {
     for (const route of [() => fail(500, null), () => response(200, models({ default_prompt: 4, suggestion_limit: 0, wd14_general_threshold: 2, wd14_character_threshold: 'x' }))]) {
         const { c } = await opened({ [`GET ${MODELS}`]: route });
@@ -588,7 +542,7 @@ test('model-unavailable and model-busy set the status line only', async () => {
     await c.generate();
     const before = c.state;
     for (const [code, message] of [
-        ['model-unavailable', 'WD14 SwinV2 is not downloaded. Download it in System › Auto-tagging.'],
+        ['model-unavailable', 'WD14 SwinV2 is not downloaded. Download it from the legacy Auto-tag page.'],
         ['model-busy', 'A tagging model is busy with another operation. Try again when it finishes.'],
         ['unsupported-media', 'Images larger than 4096 px per side or 16,777,216 px are not supported.'],
     ]) {

tests/js/workspace-images-tagging-bulk.test.js

@@ -129,9 +129,9 @@ test('a model that is not downloaded is named with the server sentence', () => {
     const { modelUnavailable } = state;
     assert.equal(modelUnavailable(null, 'wd14-vit'), '');
     assert.equal(modelUnavailable({ 'wd14-vit': { downloaded: true } }, 'wd14-vit'), '');
-    assert.equal(modelUnavailable({ 'wd14-vit': { downloaded: false } }, 'wd14-vit'), 'WD14 ViT is not downloaded. Download it in System › Auto-tagging.');
+    assert.equal(modelUnavailable({ 'wd14-vit': { downloaded: false } }, 'wd14-vit'), 'WD14 ViT is not downloaded. Download it from the legacy Auto-tag page.');
     assert.equal(modelUnavailable({ gguf: { downloaded: false, name: 'GGUF (Recommended)' } }, 'gguf'),
-        'GGUF (Recommended) is not downloaded. Download it in System › Auto-tagging.');
+        'GGUF (Recommended) is not downloaded. Download it from the legacy Auto-tag page.');
     assert.throws(() => modelUnavailable({}, 'nope'), TypeError);
 });
 

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

@@ -341,22 +341,6 @@ test('a host save names the settings that apply after a restart (D128)', async (
     assert.equal(drafts.statusText(), 'Unsaved changes.');
 });
 
-test('a host save refused for one setting says the server reason and names no source (S11 CUJ 2a)', async () => {
-    const { INVALID_SETTING_CODE } = await source;
-    const domains = adapters({ host: { autotag_general_threshold: 0.35 } });
-    const drafts = await loaded(domains);
-    const message = 'General-tag confidence must be between 0 and 1.';
-    domains.outcome.host = () => { throw Object.assign(new Error(message), { code: INVALID_SETTING_CODE }); };
-    drafts.set('host', 'autotag_general_threshold', 1.5);
-    assert.deepEqual(await drafts.save(), { browser: 'clean', host: 'failed', runtime: 'clean', invalid: { source: null, message } });
-    assert.equal(drafts.statusText(), message);
-    assert.equal(drafts.invalidSource(), null);
-    assert.deepEqual([...drafts.failed('host')], ['autotag_general_threshold']);
-    assert.equal(drafts.get('host', 'autotag_general_threshold'), 1.5);
-    drafts.set('host', 'autotag_general_threshold', 0.4);
-    assert.equal(drafts.statusText(), 'Unsaved changes.');
-});
-
 test('a host save refused for one source says the server reason and names it until the next edit', async () => {
     const domains = adapters({ host: { gallery_root_paths: ['output', 'output/gone'] } });
     const drafts = await loaded(domains);

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

@@ -1,583 +0,0 @@
-// System › Auto-tagging (#328, System S11 Tasks 6–7): the concept's rows with real data (D132 model options and live
-// status, D133 suggestions per image), host drafts saved by the one Save row, and the actions: Download (an Activity
-// job), Unload (direct), Preview tagging review (D115) and the reviewed Tag output images batch (D134).
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const tagging = import('../../web/js/workspace/system-tagging.mjs');
-const stateModule = import('../../web/js/workspace/system-state.mjs');
-const coreModule = import('../../web/js/shared/toolkit/core.js');
-
-const CONCEPT = fs.readFileSync(path.join(__dirname, '../../docs/concepts/workspace/app.js'), 'utf8');
-const SOURCE = fs.readFileSync(path.join(__dirname, '../../web/js/workspace/system-tagging.mjs'), 'utf8');
-
-/** A minimal DOM whose elements count their live listeners (a listener's signal aborts it, as in a browser). */
-function fakeDOM() {
-    const previous = global.document;
-    const elements = [];
-    class Element {
-        constructor(tag) {
-            this.tagName = tag.toUpperCase();
-            this.children = [];
-            this.attributes = {};
-            this.listeners = [];
-            this.dataset = {};
-            this.className = '';
-            this.id = '';
-            this.value = '';
-            this.disabled = false;
-            this._text = '';
-            elements.push(this);
-        }
-        get localName() { return this.tagName.toLowerCase(); }
-        get options() { return this.children.filter(child => child.tagName === 'OPTION'); }
-        get textContent() { return this._text + this.children.map(child => child.textContent).join(''); }
-        set textContent(text) { this.children = []; this._text = String(text); }
-        append(...nodes) {
-            for (const node of nodes) {
-                node.parentNode?.children && (node.parentNode.children = node.parentNode.children.filter(child => child !== node));
-                node.parentNode = this;
-                this.children.push(node);
-            }
-        }
-        remove() { if (this.parentNode) this.parentNode.children = this.parentNode.children.filter(child => child !== this); this.parentNode = null; }
-        setAttribute(name, value) { this.attributes[name] = String(value); }
-        getAttribute(name) { return Object.hasOwn(this.attributes, name) ? this.attributes[name] : null; }
-        removeAttribute(name) { delete this.attributes[name]; }
-        addEventListener(type, callback, options = {}) {
-            if (options.signal?.aborted) return;
-            const entry = { type, callback };
-            this.listeners.push(entry);
-            options.signal?.addEventListener('abort', () => { this.listeners = this.listeners.filter(item => item !== entry); });
-        }
-        removeEventListener(type, callback) { this.listeners = this.listeners.filter(item => item.type !== type || item.callback !== callback); }
-        dispatch(type) { return Promise.all(this.listeners.filter(item => item.type === type).map(({ callback }) => callback({ type, target: this }))); }
-    }
-    global.document = { createElement: tag => new Element(tag), activeElement: null };
-    const walk = (node, found = []) => { found.push(node); node.children.forEach(child => walk(child, found)); return found; };
-    return {
-        listenerCount: () => elements.reduce((sum, element) => sum + element.listeners.length, 0),
-        find: (root, predicate) => walk(root).find(predicate),
-        restore() { global.document = previous; },
-    };
-}
-
-const HOST = { autotag_model_type: 'wd14-swinv2', autotag_existing: 'skip', autotag_general_threshold: 0.35,
-    autotag_character_threshold: 0.85, autotag_suggestion_limit: 10, autotag_template: 'Describe the image as tags.' };
-const entry = (label, size, extra = {}) => ({ name: label, label, size_label: size, downloaded: true, loaded: false, ...extra });
-const MODELS = {
-    success: true,
-    models: { 'wd14-swinv2': entry('WD14 SwinV2', '~400 MB'), 'wd14-vit': entry('WD14 ViT', '~400 MB', { downloaded: false }),
-        gguf: entry('GGUF JoyCaption', '~4.5 GB', { downloaded: false, model_exists: true, mmproj_exists: false }),
-        hf: entry('HuggingFace JoyCaption', '~16 GB', { downloaded: false }) },
-    model_loaded: false, loaded_model_type: null,
-};
-const tick = () => new Promise(resolve => setImmediate(resolve));
-const IMAGE = { filename: 'dunes_00001.png' };
-
-async function mounted({ host = HOST, models = MODELS, modelsFail = false, image = IMAGE, start, post, hostFails = false } = {}) {
-    const { mountTagging } = await tagging;
-    const { createSystemDrafts } = await stateModule;
-    const { createScope } = await coreModule;
-    const dom = fakeDOM();
-    const drafts = createSystemDrafts({
-        readBrowser: () => ({}), readRuntime: () => ({}),
-        readHost: async () => { if (hostFails) throw new Error('offline'); return { values: host, revision: 'sha256:one' }; },
-        writeBrowser: async () => ({ persisted: true }), writeHost: async () => ({ success: true, persisted: true }),
-        writeRuntime: async () => ({}),
-    });
-    const scope = createScope();
-    const calls = { get: [], post: [], toasts: [], navigated: [], opened: [], shown: [], started: [] };
-    let answer = models;
-    const api = {
-        get: async (url, options) => {
-            calls.get.push(url);
-            assert.equal(options.cache, 'no-store');
-            if (modelsFail) throw new Error('offline');
-            return answer;
-        },
-        post: async (url, body) => { calls.post.push([url, body]); return post ? post(url, body) : { success: true }; },
-    };
-    const activity = { start: async (kind, body) => { calls.started.push([kind, body]); return start ? start(kind, body) : { job: { id: 'job1' } }; } };
-    const [surface] = mountTagging(null, { api, activity, scope, drafts, notify: text => calls.toasts.push(text),
-        navigate: hash => calls.navigated.push(hash), selected: () => image, openTagging: options => calls.opened.push(options),
-        show: (plan, options) => calls.shown.push([plan, options]) });
-    const byId = id => dom.find(surface, node => node.id === id);
-    const button = label => dom.find(surface, node => node.tagName === 'BUTTON' && node.textContent === label);
-    const description = () => byId('tag-model').parentNode.children[0].children[1].textContent;
-    await drafts.reloadHost();
-    await tick();
-    return { dom, drafts, scope, surface, byId, button, description, calls, setModels: value => { answer = value; } };
-}
-
-test('the section keeps the concept surface, rows, labels and actions in order', () => {
-    const start = CONCEPT.indexOf('case "tagging":');
-    const body = CONCEPT.slice(start, CONCEPT.indexOf('break;', start));
-    const rows = [...body.matchAll(/setting\("([^"]+)", "([^"]+)", "([^"]+)"/g)].map(([, id, label, description]) => [id, label, description]);
-    assert.deepEqual(rows.map(([id]) => id), ['tag-model', 'tag-existing', 'threshold-general', 'threshold-character']);
-    for (const [id, label] of rows) assert.ok(SOURCE.includes(`id: '${id}', label: '${label}'`), `${id} keeps "${label}"`);
-    // OQ6: the true descriptions are kept verbatim; the model's design note is replaced by its live status (D132).
-    for (const [id, , description] of rows.slice(1)) assert.ok(SOURCE.includes(`'${description}'`), `${id} description`);
-    assert.ok(!SOURCE.includes(rows[0][2]));
-    for (const option of ['Skip already tagged', 'Merge with existing', 'Replace after review']) assert.ok(body.includes(option) && SOURCE.includes(`'${option}'`));
-    assert.ok(body.includes('<h2>Auto-tagging</h2>') && SOURCE.includes("'h2', 'Auto-tagging'"));
-    assert.ok(body.includes('One tagging configuration for images and prompt-library actions. Every result can be reviewed before applying.'));
-    assert.ok(body.includes('LLM tag template') && SOURCE.includes("'LLM tag template'"));
-    assert.ok(body.includes('"Preview tagging review", "tag-review", "", "ca-primary"'));
-    // Prototype copy is never shipped.
-    for (const sample of ['Simulate download', 'Simulate unload', 'Ollama']) assert.ok(!SOURCE.includes(sample), sample);
-});
-
-test('model options are the four real engines with their size, in the concept order (D132, OQ5)', async () => {
-    const { modelOptions, MODEL_IDS, modelLabel, modelSize } = await tagging;
-    assert.deepEqual(MODEL_IDS, ['wd14-swinv2', 'wd14-vit', 'gguf', 'hf']);
-    assert.deepEqual(modelOptions(MODELS.models).map(([, label]) => label),
-        ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB']);
-    // Before the status answered (or when it cannot be read) the documented labels stand in.
-    assert.deepEqual(modelOptions(null), modelOptions(MODELS.models));
-    assert.equal(modelLabel('hf', { label: '' }), 'HuggingFace JoyCaption');
-    assert.equal(modelLabel('other', null), 'other');
-    assert.equal(modelSize('other', null), '');
-});
-
-test('the Tagging model description is the chosen model’s live status (D132)', async () => {
-    const { modelDescription, readStatus, STATUS_COPY } = await tagging;
-    const status = readStatus(MODELS);
-    assert.equal(modelDescription({ phase: 'loading' }, 'wd14-vit'), 'Loading model status…');
-    assert.equal(modelDescription({ phase: 'failed' }, 'wd14-vit'), 'Model status could not be read.');
-    assert.equal(modelDescription(status, 'wd14-swinv2'), 'Downloaded. Not loaded.');
-    assert.equal(modelDescription(status, 'wd14-vit'), 'Not downloaded. Download size ~400 MB.');
-    assert.equal(modelDescription(status, 'hf'), 'Not downloaded. Download size ~16 GB.');
-    assert.equal(modelDescription(status, 'gguf'), 'Partly downloaded. Download again to finish.');
-    const both = readStatus({ ...MODELS, models: { ...MODELS.models, gguf: entry('GGUF JoyCaption', '~4.5 GB', { downloaded: false,
-        model_exists: false, mmproj_exists: false }) } });
-    assert.equal(modelDescription(both, 'gguf'), 'Not downloaded. Download size ~4.5 GB.');
-    const loaded = readStatus({ ...MODELS, model_loaded: true, loaded_model_type: 'wd14-swinv2',
-        models: { ...MODELS.models, 'wd14-swinv2': entry('WD14 SwinV2', '~400 MB', { loaded: true }) } });
-    assert.equal(loaded.loadedType, 'wd14-swinv2');
-    assert.equal(modelDescription(loaded, 'wd14-swinv2'), STATUS_COPY.loaded);
-    assert.equal(modelDescription(status, 'unknown'), STATUS_COPY.failed);
-    assert.deepEqual(readStatus(null), { phase: 'failed', models: null, loadedType: null });
-    assert.equal(readStatus({ models: {}, model_loaded: true, loaded_model_type: '/abs/path' }).loadedType, null);
-});
-
-test('controls draft their host keys; numbers as numbers, other text as typed', async () => {
-    const { SETTING_KEYS, coerceNumber, draftValue } = await tagging;
-    assert.deepEqual(SETTING_KEYS, { 'tag-model': 'autotag_model_type', 'tag-existing': 'autotag_existing',
-        'threshold-general': 'autotag_general_threshold', 'threshold-character': 'autotag_character_threshold',
-        'tag-suggestions': 'autotag_suggestion_limit', 'tag-template': 'autotag_template' });
-    assert.deepEqual(['0.4', ' 1.5 ', '15', '', 'abc', '1e-1'].map(coerceNumber), [0.4, 1.5, 15, '', 'abc', 0.1]);
-    assert.equal(draftValue('autotag_suggestion_limit', '15'), 15);
-    assert.equal(draftValue('autotag_template', ' 12 '), ' 12 ');
-    assert.equal(draftValue('autotag_existing', undefined), '');
-    const { dom, drafts, scope, byId } = await mounted();
-    try {
-        assert.equal(byId('tag-model').value, 'wd14-swinv2');
-        assert.equal(byId('threshold-general').value, '0.35');
-        assert.equal(byId('tag-template').value, HOST.autotag_template);
-        assert.deepEqual([byId('threshold-general').min, byId('threshold-general').max, byId('threshold-general').step], ['0', '1', '0.05']);
-        assert.deepEqual([byId('tag-suggestions').min, byId('tag-suggestions').max], ['1', '100']);
-        byId('tag-existing').value = 'merge'; await byId('tag-existing').dispatch('change');
-        byId('threshold-general').value = '0.4'; await byId('threshold-general').dispatch('change');
-        byId('tag-suggestions').value = '15'; await byId('tag-suggestions').dispatch('change');
-        byId('tag-template').value = 'Tags only.'; await byId('tag-template').dispatch('input');
-        assert.deepEqual(drafts.changes('host'), { autotag_existing: 'merge', autotag_general_threshold: 0.4,
-            autotag_suggestion_limit: 15, autotag_template: 'Tags only.' });
-        // Every control names its stored key, so a refused save highlights it (D92).
-        for (const id of Object.keys(SETTING_KEYS)) assert.equal(byId(id).dataset.key, SETTING_KEYS[id]);
-        assert.equal(byId('tag-template').dataset.setting, 'tag-template');
-    } finally { scope.dispose(); assert.equal(dom.listenerCount(), 0); dom.restore(); }
-});
-
-test('opening the section reads the model status once; the select waits for it', async () => {
-    const { dom, scope, byId, description, calls, surface } = await mounted();
-    try {
-        assert.deepEqual(calls.get, ['/prompt_manager/autotag/models']);
-        assert.deepEqual(calls.post, []);
-        assert.equal(byId('tag-model').disabled, false);
-        assert.equal(description(), 'Downloaded. Not loaded.');
-        assert.deepEqual(byId('tag-model').options.map(option => option.textContent),
-            ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB']);
-        assert.deepEqual(surface.children.map(node => node.className),
-            ['', '', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'field', 'row-actions', 'operation']);
-    } finally { scope.dispose(); dom.restore(); }
-    const failed = await mounted({ modelsFail: true });
-    try {
-        assert.equal(failed.description(), 'Model status could not be read.');
-        assert.equal(failed.button('Download').getAttribute('aria-disabled'), 'true');
-        assert.equal(failed.button('Unload').disabled, true);
-        await failed.button('Download').dispatch('click');
-        assert.deepEqual(failed.calls.toasts, ['Model status could not be read.']);
-        assert.deepEqual(failed.calls.started, []);
-    } finally { failed.scope.dispose(); failed.dom.restore(); }
-});
-
-test('server settings that cannot be read leave the rows disabled and say so', async () => {
-    const { dom, scope, byId, button, description, calls } = await mounted({ hostFails: true });
-    try {
-        assert.equal(byId('tag-existing').disabled, true);
-        assert.equal(byId('tag-existing').parentNode.children[0].children.at(-1).textContent, 'Server settings could not be read.');
-        assert.equal(description(), 'Model status could not be read.');
-        await button('Preview tagging review').dispatch('click');
-        assert.deepEqual(calls.toasts, ['Server settings could not be read.']);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('Download starts the model download job and opens it; the label follows the disk (OQ10)', async () => {
-    const { dom, drafts, scope, button, calls, byId } = await mounted();
-    try {
-        assert.ok(button('Download again'));
-        byId('tag-model').value = 'wd14-vit'; await byId('tag-model').dispatch('change');
-        assert.equal(drafts.get('host', 'autotag_model_type'), 'wd14-vit');
-        await button('Download').dispatch('click');
-        assert.deepEqual(calls.started, [['model-download', { model_type: 'wd14-vit' }]]);
-        assert.deepEqual(calls.navigated, ['#/activity/job1']);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('startJob toasts by code and never navigates on a refusal', async () => {
-    const { startJob, startRefusal } = await tagging;
-    const { createScope } = await coreModule;
-    const error = (code, message = 'Server says.', extra = {}) => Object.assign(new Error(message), { code, ...extra });
-    assert.equal(startRefusal(error('model-busy', 'x', { operation: 'Tagging model download · WD14 ViT' }), 'X'),
-        'The tagging model is busy: Tagging model download · WD14 ViT. Try again when it finishes.');
-    assert.equal(startRefusal(error('model-busy', 'x'), 'X'),
-        'The tagging model is busy: Another tagging operation. Try again when it finishes.');
-    for (const code of ['model-unavailable', 'review-required', 'insufficient-space']) assert.equal(startRefusal(error(code), 'X'), 'Server says.');
-    assert.equal(startRefusal(error('weird'), 'Tag output images'), 'Tag output images could not start. Try again.');
-    assert.equal(startRefusal(new Error('offline'), 'Tag output images'), 'Tag output images could not start. Try again.');
-    const scope = createScope();
-    const toasts = [];
-    const navigated = [];
-    const run = start => startJob({ activity: { start }, scope, kind: 'autotag', body: {}, what: 'Tag output images',
-        notify: text => toasts.push(text), navigate: hash => navigated.push(hash) });
-    assert.equal(await run(async () => { throw error('model-busy', 'busy', { operation: 'Generate suggestions' }); }), null);
-    assert.equal(await run(async () => ({ busy: { id: 'a1', title: 'Scan for metadata' } })), null);
-    assert.equal(await run(async () => ({ busy: null })), null);
-    assert.deepEqual(toasts, ['The tagging model is busy: Generate suggestions. Try again when it finishes.',
-        ['Another job is running: ', { text: 'Scan for metadata', href: '#/activity/a1' }, '.'],
-        'Another job is running. Try again when it ends.']);
-    assert.deepEqual(await run(async () => ({ job: { id: 'j2' } })), { id: 'j2' });
-    assert.deepEqual(navigated, ['#/activity/j2']);
-    scope.dispose();
-    assert.equal(await run(async () => { throw error('weird'); }), null);
-    assert.deepEqual(await run(async () => ({ job: { id: 'j3' } })), { id: 'j3' });
-    assert.deepEqual(navigated, ['#/activity/j2']);
-    assert.equal(toasts.length, 3);
-});
-
-test('Unload is enabled only while a model is loaded; a busy refusal names the operation', async () => {
-    const loadedModels = { ...MODELS, model_loaded: true, loaded_model_type: 'wd14-swinv2' };
-    let refuse = null;
-    const post = url => {
-        if (refuse) throw refuse;
-        return url.endsWith('/unload') ? { success: true, message: 'WD14SWINV2 model unloaded successfully', model_loaded: false } : {};
-    };
-    const { dom, scope, button, calls, setModels } = await mounted({ models: loadedModels, post });
-    try {
-        assert.equal(button('Unload').disabled, false);
-        refuse = Object.assign(new Error('A tagging model is busy'), { code: 'model-busy', operation: 'Tagging model download · WD14 ViT' });
-        await button('Unload').dispatch('click');
-        assert.deepEqual(calls.toasts, ['The tagging model is busy: Tagging model download · WD14 ViT. Try again when it finishes.']);
-        refuse = new Error('offline');
-        await button('Unload').dispatch('click');
-        assert.equal(calls.toasts.at(-1), 'The tagging model could not be unloaded. Try again.');
-        refuse = null;
-        setModels(MODELS);
-        await button('Unload').dispatch('click');
-        assert.equal(calls.toasts.at(-1), 'WD14 SwinV2 unloaded.');
-        assert.deepEqual(calls.post.map(([url]) => url), Array(3).fill('/prompt_manager/autotag/unload'));
-        // Each attempt reads the status again; nothing is loaded now.
-        assert.equal(calls.get.length, 4);
-        assert.equal(button('Unload').disabled, true);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('Preview tagging review opens the Tag image dialog with the section’s values, else says why (D115)', async () => {
-    const { NO_SELECTION, taggingPreset, draftProblem } = await tagging.then(async module => ({ ...module,
-        NO_SELECTION: (await import('../../web/js/workspace/vocabulary.mjs')).NO_SELECTION }));
-    assert.equal(NO_SELECTION, 'Select an image in Images first.');
-    assert.deepEqual(taggingPreset(HOST), { model: 'wd14-swinv2', options: { general_threshold: 0.35, character_threshold: 0.85,
-        suggestion_limit: 10 } });
-    assert.deepEqual(taggingPreset({ ...HOST, autotag_model_type: 'gguf' }), { model: 'gguf',
-        options: { instructions: HOST.autotag_template, suggestion_limit: 10 } });
-    assert.equal(draftProblem(HOST), null);
-    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');
-    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: '  ' }),
-        { key: 'autotag_template', message: 'LLM tag template must be non-empty text.' });
-    assert.deepEqual(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: 'x'.repeat(4001) }),
-        { key: 'autotag_template', message: 'LLM tag template must be at most 4000 characters.' });
-    // Characters are code points, as Python's len counts them: 4000 emoji (8000 UTF-16 units) are allowed.
-    assert.equal(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '🏜'.repeat(4000) }), null);
-    assert.equal(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '🏜'.repeat(4001) }).key, 'autotag_template');
-    // A WD14 run never reads the template, nor a language model the thresholds.
-    assert.equal(draftProblem({ ...HOST, autotag_template: '' }), null);
-    assert.equal(draftProblem({ ...HOST, autotag_model_type: 'gguf', autotag_general_threshold: 7 }), null);
-
-    const none = await mounted({ image: null });
-    try {
-        const preview = none.button('Preview tagging review');
-        assert.equal(preview.getAttribute('aria-disabled'), 'true');
-        assert.equal(preview.className, 'ca-primary');
-        await preview.dispatch('click');
-        assert.deepEqual(none.calls.toasts, ['Select an image in Images first.']);
-        assert.deepEqual(none.calls.opened, []);
-    } finally { none.scope.dispose(); none.dom.restore(); }
-
-    const { dom, scope, button, byId, calls } = await mounted();
-    try {
-        await button('Preview tagging review').dispatch('click');
-        assert.equal(calls.opened.length, 1);
-        assert.equal(calls.opened[0].image, IMAGE);
-        assert.equal(calls.opened[0].source, 'tags');
-        assert.deepEqual(calls.opened[0].preset, taggingPreset(HOST));
-        byId('threshold-general').value = '1.5'; 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, ['General-tag confidence must be between 0 and 1.']);
-        assert.equal(calls.opened.length, 1);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-const PLAN = { images: 3, prompts: 2, already_tagged: 1, to_tag: 1,
-    model: { type: 'wd14-swinv2', label: 'WD14 SwinV2', size_label: '~400 MB', downloaded: true }, existing: 'skip',
-    review_required: false, backup: { policy: 'on' }, disk: { free_bytes: 10 * 2 ** 30, required_bytes: 2 ** 20, sufficient: true } };
-
-test('the batch review grid, body and Cancel-only reasons (D134, CUJ 4–5)', async () => {
-    const { batchGrid, batchBody, batchCloseNote, existingLabel, REPLACE_NOTE, NOTHING_TO_TAG, NO_LINKED_IMAGES } = await tagging;
-    assert.deepEqual(batchGrid(PLAN, HOST), [['Model', 'WD14 SwinV2 · ~400 MB'], ['Existing tags', 'Skip already tagged'],
-        ['Images linked', '3'], ['Prompts', '2'], ['Already tagged', '1'], ['Prompts to tag', 'up to 1'],
-        ['Settings', 'General 0.35 · Character 0.85'], ['Backup', 'Create and verify before changes']]);
-    const llm = { ...HOST, autotag_model_type: 'gguf' };
-    assert.deepEqual(batchGrid({ ...PLAN, model: { type: 'gguf' }, backup: { policy: 'off' } }, llm).slice(-2),
-        [['Settings', 'Template of 27 characters'], ['Backup', 'No safety backup (the policy is off)']]);
-    assert.equal(batchGrid({}, HOST)[2][1], '0');
-    assert.equal(existingLabel('odd'), 'odd');
-    assert.deepEqual(batchBody(HOST), { model_type: 'wd14-swinv2', existing: 'skip',
-        options: { general_threshold: 0.35, character_threshold: 0.85 } });
-    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);
-    assert.equal(REPLACE_NOTE, 'Replacing tags needs a review of each image. Use Preview tagging review, or choose Skip or Merge for a batch run.');
-    assert.equal(batchCloseNote({ ...PLAN, model: { ...PLAN.model, downloaded: false } }), 'WD14 SwinV2 is not downloaded. Download it first.');
-    assert.equal(batchCloseNote({ ...PLAN, disk: { free_bytes: 2 ** 20, required_bytes: 2 ** 21, sufficient: false } }),
-        'Not enough free disk space: the safety backup needs about 2.0 MB and 1.0 MB is free. Nothing is written until there is room.');
-    assert.equal(batchCloseNote({ ...PLAN, prompts: 0, to_tag: 0 }), NO_LINKED_IMAGES);
-    assert.equal(batchCloseNote({ ...PLAN, to_tag: 0 }), NOTHING_TO_TAG);
-    assert.equal(NOTHING_TO_TAG, 'Every prompt with an output image is already tagged.');
-});
-
-test('showBatchPlan opens the review with the backup box, or the Cancel-only review', async () => {
-    const { showBatchPlan, REVIEW_TITLE, BATCH_SENTENCE } = await tagging;
-    const { createScope } = await coreModule;
-    const scope = createScope();
-    const reviews = [];
-    const closed = [];
-    const started = [];
-    const options = { values: HOST, scope, activity: { start: async (kind, body) => { started.push([kind, body]); return { job: { id: 'b1' } }; } },
-        notify: () => {}, navigate: () => {}, openReview: review => reviews.push(review), openCloseOnly: review => closed.push(review) };
-    showBatchPlan(PLAN, options);
-    assert.equal(reviews.length, 1);
-    const [review] = reviews;
-    assert.equal(review.title, REVIEW_TITLE);
-    assert.equal(review.title, 'Review tag output images');
-    assert.equal(review.heading, 'Tag output images');
-    assert.equal(review.sentence, BATCH_SENTENCE);
-    assert.equal(review.primary.label, 'Start tagging');
-    assert.equal(review.cancelLabel, 'Cancel');
-    assert.equal(review.backup.copy.heading, 'Back up the database first (recommended)');
-    await review.onStart();
-    assert.deepEqual(started, [['autotag', { model_type: 'wd14-swinv2', existing: 'skip',
-        options: { general_threshold: 0.35, character_threshold: 0.85 } }]]);
-    showBatchPlan({ ...PLAN, backup: { policy: 'off' } }, options);
-    assert.equal(reviews[1].backup, null);
-    showBatchPlan({ ...PLAN, review_required: true }, options);
-    assert.equal(closed.length, 1);
-    assert.equal(closed[0].note.startsWith('Replacing tags needs a review'), true);
-    assert.equal(closed[0].grid[0][0], 'Model');
-    scope.dispose();
-});
-
-test('Tag output images › Review previews the drafts, else says why; a refused preview is toasted', async () => {
-    let refuse = null;
-    const post = url => {
-        if (refuse) throw refuse;
-        assert.equal(url, '/prompt_manager/autotag/batch/preview');
-        return PLAN;
-    };
-    const { dom, scope, button, byId, calls } = await mounted({ post });
-    try {
-        const review = button('Review');
-        assert.equal(review.getAttribute('aria-disabled'), null);
-        await review.dispatch('click');
-        await tick();
-        assert.deepEqual(calls.post, [['/prompt_manager/autotag/batch/preview', { model_type: 'wd14-swinv2', existing: 'skip' }]]);
-        assert.equal(calls.shown.length, 1);
-        assert.equal(calls.shown[0][0], PLAN);
-        assert.deepEqual(calls.shown[0][1].values, HOST);
-        assert.equal(review.textContent, 'Review');
-        refuse = Object.assign(new Error('busy'), { code: 'busy', running: { id: 'r1', title: 'Optimize database' } });
-        await review.dispatch('click');
-        await tick();
-        assert.deepEqual(calls.toasts.at(-1), ['Another job is running: ', { text: 'Optimize database', href: '#/activity/r1' }, '.']);
-        refuse = new Error('offline');
-        await review.dispatch('click');
-        await tick();
-        assert.equal(calls.toasts.at(-1), 'The plan could not be reviewed. Nothing was changed.');
-        // A model that is not on disk cannot be reviewed: the button explains instead.
-        byId('tag-model').value = 'wd14-vit'; await byId('tag-model').dispatch('change');
-        assert.equal(review.getAttribute('aria-disabled'), 'true');
-        await review.dispatch('click');
-        assert.equal(calls.toasts.at(-1), 'WD14 ViT is not downloaded. Download it first.');
-        assert.equal(calls.post.length, 3);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('settingRefusal marks only an Auto-tagging save\'s plain 400 as invalid-setting (CUJ 2a)', async () => {
-    const { settingRefusal } = await import('../../web/js/workspace/system.mjs');
-    const refusal = (extra = {}) => Object.assign(new Error('General-tag confidence must be between 0 and 1.'),
-        { status: 400, refused: true, code: null, ...extra });
-    const tagging = { autotag_general_threshold: 1.5, expected_revision: 'sha256:one' };
-    assert.equal(settingRefusal(refusal(), tagging).code, 'invalid-setting');
-    // Another section's refusal keeps the generic copy, even with a plain 400.
-    const other = refusal({ message: 'Result timeout must be between 0 and 300.' });
-    assert.equal(settingRefusal(other, { result_timeout: 999, expected_revision: 'sha256:one' }).code, null);
-    assert.equal(settingRefusal(refusal(), undefined).code, null);
-    for (const extra of [{ status: 409 }, { refused: false }, { code: 'jxl-unavailable' }]) {
-        assert.notEqual(settingRefusal(refusal(extra), tagging).code, 'invalid-setting');
-    }
-    assert.equal(settingRefusal(undefined, tagging), undefined);
-});
-
-test('a part-downloaded GGUF offers Download again', async () => {
-    const { downloadLabel, partlyDownloaded } = await tagging;
-    const partial = MODELS.models.gguf;
-    assert.equal(partlyDownloaded('gguf', partial), true);
-    assert.equal(downloadLabel('gguf', partial), 'Download again');
-    assert.equal(downloadLabel('gguf', { ...partial, model_exists: false }), 'Download');
-    assert.equal(downloadLabel('hf', MODELS.models.hf), 'Download');
-    assert.equal(downloadLabel('wd14-swinv2', MODELS.models['wd14-swinv2']), 'Download again');
-    assert.equal(partlyDownloaded('hf', { model_exists: true, mmproj_exists: false }), false);
-    const { dom, scope, byId, button, description } = await mounted();
-    try {
-        byId('tag-model').value = 'gguf'; await byId('tag-model').dispatch('change');
-        assert.equal(description(), 'Partly downloaded. Download again to finish.');
-        assert.ok(button('Download again'));
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('the disk note says what is short in the server\'s words, and guesses no unknown byte counts', async () => {
-    const { diskShortNote, DISK_SHORT_UNKNOWN } = await tagging;
-    assert.equal(diskShortNote({ required_bytes: 3 * 2 ** 20, free_bytes: 2 ** 19, sufficient: false }),
-        'Not enough free disk space: the safety backup needs about 3.0 MB and 0.5 MB is free. Nothing is written until there is room.');
-    for (const disk of [{ required_bytes: NaN, free_bytes: 1 }, { required_bytes: 1, free_bytes: Infinity }, { required_bytes: -1, free_bytes: 1 },
-        { required_bytes: '1', free_bytes: 1 }, null]) {
-        assert.equal(diskShortNote(disk), DISK_SHORT_UNKNOWN);
-    }
-    assert.equal(DISK_SHORT_UNKNOWN, 'Not enough free disk space for the safety backup. Nothing is written until there is room.');
-    assert.ok(!diskShortNote({ required_bytes: 1, free_bytes: 0 }).includes('apply'));
-});
-
-test('a drafts repaint never re-enables Download while its start is in flight', async () => {
-    let answer;
-    const start = () => new Promise(resolve => { answer = resolve; });
-    const { dom, scope, byId, button, calls } = await mounted({ start });
-    try {
-        const download = button('Download again');
-        const pressed = download.dispatch('click');
-        await tick();
-        assert.equal(download.getAttribute('aria-disabled'), 'true');
-        byId('tag-existing').value = 'merge'; await byId('tag-existing').dispatch('change');
-        assert.equal(download.getAttribute('aria-disabled'), 'true');
-        // A second press while it starts is ignored.
-        await download.dispatch('click');
-        assert.equal(calls.started.length, 1);
-        answer({ job: { id: 'd1' } });
-        await pressed;
-        assert.equal(download.getAttribute('aria-disabled'), null);
-        assert.deepEqual(calls.navigated, ['#/activity/d1']);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('an Unload that found nothing loaded says nothing and reads the status again', async () => {
-    const { dom, scope, button, calls } = await mounted({ models: { ...MODELS, model_loaded: true, loaded_model_type: 'wd14-swinv2' },
-        post: () => ({ success: true, message: 'No model was loaded' }) });
-    try {
-        await button('Unload').dispatch('click');
-        assert.deepEqual(calls.toasts, []);
-        assert.equal(calls.get.length, 2);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('an unknown saved engine has its own reason', async () => {
-    const { UNKNOWN_MODEL } = await tagging;
-    const { dom, scope, button, calls } = await mounted({ host: { ...HOST, autotag_model_type: 'wd14-convnext' } });
-    try {
-        await button('Preview tagging review').dispatch('click');
-        await button('Download').dispatch('click');
-        await button('Review').dispatch('click');
-        assert.deepEqual(calls.toasts, [UNKNOWN_MODEL, UNKNOWN_MODEL, UNKNOWN_MODEL]);
-        assert.equal(UNKNOWN_MODEL, 'The saved tagging model is not one of these engines. Choose one and save preferences.');
-        assert.deepEqual(calls.started, []);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('a review whose dialog fails to open is toasted, not lost', async () => {
-    const { dom, scope, button, calls } = await mounted({ post: () => PLAN });
-    try {
-        calls.shown.push = () => { throw new Error('dialog failed'); };
-        await button('Review').dispatch('click');
-        await tick();
-        assert.equal(calls.toasts.at(-1), 'The plan could not be reviewed. Nothing was changed.');
-        assert.equal(button('Review').getAttribute('aria-disabled'), null);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
-test('a status read, an unload and a preview that finish after the section left do nothing', async () => {
-    const { mountTagging } = await tagging;
-    const { createSystemDrafts } = await stateModule;
-    const { createScope } = await coreModule;
-    const dom = fakeDOM();
-    const pending = [];
-    const later = value => new Promise(resolve => pending.push(() => resolve(value)));
-    const drafts = createSystemDrafts({ readBrowser: () => ({}), readRuntime: () => ({}),
-        readHost: async () => ({ values: HOST, revision: 'sha256:one' }), writeBrowser: async () => ({}), writeHost: async () => ({}),
-        writeRuntime: async () => ({}) });
-    await drafts.load('host');
-    const scope = createScope();
-    const toasts = [];
-    const shown = [];
-    let gets = 0;
-    const loaded = { ...MODELS, model_loaded: true, loaded_model_type: 'wd14-swinv2',
-        models: { ...MODELS.models, 'wd14-swinv2': entry('WD14 SwinV2', '~400 MB', { loaded: true }) } };
-    const api = { get: () => { gets += 1; return gets === 1 ? Promise.resolve(loaded) : later(MODELS); }, post: url => later(url.endsWith('/unload') ? { success: true, model_loaded: false } : PLAN) };
-    const [surface] = mountTagging(null, { api, activity: {}, scope, drafts, notify: text => toasts.push(text), navigate: () => {},
-        selected: () => IMAGE, openTagging: () => {}, show: plan => shown.push(plan) });
-    try {
-        await tick();
-        const find = label => dom.find(surface, node => node.tagName === 'BUTTON' && node.textContent === label);
-        const description = () => dom.find(surface, node => node.id === 'tag-model').parentNode.children[0].children[1].textContent;
-        assert.equal(description(), 'Downloaded and loaded.');
-        const unloading = find('Unload').dispatch('click');
-        const reviewing = find('Review').dispatch('click');
-        await tick();
-        scope.dispose();
-        for (const settle of pending.splice(0)) settle();
-        await unloading;
-        await reviewing;
-        await tick();
-        for (const settle of pending.splice(0)) settle();
-        await tick();
-        assert.deepEqual(toasts, []);
-        assert.deepEqual(shown, []);
-        // The status read after the unload never reached the page either.
-        assert.equal(description(), 'Downloaded and loaded.');
-        assert.equal(dom.listenerCount(), 0);
-    } finally { dom.restore(); }
-});

tests/test_api_annotation_suggest.py

@@ -36,7 +36,7 @@ SUGGEST = "/prompt_manager/image-annotations/suggest"
 WAIT = 30.0
 WD14 = {"general_threshold": 0.35, "character_threshold": 0.85}
 LLM = {"instructions": "Generate tags."}
-UNAVAILABLE = "Download it in System › Auto-tagging."
+UNAVAILABLE = "Download it from the legacy Auto-tag page."
 
 SCORED = [("sandstone", 0.98), ("desert", 0.96)] + [
     (f"tag_{i:03d}", round(0.9 - i * 0.005, 4)) for i in range(150)

tests/test_api_annotations.py

@@ -1145,10 +1145,8 @@ class TestEnvelopes(AnnotationAPITestCase):
             sorted(await self.json_of(resp)),
             [
                 "default_prompt",
-                "existing",  # #328 adds the saved batch policy and model
                 "loaded_model_type",
                 "model_loaded",
-                "model_type",
                 "models",
                 "success",
                 "suggestion_limit",  # B2 adds it (D68); nothing else changes

tests/test_autotag_engine.py

@@ -19,15 +19,8 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from PIL import Image
 
-# py.autotag reads its saved defaults from py.config, which imports ComfyUI's
-# ``server`` at load: stand in for it when this module runs alone.
-_mock_server = MagicMock()
-_mock_server.PromptServer.instance.routes = MagicMock()
-sys.modules.setdefault("server", _mock_server)
-
-from py import autotag  # noqa: E402
-from py.autotag import MODELS, AutoTagService  # noqa: E402
-from py.config import AutotagConfig  # noqa: E402
+from py import autotag
+from py.autotag import MODELS, AutoTagService
 
 
 @contextlib.contextmanager
@@ -261,19 +254,12 @@ class TestWd14Thresholding(EngineTestCase):
         self.assertEqual(list(feeds.keys()), ["input"])
         self.assertEqual(tuple(feeds["input"].shape), (1, 8, 8, 3))
 
-    def test_service_thresholds_are_the_saved_defaults(self):
-        # #328: one configuration; the service has no thresholds of its own.
-        service = self._loaded([0.9, 0.3, 0.8, 0.99, 0.99, 0.5])
-        with (
-            patch.object(AutotagConfig, "GENERAL_THRESHOLD", 0.25),
-            patch.object(AutotagConfig, "CHARACTER_THRESHOLD", 0.75),
-        ):
-            self.assertEqual(
-                (service.wd14_general_threshold, service.wd14_character_threshold),
-                (0.25, 0.75),
-            )
-            tags = service.generate_tags(str(self.image_path))
-        self.assertEqual(tags, ["1girl", "hatsune_miku", "long_hair", "smile"])
+    def test_service_threshold_setters_clamp(self):
+        service = self._loaded([0.0] * 6)
+        service.wd14_general_threshold = 1.7
+        service.wd14_character_threshold = -2
+        self.assertEqual(service.wd14_general_threshold, 1.0)
+        self.assertEqual(service.wd14_character_threshold, 0.0)
 
 
 class TestGgufNormalisation(EngineTestCase):
@@ -383,13 +369,10 @@ class TestTagSuggestions(EngineTestCase):
 
     def test_thresholds_default_to_the_service_values(self):
         service = self._wd14()
-        with (
-            patch.object(AutotagConfig, "GENERAL_THRESHOLD", 0.95),
-            patch.object(AutotagConfig, "CHARACTER_THRESHOLD", 0.95),
-        ):
-            suggestions = service.generate_tag_suggestions(
-                str(self.image_path), limit=10
-            )
+        service.wd14_general_threshold = 0.95
+        service.wd14_character_threshold = 0.95
+
+        suggestions = service.generate_tag_suggestions(str(self.image_path), limit=10)
 
         self.assertEqual(suggestions, [("sandstone", 0.98), ("desert", 0.96)])
 

tests/test_config.py

@@ -413,21 +413,9 @@ class TestAutotagConfig(unittest.TestCase):
         self.config_class = getattr(config_module, "AutotagConfig", None)
         self.assertIsNotNone(self.config_class, "AutotagConfig is not implemented")
         self._orig = PromptManagerConfig.get_config()
-        self._defaults = {
-            attr: getattr(self.config_class, attr, None)
-            for attr in (
-                "MODEL_TYPE",
-                "EXISTING",
-                "GENERAL_THRESHOLD",
-                "CHARACTER_THRESHOLD",
-                "TEMPLATE",
-                "SUGGESTION_LIMIT",
-            )
-        }
 
     def tearDown(self):
-        for attr, value in self._defaults.items():
-            setattr(self.config_class, attr, value)
+        self.config_class.SUGGESTION_LIMIT = 10
         PromptManagerConfig.update_config(self._orig)
 
     def _load(self, value):
@@ -458,23 +446,8 @@ class TestAutotagConfig(unittest.TestCase):
         self.assertEqual(self.config_class.suggestion_limit(), 10)
         self.assertEqual(
             PromptManagerConfig.get_config()["autotag"],
-            {
-                "defaults": {
-                    "model_type": "wd14-swinv2",
-                    "existing": "skip",
-                    "general_threshold": 0.35,
-                    "character_threshold": 0.85,
-                    "suggestion_limit": 10,
-                }
-            },
+            {"defaults": {"suggestion_limit": 10}},
         )
-        # The built-in template is not written; a saved one is.
-        self.config_class.TEMPLATE = "Saved."
-        self.assertEqual(
-            PromptManagerConfig.get_config()["autotag"]["defaults"]["template"],
-            "Saved.",
-        )
-        self.config_class.TEMPLATE = config_module.DEFAULT_TAG_TEMPLATE
         with tempfile.TemporaryDirectory() as tmpdir:
             path = os.path.join(tmpdir, "config.json")
             PromptManagerConfig.update_config(
@@ -493,80 +466,6 @@ class TestAutotagConfig(unittest.TestCase):
                 )
                 self.assertEqual(self.config_class.suggestion_limit(), value)
 
-    def test_autotag_defaults_fall_back_per_key_on_load(self):
-        """#328: each saved tagging default is checked alone on load; a bad
-        hand-edited value falls back to its default with one warning and
-        leaves the other keys as saved."""
-        good = {
-            "model_type": "gguf",
-            "existing": "merge",
-            "general_threshold": 0.4,
-            "character_threshold": 0.7,
-            "template": "Tags only.",
-            "suggestion_limit": 15,
-        }
-        fallback = {
-            "model_type": "wd14-swinv2",
-            "existing": "skip",
-            "general_threshold": 0.35,
-            "character_threshold": 0.85,
-            "template": config_module.DEFAULT_TAG_TEMPLATE,
-            "suggestion_limit": 10,
-        }
-        bad_values = {
-            "model_type": ["wd14-convnext", 3, None],
-            "existing": ["replace", "", True],
-            "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],
-        }
-        for key, values in bad_values.items():
-            for value in values:
-                with self.subTest(key=key, value=value):
-                    saved = dict(good, **{key: value})
-                    with tempfile.TemporaryDirectory() as tmpdir:
-                        path = os.path.join(tmpdir, "config.json")
-                        with open(path, "w") as f:
-                            json.dump({"autotag": {"defaults": saved}}, f)
-                        with self.assertLogs(
-                            "prompt_manager.config", level="WARNING"
-                        ) as logs:
-                            PromptManagerConfig.load_from_file(path)
-                    self.assertEqual(len(logs.records), 1, logs.output)
-                    self.assertIn(f"autotag.defaults.{key}", logs.output[0])
-                    loaded = {
-                        k: getattr(self.config_class, attr)
-                        for k, (attr, _v, _d) in self.config_class._KEYS.items()
-                    }
-                    self.assertEqual(loaded, dict(good, **{key: fallback[key]}))
-
-    def test_tagging_validators_moved_with_their_messages(self):
-        validate_threshold = config_module.validate_threshold
-        validate_template = config_module.validate_template
-        self.assertEqual(validate_threshold("general_threshold", 1), 1.0)
-        for value, message in (
-            (float("nan"), "general_threshold must be a finite number"),
-            ("0.4", "general_threshold must be a finite number"),
-            (1.01, "general_threshold must be between 0 and 1"),
-        ):
-            with self.assertRaises(ValueError) as caught:
-                validate_threshold("general_threshold", value)
-            self.assertEqual(str(caught.exception), message)
-        self.assertEqual(validate_template("Tags."), "Tags.")
-        for value, message in (
-            ("  ", "instructions must be non-empty text"),
-            ("x" * 4001, "instructions must be at most 4000 characters"),
-            ("\ud800", "instructions must be valid Unicode text"),
-        ):
-            with self.assertRaises(ValueError) as caught:
-                validate_template(value)
-            self.assertEqual(str(caught.exception), message)
-        self.assertEqual(
-            config_module.MODEL_TYPES, {"gguf", "hf", "wd14-swinv2", "wd14-vit"}
-        )
-
     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_database.py

@@ -1398,50 +1398,6 @@ class TestModelHousekeeping(DatabaseTestCase):
         self.assertIsNot(self.db.model.get_connection(), failing)
 
 
-class TestAutotagBatchCandidates(DatabaseTestCase):
-    """#328: the batch's candidate read never loads workflow documents."""
-
-    def test_autotag_candidates_skip_workflow_data(self):
-        from utils.hashing import generate_prompt_hash
-
-        first = self.db.save_prompt(
-            text="a", tags=["one", "two"], prompt_hash=generate_prompt_hash("a")
-        )
-        second = self.db.save_prompt(text="b", prompt_hash=generate_prompt_hash("b"))
-        old = self.db.link_image_to_prompt(
-            first, "/out/a.png", {"workflow": {"big": "x" * 1000}}
-        )
-        new = self.db.link_image_to_prompt(second, "/out/b.png")
-        statements = []
-        conn = self.db.model.get_connection()  # this thread's own connection
-        conn.set_trace_callback(statements.append)
-        try:
-            rows = self.db.autotag_batch_candidates()
-        finally:
-            conn.set_trace_callback(None)
-        self.assertEqual(
-            rows[0],
-            {
-                "id": new,
-                "image_path": "/out/b.png",
-                "prompt_id": second,
-                "prompt_tags": [],
-            },
-        )
-        self.assertEqual(
-            {**rows[1], "prompt_tags": sorted(rows[1]["prompt_tags"])},
-            {
-                "id": old,
-                "image_path": "/out/a.png",
-                "prompt_id": first,
-                "prompt_tags": ["one", "two"],
-            },
-        )
-        self.assertEqual(len(rows), 2)
-        self.assertTrue(statements)
-        self.assertFalse(any("workflow_data" in sql for sql in statements))
-
-
 if __name__ == "__main__":
     unittest.main()
 

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,17 +339,15 @@ 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()
             self.assertTrue(registration.dispose(2))
 

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()), {})

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

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,61 +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)
-        with self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs:
-            self.assertFalse(self.monitor.stop_monitoring())
-        self.assertIn("Error while stopping image monitoring", "\n".join(logs.output))
-        fake.stop_error = None  # tearDown's stop calls stop() again
-
-    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):
@@ -405,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:
@@ -473,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()
@@ -612,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):
@@ -627,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)."""
 
@@ -675,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
@@ -768,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_image_tag_jobs.py

@@ -310,7 +310,7 @@ class TestAutoTag(ImageTagJobTestCase):
         self.assertTrue(
             any(
                 line.endswith(
-                    "is not downloaded. Download it in System › Auto-tagging."
+                    "is not downloaded. Download it from the legacy Auto-tag page."
                 )
                 for line in job.log
             ),

tests/test_job_admission.py

@@ -460,7 +460,7 @@ class TestLegacyRoutesHoldTheRegistry(_LegacyHoldCase):
     async def test_second_legacy_autotag_batch_keeps_its_json_409(self):
         from py.api.autotag_routes import _BUSY_ERROR
 
-        self._run_job("autotag", "Tag output images (legacy page)")
+        self._run_job("autotag", "Auto-tag images (legacy page)")
         resp = await self.client.request(
             "POST", "/prompt_manager/autotag/start", json={}
         )

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

@@ -976,129 +976,3 @@ class TestSourceFormError(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
-
-
-class TestAutotagDefaultsSettings(SourcesTestCase):
-    """#328: the tagging defaults save through POST /settings like the others."""
-
-    ATTRS = (
-        "MODEL_TYPE",
-        "EXISTING",
-        "GENERAL_THRESHOLD",
-        "CHARACTER_THRESHOLD",
-        "TEMPLATE",
-        "SUGGESTION_LIMIT",
-    )
-    SAVED = {
-        "autotag_model_type": "gguf",
-        "autotag_existing": "merge",
-        "autotag_general_threshold": 0.4,
-        "autotag_character_threshold": 0.8,
-        "autotag_template": "Tags only.",
-        "autotag_suggestion_limit": 15,
-    }
-
-    async def asyncSetUp(self):
-        await super().asyncSetUp()
-        from py.config import AutotagConfig
-
-        self.autotag = AutotagConfig
-        for attr in self.ATTRS:
-            self.addCleanup(setattr, AutotagConfig, attr, getattr(AutotagConfig, attr))
-
-    def _runtime(self):
-        return {attr: getattr(self.autotag, attr) for attr in self.ATTRS}
-
-    async def test_autotag_defaults_save_round_trip(self):
-        self._write_config({"custom": {"keep": True}})
-        revision = (await self._get())["revision"]
-        status, data = await self._post(
-            "/prompt_manager/settings", {"expected_revision": revision, **self.SAVED}
-        )
-        self.assertEqual(status, 200, data)
-        self.assertEqual(data["restart_required_fields"], [])
-        saved = self._read_config()
-        self.assertEqual(
-            saved["autotag"]["defaults"],
-            {key[len("autotag_") :]: value for key, value in self.SAVED.items()},
-        )
-        self.assertEqual(saved["custom"], {"keep": True})
-        self.assertEqual(
-            self._runtime(),
-            {
-                "MODEL_TYPE": "gguf",
-                "EXISTING": "merge",
-                "GENERAL_THRESHOLD": 0.4,
-                "CHARACTER_THRESHOLD": 0.8,
-                "TEMPLATE": "Tags only.",
-                "SUGGESTION_LIMIT": 15,
-            },
-        )
-        settings = (await self._get())["settings"]
-        self.assertEqual({key: settings[key] for key in self.SAVED}, self.SAVED)
-
-    async def test_stale_revision_changes_no_default(self):
-        revision = (await self._get())["revision"]
-        self._write_config({"custom": {"edited": "elsewhere"}})
-        before = (self._config_bytes(), self._runtime())
-        status, data = await self._post(
-            "/prompt_manager/settings", {"expected_revision": revision, **self.SAVED}
-        )
-        self.assertEqual(status, 409, data)
-        self.assertEqual(data["code"], "settings-changed")
-        self.assertEqual((self._config_bytes(), self._runtime()), before)
-
-    async def test_bad_default_message_names_the_setting(self):
-        cases = (
-            (
-                "autotag_general_threshold",
-                1.5,
-                "General-tag confidence must be between 0 and 1.",
-            ),
-            (
-                "autotag_character_threshold",
-                "0.8",
-                "Character-tag confidence must be a finite number.",
-            ),
-            (
-                "autotag_character_threshold",
-                True,
-                "Character-tag confidence must be a finite number.",
-            ),
-            (
-                "autotag_model_type",
-                "wd14-convnext",
-                "Tagging model must be one of gguf, hf, wd14-swinv2, wd14-vit.",
-            ),
-            (
-                "autotag_existing",
-                "replace",
-                "Existing tags must be skip, merge or replace_after_review.",
-            ),
-            ("autotag_template", " ", "LLM tag template must be non-empty text."),
-            (
-                "autotag_template",
-                "x" * 4001,
-                "LLM tag template must be at most 4000 characters.",
-            ),
-            (
-                "autotag_suggestion_limit",
-                0,
-                "Suggestions per image must be a whole number from 1 to 100.",
-            ),
-            (
-                "autotag_suggestion_limit",
-                2.5,
-                "Suggestions per image must be a whole number from 1 to 100.",
-            ),
-        )
-        self._write_config({"custom": {"keep": True}})
-        before = (self._config_bytes(), self._runtime())
-        for key, value, message in cases:
-            with self.subTest(key=key, value=value):
-                status, data = await self._post(
-                    "/prompt_manager/settings", {**self.SAVED, key: value}
-                )
-                self.assertEqual(status, 400, data)
-                self.assertEqual(data["error"], message)
-                self.assertEqual((self._config_bytes(), self._runtime()), before)

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/"
@@ -981,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
@@ -1024,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)

tools/vendor/frontend-coverage-baseline.json

@@ -545,12 +545,6 @@
     "functions": 98,
     "statements": 98
   },
-  "workspace/system-tagging.mjs": {
-    "lines": 80,
-    "branches": 70,
-    "functions": 75,
-    "statements": 80
-  },
   "workspace/system-thumbnails.mjs": {
     "lines": 98,
     "branches": 95,

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,69 +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.
-        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 observer_ok:
-                self.logger.warning(
-                    f"watchdog observer still running after {timeout} s"
-                )
-            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 bounded join."""
         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
-        return not observer.is_alive()
+        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/admin.html

@@ -1428,13 +1428,12 @@ No sentences, no commentary, no captions. Only tags. Keep length short but descr
                 <div class="w-full bg-pm-input rounded-full h-1.5">
                     <div id="downloadProgressBar" class="bg-pm-accent h-1.5 rounded-full transition-all duration-300" style="width: 0%"></div>
                 </div>
-                <p class="text-pm-secondary text-xs mt-2">The download continues in Activity.</p>
             </div>
 
             <div class="flex justify-center">
                 <button id="cancelDownloadBtn"
                         class="px-3 py-1.5 text-pm-error bg-transparent hover:bg-pm-error-tint border border-pm text-xs font-medium rounded-pm-sm transition-colors">
-                    Close
+                    Cancel
                 </button>
             </div>
         </div>

web/gallery.html

@@ -730,14 +730,13 @@ No sentences, no commentary, no captions. Only tags. Keep length short but descr
                 <div class="w-full bg-pm-input rounded-full h-2">
                     <div id="downloadProgressBar" class="bg-pm-accent h-2 rounded-full transition-all duration-300" style="width: 0%"></div>
                 </div>
-                <p class="text-pm-secondary text-xs mt-2">The download continues in Activity.</p>
             </div>
 
             <!-- Cancel Button -->
             <div class="flex justify-center">
                 <button id="cancelDownloadBtn"
                         class="px-3 py-1 bg-pm-error hover:bg-pm-error text-pm text-xs font-medium rounded-pm-sm transition-colors">
-                    Close
+                    Cancel
                 </button>
             </div>
         </div>

web/js/admin.js

@@ -3689,7 +3689,6 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 document.getElementById('downloadStatus').textContent = 'Preparing...';
                 document.getElementById('downloadProgressPercent').textContent = '0%';
                 document.getElementById('downloadProgressBar').style.width = '0%';
-                document.getElementById('downloadProgressBar').classList.remove('animate-pulse');
 
                 this.hideModal("autoTagModal");
                 this.showModal("autoTagDownloadModal");
@@ -3700,21 +3699,18 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     this.autoTagState.downloadEventSource.onmessage = (event) => {
                         const data = JSON.parse(event.data);
 
-                        // The server sends `type` (progress / complete / error); the download is an
-                        // Activity job with no byte progress, so the bar is indeterminate (#328).
-                        if (data.type === 'progress') {
-                            document.getElementById('downloadStatus').textContent = 'Downloading\u2026';
-                            document.getElementById('downloadProgressPercent').textContent = '';
-                            const bar = document.getElementById('downloadProgressBar');
-                            bar.style.width = '100%';
-                            bar.classList.add('animate-pulse');
-                        } else if (data.type === 'complete') {
+                        if (data.status === 'downloading') {
+                            const percent = Math.round(data.progress * 100);
+                            document.getElementById('downloadStatus').textContent = data.message || 'Downloading...';
+                            document.getElementById('downloadProgressPercent').textContent = `${percent}%`;
+                            document.getElementById('downloadProgressBar').style.width = `${percent}%`;
+                        } else if (data.status === 'complete') {
                             this.autoTagState.downloadEventSource.close();
                             this.hideModal("autoTagDownloadModal");
                             this.showModal("autoTagModal");
                             this.checkAutoTagModels();
                             this.showNotification('Model downloaded successfully!', 'success');
-                        } else if (data.type === 'error') {
+                        } else if (data.status === 'error') {
                             this.autoTagState.downloadEventSource.close();
                             this.hideModal("autoTagDownloadModal");
                             this.showModal("autoTagModal");
@@ -3970,8 +3966,6 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 }
 
                 document.getElementById('reviewImage').src = imageUrl;
-                // The record's file name, else the last segment of its path (#328: `filename` was never declared).
-                const filename = image.filename || String(image.image_path || image.path || '').split(/[\\/]/).pop();
                 document.getElementById('reviewImageName').textContent = filename || 'Unknown';
                 document.getElementById('reviewTagsVisible').innerHTML = '<div class="text-pm-secondary">Generating tags...</div>';
                 document.getElementById('reviewTagsHidden').innerHTML = '';

web/js/api-client.js

@@ -67,12 +67,6 @@
                 current.source.length > 0 && current.source.length <= 4096) {
                 this.source = current.source;
             }
-            // A model-busy answer names the operation that holds the tagging model (#328).
-            this.operation = null;
-            if (this.code === "model-busy" && current && typeof current.operation === "string" &&
-                current.operation.length > 0 && current.operation.length <= 200) {
-                this.operation = current.operation;
-            }
         }
     }
 

web/js/gallery.js

@@ -3421,7 +3421,6 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 document.getElementById('downloadStatus').textContent = 'Preparing...';
                 document.getElementById('downloadProgressPercent').textContent = '0%';
                 document.getElementById('downloadProgressBar').style.width = '0%';
-                document.getElementById('downloadProgressBar').classList.remove('animate-pulse');
 
                 this.hideModal("autoTagModal");
                 this.showModal("autoTagDownloadModal");
@@ -3432,21 +3431,18 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     this.autoTagState.downloadEventSource.onmessage = (event) => {
                         const data = JSON.parse(event.data);
 
-                        // The server sends `type` (progress / complete / error); the download is an
-                        // Activity job with no byte progress, so the bar is indeterminate (#328).
-                        if (data.type === 'progress') {
-                            document.getElementById('downloadStatus').textContent = 'Downloading\u2026';
-                            document.getElementById('downloadProgressPercent').textContent = '';
-                            const bar = document.getElementById('downloadProgressBar');
-                            bar.style.width = '100%';
-                            bar.classList.add('animate-pulse');
-                        } else if (data.type === 'complete') {
+                        if (data.status === 'downloading') {
+                            const percent = Math.round(data.progress * 100);
+                            document.getElementById('downloadStatus').textContent = data.message || 'Downloading...';
+                            document.getElementById('downloadProgressPercent').textContent = `${percent}%`;
+                            document.getElementById('downloadProgressBar').style.width = `${percent}%`;
+                        } else if (data.status === 'complete') {
                             this.autoTagState.downloadEventSource.close();
                             this.hideModal("autoTagDownloadModal");
                             this.showModal("autoTagModal");
                             this.checkAutoTagModels();
                             this.showNotification('Model downloaded successfully!', 'success');
-                        } else if (data.type === 'error') {
+                        } else if (data.status === 'error') {
                             this.autoTagState.downloadEventSource.close();
                             this.hideModal("autoTagDownloadModal");
                             this.showModal("autoTagModal");
@@ -3547,25 +3543,29 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     this.autoTagState.eventSource.onmessage = (event) => {
                         const data = JSON.parse(event.data);
 
-                        // The server sends `type` frames, as the admin page reads them (#328).
-                        if (data.type === 'progress') {
-                            document.getElementById('autoTagCurrentFile').textContent = data.status || 'Processing...';
-                            document.getElementById('autoTagProgressPercent').textContent = `${data.progress || 0}%`;
-                            document.getElementById('autoTagProgressBar').style.width = `${data.progress || 0}%`;
-                            if (data.processed !== undefined) {
-                                document.getElementById('autoTagProcessed').textContent = data.processed;
-                                document.getElementById('autoTagApplied').textContent = data.tagged || 0;
-                                document.getElementById('autoTagSkipped').textContent = data.skipped || 0;
-                            }
-                        } else if (data.type === 'complete') {
+                        if (data.status === 'loading_model') {
+                            document.getElementById('autoTagCurrentFile').textContent = 'Loading model...';
+                        } else if (data.status === 'processing') {
+                            const percent = Math.round((data.processed / data.total) * 100);
+                            document.getElementById('autoTagCurrentFile').textContent = data.current_file || 'Processing...';
+                            document.getElementById('autoTagProgressPercent').textContent = `${percent}%`;
+                            document.getElementById('autoTagProgressBar').style.width = `${percent}%`;
+                            document.getElementById('autoTagProcessed').textContent = data.processed;
+                            document.getElementById('autoTagApplied').textContent = data.tags_applied;
+                            document.getElementById('autoTagSkipped').textContent = data.skipped;
+                        } else if (data.status === 'complete') {
                             this.autoTagState.eventSource.close();
                             this.hideModal("autoTagProgressModal");
-                            this.showNotification(`Auto tagging complete! Applied tags to ${data.tagged || 0} prompts.`, 'success');
+                            this.showNotification(`Auto tagging complete! Applied tags to ${data.tags_applied} prompts.`, 'success');
                             this.loadImages(); // Refresh the gallery
-                        } else if (data.type === 'error') {
+                        } else if (data.status === 'error') {
                             this.autoTagState.eventSource.close();
                             this.hideModal("autoTagProgressModal");
                             this.showNotification(`Auto tag error: ${data.message}`, 'error');
+                        } else if (data.status === 'cancelled') {
+                            this.autoTagState.eventSource.close();
+                            this.hideModal("autoTagProgressModal");
+                            this.showNotification('Auto tagging cancelled', 'info');
                         }
                     };
 

web/js/workspace/activity-kinds.mjs

@@ -104,24 +104,6 @@ function maintenanceFinish(job) {
 // D85: an image tagging job says which of its two modes started.
 const IMAGE_TAG_START_TOASTS = Object.freeze({ add: 'Tagging started.', auto: 'Auto-tagging started.' });
 
-/** D89: the image tagging job's view, shared with Tag output images (#328). */
-const IMAGE_TAGS = Object.freeze({
-    ...GENERIC,
-    pillVerb: 'Tagging',
-    startToast: job => IMAGE_TAG_START_TOASTS[job.scope?.mode] ?? titleStarted(job),
-    finishToast: namedFinish(job => job.title, taggedOf, tagLine),
-    line: tagLine,
-    kept: taggedOf,
-    scope: imagesOf,
-    tiles: tiles([['tagged', 'Tagged', 'added'], ['unchanged', 'Unchanged', ''], ['skipped', 'Skipped', 'warn'],
-        ['errors', 'Errors', 'bad']]),
-    outcomes: tiles([['tagged', 'Tagged'], ['errors', 'Errors'], ['skipped', 'Skipped'], ['unchanged', 'Unchanged']]),
-    openable: groups('tagged', 'unchanged'),
-    log: 'Tagging log',
-    cancelLabel: 'Cancel tagging',
-    cancel: 'Cancel tagging',
-});
-
 /** Every kind with a descriptor of its own. */
 export const KINDS = Object.freeze({
     __proto__: null,
@@ -143,10 +125,22 @@ export const KINDS = Object.freeze({
         cancel: 'Cancel scan',
     }),
     // D89: Tagged (green), Unchanged, Skipped (warning) and Errors (red); Tagged and Unchanged rows open the viewer.
-    'image-tags': IMAGE_TAGS,
-    // #328 (extends D111): Tag output images, the prompt-tag batch, counts its images the same way. Its legacy-page
-    // hold counts nothing and is not cancellable, so `viewOf` gives it the generic held view.
-    autotag: IMAGE_TAGS,
+    'image-tags': Object.freeze({
+        ...GENERIC,
+        pillVerb: 'Tagging',
+        startToast: job => IMAGE_TAG_START_TOASTS[job.scope?.mode] ?? titleStarted(job),
+        finishToast: namedFinish(job => job.title, taggedOf, tagLine),
+        line: tagLine,
+        kept: taggedOf,
+        scope: imagesOf,
+        tiles: tiles([['tagged', 'Tagged', 'added'], ['unchanged', 'Unchanged', ''], ['skipped', 'Skipped', 'warn'],
+            ['errors', 'Errors', 'bad']]),
+        outcomes: tiles([['tagged', 'Tagged'], ['errors', 'Errors'], ['skipped', 'Skipped'], ['unchanged', 'Unchanged']]),
+        openable: groups('tagged', 'unchanged'),
+        log: 'Tagging log',
+        cancelLabel: 'Cancel tagging',
+        cancel: 'Cancel tagging',
+    }),
     // D111: Generated (green), Skipped (already fresh) and Errors (red); a row with a preview opens the viewer.
     thumbnails: Object.freeze({
         ...GENERIC,

web/js/workspace/image-tagging-state.mjs

@@ -179,15 +179,14 @@ function validateReceipt(value) {
 }
 
 /**
- * Thresholds, instructions and suggestion count from the server, else the documented defaults, the models'
- * download status (`models`, null when unknown) and the saved tagging model (`model`, null when unknown; #328).
+ * Thresholds, instructions and suggestion count from the server, else the documented defaults, and the models'
+ * download status (`models`, null when unknown).
  */
 async function readDefaults(api, signal) {
     try {
         const value = await api.get(MODELS_URL, {signal, cache: 'no-store'});
-        if (!object(value)) return {defaults: DEFAULTS, models: null, model: null};
+        if (!object(value)) return {defaults: DEFAULTS, models: null};
         return {
-            model: typeof value.model_type === 'string' && modelOf(value.model_type) ? value.model_type : null,
             defaults: {
                 general_threshold: unit(value.wd14_general_threshold) ? value.wd14_general_threshold : DEFAULTS.general_threshold,
                 character_threshold: unit(value.wd14_character_threshold) ? value.wd14_character_threshold : DEFAULTS.character_threshold,
@@ -198,11 +197,11 @@ async function readDefaults(api, signal) {
         };
     } catch {
         // The defaults keep the dialog usable; Generate reports a real failure itself.
-        return {defaults: DEFAULTS, models: null, model: null};
+        return {defaults: DEFAULTS, models: null};
     }
 }
 
-export const UNAVAILABLE_HINT = 'Download it in System › Auto-tagging.';
+const UNAVAILABLE_HINT = 'Download it from the legacy Auto-tag page.';
 /**
  * Why `model` cannot run, from the `/autotag/models` status (the server's own `model-unavailable` sentence), else ''
  * (downloaded, or the status is unknown: the job then reports a missing model itself).
@@ -264,7 +263,6 @@ export function createImageTaggingController({api, target, source = 'images', on
     requireValue(SOURCES.has(source), 'Unknown tagging source');
     requireValue(typeof onLateSave === 'function', 'onLateSave must be a function');
     const chosen = validatePreset(preset);
-    let modelPicked = false; // the user chose a model: the saved one no longer applies
 
     let state = freeze(derive(initialState(source, chosen)));
     const listeners = new Set();
@@ -338,11 +336,8 @@ export function createImageTaggingController({api, target, source = 'images', on
         }
         capture = {token: value.capture.token, sha256: value.capture.sha256};
         epoch = value.library_epoch;
-        const read = await defaultsRead;
-        ({defaults} = read);
+        ({defaults} = await defaultsRead);
         if (closed || serial !== openSerial) return;
-        // The saved model (System › Auto-tagging) unless a preset or the user already chose one (#328).
-        const savedModel = !chosen && !modelPicked && read.model ? {model: read.model} : {};
         observedOnce = true;
         const {width, height, media_type: mediaType, preview_url: previewUrl, generate} = value.capture;
         // A kept draft stays as typed unless another writer changed the set meanwhile: then the set leads it (I2).
@@ -355,7 +350,7 @@ export function createImageTaggingController({api, target, source = 'images', on
             savedTags: value.tags.slice(), tagRevision: value.tag_revision,
             manual: draft === null ? value.tags.join(', ') : changed ? mergeCurrent(value.tags, draft) : draft,
             draftRevision: state.draftRevision + 1,
-            ...savedModel, options: {...defaults, ...chosen?.options}, optionsRevision: state.optionsRevision + 1,
+            options: {...defaults, ...chosen?.options}, optionsRevision: state.optionsRevision + 1,
             generateSupported: generate.supported, generateReason: generate.reason,
             statusText: changed ? `${COPY.changedElsewhere} ${savedNow(value.tags)}${reason ? ` ${reason}` : ''}` : reason,
         });
@@ -367,9 +362,7 @@ export function createImageTaggingController({api, target, source = 'images', on
 
     function setModel(id) {
         requireValue(modelOf(id), 'Unknown tagging model');
-        if (closed) return;
-        modelPicked = true;
-        if (id === state.model) return;
+        if (closed || id === state.model) return;
         stopGenerating();
         const phase = state.phase === 'generating' || state.phase === 'generate-error' ? 'ready' : state.phase;
         set({
@@ -542,7 +535,6 @@ export function createTaggingOptionsController({api} = {}) {
     let defaults = DEFAULTS;
     let models = null;
     let abort = null;
-    let modelPicked = false;
     const deriveOptions = value => ({...value, canGenerate: false, unavailable: modelUnavailable(models, value.model),
         canStart: value.phase === 'ready' && !modelUnavailable(models, value.model)});
     let state = freeze(deriveOptions({phase: 'loading', model: MODEL_OPTIONS[0].id, options: {...DEFAULTS}, optionsRevision: 0}));
@@ -558,15 +550,11 @@ export function createTaggingOptionsController({api} = {}) {
         const read = await readDefaults(api, abort.signal);
         if (closed) return;
         ({defaults, models} = read);
-        // The saved model (System › Auto-tagging) unless the user already chose one (#328).
-        const savedModel = !modelPicked && read.model ? {model: read.model} : {};
-        set({phase: 'ready', ...savedModel, options: {...defaults}, optionsRevision: state.optionsRevision + 1});
+        set({phase: 'ready', options: {...defaults}, optionsRevision: state.optionsRevision + 1});
     }
     function setModel(id) {
         requireValue(modelOf(id), 'Unknown tagging model');
-        if (closed) return;
-        modelPicked = true;
-        if (id === state.model) return;
+        if (closed || id === state.model) return;
         // As in the Tag image dialog: the model's fields start from the defaults again; the count is kept (D91).
         set({model: id, optionsRevision: state.optionsRevision + 1,
             options: {...state.options, general_threshold: defaults.general_threshold,

web/js/workspace/system-integrations.mjs

@@ -24,7 +24,7 @@ import { createButton } from '../shared/toolkit/core.js';
 import { createBridgeClient } from '../shared/toolkit/prompt-bridge.js';
 import { settingRow, operationRow } from './system-controls.mjs';
 import { HOST_UNAVAILABLE } from './system-appearance.mjs';
-import { openCloseOnlyReview, openReviewDialog } from './workspace-dialogs.mjs';
+import { closeWorkspaceDialog, openContentDialog, openReviewDialog } from './workspace-dialogs.mjs';
 import { BACKUP_COPY, applyPlan, backupText, planNote, protectedText, reviewRefusal } from './maintenance-review.mjs';
 import { downloadDatabaseBackup } from './activity-scan.mjs';
 import { showWorkspaceToast } from './toast.mjs';
@@ -232,10 +232,26 @@ function namesList(plan) {
     return [list];
 }
 
+/** The settings file (home shown as `~`) as the LoraManager row's hover title. */
+function settingsTitle(dd, plan) {
+    if (typeof plan.layout?.settings_file === 'string') dd.title = plan.layout.settings_file;
+}
+
 function closeOnly({ scope, trigger, plan, note }) {
-    const titles = typeof plan.layout?.settings_file === 'string' ? { [LAYOUT_TERM]: plan.layout.settings_file } : {};
-    openCloseOnlyReview({ scope, trigger, title: IMPORT_TITLE, heading: 'LoRA reference data', grid: importGrid(plan),
-        options: namesList(plan), sentence: note, titles });
+    const grid = el('dl', undefined, 'meta-grid');
+    for (const [term, value] of importGrid(plan)) {
+        const entry = el('div');
+        const dd = el('dd', value);
+        if (term === LAYOUT_TERM) settingsTitle(dd, plan);
+        entry.append(el('dt', term), dd);
+        grid.append(entry);
+    }
+    const close = createButton('Close');
+    close.addEventListener('click', () => closeWorkspaceDialog());
+    const actions = el('div', undefined, 'dialog-actions');
+    actions.append(close);
+    openContentDialog({ scope, trigger, title: IMPORT_TITLE, nodes: [el('h3', 'LoRA reference data'), grid, ...namesList(plan),
+        el('p', note, 'small'), actions] });
 }
 
 /** Show the reviewed import; Start applies exactly this token (D107). */

web/js/workspace/system-state.mjs

@@ -22,8 +22,7 @@
  * write that saved part of its changes throws with `partial: {saved: [keys], revision}`: those keys are saved, the
  * revision is adopted and only the rest fail (`partial`, S10). A host
  * write refused as `invalid-source` (its error's `source` and server message) makes that message the status and
- * `invalidSource()` that source, so Sources marks its row (S4). One refused as `invalid-setting` (S11: the server
- * named the setting it refused) makes that message the status too, naming no source.
+ * `invalidSource()` that source, so Sources marks its row (S4).
  */
 export { SYSTEM_SECTIONS, isSystemSection } from './state.mjs';
 
@@ -49,9 +48,6 @@ export const RESTART_LABELS = Object.freeze({ monitoring_enabled: 'Watch for new
 export const DRAFT_DOMAINS = Object.freeze(['browser', 'host', 'runtime']);
 const CONFLICT_CODE = 'settings-changed';
 const INVALID_SOURCE_CODE = 'invalid-source';
-/** S11: a `/settings` save refused for one value (a 400 whose message names the setting, e.g. a confidence of 1.5). */
-export const INVALID_SETTING_CODE = 'invalid-setting';
-const MESSAGE_CODES = new Set([INVALID_SOURCE_CODE, INVALID_SETTING_CODE]);
 const ADAPTERS = ['readBrowser', 'readHost', 'readRuntime', 'writeBrowser', 'writeHost', 'writeRuntime'];
 
 /**
@@ -186,9 +182,8 @@ export function createSystemDrafts(adapters) {
             commit(domain, written);
             return 'applied';
         } catch (error) {
-            if (domain === 'host' && MESSAGE_CODES.has(error?.code) && typeof error.message === 'string') {
-                const source = error.code === INVALID_SOURCE_CODE && typeof error.source === 'string' ? error.source : null;
-                hostDetail.invalid = { source, message: error.message };
+            if (domain === 'host' && error?.code === INVALID_SOURCE_CODE && typeof error.message === 'string') {
+                hostDetail.invalid = { source: typeof error.source === 'string' ? error.source : null, message: error.message };
             }
             const partial = domain === 'host' ? error?.partial : null;
             if (partial && Array.isArray(partial.saved)) {

web/js/workspace/system-tagging.mjs

@@ -1,503 +0,0 @@
-/**
- * System › Auto-tagging (#328, System S11 Tasks 6–7): the concept's `renderSystem` "tagging" body (app.js 685–686).
- *
- * One `section.surface` "Auto-tagging" with the concept's rows, in its order, built with system-controls.mjs:
- * - "Tagging model" (`#tag-model`, host key `autotag_model_type`). D132: the four real engines in the concept's order,
- *   each `<label> · <size_label>` from `GET /prompt_manager/autotag/models` (read once per mount; it never loads or
- *   downloads a model), and the row's description is the chosen model's live status instead of the concept's design
- *   note. While the read is pending the select is disabled and says "Loading model status…".
- * - "Existing tags", "General-tag confidence", "Character-tag confidence": the concept's labels and descriptions
- *   verbatim (they state the shipped defaults); host keys `autotag_existing`, `autotag_general_threshold`,
- *   `autotag_character_threshold`. D133 adds "Suggestions per image" (`autotag_suggestion_limit`, 1–100) after them.
- * - The `.field` "LLM tag template" (`#tag-template`, `autotag_template`).
- * - `.row-actions`: "Preview tagging review" (`ca-primary`) opens the Tag image dialog for the image selected in Images
- *   with the section's current model and values, aria-disabled without one (the D115 sentence) or with an invalid
- *   value (the toast names it). D132: the concept's two simulated job buttons are "Download" (or
- *   "Download again" for a model on disk), which starts the `model_download` Activity job and opens it, and "Unload",
- *   a direct `POST /autotag/unload` (enabled while a model is loaded; a busy model's refusal names the operation).
- * - D134: the `.operation` "Tag output images" › "Review" previews the prompt-tag batch
- *   (`POST /autotag/batch/preview`, read-only) and shows it in the shared review dialog with the D55 backup box; "Start
- *   tagging" runs the cancellable `autotag` Activity job. A review that cannot start (Replace after review, a short
- *   disk, nothing to tag) offers only Cancel and says why.
- *
- * Every value is a host draft saved by the one Save row (system.mjs); every listener sits on the section's scope.
- */
-import { createButton } from '../shared/toolkit/core.js';
-import { settingRow, operationRow } from './system-controls.mjs';
-import { HOST_UNAVAILABLE } from './system-appearance.mjs';
-import { openCloseOnlyReview, openReviewDialog } from './workspace-dialogs.mjs';
-import { BACKUP_COPY, backupText, holding, reviewRefusal } from './maintenance-review.mjs';
-import { busyToast, downloadDatabaseBackup } from './activity-scan.mjs';
-import { MODEL_OPTIONS } from './image-tagging-state.mjs';
-import { openImageTagging } from './image-tagging.mjs';
-import { selectedImage } from './images.mjs';
-import { NO_SELECTION } from './vocabulary.mjs';
-import { showWorkspaceToast } from './toast.mjs';
-import { navigateTo } from './state.mjs';
-
-export const MODELS_URL = '/prompt_manager/autotag/models';
-export const UNLOAD_URL = '/prompt_manager/autotag/unload';
-export const BATCH_PREVIEW_URL = '/prompt_manager/autotag/batch/preview';
-export const DOWNLOAD_KIND = 'model-download';
-export const BATCH_KIND = 'autotag';
-export const REVIEW_TITLE = 'Review tag output images';
-export const BATCH_TITLE = 'Tag output images';
-export const START_LABEL = 'Start tagging';
-export const INTRO = 'One tagging configuration for images and prompt-library actions. Every result can be reviewed before applying.';
-export const BATCH_DESCRIPTION = 'Add tags to each prompt from its linked output images with the model above. Review the scope first.';
-export const SUGGESTIONS_DESCRIPTION = 'From 1 to 100: the most suggestions Generate shows for one image.';
-
-/** D132: the engines in the concept's order, with the labels and sizes the server states when it cannot be read. */
-export const MODEL_LABELS = Object.freeze({
-    'wd14-swinv2': Object.freeze({ label: 'WD14 SwinV2', size: '~400 MB' }),
-    'wd14-vit': Object.freeze({ label: 'WD14 ViT', size: '~400 MB' }),
-    gguf: Object.freeze({ label: 'GGUF JoyCaption', size: '~4.5 GB' }),
-    hf: Object.freeze({ label: 'HuggingFace JoyCaption', size: '~16 GB' }),
-});
-export const MODEL_IDS = Object.freeze(MODEL_OPTIONS.map(option => option.id));
-const CLASSIFIERS = new Set(MODEL_OPTIONS.filter(option => option.classifier).map(option => option.id));
-
-export const EXISTING_OPTIONS = Object.freeze([['skip', 'Skip already tagged'], ['merge', 'Merge with existing'],
-    ['replace_after_review', 'Replace after review']]);
-
-/** The host draft key of each control (`id` → key). */
-export const SETTING_KEYS = Object.freeze({
-    'tag-model': 'autotag_model_type',
-    'tag-existing': 'autotag_existing',
-    'threshold-general': 'autotag_general_threshold',
-    'threshold-character': 'autotag_character_threshold',
-    'tag-suggestions': 'autotag_suggestion_limit',
-    'tag-template': 'autotag_template',
-});
-const NUMERIC = new Set(['autotag_general_threshold', 'autotag_character_threshold', 'autotag_suggestion_limit']);
-const MAX_TEMPLATE_CHARS = 4000;
-
-export const STATUS_COPY = Object.freeze({
-    loading: 'Loading model status…',
-    failed: 'Model status could not be read.',
-    downloaded: 'Downloaded. Not loaded.',
-    loaded: 'Downloaded and loaded.',
-    partial: 'Partly downloaded. Download again to finish.',
-    missing: size => `Not downloaded. Download size ${size}.`,
-});
-
-/** The messages that name a setting the section cannot use (the server's own wording). */
-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.',
-    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.',
-    autotag_template_length: `LLM tag template must be at most ${MAX_TEMPLATE_CHARS} characters.`,
-});
-/** Characters as Python's `len` counts them (code points), not UTF-16 units. */
-export const characters = text => [...String(text ?? '')].length;
-
-export const REPLACE_NOTE = 'Replacing tags needs a review of each image. Use Preview tagging review, or choose Skip or Merge for a batch run.';
-export const NOTHING_TO_TAG = 'Every prompt with an output image is already tagged.';
-export const NO_LINKED_IMAGES = 'No output image is linked to a prompt yet, so there is nothing to tag.';
-export const STATUS_UNREAD = 'The model status is still being read. Try again in a moment.';
-export const SETTINGS_UNREAD = 'The settings are still being read. Try again in a moment.';
-export const UNLOAD_FAILED = 'The tagging model could not be unloaded. Try again.';
-export const UNKNOWN_MODEL = 'The saved tagging model is not one of these engines. Choose one and save preferences.';
-export const DISK_SHORT_UNKNOWN = 'Not enough free disk space for the safety backup. Nothing is written until there is room.';
-export const modelBusy = operation => `The tagging model is busy: ${operation || 'Another tagging operation'}. Try again when it finishes.`;
-export const notDownloaded = label => `${label} is not downloaded. Download it first.`;
-const START_SAYS = new Set(['model-unavailable', 'review-required', 'insufficient-space']);
-
-const number = value => (Number.isSafeInteger(value) ? value : 0).toLocaleString('en-US');
-const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
-
-function el(tag, text, className) {
-    const node = document.createElement(tag);
-    if (text !== undefined) node.textContent = text;
-    if (className) node.className = className;
-    return node;
-}
-
-/** The engine's display name: the server's label, else the documented one. */
-export function modelLabel(id, entry) {
-    return typeof entry?.label === 'string' && entry.label ? entry.label : MODEL_LABELS[id]?.label ?? id;
-}
-
-/** The download size the server states, else the documented one. */
-export function modelSize(id, entry) {
-    return typeof entry?.size_label === 'string' && entry.size_label ? entry.size_label : MODEL_LABELS[id]?.size ?? '';
-}
-
-/** D132 (OQ5): `<label> · <size_label>` per engine, in the concept's order. */
-export function modelOptions(models) {
-    return MODEL_IDS.map(id => [id, `${modelLabel(id, models?.[id])} · ${modelSize(id, models?.[id])}`]);
-}
-
-/**
- * D132: the Tagging model description for `status` (`{phase: loading|loaded|failed, models}`) and the chosen `model`.
- * GGUF with only one of its two files on disk is partly downloaded.
- */
-export function modelDescription(status, model) {
-    if (status?.phase === 'loading') return STATUS_COPY.loading;
-    const entry = status?.models?.[model];
-    if (status?.phase !== 'loaded' || !object(entry)) return STATUS_COPY.failed;
-    if (entry.downloaded === true) return entry.loaded === true ? STATUS_COPY.loaded : STATUS_COPY.downloaded;
-    if (partlyDownloaded(model, entry)) return STATUS_COPY.partial;
-    return STATUS_COPY.missing(modelSize(model, entry));
-}
-
-/** GGUF with only one of its two files on disk (a download that did not finish). */
-export const partlyDownloaded = (model, entry) => model === 'gguf' && object(entry) && entry.downloaded !== true
-    && entry.model_exists !== entry.mmproj_exists;
-
-/** D132 (OQ10): "Download again" for an engine on disk or partly on disk, else "Download". */
-export const downloadLabel = (model, entry) => (entry?.downloaded === true || partlyDownloaded(model, entry) ? 'Download again' : 'Download');
-
-/** The `/autotag/models` answer as section state: the per-engine entries and the loaded engine, if any. */
-export function readStatus(value) {
-    if (!object(value) || !object(value.models)) return { phase: 'failed', models: null, loadedType: null };
-    const loadedType = value.model_loaded === true && MODEL_IDS.includes(value.loaded_model_type) ? value.loaded_model_type : null;
-    return { phase: 'loaded', models: value.models, loadedType };
-}
-
-/** A number control's draft: a number when its text is one, else the trimmed text (the server then names the setting). */
-export function coerceNumber(text) {
-    const value = String(text ?? '').trim();
-    if (value === '') return value;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : value;
-}
-
-/** The draft value a control's text stands for. */
-export function draftValue(key, text) {
-    return NUMERIC.has(key) ? coerceNumber(text) : String(text ?? '');
-}
-
-const unit = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
-
-/**
- * The first setting the chosen model would use that the section cannot send, as `{key, message}`, else null: WD14
- * 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;
-    const keys = CLASSIFIERS.has(model) ? ['autotag_general_threshold', 'autotag_character_threshold'] : ['autotag_template'];
-    if (limit) keys.push('autotag_suggestion_limit');
-    for (const key of keys) {
-        const value = values[key];
-        if (key === 'autotag_template') {
-            if (typeof value !== 'string' || value.trim() === '') return { key, message: SETTING_PROBLEMS.autotag_template };
-            if (characters(value) > MAX_TEMPLATE_CHARS) return { key, message: SETTING_PROBLEMS.autotag_template_length };
-            continue;
-        }
-        const valid = key === 'autotag_suggestion_limit' ? Number.isInteger(value) && value >= 1 && value <= 100 : unit(value);
-        if (!valid) return { key, message: SETTING_PROBLEMS[key] };
-    }
-    return null;
-}
-
-/** The Tag image dialog's preset (`{model, options}`) from the drafts: only the chosen model's own options. */
-export function taggingPreset(values) {
-    const model = values.autotag_model_type;
-    const options = CLASSIFIERS.has(model)
-        ? { 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 } };
-}
-
-/** The `POST /jobs/autotag` body for the drafts (WD14: both thresholds; the language models: the template). */
-export function batchBody(values) {
-    const model = values.autotag_model_type;
-    const options = CLASSIFIERS.has(model)
-        ? { 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 };
-}
-
-/** The toast for a start the server refused or that failed (`what` names the action). */
-export function startRefusal(error, what) {
-    if (error?.code === 'model-busy') return modelBusy(error.operation);
-    if (START_SAYS.has(error?.code) && error.message) return error.message;
-    return `${what} could not start. Try again.`;
-}
-
-/**
- * Start a job of route `kind` (`model-download`, `autotag`) through the Activity store, which toasts the start; open
- * its view. A slot held by another job names it (D57); any other refusal is toasted by its code. Resolves with the
- * job, or null when none started.
- */
-export async function startJob({ activity, scope, kind, body, what, notify = showWorkspaceToast, navigate = navigateTo }) {
-    let result;
-    try {
-        result = await activity.start(kind, body);
-    } catch (error) {
-        if (!scope.signal.aborted) notify(startRefusal(error, what));
-        return null;
-    }
-    if (scope.signal.aborted) return result.job ?? null;
-    if (result.busy !== undefined) {
-        notify(busyToast(result.busy));
-        return null;
-    }
-    navigate(`#/activity/${result.job.id}`);
-    return result.job;
-}
-
-/** The existing-tags policy's label. */
-export const existingLabel = value => EXISTING_OPTIONS.find(([id]) => id === value)?.[1] ?? String(value ?? '');
-
-/** D134: the review's rows from the server's preview and the drafts it was made with. */
-export function batchGrid(plan, values) {
-    const id = plan.model?.type ?? values.autotag_model_type;
-    const settings = CLASSIFIERS.has(id)
-        ? `General ${values.autotag_general_threshold} · Character ${values.autotag_character_threshold}`
-        : `Template of ${number(characters(values.autotag_template))} characters`;
-    return [
-        ['Model', `${modelLabel(id, plan.model)} · ${modelSize(id, plan.model)}`],
-        ['Existing tags', existingLabel(plan.existing ?? values.autotag_existing)],
-        ['Images linked', number(plan.images)],
-        ['Prompts', number(plan.prompts)],
-        ['Already tagged', number(plan.already_tagged)],
-        ['Prompts to tag', `up to ${number(plan.to_tag)}`],
-        ['Settings', settings],
-        ['Backup', backupText(plan.backup)],
-    ];
-}
-
-const megabytes = bytes => `${(bytes / 2 ** 20).toLocaleString('en-US', { minimumFractionDigits: 1, maximumFractionDigits: 1 })} MB`;
-
-/**
- * A disk without room for the batch's safety backup, in the server's insufficient-space wording
- * (`short_space_message`); byte counts that are not numbers are not guessed.
- */
-export function diskShortNote(disk) {
-    const required = disk?.required_bytes;
-    const free = disk?.free_bytes;
-    if (!Number.isFinite(required) || !Number.isFinite(free) || required < 0 || free < 0) return DISK_SHORT_UNKNOWN;
-    return `Not enough free disk space: the safety backup needs about ${megabytes(required)} and ${megabytes(free)} is free. `
-        + 'Nothing is written until there is room.';
-}
-
-/** Why the reviewed batch cannot start (the Cancel-only review's sentence), or null. */
-export function batchCloseNote(plan) {
-    if (plan.review_required === true) return REPLACE_NOTE;
-    if (plan.model?.downloaded === false) return notDownloaded(modelLabel(plan.model.type, plan.model));
-    if (plan.disk?.sufficient === false) return diskShortNote(plan.disk);
-    if (!Number.isSafeInteger(plan.prompts) || plan.prompts === 0) return NO_LINKED_IMAGES;
-    if (plan.to_tag === 0) return NOTHING_TO_TAG;
-    return null;
-}
-
-export const BATCH_SENTENCE = 'Nothing is written until you start. Missing files and files outside the output folders are '
-    + 'counted, so the prompts to tag are an upper bound; Activity reports what was tagged.';
-
-/** The Cancel-only review: the counts and why the batch cannot start (CUJ 5), in the shared close-only shell. */
-export function openBatchCloseOnly({ scope, trigger, grid, note }) {
-    openCloseOnlyReview({ scope, trigger, title: REVIEW_TITLE, heading: BATCH_TITLE, grid, sentence: note, closeLabel: 'Cancel' });
-}
-
-/** D134: show the previewed batch; Start tagging runs it as the `autotag` job. */
-export function showBatchPlan(plan, { values, activity, scope, trigger = null, notify = showWorkspaceToast, navigate = navigateTo,
-    backup = () => downloadDatabaseBackup(), openReview = openReviewDialog, openCloseOnly = openBatchCloseOnly }) {
-    const grid = batchGrid(plan, values);
-    const note = batchCloseNote(plan);
-    if (note) {
-        openCloseOnly({ scope, trigger, grid, note });
-        return;
-    }
-    const body = batchBody(values);
-    openReview({ scope, trigger, title: REVIEW_TITLE, heading: BATCH_TITLE, grid, sentence: BATCH_SENTENCE,
-        backup: plan.backup?.policy === 'off' ? null : { copy: BACKUP_COPY, onBackup: backup }, cancelLabel: 'Cancel',
-        primary: { label: START_LABEL },
-        onStart: () => startJob({ activity, scope, kind: BATCH_KIND, body, what: BATCH_TITLE, notify, navigate }) });
-}
-
-/** Preview the batch for the drafts (read-only) and show it; the pressed button reads "Reviewing…" until it answered. */
-export async function reviewBatch({ api, activity, scope, values, trigger = null, notify = showWorkspaceToast, navigate = navigateTo,
-    show = showBatchPlan }) {
-    await holding(trigger, 'Reviewing…', async () => {
-        let plan;
-        try {
-            plan = await api.post(BATCH_PREVIEW_URL, { model_type: values.autotag_model_type, existing: values.autotag_existing },
-                { signal: scope.signal });
-        } catch (error) {
-            if (scope.signal.aborted) return;
-            notify(error?.code === 'busy' ? busyToast(error.running) : reviewRefusal(error));
-            return;
-        }
-        if (!scope.signal.aborted) show(plan, { values, activity, scope, trigger, notify, navigate });
-    });
-}
-
-/** Mark `button` aria-disabled (with its reason as a hover title) or enabled. */
-function setAvailable(button, reason) {
-    if (reason) {
-        button.setAttribute('aria-disabled', 'true');
-        button.dataset.reason = reason;
-    } else {
-        button.removeAttribute('aria-disabled');
-        delete button.dataset.reason;
-    }
-}
-
-/**
- * Mount Auto-tagging in `container` (System's `.settings-layout`); returns its surface. `drafts` is the System draft
- * store, `activity` the page's Activity store. `selected()` is the image selected in Images (null when none) and
- * `openTagging` opens the Tag image dialog and `show` the previewed batch; all three are injectable for tests.
- */
-export function mountTagging(container, { api, activity, scope, drafts, notify = showWorkspaceToast, navigate = navigateTo,
-    selected = selectedImage, openTagging = openImageTagging, show = showBatchPlan }) {
-    const surface = el('section', undefined, 'surface');
-    surface.append(el('h2', 'Auto-tagging'), el('p', INTRO));
-    const controls = [];
-    const add = (row, id) => {
-        const input = row.children[1];
-        input.dataset.key = SETTING_KEYS[id];
-        controls.push({ id, key: SETTING_KEYS[id], input, text: row.children[0] });
-        surface.append(row);
-        return row;
-    };
-    const modelRow = add(settingRow({ id: 'tag-model', label: 'Tagging model', description: STATUS_COPY.loading,
-        control: { type: 'select', options: modelOptions(null) } }), 'tag-model');
-    add(settingRow({ id: 'tag-existing', label: 'Existing tags', description: 'Skipping remains the default; replace and merge are explicit.',
-        control: { type: 'select', options: EXISTING_OPTIONS } }), 'tag-existing');
-    add(settingRow({ id: 'threshold-general', label: 'General-tag confidence', description: 'Current WD14 default: 0.35.',
-        control: { type: 'number', min: 0, max: 1, step: 0.05 } }), 'threshold-general');
-    add(settingRow({ id: 'threshold-character', label: 'Character-tag confidence', description: 'Current WD14 default: 0.85.',
-        control: { type: 'number', min: 0, max: 1, step: 0.05 } }), 'threshold-character');
-    // D133: the persisted suggestion count, which the concept does not show.
-    add(settingRow({ id: 'tag-suggestions', label: 'Suggestions per image', description: SUGGESTIONS_DESCRIPTION,
-        control: { type: 'number', min: 1, max: 100, step: 1 } }), 'tag-suggestions');
-
-    const field = el('div', undefined, 'field');
-    const templateLabel = el('label', 'LLM tag template');
-    templateLabel.htmlFor = 'tag-template';
-    const template = el('textarea');
-    template.id = 'tag-template';
-    template.dataset.setting = 'tag-template';
-    template.dataset.key = SETTING_KEYS['tag-template'];
-    field.append(templateLabel, template);
-    surface.append(field);
-    controls.push({ id: 'tag-template', key: SETTING_KEYS['tag-template'], input: template, text: null });
-
-    for (const { key, input } of controls) {
-        // Text controls draft while typing (the Save row follows at once); selects and numbers on change.
-        const event = input.localName === 'textarea' ? 'input' : 'change';
-        scope.listen(input, event, () => drafts.set('host', key, draftValue(key, input.value)));
-    }
-
-    const actions = el('div', undefined, 'row-actions');
-    const preview = createButton('Preview tagging review', 'ca-primary');
-    const download = createButton('Download');
-    const unload = createButton('Unload');
-    actions.append(preview, download, unload);
-    surface.append(actions);
-    const batch = operationRow({ scope, title: BATCH_TITLE, description: BATCH_DESCRIPTION, label: 'Review',
-        onClick: trigger => {
-            if (trigger.getAttribute('aria-disabled') === 'true') { notify(trigger.dataset.reason); return; }
-            reviewBatch({ api, activity, scope, values: current(), trigger, notify, navigate, show })
-                .catch(error => { if (!scope.signal.aborted) notify(reviewRefusal(error)); })
-                .finally(() => { if (!scope.signal.aborted) repaint(); });
-        } });
-    surface.append(batch);
-    const review = batch.children[1].children[0];
-
-    let status = { phase: 'loading', models: null, loadedType: null };
-    let starting = false;
-    // The "could not be read" line under each row, while the server settings could not be read.
-    const notes = new Map();
-    const image = selected();
-    const current = () => Object.fromEntries(Object.values(SETTING_KEYS).map(key => [key, drafts.get('host', key)]));
-    const chosen = () => drafts.get('host', 'autotag_model_type');
-    const known = () => MODEL_IDS.includes(chosen());
-
-    const repaint = () => {
-        const values = current();
-        const unread = values.autotag_model_type === undefined;
-        const failed = drafts.hostState?.() === 'failed' && unread;
-        for (const { key, input, text } of controls) {
-            const value = values[key];
-            input.disabled = value === undefined || (key === 'autotag_model_type' && status.phase === 'loading');
-            // A focused field keeps what the user is typing; a select always shows its value.
-            if (value !== undefined && (document.activeElement !== input || input.localName === 'select')) input.value = String(value);
-            if (!text) continue;
-            notes.get(key)?.remove();
-            notes.delete(key);
-            if (failed) {
-                const note = el('p', HOST_UNAVAILABLE, 'small');
-                notes.set(key, note);
-                text.append(note);
-            }
-        }
-        const labels = modelOptions(status.models);
-        for (const [index, option] of [...modelRow.children[1].options].entries()) option.textContent = labels[index][1];
-        modelRow.children[0].children[1].textContent = unread && status.phase !== 'loading' ? STATUS_COPY.failed
-            : modelDescription(status, values.autotag_model_type);
-
-        const unknown = { message: failed ? HOST_UNAVAILABLE : unread ? SETTINGS_UNREAD : UNKNOWN_MODEL };
-        const problem = known() ? draftProblem(values) : unknown;
-        setAvailable(preview, !image ? NO_SELECTION : problem?.message);
-        const entry = status.models?.[values.autotag_model_type];
-        // A start in flight keeps Download as it is (aria-disabled), whatever a draft change repaints.
-        if (!starting) {
-            download.textContent = downloadLabel(values.autotag_model_type, entry);
-            if (status.phase === 'loading') setAvailable(download, STATUS_UNREAD);
-            else if (!known()) setAvailable(download, unknown.message);
-            else if (status.phase !== 'loaded') setAvailable(download, STATUS_COPY.failed);
-            else setAvailable(download, null);
-        }
-        // Unload is offered only while a model is loaded.
-        unload.disabled = !(status.phase === 'loaded' && status.loadedType);
-        if (review.textContent === 'Reviewing…') return;
-        const batchProblem = known() ? draftProblem(values, { limit: false }) : unknown;
-        setAvailable(review, entry?.downloaded === false ? notDownloaded(modelLabel(values.autotag_model_type, entry))
-            : batchProblem?.message);
-    };
-
-    let reads = 0;
-    const readModels = async () => {
-        const read = ++reads;
-        let next;
-        try {
-            next = readStatus(await api.get(MODELS_URL, { signal: scope.signal, cache: 'no-store' }));
-        } catch {
-            next = { phase: 'failed', models: null, loadedType: null };
-        }
-        if (read !== reads || scope.signal.aborted) return;
-        status = next;
-        repaint();
-    };
-
-    scope.listen(preview, 'click', () => {
-        if (preview.getAttribute('aria-disabled') === 'true') { notify(preview.dataset.reason); return; }
-        openTagging({ api, scope, image, source: 'tags', trigger: preview, preset: taggingPreset(current()) });
-    });
-    scope.listen(download, 'click', async () => {
-        if (download.getAttribute('aria-disabled') === 'true') { notify(download.dataset.reason); return; }
-        const model = chosen();
-        starting = true;
-        try {
-            await holding(download, null, () => startJob({ activity, scope, kind: DOWNLOAD_KIND, body: { model_type: model },
-                what: `Tagging model download · ${modelLabel(model, status.models?.[model])}`, notify, navigate }));
-        } finally {
-            starting = false;
-        }
-        if (!scope.signal.aborted) repaint();
-    });
-    scope.listen(unload, 'click', async () => {
-        const model = status.loadedType;
-        unload.disabled = true;
-        try {
-            const result = await api.post(UNLOAD_URL, {}, { signal: scope.signal });
-            if (scope.signal.aborted) return;
-            // Only an answer that unloaded something says so; "No model was loaded" just reads the status again.
-            if (result?.model_loaded === false) notify(`${modelLabel(model, status.models?.[model])} unloaded.`);
-        } catch (error) {
-            if (scope.signal.aborted) return;
-            notify(error?.code === 'model-busy' ? modelBusy(error.operation) : UNLOAD_FAILED);
-        }
-        await readModels();
-    });
-
-    scope.cleanup(drafts.subscribe(repaint));
-    repaint();
-    readModels();
-    return [surface];
-}

web/js/workspace/system.mjs

@@ -6,22 +6,20 @@
  * truthful and "Save preferences" is aria-disabled while nothing is unsaved. A section not delivered yet shows the
  * per-section hand-off to its legacy tool (D94), never mock placeholders. Overview (system-overview.mjs),
  * Appearance (system-appearance.mjs), Sources & scans (system-sources.mjs), Integrations (system-integrations.mjs),
- * Auto-tagging (system-tagging.mjs), Maintenance (system-maintenance.mjs) and Backup & export (system-backups.mjs) are
- * native.
+ * Maintenance (system-maintenance.mjs) and Backup & export (system-backups.mjs) are native.
  *
  * Switching sections keeps the shell (and focus on the pressed button) and disposes the old section's scope, so its
  * listeners and timers never outlive it. The drafts are module-level (Q10): they live for the page session.
  */
 import { createButton, createScope } from '../shared/toolkit/core.js';
 import { SYSTEM_SECTIONS, navigateTo } from './state.mjs';
-import { createSystemDrafts, DRAFT_DOMAINS, INVALID_SETTING_CODE } from './system-state.mjs';
+import { createSystemDrafts, DRAFT_DOMAINS } from './system-state.mjs';
 import { sectionNav } from './system-controls.mjs';
 import { mountOverview } from './system-overview.mjs';
 import { mountAppearance } from './system-appearance.mjs';
 import { mountSources } from './system-sources.mjs';
 import { mountMaintenance } from './system-maintenance.mjs';
 import { mountBackups } from './system-backups.mjs';
-import { mountTagging } from './system-tagging.mjs';
 import { LORA_ENABLE_URL, LORA_STATUS_URL, loraValues, mountIntegrations, writeHostInParts } from './system-integrations.mjs';
 import { busyToast } from './activity-scan.mjs';
 import { showWorkspaceToast } from './toast.mjs';
@@ -30,10 +28,12 @@ import { displayPreferences, readPreferences, reconcilePreferences, subscribePre
 const SETTINGS_URL = '/prompt_manager/settings';
 const ADMIN = Object.freeze({ href: '/prompt_manager/admin', label: 'Open existing administration' });
 /**
- * D94: where each section's capabilities live until its PR (the plan's legacy capability coverage): only Diagnostics &
- * logs still hands off, to the admin page's Logs and Diagnostics tools.
+ * D94: where each section's capabilities live until its PR (the plan's legacy capability coverage): the admin page's
+ * dashboard, Settings, Maintenance, Backup, Restore, Scan, Logs, Diagnostics and Auto-tag tools, and the gallery's
+ * settings, thumbnails, duplicates and cache tools.
  */
 export const SECTION_HANDOFFS = Object.freeze({
+    tagging: [ADMIN],
     diagnostics: [ADMIN],
 });
 export const NOT_DELIVERED = 'This setting is not available here yet.';
@@ -56,20 +56,6 @@ function el(tag, text, className) {
     return node;
 }
 
-/**
- * S11 (CUJ 2a): a `/settings` save that carried Auto-tagging values (`autotag_*` keys in `body`) and was refused with a
- * plain 400 naming the setting ("General-tag confidence must be between 0 and 1."): mark it `invalid-setting`, so the
- * Save row shows the server's sentence. Every other section's refusal is left as it was (the generic copy).
- */
-export function settingRefusal(error, body) {
-    const tagging = Object.keys(body ?? {}).some(key => key.startsWith('autotag_'));
-    if (tagging && error?.status === 400 && error.refused === true && !error.code && typeof error.message === 'string'
-        && error.message) {
-        error.code = INVALID_SETTING_CODE;
-    }
-    return error;
-}
-
 /** A domain whose settings no delivered section edits yet: nothing can be drafted, and a write would say it failed. */
 const undelivered = async () => { throw new Error(NOT_DELIVERED); };
 
@@ -106,8 +92,7 @@ export function systemDrafts(api) {
             // a save where only one part was written reports which (writeHostInParts, review I3).
             try {
                 return await writeHostInParts({ changes, saved: drafts.saved('host'), expected_revision,
-                    postLora: body => api.post(LORA_ENABLE_URL, body),
-                    postSettings: body => api.post(SETTINGS_URL, body).catch(error => { throw settingRefusal(error, body); }) });
+                    postLora: body => api.post(LORA_ENABLE_URL, body), postSettings: body => api.post(SETTINGS_URL, body) });
             } catch (error) {
                 // A sources change waits for a running record-changing job (S4): name it, as a refused start does (D57).
                 if (error?.code === 'busy') showWorkspaceToast(busyToast(await runningJob(error)));
@@ -143,14 +128,13 @@ function markFailed(layout, store) {
 
 /**
  * The sections delivered so far: Overview (S2 Task 6), Appearance (S3 Task 8), Sources & scans (S4 Task 11),
- * Integrations (S10 Task 27), Auto-tagging (S11 Task 6, #328), Maintenance (S7 Task 19) and Backup & export (S9 Task 24).
+ * Integrations (S10 Task 27), Maintenance (S7 Task 19) and Backup & export (S9 Task 24).
  */
 export const DELIVERED_SECTIONS = Object.freeze({
     overview: mountOverview,
     appearance: mountAppearance,
     sources: mountSources,
     integrations: mountIntegrations,
-    tagging: mountTagging,
     maintenance: mountMaintenance,
     backups: mountBackups,
 });

web/js/workspace/vocabulary.mjs

@@ -18,8 +18,7 @@ import { selectedImage } from './images.mjs';
 import { onImageTagsSaved, openImageTagging } from './image-tagging.mjs';
 import { showWorkspaceToast } from './toast.mjs';
 
-/** D115: why Auto-tag images (and System › Auto-tagging's Preview tagging review) only explains without a selection. */
-export const NO_SELECTION = 'Select an image in Images first.';
+const NO_SELECTION = 'Select an image in Images first.';
 
 const COPY = {
     tags: {empty: 'No tags yet.', error: 'Tags could not be loaded. Nothing was changed.', more: 'Load more tags'},

web/js/workspace/workspace-dialogs.mjs

@@ -482,35 +482,6 @@ export function openReviewDialog({ scope, title, heading = null, grid, options =
     };
 }
 
-/**
- * A review that cannot start: the concept's record-changing review shell (`maintenancePlan`) with its `h3`, the
- * `dl.meta-grid` rows, any `options` nodes, the reason as its `p.small` and a single dismissal (`closeLabel`). `titles`
- * maps a grid term to its value's hover title. Used by Integrations (D107, "Close") and Auto-tagging (D134, "Cancel").
- */
-export function openCloseOnlyReview({ scope, title, heading = null, grid, options = [], sentence, closeLabel = 'Close', titles = {},
-    trigger = null }) {
-    requireScope(scope);
-    requireGrid(grid);
-    for (const [name, text] of Object.entries({ title, sentence, closeLabel })) {
-        if (typeof text !== 'string' || !text) throw new TypeError(`The review needs its ${name}`);
-    }
-    const nodes = heading ? [el('h3', heading)] : [];
-    const list = el('dl', undefined, 'meta-grid');
-    for (const [term, value] of grid) {
-        const entry = el('div');
-        const dd = el('dd', value);
-        if (typeof titles[term] === 'string') dd.title = titles[term];
-        entry.append(el('dt', term), dd);
-        list.append(entry);
-    }
-    const close = createButton(closeLabel);
-    close.addEventListener('click', () => closeWorkspaceDialog());
-    const actions = el('div', undefined, 'dialog-actions');
-    actions.append(close);
-    nodes.push(list, ...options, el('p', sentence, 'small'), actions);
-    show(title, nodes, { scope, trigger });
-}
-
 /**
  * The concept's "Review metadata scan" (`scan-review`, D55). `sources` is the number of output folders the scan reads.
  * The scope is the concept's "New and unresolved files"; the "All files" checkbox (D58, the concept's `.setting-row`

web/js/workspace/workspace.css

@@ -432,10 +432,3 @@ pre.prompt-text { font: inherit; font-size: 12px; line-height: 1.75; margin-bloc
 @media (max-width: 700px) {
   #workspace-main .setting-row :is(#send-destination, #renderer) { max-width: 160px !important; /* D106 */ }
 }
-/* D132: at phone width the concept's 120px cap cuts every engine label ("WD14 SwinV2 · ~400 MB"); the Tagging model
-   select alone keeps its natural width there (its widest engine label) and, with no room beside the row text, wraps
-   under it. */
-@media (max-width: 700px) {
-  #workspace-main .setting-row:has(> #tag-model) { flex-wrap: wrap; /* D132 */ }
-  #workspace-main .setting-row #tag-model { flex-shrink: 0; max-width: 100% !important; /* D132 */ }
-}