Merge remote-tracking branch 'origin/main' into fix/252-no-sampler-scan

The numeric pattern had overlapping quantifiers that backtrack quadratically
on a long digit run ending in a non-digit; it now has none.

TESTING.md

@@ -3826,7 +3826,9 @@ threshold off that grid is refused ("General-tag confidence must be a multiple o
 0.05.", `validate_saved_threshold`; `draftProblem` holds back Preview tagging review and
 the batch Review with the same sentence) and falls back on load; an accepted one is
 stored exactly on the grid (#369). A per-request threshold keeps its own check: `/image-annotations/suggest` and
-`/jobs/autotag` take 0–1; the legacy `/autotag/single` and `/autotag/start` only require a number. `GET /autotag/models` reports the
+`/jobs/autotag` take 0–1; the legacy `/autotag/start` passes its options through
+`validate_options` and starts the `autotag` job titled "Tag output images (legacy page)";
+the legacy `/autotag/single` only requires a number. `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.
@@ -3892,6 +3894,57 @@ images", "Tag output images (legacy page)", "Tagging one image (legacy page)",
   is pinned by `tests/test_autotag_schema.py` (forward-only: one empty `WITHOUT ROWID`
   table, optional in old backups, refused without the annotation group).
 
+- **The legacy pages (#379, PR 2)** write image tags, never prompt tags.
+  `POST /autotag/start` (the admin and gallery batch) reads `model_type`, `prompt`,
+  `skip_tagged` (Skip or Merge), `keep_in_memory` and the thresholds (else the saved
+  ones), checks them with `validate_options` (WD14: both thresholds; GGUF/HF:
+  `instructions` = the non-blank `prompt`, else the saved template; the saved
+  "Suggestions per image") and starts the `autotag` job "Tag output images (legacy
+  page)" (gate owner `legacy-batch`) through the native start, so the safety backup and
+  the disk check apply. A second legacy batch answers JSON 409 `{success: false, error:
+  "Auto-tagging is already running"}` (also when another legacy start wins the race past
+  that check); `SseStream` hands a non-2xx JSON `error` to `onerror` as `serverMessage`,
+  which both pages show instead of "Connection lost during auto tagging". Any other refusal (a job in the way: "<title>
+  already running", `model-unavailable`, `insufficient-space`, `model-busy`, a bad
+  option) is one `{type: "error", status: "error", message}` frame. The stream relays
+  the job: the phases as `{type: "progress", progress: 0 | 5 | 8, status: "Taking a
+  safety backup…" | "Loading model…" | "Listing output images…"}`, each image as
+  `{type: "progress", progress: 10 + progress × 85 / 100, status, processed, tagged,
+  skipped}` (at most every 0.5 s; `processed` = Tagged + Unchanged + Errors), and the end
+  as `complete` (`processed`, `tagged`, `skipped`, `errors`, `skipped_outside_roots: 0`,
+  `status` "Complete" or "No still images found", `model_status`, `model_loaded`),
+  `{type: "cancelled", message: "Cancelled. Tags already added were kept."}` or an
+  `error` frame with the job's status line. A job quiet for 5 s repeats its last frame,
+  and a closed stream cancels the job (the legacy pages have no other stop).
+  `POST /autotag/single` takes `existing` (`"skip"` or `"merge"`, default merge). Under
+  Skip, an image whose current bytes are auto-tagged answers `{success, already_tagged:
+  true, image_tags, prompt_id, filename}` after one stat, without the model gate.
+  Otherwise the image is captured and the model runs on the capture under the gate with
+  the saved cap; the answer adds `tags`, `sha256` (the captured bytes) and `image_tags`,
+  and `service.custom_prompt` is never set. Refusals: `409 model-unavailable`, `413
+  too-large`, `404 file-not-found`, `409 file-changed`, `503 busy`, `415 not-a-still`
+  (the image is marked), `409 model-busy`. `POST /autotag/apply` takes exactly
+  `{image_id, sha256, tags}` or `{path, root_index?, sha256, tags}` (64 KiB), re-hashes
+  the file and unions the tags into that image (`add_image_tags`, marked): `{success,
+  added_tags, total_tags}`; an empty list only marks the image. A body with `prompt_id`
+  is `400` "This page is out of date. Reload it."; a changed file `409 file-changed`
+  ("The image changed since its tags were generated."); a full set `409 tag-limit`; a
+  restore `409 storage-changed`. The admin review asks each image with Skip first: an
+  auto-tagged one shows "Image Already Auto-tagged" / "A tagging model already tagged
+  this image. Generate new tags?" with its image tags (Skip, Skip All Tagged, Re-tag asks
+  again with Merge); the gallery review always merges. Apply & Next sends the image and
+  its `sha256` (linked or not). The batch copy: "Skip images already auto-tagged",
+  "Auto tagging complete! Tagged N images." ("1 image"), and under both progress bars
+  "Closing this window stops tagging. Tags already added are kept. Prompt Manager's
+  Activity page shows the time left.". Pinned by `tests/test_autotag_legacy.py`,
+  `tests/js/image-helpers.test.js` and `legacy-autotag.spec`.
+- **Tag image dialog marks (DEC4).** A save after Generate suggestions ran on that
+  capture marks the image auto-tagged (also a replayed save, and a saved retry after
+  `tag-conflict`); a save without Generate does not. The API keeps the suggested capture
+  tokens; each new one drops the tokens whose capture is gone (`expires_in`, which never
+  resets a capture's idle clock), a release or a saved receipt drops its own, and
+  closing the captures clears them (`TestDialogMarks`).
+
 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
@@ -4440,8 +4493,17 @@ impact and command receipts report `image_count` / `images` /
 `(size, mtime_ns)` equals its verified fingerprint; an in-place rewrite that
 preserves both keeps the old set matching until the file is next observed. The
 Images Tags filter (a file matches when every tag is on its linked positive or
-its current image tag set) and `q` search stream the tagged records once and
-stat only the listed files whose records carry a filter tag or a `q` hit; the
+its current image tag set) and `q` search find their candidates through the tag
+index (#379), never by streaming every image tag row: `image_tag_ids` reads the
+tag names that tag at least one image (an `EXISTS` on `idx_media_image_tags_tag`)
+and keeps a name when it equals a Tags filter tag exactly or contains `q`
+case-folded; `image_tag_locators` reads the files carrying those ids (`tag_id IN`,
+500 ids a chunk). Only the listed ones among them are stat'ed, and only their
+current records count; a linked positive's prompt tags still combine with the
+image tags under a Tags filter. `test_indexed_candidates_equal_the_full_stream`
+compares the lookup with the old full stream (kept in the test as the reference)
+and `test_tag_search_reads_image_tags_only_by_tag_id` traces every statement; the
+
 inspector's `image_tags` facet (`current` / `none` / `unavailable`) uses the
 inspection's own stable stat (`tests/test_api_workspace_images.py`
 `TestWorkspaceImageTags`, `tests/test_api_prompt_inspector.py`). The

database/annotations.py

@@ -110,12 +110,16 @@ _MARKED_LOCATORS = (
     f"SELECT DISTINCT f.locator FROM {AUTOTAG_TABLE} m "  # nosec B608
     f"JOIN {BYTES_TABLE} b ON b.id=m.byte_id JOIN {FILES_TABLE} f ON f.id=b.file_id"
 )
-_RECORDS = (
-    "SELECT f.locator,b.id,b.size,b.mtime_ns,t.name "  # nosec B608
-    f"FROM {FILES_TABLE} f JOIN {BYTES_TABLE} b ON b.file_id=f.id "
-    f"LEFT JOIN {IMAGE_TAGS_TABLE} mit ON mit.byte_id=b.id "
-    "LEFT JOIN tags t ON t.id=mit.tag_id "
-    "ORDER BY f.locator,b.first_seen_at,b.id,mit.position"
+# Tag search (#379): the names that tag at least one image (the tag index
+# answers the EXISTS), then the locators carrying chosen names (by tag_id).
+_IMAGE_TAG_NAMES = (
+    "SELECT t.id,t.name FROM tags t WHERE EXISTS "  # nosec B608
+    f"(SELECT 1 FROM {IMAGE_TAGS_TABLE} mit WHERE mit.tag_id=t.id)"
+)
+_TAG_LOCATORS = (
+    f"SELECT DISTINCT f.locator FROM {IMAGE_TAGS_TABLE} mit "  # nosec B608
+    f"JOIN {BYTES_TABLE} b ON b.id=mit.byte_id "
+    f"JOIN {FILES_TABLE} f ON f.id=b.file_id WHERE mit.tag_id IN ({{marks}})"
 )
 
 
@@ -516,20 +520,32 @@ class AnnotationOperations:
         with self._annotation_read() as conn:
             return {row[0] for row in conn.execute(_MARKED_LOCATORS)}
 
-    def iter_image_tag_records(self) -> Iterator[tuple[str, int, int, list[str]]]:
-        """Stream every byte record as ``(locator, size, mtime_ns, tags)``.
+    def image_tag_ids(self, wanted, query: str) -> list[int]:
+        """Ids of the tag names on at least one image that a search wants.
 
-        One SELECT ordered by locator, then by the bytes' first sighting, with
-        each set's names in position order.
+        A name counts when it is in ``wanted`` exactly (the Tags filter) or
+        contains ``query`` case-folded (the text search; ``query`` is
+        already folded). One read of the names that tag an image.
         """
-        conn = self.model.get_connection()
-        current: tuple | None = None
-        for locator, byte_id, size, mtime_ns, name in conn.execute(_RECORDS):
-            if current is None or current[0] != byte_id:
-                if current is not None:
-                    yield current[1]
-                current = (byte_id, (locator, size, mtime_ns, []))
-            if name is not None:
-                current[1][3].append(name)
-        if current is not None:
-            yield current[1]
+        wanted = set(wanted)
+        with self._annotation_read() as conn:
+            return [
+                tag_id
+                for tag_id, name in conn.execute(_IMAGE_TAG_NAMES)
+                if name in wanted or (query and query in name.casefold())
+            ]
+
+    def image_tag_locators(self, tag_ids) -> set[str]:
+        """Locators with any byte record (current or not) carrying one of
+        ``tag_ids``, through the tag index, in chunks of 500 ids."""
+        ids = list(dict.fromkeys(tag_ids))
+        found: set[str] = set()
+        with self._annotation_read() as conn:
+            for start in range(0, len(ids), _LOOKUP_CHUNK):
+                chunk = ids[start : start + _LOOKUP_CHUNK]
+                marks = ",".join("?" * len(chunk))
+                found.update(
+                    row[0]
+                    for row in conn.execute(_TAG_LOCATORS.format(marks=marks), chunk)
+                )
+        return found

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/__init__.py

@@ -363,6 +363,9 @@ class PromptManagerAPI(
         # Private media captures of the annotation routes (py/api/annotations.py),
         # created on first use with their restore subscription.
         self._captures = None
+        # Capture tokens Generate suggestions ran on: a save of one marks the
+        # image auto-tagged (#379).
+        self._suggested_tokens = set()
         self._captures_unsubscribe = None
         # Set by close_annotation_captures (shutdown): no store is recreated.
         self._captures_closed = False
@@ -1104,196 +1107,3 @@ class PromptManagerAPI(
                         result["parameters"][field] = metadata[field]
 
         return result
-
-    def _extract_readable_prompt(self, parsed_data):
-        """Extract human-readable prompt text from ComfyUI/A1111 data."""
-
-        def safe_to_string(value):
-            if isinstance(value, str):
-                return value
-            elif isinstance(value, list):
-                return " ".join(str(item) for item in value if item)
-            elif value is not None:
-                return str(value)
-            return None
-
-        # First check if we already extracted a positive prompt (A1111 format)
-        if parsed_data.get("positive_prompt"):
-            return parsed_data["positive_prompt"]
-
-        # Check if prompt is already a string
-        if isinstance(parsed_data.get("prompt"), str):
-            return parsed_data["prompt"]
-
-        # Check if prompt is a simple value that can be converted
-        if parsed_data.get("prompt") and not isinstance(
-            parsed_data.get("prompt"), dict
-        ):
-            return safe_to_string(parsed_data["prompt"])
-
-        prompt_data = parsed_data.get("prompt")
-        if isinstance(prompt_data, dict):
-            # Use the enhanced logic from parse-metadata.py
-            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
-                prompt_data
-            )
-            if positive_prompt:
-                return positive_prompt
-
-        # Check workflow data if available
-        workflow_data = parsed_data.get("workflow")
-        if isinstance(workflow_data, dict):
-            positive_prompt = self._extract_positive_prompt_from_comfyui_data(
-                workflow_data
-            )
-            if positive_prompt:
-                return positive_prompt
-
-        # Check parameters for positive prompt
-        if parsed_data.get("parameters", {}).get("positive"):
-            return safe_to_string(parsed_data["parameters"]["positive"])
-
-        return None
-
-    def _get_node_inputs(self, node):
-        """Safely get inputs from a node, handling both dict and list formats.
-
-        Old format: inputs is a dict with direct key-value pairs
-            inputs = {"text": "my prompt", "seed": 123}
-
-        New format: inputs is a list of connection objects
-            inputs = [
-                {"name": "text", "type": "STRING", "link": null,
-                 "widget": {"name": "text"}},
-                {"name": "clip", "type": "CLIP", "link": 11}
-            ]
-        """
-        if not isinstance(node, dict):
-            return {}
-
-        inputs = node.get("inputs", {})
-
-        # If inputs is already a dict, return it
-        if isinstance(inputs, dict):
-            return inputs
-
-        # If inputs is a list, convert to dict format
-        if isinstance(inputs, list):
-            inputs_dict = {}
-            for input_item in inputs:
-                if isinstance(input_item, dict) and "name" in input_item:
-                    name = input_item["name"]
-                    inputs_dict[name] = input_item
-            return inputs_dict
-
-        return {}
-
-    def _find_text_in_node(self, node):
-        """Try to find text content in a node using various strategies.
-
-        Handles both old and new workflow formats.
-        """
-        if not isinstance(node, dict):
-            return None
-
-        # Strategy 1: Check normalized inputs for 'text' field
-        inputs = self._get_node_inputs(node)
-        if "text" in inputs and isinstance(inputs["text"], str):
-            return inputs["text"]
-
-        # Strategy 2: For text encoder nodes, check widgets_values
-        class_type = node.get("class_type", node.get("type", ""))
-        text_encoder_types = [
-            "CLIPTextEncode",
-            "CLIPTextEncodeSDXL",
-            "CLIPTextEncodeSDXLRefiner",
-            "CLIPTextEncodeFlux",
-            "PromptManager",
-            "PromptManagerText",
-            "BNK_CLIPTextEncoder",
-            "Text Encoder",
-            "CLIP Text Encode",
-        ]
-
-        if any(
-            encoder_type.lower() in class_type.lower()
-            for encoder_type in text_encoder_types
-        ):
-            widgets_values = node.get("widgets_values", [])
-            if widgets_values and len(widgets_values) > 0:
-                if isinstance(widgets_values[0], str) and widgets_values[0].strip():
-                    return widgets_values[0]
-
-        return None
-
-    def _extract_positive_prompt_from_comfyui_data(self, data):
-        """Extract positive prompt from ComfyUI data.
-
-        Handles both old and new formats.
-        """
-        if not isinstance(data, dict):
-            return None
-
-        # Build nodes dictionary
-        nodes_by_id = {}
-        if "nodes" in data:
-            # Handle nodes array format
-            for node in data["nodes"]:
-                if isinstance(node, dict):
-                    nid = node.get("id")
-                    if nid is not None:
-                        nodes_by_id[nid] = node
-        else:
-            # Handle flat dictionary format (node_id -> node_data)
-            for nid_str, node in data.items():
-                try:
-                    nid = int(nid_str)
-                except (ValueError, TypeError):
-                    nid = nid_str
-                if isinstance(node, dict):
-                    if "id" in node:
-                        nid = node["id"]
-                    nodes_by_id[nid] = node
-
-        if not nodes_by_id:
-            return None
-
-        # First, try to find positive/negative connection pattern
-        pos_id = None
-        for node in nodes_by_id.values():
-            if isinstance(node, dict):
-                inputs = self._get_node_inputs(node)
-                if "positive" in inputs and "negative" in inputs:
-                    try:
-                        pos_input = inputs["positive"]
-                        if isinstance(pos_input, list) and len(pos_input) > 0:
-                            pos_id = int(pos_input[0])
-                            break
-                    except (ValueError, TypeError, IndexError):
-                        continue
-
-        # Get text from the positive node
-        if pos_id is not None and pos_id in nodes_by_id:
-            text_val = self._find_text_in_node(nodes_by_id[pos_id])
-            if text_val:
-                return text_val
-
-        # Fallback: find any text encoder node with text content
-        text_nodes = []
-        for node in nodes_by_id.values():
-            if isinstance(node, dict):
-                text_val = self._find_text_in_node(node)
-                if text_val:
-                    # Try to determine if this is positive or negative
-                    node_title = node.get("title", "").lower()
-                    if "neg" not in node_title and "negative" not in node_title:
-                        # Prioritize non-negative prompts
-                        text_nodes.insert(0, text_val)
-                    else:
-                        text_nodes.append(text_val)
-
-        # Return the first positive-looking prompt
-        if text_nodes:
-            return text_nodes[0]
-
-        return None

py/api/admin.py

@@ -47,7 +47,7 @@ try:
         extract_generation_params,
         parse_page_json,
     )
-    from ...utils.prompt_pair_resolver import resolve_prompt_pair
+    from ...utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
     from ...utils.review_capture import reviewable
 except ImportError:
     from database.pair_ingestion import blank_positive, ingest_resolved_pair
@@ -62,7 +62,7 @@ except ImportError:
         extract_generation_params,
         parse_page_json,
     )
-    from utils.prompt_pair_resolver import resolve_prompt_pair
+    from utils.prompt_pair_resolver import resolve_prompt_pair, sampler_less_prompt
     from utils.review_capture import reviewable
 
 
@@ -1754,13 +1754,24 @@ class AdminRoutesMixin:
             canonical.get("parameters"), str
         ):
             return resolution["state"]
+        elif canonical.get("prompt"):
+            # No node takes a positive or negative input (a guider or wrapper
+            # graph): the one wired text, never a guess (#252).
+            found = sampler_less_prompt(canonical["prompt"])
+            prompt_text = found["text"]
+            if prompt_text is None and isinstance(canonical.get("parameters"), str):
+                # A metadata saver also wrote A1111 text: its positive prompt.
+                parsed = self._parse_comfyui_prompt(metadata)["positive_prompt"]
+                prompt_text = parsed.strip() if parsed and parsed.strip() else None
+            if prompt_text is None:
+                linked = self._link_recorded_run(
+                    media_file, canonical, detailed, history
+                )
+                if linked is not None:
+                    return linked
+                return "unresolved" if found["state"] == "ambiguous" else "found"
         else:
-            parsed = self._parse_comfyui_prompt(metadata)
-            if not (parsed.get("prompt") or parsed.get("parameters")):
-                return None
-            prompt_text = self._extract_readable_prompt(parsed)
-            if prompt_text is not None and not isinstance(prompt_text, str):
-                prompt_text = str(prompt_text)
+            prompt_text = self._parse_comfyui_prompt(metadata)["positive_prompt"]
             if not (prompt_text and prompt_text.strip()):
                 return "found"
             prompt_text = prompt_text.strip()

py/api/annotations.py

@@ -296,6 +296,7 @@ class AnnotationRoutesMixin:
                 self._captures_closed = True
             unsubscribe, self._captures_unsubscribe = self._captures_unsubscribe, None
             store, self._captures = self._captures, None
+            self._suggested_tokens = set()
         if unsubscribe is not None:
             unsubscribe()
         if store is not None:
@@ -515,6 +516,7 @@ class AnnotationRoutesMixin:
         store = self._captures
         if store is not None and _TOKEN.fullmatch(token) is not None:
             store.release(token)
+        self._suggested_tokens.discard(token)
         return web.json_response(
             {"success": True}, headers={"Cache-Control": "no-store"}
         )
@@ -564,6 +566,9 @@ class AnnotationRoutesMixin:
             return _coded("capture-expired", _OTHER_FILE)
         if facts.sha256 != capture.sha256:
             return _coded("file-changed")
+        # A save after Generate suggestions ran on this capture marks the
+        # image auto-tagged (#379), so a Skip batch leaves the review alone.
+        suggested = token in self._suggested_tokens
         try:
             receipt = await self._run_in_executor(
                 self.db.replace_image_tags,
@@ -574,6 +579,7 @@ class AnnotationRoutesMixin:
                 expected_epoch=expected_epoch,
                 expected_tag_revision=revision,
                 tags=tags,
+                mark_autotagged=suggested,
             )
         except AnnotationCommandError as exc:
             current = exc.current or {}
@@ -590,10 +596,23 @@ class AnnotationRoutesMixin:
         except Exception:
             self.logger.exception("Image tag save failed")
             return _error(500, "save-failed", "The tags could not be saved.")
+        # Dropped only after a saved or replayed receipt: a retry after a
+        # tag-conflict still marks.
+        self._suggested_tokens.discard(token)
         return web.json_response(
             {"success": True, **receipt}, headers={"Cache-Control": "no-store"}
         )
 
+    def _remember_suggested(self, store, token: str) -> None:
+        """Note that Generate ran on *token*; forget tokens whose capture is
+        gone. ``expires_in`` does not reset a capture's idle clock."""
+        self._suggested_tokens = {
+            kept
+            for kept in self._suggested_tokens
+            if store.expires_in(kept) is not None
+        }
+        self._suggested_tokens.add(token)
+
     # -- suggest ---------------------------------------------------------------
 
     async def suggest_image_tags(self, request: web.Request) -> web.Response:
@@ -675,6 +694,7 @@ class AnnotationRoutesMixin:
         finally:
             if not started:
                 store.release_use(token)
+        self._remember_suggested(store, token)
         return web.json_response(
             {
                 "success": True,

py/api/images.py

@@ -575,12 +575,6 @@ def _current_fingerprint(path: Path) -> tuple[int, int] | None:
     return observed.st_size, observed.st_mtime_ns
 
 
-def _image_tags_relevant(names: list, wanted: set, query: str) -> bool:
-    if wanted and not wanted.isdisjoint(names):
-        return True
-    return bool(query) and any(query in name.casefold() for name in names)
-
-
 def _workspace_key(entry: tuple, order: str) -> tuple:
     """The keyset sort key of *entry* (a _Listed or a 4-tuple entry)."""
     if not isinstance(entry, _Listed):
@@ -2170,8 +2164,9 @@ class ImageRoutesMixin:
     def _image_tag_matches(self, listings: list[tuple], filters: dict) -> dict:
         """Normalized path -> _ImageTagMatch for files whose image tags count.
 
-        Streams the tagged byte records once and keeps only listed locators
-        carrying a filter tag or a ``q`` hit; only those candidates are
+        Looks the relevant tag names up (exact under Tags, a case-folded
+        substring for ``q``) and their files through the tag index, keeping
+        only listed locators; only those candidates are
         stat'ed (never every listed file), and a candidate's tags count only
         while a byte record is verified at its present ``(size, mtime_ns)``
         (spec amendment S1). Under a Tags filter the candidates' linked
@@ -2180,16 +2175,15 @@ class ImageRoutesMixin:
         tags, query, category = filters["tags"], filters["query"], filters["category"]
         wanted = set(tags)
         located = self._workspace_locators(listings)
+        # The tag index answers which files carry a relevant name (#379); no
+        # read streams every image tag row.
+        tag_ids = self.db.image_tag_ids(wanted, query)
         candidates = {}
-        records = self.db.iter_image_tag_records()
-        try:
-            for locator, _size, _mtime_ns, names in records:
+        if tag_ids:
+            for locator in self.db.image_tag_locators(tag_ids):
                 entry = located.get(locator)
-                if entry is not None and locator not in candidates:
-                    if _image_tags_relevant(names, wanted, query):
-                        candidates[locator] = entry
-        finally:
-            records.close()
+                if entry is not None:
+                    candidates[locator] = entry
         stats = {}
         for locator, entry in candidates.items():
             fingerprint = _current_fingerprint(entry.path)

tests/browser/legacy-autotag.spec.mjs

@@ -95,8 +95,14 @@ 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 });
+        // Each change from its own record: frames that land in one task share one
+        // callback, and the node's text by then is only the last of them.
+        new MutationObserver(records => {
+            for (const record of records) {
+                if (record.type === 'characterData') window.progressSeen.push(record.target.data);
+                for (const added of record.addedNodes) window.progressSeen.push(added.textContent);
+            }
+        }).observe(node, { childList: true, characterData: true, subtree: true });
     });
 }
 
@@ -108,25 +114,58 @@ async function runGalleryBatch(page) {
     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();
+    // #379: the batch counts images, never prompts.
+    await expect(page.getByText(/^Auto tagging complete! Tagged \d+ images?\.$/)).toBeVisible();
+}
+
+const CLOSE_NOTE = 'Closing this window stops tagging. Tags already added are kept. Prompt Manager\'s Activity page shows the '
+    + 'time left.';
+
+async function serverJobs(request) {
+    const response = await request.get('/prompt_manager/jobs');
+    await expect(response).toBeOK();
+    return (await response.json()).jobs;
+}
+
+async function runNativeBatch(request) {
+    const started = await request.post('/prompt_manager/jobs/autotag', { data: { model_type: 'wd14-swinv2', existing: 'skip',
+        options: { general_threshold: 0.35, character_threshold: 0.85 } } });
+    expect(started.status()).toBe(202);
+    const { job } = await started.json();
+    await expect.poll(async () => (await serverJobs(request)).find(item => item.id === job.id)?.state).toBe('finished');
 }
 
 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%');
+    // The phase frames (model 5%, listing 8%) then the per-image frames (from 10%) move the bar.
+    expect(seen).toContain('8%');
+    expect(seen.some(value => parseInt(value, 10) >= 10)).toBe(true);
+    await expect(page.locator('#autoTagCloseNote')).toHaveText(CLOSE_NOTE);
+    // The batch ran as the autotag job of the legacy page.
+    expect((await serverJobs(request)).filter(job => job.kind === 'autotag').map(job => [job.title, job.state]))
+        .toEqual([['Tag output images (legacy page)', 'finished']]);
     expect((await downloads(request)).length).toBe(0);
 });
 
+test('admin batch copy names images, not prompts (#379)', async ({ page }) => {
+    await page.goto('/prompt_manager/admin');
+    await page.locator('#autoTagBtn').click();
+    await expect(page.locator('input[name="autoTagMode"][value="skip"] + span')).toHaveText('Skip images already auto-tagged');
+    await expect(page.getByText('"auto-scanned" is not counted as a real tag')).toHaveCount(0);
+    await expect(page.locator('#autoTagCloseNote')).toHaveText(CLOSE_NOTE);
+    await expect(page.locator('#retagConfirmModal h3')).toHaveText('Image Already Auto-tagged');
+    await expect(page.locator('#retagConfirmModal')).toContainText('A tagging model already tagged this image. Generate new tags?');
+});
+
 test('admin review opens the first image', async ({ page }) => {
     await page.goto('/prompt_manager/admin');
     await page.locator('#autoTagBtn').click();
     await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
     await page.locator('#startReviewBtn').click();
-    // The first image's prompt is already tagged: confirm a new pass, then the review opens on that image.
-    await page.locator('#retagConfirmBtn').click();
+    // #379: no image is auto-tagged yet (prompt tags no longer count), so the review opens on the first image.
+    await expect(page.locator('#retagConfirmModal')).toBeHidden();
     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);
@@ -150,3 +189,70 @@ test('gallery unload works and is refused while the gate is held', async ({ page
     await unload.click();
     await expect(page.getByText('WD14-SWINV2 model unloaded successfully')).toBeVisible();
 });
+
+/** The admin review lists every row, videos too: Skip any image that is not one until the confirmation shows. */
+async function untilAutoTagged(page, confirm) {
+    // Each image's skip check answers before its confirmation or its error shows.
+    const failed = page.locator('#reviewTagsVisible .text-pm-error');
+    for (let tries = 0; tries < 5; tries++) {
+        await expect.poll(async () => (await confirm.isVisible()) || (await failed.count()) > 0).toBe(true);
+        if (await confirm.isVisible()) return;
+        const answered = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/single'));
+        await page.locator('#skipReviewBtn').click();
+        await answered;
+    }
+    await expect(confirm).toBeVisible();
+}
+
+// #379: the admin review asks before re-tagging an image a model already tagged, and Apply & Next writes that image's
+// tags (its bytes, never its prompt).
+test('admin review: an auto-tagged image asks first; Re-tag then Apply & Next tags the image', async ({ page, request }) => {
+    await runNativeBatch(request);
+    await page.goto('/prompt_manager/admin');
+    await page.locator('#autoTagBtn').click();
+    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
+    await page.locator('#startReviewBtn').click();
+    const confirm = page.locator('#retagConfirmModal');
+    await untilAutoTagged(page, confirm);
+    await expect(confirm.locator('#retagExistingTags span').first()).toHaveText('sandstone');
+    await page.locator('#retagConfirmBtn').click();
+    await expect(page.locator('#autoTagReviewModal')).toBeVisible();
+    await expect(page.locator('#reviewTagsVisible .tag-chip').first()).toContainText('sandstone');
+    const applied = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/apply'));
+    const answer = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/apply'));
+    await page.locator('#applyReviewBtn').click();
+    const body = (await applied).postDataJSON();
+    expect(body.prompt_id).toBeUndefined();
+    expect(body.sha256).toMatch(/^[0-9a-f]{64}$/);
+    expect((await answer).status()).toBe(200);
+});
+
+test('admin review: Skip All Tagged passes every auto-tagged image', async ({ page, request }) => {
+    await runNativeBatch(request);
+    await page.goto('/prompt_manager/admin');
+    await page.locator('#autoTagBtn').click();
+    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
+    await page.locator('#startReviewBtn').click();
+    const confirm = page.locator('#retagConfirmModal');
+    await untilAutoTagged(page, confirm);
+    await page.locator('#retagSkipAllBtn').click();
+    await expect(page.locator('#retagConfirmModal')).toBeHidden();
+    await expect(page.getByText('Review complete!')).toBeVisible();
+});
+
+test('gallery review: Apply & Next tags the image by its path and bytes', async ({ page }) => {
+    await page.goto('/prompt_manager/gallery');
+    await page.locator('#autoTagBtn').click();
+    await page.locator('input[name="autoTagModel"][value="wd14-swinv2"]').check();
+    const suggested = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/single'));
+    await page.locator('#startReviewBtn').click();
+    expect((await suggested).postDataJSON().existing).toBe('merge');
+    await expect(page.locator('#reviewTagsContainer .tag-chip').first()).toContainText('sandstone');
+    const applied = page.waitForRequest(item => item.url().endsWith('/prompt_manager/autotag/apply'));
+    const answer = page.waitForResponse(item => item.url().endsWith('/prompt_manager/autotag/apply'));
+    await page.locator('#applyReviewBtn').click();
+    const body = (await applied).postDataJSON();
+    expect(Object.keys(body).sort()).toEqual(['path', 'root_index', 'sha256', 'tags'].filter(key => key in body).sort());
+    expect(body.prompt_id).toBeUndefined();
+    expect((await answer).status()).toBe(200);
+});

tests/browser/workflows.spec.mjs

@@ -132,7 +132,8 @@ test('the gallery cache clear keeps preferences and other tools caches', async (
     }))).toEqual({ theme: 'light', other: 'keep', prefixed: 'keep', notice: '3.2.0', caches: ['other-tool-gallery-thumbnails'] });
 });
 
-test('actual gallery review generates and persists tags for the selected root', async ({ page, request }) => {
+// #379: the reviewed tags are that image's own tags; no prompt changes.
+test('actual gallery review generates and persists tags for the selected root\'s image', async ({ page, request }) => {
     await page.goto('/prompt_manager/gallery');
     await expect(page.locator('#galleryGrid .image-item')).toHaveCount(2);
     await page.locator('#autoTagBtn').click();
@@ -140,13 +141,15 @@ test('actual gallery review generates and persists tags for the selected root',
     await page.locator('#startReviewBtn').click();
     const generation = await generated;
     expect(generation.request().postDataJSON().root_index).toBe(0);
-    await expect(page.locator('#reviewTagsContainer')).toContainText('generated');
+    await expect(page.locator('#reviewTagsContainer')).toContainText('sandstone');
     const result = page.waitForResponse(response => response.url().endsWith('/prompt_manager/autotag/apply'));
     await page.locator('#applyReviewBtn').click();
     expect((await (await result).json()).success).toBe(true);
     const data = await (await request.get('/prompt_manager/recent?limit=20')).json();
-    expect(data.results.find(prompt => prompt.text === 'Cat portrait').tags).toContain('generated');
-    expect(data.results.find(prompt => prompt.text === 'Dog landscape').tags).not.toContain('generated');
+    expect(data.results.find(prompt => prompt.text === 'Cat portrait').tags).toEqual(['cats']);
+    expect(data.results.find(prompt => prompt.text === 'Dog landscape').tags).toEqual(['dogs']);
+    const tagged = await (await request.get('/prompt_manager/images/output?mode=workspace&tags=sandstone')).json();
+    expect(tagged.images.map(image => `${image.root_index}:${image.path}`)).toEqual(['0:shared/same.png']);
 });
 
 test('actual Tags page reloads the selected filter and opens its image viewer', async ({ page }) => {

tests/browser/workspace-tagging.spec.mjs

@@ -513,6 +513,41 @@ test('search finds an image by its image tag', async ({ page, request }) => {
     await expect(card(page, UNLINKED)).toBeVisible();
 });
 
+// #379 CUJ 8: the Tags filter finds images by their own image tags through the tag index; no prompt carries them, and
+// selecting a match shows its prompt. A linked prompt's tag still combines with the image tags.
+test('the Tags filter finds images by image tags only, and selecting one shows its prompt (#379)', async ({ page, request }) => {
+    await saveImageTags(request, FIRST, ['beach', '1girl', 'waves']);
+    await saveImageTags(request, SECOND, ['beach', 'waves']);
+    await saveImageTags(request, UNLINKED, ['beach', '1girl', 'waves', 'gulls']);
+    await page.goto(images);
+    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(manifest.files.length);
+    const filters = page.locator('#workspace-main search.toolbar').getByRole('button', { name: /^Filters(?: · \d+)?$/ });
+    const refine = page.getByRole('dialog', { name: 'Refine this view', exact: true });
+    const applyTags = async value => {
+        await filters.click();
+        await refine.getByLabel('Tags', { exact: true }).fill(value);
+        const listing = page.waitForRequest(item => item.url().includes('/images/output?')
+            && new URL(item.url()).searchParams.get('tags') !== null);
+        await refine.getByRole('button', { name: 'Apply filters', exact: true }).click();
+        await listing;
+    };
+    await applyTags('beach, 1girl, waves');
+    // Every listed image whose image tags hold all three; SECOND lacks 1girl.
+    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
+    await expect(card(page, FIRST)).toBeVisible();
+    await expect(card(page, UNLINKED)).toBeVisible();
+    await expect(card(page, SECOND)).toHaveCount(0);
+    // The newest match is selected; the inspector shows its linked prompt.
+    await infoButton(page, FIRST).click();
+    await expect(card(page, FIRST)).toHaveClass(/\bselected\b/);
+    await expect(panel(page).locator('.panel-heading h2')).toHaveText(manifest.title);
+    // The linked positive's own tag combines: SECOND has beach and waves itself and minimal through its prompt.
+    await applyTags(`beach, waves, ${manifest.prompt_tags[0]}`);
+    await expect(page.locator('.gallery-body article[data-image-key]')).toHaveCount(2);
+    await expect(card(page, FIRST)).toBeVisible();
+    await expect(card(page, SECOND)).toBeVisible();
+});
+
 // Task C4 rulings: a save re-reads the selected file's details without a loading flash, and under a Tags filter or a
 // search the loaded listing is re-read in place (scroll and selection kept while the file still matches).
 const cards = page => page.locator('.gallery-body article[data-image-key]');

tests/js/gallery-review.test.js

@@ -36,33 +36,48 @@ function fixture() {
     const reply = (index, data) => requests[index].resolve({ json: async () => data });
     return { manager, requests, reply, notifications };
 }
-test('gallery review retains root identity and applies tags with the returned prompt ID', async () => {
+const SHA = 'a'.repeat(64);
+test('gallery review retains root identity and applies the tags to the image by its sha256 (#379)', async () => {
     const { manager, requests, reply } = fixture();
     const load = manager.loadNextReviewImage();
     assert.equal(requests[0].body.root_index, 1);
-    reply(0, { success: true, prompt_id: 42, tags: ['smile'] });
+    assert.equal(requests[0].body.existing, 'merge');
+    reply(0, { success: true, prompt_id: 42, tags: ['smile'], sha256: SHA, image_tags: [] });
     await load;
     manager.loadNextReviewImage = () => {};
     const apply = manager.applyReviewTags();
-    assert.deepEqual(requests[1].body, { prompt_id: 42, tags: ['smile'] });
+    assert.equal(requests[1].url, '/prompt_manager/autotag/apply');
+    assert.deepEqual(requests[1].body, ImageHelpers.autotagApplyBody(
+        { id: 'digest', path: 'same.png', root_index: 1 }, SHA, ['smile']));
+    assert.equal('prompt_id' in requests[1].body, false);
     reply(1, { success: true });
     await apply;
 });
-test('unlinked images do not submit an invalid apply request or advance', async () => {
+test('an unlinked image applies to the image like a linked one', async () => {
     const { manager, requests, reply } = fixture();
     const load = manager.loadNextReviewImage();
-    reply(0, { success: true, prompt_id: null, tags: ['smile'] });
+    reply(0, { success: true, prompt_id: null, tags: ['smile'], sha256: SHA, image_tags: [] });
     await load;
+    manager.loadNextReviewImage = () => {};
     const apply = manager.applyReviewTags();
-    if (requests[1]) reply(1, { success: false, error: "Unexpected apply" });
+    assert.equal(requests[1].body.sha256, SHA);
+    assert.deepEqual(requests[1].body.tags, ['smile']);
+    reply(1, { success: true });
     await apply;
-    assert.equal(requests.length, 1);
-    assert.equal(manager.autoTagState.reviewIndex, 0);
+});
+test('an answer without a captured sha256 never sends an apply', async () => {
+    const { manager, requests, reply } = fixture();
+    const load = manager.loadNextReviewImage();
+    reply(0, { success: true, prompt_id: 42, tags: ['smile'] });
+    await load;
+    manager.loadNextReviewImage = () => {};
+    await manager.applyReviewTags();
+    assert.equal(requests.filter(r => r.url === '/prompt_manager/autotag/apply').length, 0);
 });
 test('a failed apply keeps the current image available for retry', async () => {
     const { manager, requests, reply } = fixture();
     const load = manager.loadNextReviewImage();
-    reply(0, { success: true, prompt_id: 42, tags: ['smile'] });
+    reply(0, { success: true, prompt_id: 42, tags: ['smile'], sha256: SHA, image_tags: [] });
     await load;
     const apply = manager.applyReviewTags();
     reply(1, { success: false, error: 'Try again' });

tests/js/image-helpers.test.js

@@ -5,6 +5,8 @@ const {
     formatImageCaption,
     workflowDocumentHtml,
     autotagSingleBody,
+    autotagApplyBody,
+    autotagCompleteMessage,
     fallbackImageSource,
 } = require("../../web/js/image-helpers.js");
 
@@ -121,3 +123,27 @@ test('metadata lookup preserves encoded filename characters and works behind a p
     assert.equal(metadataLookupUrl('/prompt_manager/images/serve/a.png?v=123'), '/prompt_manager/images/prompt/a.png');
     assert.equal(metadataLookupUrl('/elsewhere/a.png'), null);
 });
+
+test("autotagSingleBody asks to skip auto-tagged images only when told (#379)", () => {
+    assert.equal(autotagSingleBody({ id: 1 }, WD14).existing, "merge");
+    assert.equal(autotagSingleBody({ id: 1 }, { ...WD14, existing: "skip" }).existing, "skip");
+    assert.equal(autotagSingleBody({ id: 1 }, { ...WD14, existing: "odd" }).existing, "merge");
+});
+
+test("autotagApplyBody names the image, its bytes and the tags, never a prompt (#379)", () => {
+    const sha = "a".repeat(64);
+    assert.deepEqual(autotagApplyBody({ id: 4, prompt_id: 7 }, sha, ["bird"]), { image_id: 4, sha256: sha, tags: ["bird"] });
+    assert.deepEqual(autotagApplyBody({ id: "digest", path: "sub/a.png", root_index: 1 }, sha, []),
+        { path: "sub/a.png", root_index: 1, sha256: sha, tags: [] });
+    assert.deepEqual(autotagApplyBody({ id: 2 }, undefined, null), { image_id: 2, sha256: "", tags: [] });
+    const tags = ["x"];
+    autotagApplyBody({ id: 1 }, sha, tags).tags.push("y");
+    assert.deepEqual(tags, ["x"]);
+});
+
+test("autotagCompleteMessage counts images (#379)", () => {
+    assert.equal(autotagCompleteMessage(2), "Auto tagging complete! Tagged 2 images.");
+    assert.equal(autotagCompleteMessage(1), "Auto tagging complete! Tagged 1 image.");
+    assert.equal(autotagCompleteMessage(0), "Auto tagging complete! Tagged 0 images.");
+    assert.equal(autotagCompleteMessage(undefined), "Auto tagging complete! Tagged 0 images.");
+});

tests/js/sse-stream.test.js

@@ -97,6 +97,30 @@ test("connect reports a non-2xx response through onerror and never onmessage", a
     assert.equal(source.readyState, source.CLOSED);
 });
 
+test("a non-2xx JSON answer's error sentence reaches onerror as serverMessage", async () => {
+    let error = null;
+    const fetchImpl = async () => new Response(
+        JSON.stringify({ success: false, error: "Auto-tagging is already running" }),
+        { status: 409, headers: { "Content-Type": "application/json" } },
+    );
+    const source = connect("/x", { fetchImpl });
+    source.onerror = (err) => { error = err; };
+    await until(() => error !== null);
+    assert.match(error.message, /409/);
+    assert.equal(error.status, 409);
+    assert.equal(error.serverMessage, "Auto-tagging is already running");
+});
+
+test("a non-2xx answer without a JSON error has no serverMessage", async () => {
+    let error = null;
+    const fetchImpl = async () => new Response("nope", { status: 500 });
+    const source = connect("/x", { fetchImpl });
+    source.onerror = (err) => { error = err; };
+    await until(() => error !== null);
+    assert.equal(error.status, 500);
+    assert.equal(error.serverMessage, undefined);
+});
+
 test("connect reports a network failure through onerror", async () => {
     let error = null;
     const source = connect("/x", { fetchImpl: async () => { throw new TypeError("Failed to fetch"); } });

tests/test_annotations.py

@@ -430,7 +430,9 @@ class ReplaceImageTagsTests(AnnotationTestCase):
             self.assertTrue(
                 self.db.refresh_image_fingerprint(loc, DIGEST_A, SIZE, MTIME + 1)
             )
-            list(self.db.iter_image_tag_records())
+            self.assertEqual(
+                self.db.image_tag_locators(self.db.image_tag_ids(["img"], "")), {loc}
+            )
         self.assertEqual(self.db.get_prompt_by_id(prompt)["tags"], ["prompt-tag"])
 
 
@@ -551,14 +553,26 @@ class CurrentImageTagsTests(AnnotationTestCase):
         self.assertEqual(current, {locators[0]: ["z", "y"], locators[502]: ["x"]})
         lookups = [s for s in statements if "media_annotation_files" in s]
         self.assertEqual(len(lookups), 2)
+        # The tag search finds every record's file by tag id, and the empty
+        # set's file never.
         self.assertEqual(
-            list(self.db.iter_image_tag_records()),
-            [
-                (locators[0], SIZE, MTIME, ["z", "y"]),
-                (locators[250], SIZE, MTIME + 1, []),
-                (locators[502], SIZE, MTIME + 2, ["x"]),
-            ],
+            self.db.image_tag_locators(self.db.image_tag_ids(["z", "x"], "")),
+            {locators[0], locators[502]},
         )
+        self.assertEqual(
+            self.db.current_image_tags({locators[250]: (SIZE, MTIME + 1)}),
+            {locators[250]: []},
+        )
+
+    def test_tag_locators_cover_more_ids_than_one_chunk(self):
+        # A broad text search can match more than 500 names: every id's file
+        # comes back across the chunks.
+        locators = [self.locator(f"t{i:04}.png") for i in range(503)]
+        for i, loc in enumerate(locators):
+            self.replace(loc, tags=[f"name_{i:04}"])
+        ids = self.db.image_tag_ids([], "name_")
+        self.assertEqual(len(ids), 503)
+        self.assertEqual(self.db.image_tag_locators(ids), set(locators))
 
 
 class AutotagMarkTests(AnnotationTestCase):

tests/test_api_admin.py

@@ -846,6 +846,14 @@ class TestSettingsReadMonitorThroughModule(AdminAPITestCase):
         self.assertEqual(data["settings"]["gallery_root_paths"], ["output"])
 
 
+def _wired_prompt(text):
+    """A sampler-less graph whose one encoder feeds a guider (#252)."""
+    return {
+        "1": {"class_type": "CLIPTextEncode", "inputs": {"text": text}},
+        "2": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}},
+    }
+
+
 def _raise(*args, **kwargs):
     raise RuntimeError("boom")
 
@@ -2186,11 +2194,7 @@ class TestOutputScanInternals(AdminAPITestCase):
 
     def test_ingest_outcomes(self):
         f = Path("gen.png")
-        meta = {
-            "prompt": json.dumps(
-                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
-            )
-        }
+        meta = {"prompt": json.dumps(_wired_prompt("a cat"))}
         self.assertIsNone(self.api._ingest_scanned_file(f, {}))
         self.assertIsNone(self.api._ingest_scanned_file(f, {"prompt": "{}"}))
         self.assertEqual(
@@ -2202,31 +2206,19 @@ class TestOutputScanInternals(AdminAPITestCase):
 
     def test_ingest_link_failures_are_tolerated(self):
         f = Path("gen.png")
-        meta = {
-            "prompt": json.dumps(
-                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a dog"}}}
-            )
-        }
+        meta = {"prompt": json.dumps(_wired_prompt("a dog"))}
         self.api.db.link_image_to_prompt = _raise
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "added")
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")
 
     def test_ingest_save_failure_counts_as_found(self):
         f = Path("gen.png")
-        meta = {
-            "prompt": json.dumps(
-                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a bird"}}}
-            )
-        }
+        meta = {"prompt": json.dumps(_wired_prompt("a bird"))}
         self.api.db.save_prompt = lambda *a, **k: None
         self.assertEqual(self.api._ingest_scanned_file(f, meta), "found")
 
     def test_batch_counts_and_per_file_errors(self):
-        meta = {
-            "prompt": json.dumps(
-                {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a fish"}}}
-            )
-        }
+        meta = {"prompt": json.dumps(_wired_prompt("a fish"))}
         self.api.db.get_prompt_by_hash = _raise
         counts = self.api._ingest_scan_batch_sync(
             [(Path("a.png"), meta), (Path("b.png"), {})]
@@ -2915,7 +2907,7 @@ class TestScanReadsVideos(AdminAPITestCase):
         shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg not installed"
     )
     async def test_scan_adds_prompts_found_in_videos(self):
-        graph = {"1": {"class_type": "CLIPTextEncode", "inputs": {"text": "a cat"}}}
+        graph = _wired_prompt("a cat")
         _write_mp4(
             self.output_dir / "clip.mp4", json.dumps({"prompt": json.dumps(graph)})
         )

tests/test_api_annotation_suggest.py

@@ -363,23 +363,20 @@ class TestModelGate(SuggestTestCase):
         prompt_id = self._save_prompt("batch prompt")
         self.api.db.link_image_to_prompt(prompt_id, str(self.output_dir / "sub/a.png"))
         started, proceed = threading.Event(), threading.Event()
-
-        def slow_generate(image_path, **kwargs):
-            started.set()
-            proceed.wait(WAIT)
-            return ["batch"]
-
-        self.tagger.generate_tags = slow_generate
+        # The legacy batch is the autotag job (#379): it suggests per image.
+        self.tagger.block = (started, proceed)
         batch = asyncio.ensure_future(
             self.client.post("/prompt_manager/autotag/start?model_type=wd14-vit")
         )
         try:
             await asyncio.get_running_loop().run_in_executor(None, started.wait, WAIT)
+            calls = len(self.tagger.calls)
             status, body = await self.suggest(self.suggest_body(observed, "gguf"))
             self.assertEqual((status, body["code"]), (409, "model-busy"))
-            self.assertEqual(self.tagger.calls, [])
+            self.assertEqual(len(self.tagger.calls), calls)
             self.assertEqual(self.tagger.loaded, "wd14-vit")  # not swapped
         finally:
+            self.tagger.block = None
             proceed.set()
             response = await batch
             await response.read()

tests/test_api_autotag.py

@@ -5,6 +5,7 @@ no network request is made.
 """
 
 import asyncio
+import hashlib
 import json
 import os
 import shutil
@@ -34,6 +35,7 @@ from aiohttp.test_utils import AioHTTPTestCase
 
 from database.operations import PromptDatabase
 from py.api import PromptManagerAPI
+from py.api.autotag_routes import MODEL_BUSY_ERROR
 from py.api.jobs import JobBusy
 from utils.hashing import generate_prompt_hash
 
@@ -70,6 +72,7 @@ class FakeAutotagService:
         self.status_calls = 0
         self.status_threads = []
         self.status_paths = {}
+        self.suggest_calls = 0
 
     def get_models_status(self):
         self.status_calls += 1
@@ -115,6 +118,25 @@ class FakeAutotagService:
             raise self.generate_error
         return list(self.tags)
 
+    def generate_tag_suggestions(
+        self,
+        image_path,
+        *,
+        limit,
+        prompt=None,
+        general_threshold=None,
+        character_threshold=None,
+    ):
+        """The suggestion entry point (#379): the fixed tags, at most ``limit``."""
+        self.suggest_calls += 1
+        tags = self.generate_tags(
+            image_path,
+            prompt=prompt,
+            general_threshold=general_threshold,
+            character_threshold=character_threshold,
+        )
+        return [(name, None) for name in tags[:limit]]
+
 
 class AutotagAPITestCase(AioHTTPTestCase):
     """Stands up the PromptManager routes with a temp DB, temp output dir and a
@@ -175,8 +197,17 @@ class AutotagAPITestCase(AioHTTPTestCase):
         )
 
     def _make_image(self, directory, name="img.png"):
+        """A small, valid image (the legacy review captures and probes it)."""
+        from PIL import Image
+
         path = directory / name
-        path.write_bytes(b"\x89PNG\r\n\x1a\n")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        shade = sum(name.encode()) % 256
+        fmt = {".jpg": "JPEG", ".jpeg": "JPEG", ".webp": "WEBP"}.get(
+            path.suffix.lower(), "PNG"
+        )
+        with Image.new("RGB", (4, 4), (shade, 64, 128)) as image:
+            image.save(path, fmt)
         return path
 
     def _link_image(self, prompt_id, path):
@@ -216,10 +247,9 @@ class TestAutotagSingleContainment(AutotagAPITestCase):
         self.assertEqual(data["tags"], ["1girl", "smile"])
         self.assertEqual(data["prompt_id"], prompt_id)
         self.assertEqual(len(self.service.generate_calls), 1)
-        self.assertEqual(
-            os.path.realpath(self.service.generate_calls[0][0]),
-            os.path.realpath(str(image)),
-        )
+        # #379: the model reads a private capture of the image, never the file.
+        self.assertNotIn(str(self.output_dir), self.service.generate_calls[0][0])
+        self.assertEqual(data["sha256"], hashlib.sha256(image.read_bytes()).hexdigest())
 
     async def test_path_inside_output_dir_is_tagged(self):
         image = self._make_image(self.output_dir)
@@ -449,238 +479,6 @@ class TestAutotagSideEffectRoutesArePostOnly(AutotagAPITestCase):
         self.assertTrue((await resp.json())["success"])
 
 
-class TestAutotagBatch(AutotagAPITestCase):
-    """Batch tagging over the DB image list with SSE progress reporting."""
-
-    def _seed(self):
-        """Three prompts: A (one image), B (two images), C (missing file)."""
-        a = self._save_prompt("prompt a")
-        b = self._save_prompt("prompt b")
-        c = self._save_prompt("prompt c")
-        self._link_image(a, self._make_image(self.output_dir, "a1.png"))
-        self._link_image(b, self._make_image(self.output_dir, "b1.png"))
-        self._link_image(b, self._make_image(self.output_dir, "b2.png"))
-        self._link_image(c, self.output_dir / "missing.png")
-        return a, b, c
-
-    async def _start(self, query="model_type=gguf", body=None):
-        if body is None:
-            resp = await self.client.request(
-                "POST", f"/prompt_manager/autotag/start?{query}"
-            )
-        else:
-            resp = await self._post_json(f"/prompt_manager/autotag/start?{query}", body)
-        return resp, self._sse_events(await resp.text())
-
-    async def test_batch_tags_each_prompt_once_and_reports_counts(self):
-        a, b, c = self._seed()
-
-        resp, events = await self._start()
-
-        self.assertEqual(resp.status, 200)
-        done = events[-1]
-        self.assertEqual(done["type"], "complete")
-        self.assertEqual(done["processed"], 2)
-        self.assertEqual(done["tagged"], 2)
-        self.assertEqual(done["skipped"], 2)
-        self.assertEqual(done["errors"], 0)
-        self.assertEqual(len(self.service.generate_calls), 2)
-        self.assertEqual(self.api.db.get_prompt_by_id(a)["tags"], ["1girl", "smile"])
-        self.assertEqual(self.api.db.get_prompt_by_id(b)["tags"], ["1girl", "smile"])
-        self.assertEqual(self.api.db.get_prompt_by_id(c)["tags"], [])
-        progress = [e for e in events if e["type"] == "progress"]
-        self.assertTrue(all(0 <= e["progress"] <= 100 for e in progress))
-        self.assertTrue(any("processed" in e for e in progress))
-
-    async def test_rows_outside_output_dirs_are_skipped_and_counted(self):
-        inside = self._save_prompt("inside")
-        outside = self._save_prompt("outside")
-        self._link_image(inside, self._make_image(self.output_dir, "in.png"))
-        secret = self._make_image(self.secret_dir, "password.png")
-        self._link_image(outside, secret)
-
-        _, events = await self._start()
-
-        done = events[-1]
-        self.assertEqual(done["type"], "complete")
-        self.assertEqual(done["processed"], 1)
-        self.assertEqual(done["tagged"], 1)
-        self.assertEqual(done["skipped"], 1)
-        self.assertEqual(done["skipped_outside_roots"], 1)
-        self.assertEqual(len(self.service.generate_calls), 1)
-        self.assertEqual(
-            os.path.realpath(self.service.generate_calls[0][0]),
-            os.path.realpath(str(self.output_dir / "in.png")),
-        )
-        self.assertEqual(self.api.db.get_prompt_by_id(outside)["tags"], [])
-        progress = [e for e in events if e["type"] == "progress" and "skipped" in e]
-        self.assertTrue(progress)
-        self.assertTrue(all("skipped_outside_roots" in e for e in progress))
-        body = json.dumps(events)
-        self.assertNotIn(str(self.secret_dir), body)
-
-    async def test_second_start_while_running_is_409(self):
-        self._seed()
-        started = threading.Event()
-        release = threading.Event()
-
-        def slow_generate(image_path, **kwargs):
-            started.set()
-            release.wait(5)
-            return ["slow"]
-
-        self.service.generate_tags = slow_generate
-        first = asyncio.ensure_future(self._start())
-        try:
-            await asyncio.get_event_loop().run_in_executor(None, started.wait, 5)
-            self.assertTrue(started.is_set())
-
-            resp = await self.client.request(
-                "POST", "/prompt_manager/autotag/start?model_type=gguf"
-            )
-
-            self.assertEqual(resp.status, 409)
-            self.assertEqual(
-                await resp.json(),
-                {"success": False, "error": "Auto-tagging is already running"},
-            )
-        finally:
-            release.set()
-            resp1, events = await first
-        self.assertEqual(resp1.status, 200)
-        self.assertEqual(events[-1]["type"], "complete")
-
-    async def test_lock_is_released_after_a_run(self):
-        self._seed()
-
-        resp1, _ = await self._start()
-        resp2, events = await self._start()
-
-        self.assertEqual(resp1.status, 200)
-        self.assertEqual(resp2.status, 200)
-        self.assertEqual(events[-1]["type"], "complete")
-
-    async def test_lock_is_released_when_the_run_fails(self):
-        self._seed()
-        self.service.load_error = RuntimeError("no model")
-
-        _, events = await self._start()
-        self.assertEqual(events[-1]["type"], "error")
-
-        self.service.load_error = None
-        resp, events = await self._start()
-        self.assertEqual(resp.status, 200)
-        self.assertEqual(events[-1]["type"], "complete")
-
-    async def test_already_tagged_prompts_are_skipped_unless_asked(self):
-        p = self._save_prompt("tagged", tags=["cat"])
-        self._link_image(p, self._make_image(self.output_dir, "t.png"))
-
-        _, events = await self._start("model_type=gguf&skip_tagged=true")
-        self.assertEqual(events[-1]["skipped"], 1)
-        self.assertEqual(self.service.generate_calls, [])
-
-        _, events = await self._start("model_type=gguf&skip_tagged=false")
-        self.assertEqual(events[-1]["tagged"], 1)
-        self.assertEqual(
-            self.api.db.get_prompt_by_id(p)["tags"], ["cat", "1girl", "smile"]
-        )
-
-    async def test_prompt_already_holding_the_tags_counts_as_skipped(self):
-        p = self._save_prompt("same", tags=["1girl", "smile"])
-        self._link_image(p, self._make_image(self.output_dir, "s.png"))
-
-        _, events = await self._start("model_type=gguf&skip_tagged=false")
-
-        self.assertEqual(events[-1]["skipped"], 1)
-        self.assertEqual(events[-1]["tagged"], 0)
-
-    async def test_generation_errors_are_counted_and_do_not_abort(self):
-        self._seed()
-        self.service.generate_error = RuntimeError("boom")
-
-        _, events = await self._start()
-
-        self.assertEqual(events[-1]["type"], "complete")
-        # a1, b1 and b2 each fail: a failed prompt is retried on its next image
-        self.assertEqual(events[-1]["errors"], 3)
-        self.assertEqual(events[-1]["tagged"], 0)
-
-    async def test_json_body_parameters_are_accepted(self):
-        self._seed()
-
-        _, events = await self._start(
-            "", {"model_type": "wd14-vit", "general_threshold": 0.5, "prompt": "p"}
-        )
-
-        self.assertEqual(events[-1]["type"], "complete")
-        self.assertEqual(self.service.load_calls, [("wd14-vit", True)])
-        self.assertEqual(self.service.generate_calls[0][2], 0.5)
-        self.assertEqual(self.service.custom_prompt, "p")
-
-    async def test_keep_in_memory_false_unloads_after_batch(self):
-        self._seed()
-
-        _, events = await self._start("model_type=gguf&keep_in_memory=false")
-
-        self.assertEqual(events[-1]["model_loaded"], False)
-        self.assertEqual(self.service.unload_calls, 1)
-
-    async def test_model_not_downloaded_is_an_error_event(self):
-        self.service.downloaded = False
-
-        _, events = await self._start()
-
-        self.assertEqual(events[-1]["type"], "error")
-        self.assertEqual(self.service.load_calls, [])
-
-    async def test_load_failure_is_an_error_event_without_details(self):
-        self.service.load_error = RuntimeError("/srv/models/secret.gguf is corrupt")
-
-        _, events = await self._start()
-
-        self.assertEqual(events[-1]["type"], "error")
-        self.assertNotIn("/srv/models", events[-1]["message"])
-
-    async def test_non_numeric_threshold_is_400(self):
-        resp = await self.client.request(
-            "POST", "/prompt_manager/autotag/start?general_threshold=abc"
-        )
-        self.assertEqual(resp.status, 400)
-
-    async def test_invalid_json_body_is_400(self):
-        resp = await self.client.request(
-            "POST",
-            "/prompt_manager/autotag/start",
-            data="{not json",
-            headers={"Content-Type": "application/json"},
-        )
-        self.assertEqual(resp.status, 400)
-
-    async def test_client_disconnect_stops_the_batch_and_unloads(self):
-        self._seed()
-        real_write = web.StreamResponse.write
-        state = {"writes": 0}
-
-        async def flaky_write(response, data):
-            state["writes"] += 1
-            if b"Processing " in data:
-                raise ConnectionResetError("Cannot write to closing transport")
-            return await real_write(response, data)
-
-        with patch.object(web.StreamResponse, "write", flaky_write):
-            try:
-                resp = await self.client.request(
-                    "POST", "/prompt_manager/autotag/start?keep_in_memory=false"
-                )
-                await resp.read()
-            except Exception:
-                pass
-
-        self.assertEqual(len(self.service.generate_calls), 1)
-        self.assertEqual(self.service.unload_calls, 1)
-
-
 class TestAutotagModelsAndDownloadErrors(AutotagAPITestCase):
 
     async def test_models_error_is_500(self):
@@ -834,7 +632,15 @@ class TestAutotagSingleEdgeCases(AutotagAPITestCase):
 
         self.assertEqual(resp.status, 200)
         self.assertEqual(self.service.load_calls, [("wd14-vit", True)])
-        self.assertEqual(self.service.custom_prompt, "terse")
+        # #379: the request's prompt is for this call only.
+        self.assertEqual(self.service.custom_prompt, "")
+        resp = await self._post_json(
+            "/prompt_manager/autotag/single",
+            {"path": str(image), "model_type": "gguf", "prompt": "terse"},
+        )
+        self.assertEqual(resp.status, 200)
+        self.assertEqual(self.service.generate_calls[-1][1], "terse")
+        self.assertEqual(self.service.custom_prompt, "")
 
     async def test_image_id_without_stored_path_is_404(self):
         prompt_id = self._save_prompt()
@@ -850,64 +656,6 @@ class TestAutotagSingleEdgeCases(AutotagAPITestCase):
         self.assertEqual(resp.status, 404)
 
 
-class TestApplyAutotag(AutotagAPITestCase):
-
-    async def test_missing_prompt_id_is_400(self):
-        resp = await self._post_json("/prompt_manager/autotag/apply", {"tags": ["a"]})
-        self.assertEqual(resp.status, 400)
-
-    async def test_no_tags_is_a_noop(self):
-        resp = await self._post_json("/prompt_manager/autotag/apply", {"prompt_id": 1})
-        data = await resp.json()
-        self.assertTrue(data["success"])
-        self.assertEqual(data["message"], "No tags to apply")
-
-    async def test_unknown_prompt_is_404(self):
-        resp = await self._post_json(
-            "/prompt_manager/autotag/apply", {"prompt_id": 999, "tags": ["a"]}
-        )
-        self.assertEqual(resp.status, 404)
-
-    async def test_tags_are_merged_without_duplicates(self):
-        prompt_id = self._save_prompt(tags=["cat"])
-
-        resp = await self._post_json(
-            "/prompt_manager/autotag/apply",
-            {"prompt_id": prompt_id, "tags": ["cat", "dog"]},
-        )
-
-        data = await resp.json()
-        self.assertEqual(data["added_tags"], ["dog"])
-        self.assertEqual(data["total_tags"], 2)
-        self.assertEqual(
-            self.api.db.get_prompt_by_id(prompt_id)["tags"], ["cat", "dog"]
-        )
-
-    async def test_string_tags_from_db_are_split(self):
-        prompt_id = self._save_prompt()
-        with patch.object(
-            self.api.db,
-            "get_prompt_by_id",
-            return_value={"id": prompt_id, "tags": "cat, dog"},
-        ):
-            resp = await self._post_json(
-                "/prompt_manager/autotag/apply",
-                {"prompt_id": prompt_id, "tags": ["dog", "owl"]},
-            )
-        data = await resp.json()
-        self.assertEqual(data["added_tags"], ["owl"])
-        self.assertEqual(data["total_tags"], 3)
-
-    async def test_db_error_is_500(self):
-        with patch.object(
-            self.api.db, "get_prompt_by_id", side_effect=RuntimeError("db")
-        ):
-            resp = await self._post_json(
-                "/prompt_manager/autotag/apply", {"prompt_id": 1, "tags": ["a"]}
-            )
-        self.assertEqual(resp.status, 500)
-
-
 class TestAutotagErrorBodiesHideServerPaths(AutotagAPITestCase):
     """Every autotag handler reports exceptions through the shared public helper."""
 
@@ -932,9 +680,12 @@ class TestAutotagErrorBodiesHideServerPaths(AutotagAPITestCase):
         await self._assert_hidden(resp)
 
     async def test_apply_error(self):
-        with patch.object(self.api.db, "get_prompt_by_id", side_effect=self._locked()):
+        image = self._make_image(self.output_dir)
+        digest = hashlib.sha256(image.read_bytes()).hexdigest()
+        with patch.object(self.api.db, "add_image_tags", side_effect=self._locked()):
             resp = await self._post_json(
-                "/prompt_manager/autotag/apply", {"prompt_id": 1, "tags": ["a"]}
+                "/prompt_manager/autotag/apply",
+                {"path": str(image), "sha256": digest, "tags": ["a"]},
             )
         await self._assert_hidden(resp)
 
@@ -1008,10 +759,13 @@ class TestLegacyRoutesShareTheModelGate(AutotagAPITestCase):
                     "POST", "/prompt_manager/autotag/download/gguf"
                 )
             )
-            await self._busy(
-                await self.client.request(
-                    "POST", "/prompt_manager/autotag/start?model_type=gguf"
-                )
+            # The legacy batch is read as a stream: one error frame (#379).
+            resp = await self.client.request(
+                "POST", "/prompt_manager/autotag/start?model_type=gguf"
+            )
+            self.assertEqual(
+                self._sse_events(await resp.text()),
+                [{"type": "error", "status": "error", "message": MODEL_BUSY_ERROR}],
             )
             await self._busy(
                 await self.client.request("POST", "/prompt_manager/autotag/unload")
@@ -1026,7 +780,7 @@ class TestLegacyRoutesShareTheModelGate(AutotagAPITestCase):
         self.assertEqual(self.service.unload_calls, 0)
         self.assertEqual(self.service.get_loaded_model_type(), "wd14-vit")
 
-        # A refused start released the batch lock: the next start runs.
+        # A refused start left no job behind: the next start runs.
         resp = await self.client.request(
             "POST", "/prompt_manager/autotag/start?model_type=gguf"
         )
@@ -1238,7 +992,7 @@ if __name__ == "__main__":
 
 
 class TestGalleryReviewContract(AutotagAPITestCase):
-    async def test_root_relative_gallery_targets_generate_and_apply_to_their_prompt(
+    async def test_root_relative_gallery_targets_generate_and_apply_to_their_image(
         self,
     ):
         second = self.tmp_root / "second-output"
@@ -1255,16 +1009,22 @@ class TestGalleryReviewContract(AutotagAPITestCase):
             self.assertEqual(response.status, 200)
             data = await response.json()
             self.assertEqual(data["prompt_id"], pid)
-            self.assertEqual(
-                self.service.generate_calls[-1][0], str((root / "same.png").resolve())
-            )
             response = await self._post_json(
                 "/prompt_manager/autotag/apply",
-                {"prompt_id": data["prompt_id"], "tags": data["tags"]},
+                {
+                    "path": "same.png",
+                    "root_index": index,
+                    "sha256": data["sha256"],
+                    "tags": data["tags"],
+                },
             )
             self.assertEqual(response.status, 200)
+            # The image's own tags; the prompt is never written (#379).
+            self.assertEqual(self.api.db.get_prompt_by_id(pid)["tags"], [])
+            locator = os.path.normcase(os.path.realpath(str(root / "same.png")))
             self.assertEqual(
-                set(self.api.db.get_prompt_by_id(pid)["tags"]), set(data["tags"])
+                self.api.db.read_image_tags(locator, data["sha256"])["tags"],
+                data["tags"],
             )
 
     async def test_gallery_unlinked_image_returns_no_prompt_id(self):
@@ -2058,108 +1818,6 @@ class TestTagOutputImagesJob(BatchJobTestCase):
         self.assertTrue(inside)
 
 
-# The legacy batch's per-image frames over BatchJobTestCase's library, newest
-# first, with every throttle check passing (pinned from main's generator).
-GOLDEN_LEGACY_ROWS = [
-    {
-        "type": "progress",
-        "progress": 24,
-        "status": "Processing 1/6...",
-        "processed": 1,
-        "tagged": 1,
-        "skipped": 0,
-        "skipped_outside_roots": 0,
-    },
-    {
-        "type": "progress",
-        "progress": 38,
-        "status": "Skipping 2/6 (outside allowed directories)...",
-        "processed": 1,
-        "tagged": 1,
-        "skipped": 1,
-        "skipped_outside_roots": 1,
-    },
-    {
-        "type": "progress",
-        "progress": 52,
-        "status": "Skipping 3/6 (file missing)...",
-        "processed": 1,
-        "tagged": 1,
-        "skipped": 2,
-        "skipped_outside_roots": 1,
-    },
-    {
-        "type": "progress",
-        "progress": 66,
-        "status": "Processing 4/6...",
-        "processed": 2,
-        "tagged": 2,
-        "skipped": 2,
-        "skipped_outside_roots": 1,
-    },
-    {
-        "type": "progress",
-        "progress": 80,
-        "status": "Skipping 5/6 (prompt already processed)...",
-        "processed": 2,
-        "tagged": 2,
-        "skipped": 3,
-        "skipped_outside_roots": 1,
-    },
-    {
-        "type": "progress",
-        "progress": 95,
-        "status": "Skipping 6/6 (already tagged)...",
-        "processed": 2,
-        "tagged": 2,
-        "skipped": 4,
-        "skipped_outside_roots": 1,
-    },
-]
-
-
-class TestLegacyBatchFrames(BatchJobTestCase):
-
-    async def test_legacy_batch_events_unchanged(self):
-        """Golden frames of the legacy batch over the seeded library."""
-        self._seed()
-        ticks = iter(range(1000))  # every throttle check sees a second pass
-        with patch("py.api.autotag_routes._monotonic", side_effect=lambda: next(ticks)):
-            resp = await self.client.post(
-                "/prompt_manager/autotag/start?model_type=wd14-vit&skip_tagged=true"
-            )
-            frames = self._sse_events(await resp.text())  # the stream runs here
-        self.assertEqual(
-            frames,
-            [
-                {"type": "progress", "progress": 0, "status": "Loading model..."},
-                {
-                    "type": "progress",
-                    "progress": 5,
-                    "status": "Model loaded. Fetching all images from database...",
-                },
-                {
-                    "type": "progress",
-                    "progress": 10,
-                    "status": "Found 6 images. Processing...",
-                },
-                *GOLDEN_LEGACY_ROWS,
-                {
-                    "type": "complete",
-                    "progress": 100,
-                    "processed": 2,
-                    "tagged": 2,
-                    "skipped": 4,
-                    "errors": 0,
-                    "skipped_outside_roots": 1,
-                    "status": "Complete",
-                    "model_status": "Model kept in memory",
-                    "model_loaded": True,
-                },
-            ],
-        )
-
-
 class TestTagOutputImagesEdges(BatchJobTestCase):
 
     async def test_cancel_during_backup_loads_no_model(self):

tests/test_api_core.py

@@ -835,7 +835,6 @@ class TestMetadataParsing(unittest.TestCase):
         self.assertEqual(parsed["positive_prompt"], "a cat")
         self.assertEqual(parsed["negative_prompt"], "dog")
         self.assertEqual(parsed["parameters"]["parameters"], meta["parameters"])
-        self.assertEqual(self.api._extract_readable_prompt(parsed), "a cat")
 
     def test_parse_comfyui_fields(self):
         meta = {
@@ -856,97 +855,6 @@ class TestMetadataParsing(unittest.TestCase):
         self.assertEqual(parsed["prompt"], "plain text")
         self.assertEqual(parsed["workflow"], {"nodes": []})
 
-    def test_extract_readable_prompt_variants(self):
-        extract = self.api._extract_readable_prompt
-        self.assertEqual(extract({"prompt": "plain"}), "plain")
-        self.assertEqual(extract({"prompt": ["a", "", "b"]}), "a b")
-        self.assertEqual(extract({"prompt": 42}), "42")
-        self.assertEqual(
-            extract({"prompt": None, "parameters": {"positive": ["x", "y"]}}), "x y"
-        )
-        self.assertIsNone(extract({"prompt": {}, "parameters": {}}))
-
-        graph = {
-            "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "pos"}},
-            "2": {"class_type": "CLIPTextEncode", "inputs": {"text": "neg"}},
-            "3": {
-                "class_type": "KSampler",
-                "inputs": {"positive": ["1", 0], "negative": ["2", 0]},
-            },
-        }
-        self.assertEqual(extract({"prompt": graph}), "pos")
-        self.assertEqual(extract({"prompt": {"x": 1}, "workflow": graph}), "pos")
-
-    def test_node_inputs_and_text_lookup(self):
-        self.assertEqual(self.api._get_node_inputs("nope"), {})
-        self.assertEqual(self.api._get_node_inputs({"inputs": 5}), {})
-        self.assertEqual(self.api._get_node_inputs({"inputs": {"a": 1}}), {"a": 1})
-        listed = self.api._get_node_inputs(
-            {"inputs": [{"name": "text", "link": None}, {"nope": 1}, "junk"]}
-        )
-        self.assertEqual(list(listed), ["text"])
-
-        self.assertIsNone(self.api._find_text_in_node(None))
-        self.assertEqual(self.api._find_text_in_node({"inputs": {"text": "hi"}}), "hi")
-        self.assertEqual(
-            self.api._find_text_in_node(
-                {"type": "CLIPTextEncode", "widgets_values": ["w"]}
-            ),
-            "w",
-        )
-        self.assertIsNone(
-            self.api._find_text_in_node(
-                {"type": "CLIPTextEncode", "widgets_values": [" "]}
-            )
-        )
-        self.assertIsNone(self.api._find_text_in_node({"type": "KSampler"}))
-
-    def test_positive_prompt_from_nodes_array_and_fallbacks(self):
-        extract = self.api._extract_positive_prompt_from_comfyui_data
-        self.assertIsNone(extract("x"))
-        self.assertIsNone(extract({}))
-        self.assertIsNone(extract({"nodes": []}))
-
-        workflow = {
-            "nodes": [
-                {"id": 1, "type": "CLIPTextEncode", "widgets_values": ["pos"]},
-                {
-                    "id": 2,
-                    "type": "CLIPTextEncode",
-                    "widgets_values": ["neg"],
-                    "title": "Negative",
-                },
-                {"id": 3, "type": "KSampler", "inputs": [{"name": "seed", "link": 4}]},
-                "junk",
-            ]
-        }
-        self.assertEqual(extract(workflow), "pos")
-
-        only_negative = {
-            "nodes": [
-                {
-                    "id": 2,
-                    "type": "CLIPTextEncode",
-                    "widgets_values": ["neg"],
-                    "title": "neg",
-                },
-            ]
-        }
-        self.assertEqual(extract(only_negative), "neg")
-
-        bad_link = {
-            "1": {"class_type": "CLIPTextEncode", "inputs": {"text": "pos"}},
-            "3": {
-                "class_type": "KSampler",
-                "inputs": {"positive": "oops", "negative": []},
-            },
-            "4": {
-                "class_type": "KSampler",
-                "inputs": {"positive": ["zz", 0], "negative": []},
-            },
-        }
-        self.assertEqual(extract(bad_link), "pos")
-
 
 if __name__ == "__main__":
     unittest.main()

tests/test_api_workspace_images.py

@@ -1831,6 +1831,39 @@ class TestWorkspaceCursorEncoding(unittest.TestCase):
                 self.assertEqual(_workspace_cursor_key(token, "scope", order), key)
 
 
+# The pre-#379 candidate read, kept as the differential reference for the
+# indexed lookup (`image_tag_ids` + `image_tag_locators`): every byte record
+# streamed with its tag names, a locator kept when any record's names are
+# relevant (`_image_tags_relevant`).
+_REFERENCE_RECORDS = (
+    "SELECT f.locator,b.id,t.name FROM media_annotation_files f "
+    "JOIN media_annotation_bytes b ON b.file_id=f.id "
+    "LEFT JOIN media_image_tags mit ON mit.byte_id=b.id "
+    "LEFT JOIN tags t ON t.id=mit.tag_id "
+    "ORDER BY f.locator,b.first_seen_at,b.id,mit.position"
+)
+
+
+def _image_tags_relevant(names, wanted, query):
+    if wanted and not wanted.isdisjoint(names):
+        return True
+    return bool(query) and any(query in name.casefold() for name in names)
+
+
+def reference_candidates(db, wanted, query):
+    """Locators the old full stream admitted for (``wanted``, ``query``)."""
+    records = {}
+    for locator, byte_id, name in db.model.get_connection().execute(_REFERENCE_RECORDS):
+        names = records.setdefault((locator, byte_id), [])
+        if name is not None:
+            names.append(name)
+    return {
+        locator
+        for (locator, _byte), names in records.items()
+        if _image_tags_relevant(names, set(wanted), query)
+    }
+
+
 class TestWorkspaceImageTags(ImageAPITestCase):
     """B3: image tags in the Tags filter and search (spec amendment S1)."""
 
@@ -2038,7 +2071,7 @@ class TestWorkspaceImageTags(ImageAPITestCase):
         leak = "no such table: media_annotation_files"
         with patch.object(
             self.api.db,
-            "iter_image_tag_records",
+            "image_tag_locators",
             side_effect=sqlite3.OperationalError(leak),
         ):
             # As a failed link read does under a Tags filter: a fixed coded
@@ -2056,6 +2089,140 @@ class TestWorkspaceImageTags(ImageAPITestCase):
         self.assertEqual(self.names(body), ["dunes_by_name.png"])
         self.assertIn("image tags", "\n".join(logged.output))
 
+    def seed_differential(self):
+        """Mixed-case and underscore names, a stale record, an unlisted file."""
+        a = self.media("a.png", mtime=101)
+        b = self.media("b.png", mtime=102)
+        c = self.media("c.png", mtime=103)
+        self.tag(a, ["Beach", "long_hair", "1girl"])
+        self.tag(b, ["beach", "waves"])
+        self.tag(c, ["Sunset"])
+        # c's bytes change: its old record (Sunset) is stale, the new one current.
+        make_png(c, size=(5, 5))
+        os.utime(c, (104, 104))
+        self.tag(c, ["night_sky", "BEACH"])
+        outside = Path(self._output_tmp.name) / "elsewhere" / "x.png"
+        outside.parent.mkdir(parents=True, exist_ok=True)
+        make_png(outside)
+        self.tag(outside, ["beach", "outside_only"])
+
+    async def test_indexed_candidates_equal_the_full_stream(self):
+        self.seed_differential()
+        cases = [
+            (["beach"], ""),
+            (["Beach"], ""),
+            (["long_hair", "waves"], ""),
+            ([], "beach"),
+            ([], "hair"),
+            ([], "_"),
+            ([], "sun"),
+            (["nope"], "zzz"),
+            (["outside_only"], ""),
+            (["beach"], "night"),
+        ]
+        db = self.api.db
+        for wanted, query in cases:
+            with self.subTest(wanted=wanted, query=query):
+                indexed = set(db.image_tag_locators(db.image_tag_ids(wanted, query)))
+                self.assertEqual(indexed, reference_candidates(db, wanted, query))
+        # The API answers are the indexed lookup's: exact names under Tags, a
+        # case-folded substring under q, current records only.
+        _, body = await self.get(tags="beach")
+        self.assertEqual(sorted(self.names(body)), ["b.png"])
+        _, body = await self.get(q="beach")
+        self.assertEqual(sorted(self.names(body)), ["a.png", "b.png", "c.png"])
+        _, body = await self.get(q="sunset")
+        self.assertEqual(self.names(body), [])
+
+    async def test_tag_search_reads_image_tags_only_by_tag_id(self):
+        self.seed_differential()
+        statements = []
+        original = self.api.db.model.get_connection
+
+        def trace_connection():
+            connection = original()
+            connection.set_trace_callback(statements.append)
+            return connection
+
+        with patch.object(
+            self.api.db.model, "get_connection", side_effect=trace_connection
+        ):
+            for params in ({"tags": "beach"}, {"q": "hair"}):
+                response, _ = await self.get(**params)
+                self.assertEqual(response.status, 200)
+        reads = [
+            sql
+            for sql in statements
+            if "media_image_tags" in sql and sql.lstrip().upper().startswith("SELECT")
+        ]
+        self.assertTrue(reads)
+        for sql in reads:
+            # Only a tag-id lookup, an EXISTS probe on the tag index, or the
+            # current records' own tags (byte_id IN) read the junction.
+            self.assertTrue(
+                "tag_id IN" in sql or "EXISTS" in sql or "byte_id IN" in sql, sql
+            )
+
+    async def test_the_image_tag_lookup_never_reads_prompt_tags(self):
+        self.seed_differential()
+        linked = self.media("linked.png", mtime=105)
+        prompt = self._save_prompt(
+            "Prompt with its own tag", tags=["prompt_only_beach"]
+        )
+        self.api.db.link_image_to_prompt(prompt, str(linked))
+        db = self.api.db
+        # The tag is only on a prompt: the image-tag lookup never yields it,
+        # under the Tags filter or the text search.
+        self.assertEqual(db.image_tag_ids(["prompt_only_beach"], ""), [])
+        self.assertEqual(db.image_tag_ids([], "prompt_only"), [])
+        self.assertEqual(
+            db.image_tag_locators(db.image_tag_ids([], "beach")),
+            reference_candidates(db, [], "beach"),
+        )
+        # The search still matches through the linked positive's prompt tags
+        # (the design keeps that, #379 "Behavior that does not change").
+        _, body = await self.get(q="prompt_only")
+        self.assertEqual(self.names(body), ["linked.png"])
+
+    @unittest.skipUnless(os.environ.get("PM_PERF") == "1", "timing run (PM_PERF=1)")
+    async def test_tag_search_timing(self):
+        """Linux timing for the PR body: 23,600 records, 10 tags each."""
+        import hashlib
+        import statistics
+        import time
+
+        db = self.api.db
+        epoch = db.get_execution_epoch()
+        names = [f"name_{n:04d}" for n in range(2000)]
+        root = os.path.realpath(self.output_dir)
+        for n in range(23_600):
+            path = self.output_dir / "perf" / f"{n:05d}.png"
+            path.parent.mkdir(exist_ok=True)
+            path.write_bytes(b"x")
+            os.utime(path, (n + 1, n + 1))
+            stat = path.stat()
+            db.replace_image_tags(
+                locator=os.path.normcase(os.path.join(root, "perf", path.name)),
+                sha256=hashlib.sha256(str(n).encode()).hexdigest(),
+                size=stat.st_size,
+                mtime_ns=stat.st_mtime_ns,
+                expected_epoch=epoch,
+                expected_tag_revision=0,
+                tags=[names[(n * 7 + k) % 2000] for k in range(10)],
+            )
+        await self.get(limit=1)  # the listing, warm
+        for label, params in (
+            ("one tag", {"tags": "name_0042"}),
+            ("text", {"q": "e_1"}),
+        ):
+            times = []
+            for _ in range(5):
+                started = time.perf_counter()
+                response, _ = await self.get(limit=100, **params)
+                times.append(time.perf_counter() - started)
+                self.assertEqual(response.status, 200)
+            print(f"PM_PERF {label}: median {statistics.median(times) * 1000:.0f} ms")
+
     async def test_legacy_output_failure_logs_its_traceback(self):
         self.media("legacy.png", mtime=100)
         with (

tests/test_autotag_legacy.py

@@ -0,0 +1,617 @@
+"""The legacy pages and the Tag image dialog tag images, never prompts (#379, PR 2).
+
+- ``POST /autotag/start`` (legacy admin and gallery batch) starts the
+  ``autotag`` job titled "Tag output images (legacy page)" and relays it as
+  the legacy frames; closing the stream cancels it.
+- ``POST /autotag/single`` suggests on a capture with the saved cap and
+  answers the captured ``sha256``; ``existing: "skip"`` answers
+  ``already_tagged`` for an auto-tagged image without the model gate.
+- ``POST /autotag/apply`` unions into that image's tags and marks it; a
+  ``prompt_id`` body is refused.
+- A Tag image dialog save after Generate suggestions marks the image.
+
+No real model runs: the per-image fake from test_autotag_batch answers.
+"""
+
+import asyncio
+import hashlib
+import json
+import sqlite3
+import threading
+from unittest.mock import patch
+
+from aiohttp import web
+
+try:
+    from test_autotag_batch import BatchTestCase, _absolute, _strings
+except ImportError:
+    from tests.test_autotag_batch import BatchTestCase, _absolute, _strings
+
+from database.execution_history_schema import rotate_history_epoch
+from py import model_gate
+from py.api import autotag_routes, image_tag_jobs
+from py.config import AutotagConfig
+
+START = "/prompt_manager/autotag/start"
+SINGLE = "/prompt_manager/autotag/single"
+APPLY = "/prompt_manager/autotag/apply"
+SUGGEST = "/prompt_manager/image-annotations/suggest"
+OBSERVE = "/prompt_manager/image-annotations/observe"
+TAGS = "/prompt_manager/image-annotations/tags"
+WAIT = 30.0
+LEGACY_TITLE = "Tag output images (legacy page)"
+
+
+def frames_of(text):
+    return [
+        json.loads(line[len("data: ") :])
+        for line in text.splitlines()
+        if line.startswith("data: ")
+    ]
+
+
+class LegacyTestCase(BatchTestCase):
+    async def legacy(self, query="model_type=wd14-vit&skip_tagged=true"):
+        response = await self.client.post(f"{START}?{query}")
+        return response, frames_of(await response.text())
+
+    def digest(self, path):
+        return hashlib.sha256((self.output_dir / path).read_bytes()).hexdigest()
+
+    async def single(self, body):
+        response = await self.client.post(SINGLE, json=body)
+        return response.status, await response.json()
+
+    async def apply(self, body):
+        response = await self.client.post(APPLY, json=body)
+        return response.status, await response.json()
+
+    def snapshot_prompts(self):
+        conn = sqlite3.connect(self._temp_db.name)
+        try:
+            return [
+                conn.execute(f"SELECT * FROM {t} ORDER BY 1,2").fetchall()
+                for t in ("prompts", "prompt_tags")
+            ]
+        finally:
+            conn.close()
+
+
+class TestLegacyBatch(LegacyTestCase):
+    async def test_the_legacy_batch_tags_each_image_and_relays_frames(self):
+        prompt = self.prompt("one prompt", tags=["beach"])
+        a = self.image("a.png", (1, 2, 3), sees=["bird"])
+        b = self.image("b.png", (4, 5, 6), sees=["waves"])
+        self.link(prompt, a)
+        self.link(prompt, b)
+        before = self.snapshot_prompts()
+        ticks = iter(range(1000))
+        with patch.object(
+            autotag_routes, "_monotonic", side_effect=lambda: next(ticks)
+        ):
+            response, frames = await self.legacy()
+        self.assertEqual(response.status, 200)
+        self.assertEqual(self.stored("a.png")["tags"], ["bird"])
+        self.assertEqual(self.stored("b.png")["tags"], ["waves"])
+        self.assertEqual(self.snapshot_prompts(), before)
+        phases = [f["status"] for f in frames if f.get("progress") in (0, 5, 8)]
+        self.assertEqual(
+            phases,
+            sorted(
+                phases,
+                key=[
+                    "Taking a safety backup…",
+                    "Loading model…",
+                    "Listing output images…",
+                ].index,
+            ),
+        )
+        self.assertIn("Listing output images…", phases)
+        rows = [f for f in frames if f["type"] == "progress" and "processed" in f]
+        self.assertTrue(rows)
+        for row in rows:
+            self.assertEqual(
+                set(row),
+                {"type", "progress", "status", "processed", "tagged", "skipped"},
+            )
+            self.assertTrue(10 <= row["progress"] <= 95, row)
+        self.assertEqual(
+            frames[-1],
+            {
+                "type": "complete",
+                "progress": 100,
+                "processed": 2,
+                "tagged": 2,
+                "skipped": 0,
+                "errors": 0,
+                "skipped_outside_roots": 0,
+                "status": "Complete",
+                "model_status": "Model kept in memory",
+                "model_loaded": True,
+            },
+        )
+        job = self.api._jobs.list()[0]
+        self.assertEqual(
+            (job.title, job.kind, job.state), (LEGACY_TITLE, "autotag", "finished")
+        )
+        self.assertEqual([s for s in _strings(frames) if _absolute(s)], [])
+
+        # Skip: the marked images are skipped before the model runs.
+        self.tagger.calls.clear()
+        _, again = await self.legacy()
+        self.assertEqual(again[-1]["skipped"], 2)
+        self.assertEqual(again[-1]["processed"], 0)
+        self.assertEqual(self.tagger.calls, [])
+
+    async def test_no_still_images_and_keep_in_memory_false(self):
+        _, frames = await self.legacy("model_type=wd14-vit&keep_in_memory=false")
+        self.assertEqual(frames[-1]["status"], "No still images found")
+        self.assertEqual(frames[-1]["model_loaded"], False)
+        self.assertEqual(frames[-1]["model_status"], "Model unloaded")
+        self.assertEqual(self.tagger.unload_calls, 1)
+
+    async def test_language_model_options_come_from_the_page_or_the_template(self):
+        self.image("a.png", (1, 1, 1))
+        await self.legacy("model_type=gguf&prompt=Tags%20only")
+        self.assertEqual(self.tagger.calls[-1]["prompt"], "Tags only")
+        self.assertEqual(self.tagger.calls[-1]["limit"], 10)
+        self.image("b.png", (2, 2, 2))
+        await self.relist()
+        await self.legacy("model_type=gguf&prompt=%20")
+        self.assertEqual(self.tagger.calls[-1]["prompt"], AutotagConfig.TEMPLATE)
+        self.assertEqual(self.tagger.custom_prompt, "legacy prompt")
+
+    async def test_each_refusal_is_one_error_frame(self):
+        self.tagger.downloaded["wd14-vit"] = False
+        _, frames = await self.legacy()
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0]["type"], "error")
+        self.assertEqual(frames[0]["status"], "error")
+        self.assertIn("WD14 ViT is not downloaded", frames[0]["message"])
+        self.tagger.downloaded["wd14-vit"] = True
+
+        _, frames = await self.legacy("model_type=wd14-vit&general_threshold=2")
+        self.assertEqual(
+            frames,
+            [
+                {
+                    "type": "error",
+                    "status": "error",
+                    "message": "general_threshold must be between 0 and 1",
+                }
+            ],
+        )
+
+        owner = model_gate.new_owner("image-annotations")
+        self.assertTrue(model_gate.try_acquire(owner))
+        try:
+            _, frames = await self.legacy()
+        finally:
+            model_gate.release(owner)
+        self.assertEqual(frames[0]["message"], autotag_routes.MODEL_BUSY_ERROR)
+        self.assertEqual(self.api._jobs.list(), [])
+        self.assertIsNone(model_gate.holder())
+
+        response = await self.client.post(f"{START}?general_threshold=abc")
+        self.assertEqual(response.status, 400)
+
+    async def test_busy_jobs_refuse_the_legacy_batch(self):
+        self.image("a.png", (1, 1, 1))
+        entered, proceed = threading.Event(), threading.Event()
+        self.tagger.block = (entered, proceed)
+        status, data = await self.start_batch()
+        self.assertEqual(status, 202, data)
+        job = self.api._jobs.get(data["job"]["id"])
+        try:
+            await self.wait_for(entered)
+            _, frames = await self.legacy()
+            self.assertEqual(
+                frames,
+                [
+                    {
+                        "type": "error",
+                        "status": "error",
+                        "message": "Tag output images already running",
+                    }
+                ],
+            )
+        finally:
+            self.tagger.block = None
+            proceed.set()
+        await asyncio.wait_for(asyncio.shield(job.task), WAIT)
+
+        # A second legacy batch keeps its JSON 409.
+        self.image("b.png", (2, 2, 2))
+        await self.relist()
+        entered, proceed = threading.Event(), threading.Event()
+        self.tagger.block = (entered, proceed)
+        first = asyncio.ensure_future(
+            self.legacy("model_type=wd14-vit&skip_tagged=false")
+        )
+        try:
+            await self.wait_for(entered)
+            second = await self.client.post(f"{START}?model_type=wd14-vit")
+            self.assertEqual(second.status, 409)
+            self.assertEqual(
+                await second.json(),
+                {"success": False, "error": "Auto-tagging is already running"},
+            )
+        finally:
+            self.tagger.block = None
+            proceed.set()
+        _, frames = await first
+        self.assertEqual(frames[-1]["type"], "complete")
+
+    async def test_a_legacy_start_that_loses_the_race_gets_the_json_409(self):
+        # Two starts can both pass the title check before either registers its
+        # job; the loser's busy refusal names the legacy batch and answers the
+        # same JSON 409 as a second legacy batch.
+        refusal = image_tag_jobs.Refusal(
+            409,
+            "busy",
+            f"{autotag_routes.LEGACY_BATCH_TITLE} already running",
+            web.json_response({}, status=409),
+        )
+
+        async def refused(**_kwargs):
+            return None, refusal
+
+        with patch.object(self.api, "_start_autotag", side_effect=refused):
+            response = await self.client.post(f"{START}?model_type=wd14-vit")
+        self.assertEqual(response.status, 409)
+        self.assertEqual(
+            await response.json(),
+            {"success": False, "error": "Auto-tagging is already running"},
+        )
+
+    async def test_closing_the_stream_cancels_the_job(self):
+        for n in range(3):
+            self.image(f"{n}.png", (n, n, n))
+        real_write = web.StreamResponse.write
+
+        async def flaky_write(response, data):
+            if b'"processed"' in data:
+                raise ConnectionResetError("Cannot write to closing transport")
+            return await real_write(response, data)
+
+        with patch.object(web.StreamResponse, "write", flaky_write):
+            try:
+                response = await self.client.post(f"{START}?model_type=wd14-vit")
+                await response.read()
+            except Exception:  # nosec B110 - the client sees the dropped stream
+                pass
+        job = self.api._jobs.list()[0]
+        await asyncio.wait_for(asyncio.shield(job.task), WAIT)
+        self.assertEqual(job.state, "cancelled")
+        self.assertLess(job.counters["tagged"], 3)
+
+    async def test_a_quiet_job_repeats_its_last_frame(self):
+        self.image("a.png", (1, 1, 1))
+        entered, proceed = threading.Event(), threading.Event()
+        self.tagger.block = (entered, proceed)
+        with patch.object(autotag_routes, "LEGACY_REPEAT_AFTER", 0.05):
+            run = asyncio.ensure_future(self.legacy())
+            await self.wait_for(entered)
+            await asyncio.sleep(0.3)
+            self.tagger.block = None
+            proceed.set()
+            _, frames = await run
+        statuses = [f.get("status") for f in frames]
+        repeated = [s for s in statuses if s and statuses.count(s) > 1]
+        self.assertTrue(repeated, statuses)
+        self.assertEqual(frames[-1]["type"], "complete")
+
+    async def test_a_cancel_from_activity_ends_with_a_cancelled_frame(self):
+        for n in range(2):
+            self.image(f"{n}.png", (n, n, n))
+        entered, proceed = threading.Event(), threading.Event()
+        self.tagger.block = (entered, proceed)
+        run = asyncio.ensure_future(self.legacy())
+        try:
+            await self.wait_for(entered)
+            job = self.api._jobs.active("autotag")
+            await self.client.post(f"/prompt_manager/jobs/{job.id}/cancel")
+        finally:
+            self.tagger.block = None
+            proceed.set()
+        _, frames = await run
+        self.assertEqual(
+            frames[-1],
+            {
+                "type": "cancelled",
+                "message": "Cancelled. Tags already added were kept.",
+            },
+        )
+
+
+class TestLegacySingleAndApply(LegacyTestCase):
+    async def test_single_suggests_on_a_capture_and_apply_tags_only_that_image(self):
+        prompt = self.prompt("shared prompt", tags=["keep"])
+        a = self.image("a.png", (1, 2, 3), sees=["bird", "sky"])
+        b = self.image("b.png", (4, 5, 6), sees=["cat"])
+        image_a = self.link(prompt, a)
+        self.link(prompt, b)
+        self.saved_set("b.png", b.read_bytes(), ["hand"])
+        before = self.snapshot_prompts()
+        status, data = await self.single(
+            {"image_id": image_a, "model_type": "wd14-vit"}
+        )
+        self.assertEqual(status, 200, data)
+        self.assertEqual(data["tags"], ["bird", "sky"])
+        self.assertEqual(data["sha256"], self.digest("a.png"))
+        self.assertEqual(data["image_tags"], [])
+        self.assertEqual(data["prompt_id"], prompt)
+        self.assertEqual(self.tagger.custom_prompt, "legacy prompt")
+        # Inference read the private capture, not the file.
+        self.assertNotIn(str(self.output_dir), self.tagger.read_paths[-1])
+        status, applied = await self.apply(
+            {"image_id": image_a, "sha256": data["sha256"], "tags": ["bird"]}
+        )
+        self.assertEqual(
+            (status, applied),
+            (200, {"success": True, "added_tags": ["bird"], "total_tags": 1}),
+        )
+        self.assertEqual(self.stored("a.png")["tags"], ["bird"])
+        self.assertEqual(self.stored("b.png")["tags"], ["hand"])
+        self.assertEqual(self.snapshot_prompts(), before)
+        self.assertEqual(self.marked(), {self.locator("a.png")})
+
+    async def test_skip_answers_already_tagged_without_the_gate(self):
+        a = self.image("a.png", (1, 2, 3), sees=["bird"])
+        await self.run_batch()
+        self.tagger.calls.clear()
+        owner = model_gate.new_owner("image-tag-job")
+        self.assertTrue(model_gate.try_acquire(owner))
+        try:
+            status, data = await self.single(
+                {
+                    "path": "a.png",
+                    "root_index": 0,
+                    "existing": "skip",
+                    "model_type": "wd14-vit",
+                }
+            )
+        finally:
+            model_gate.release(owner)
+        self.assertEqual(status, 200, data)
+        self.assertEqual(data["already_tagged"], True)
+        self.assertEqual(data["image_tags"], ["bird"])
+        self.assertEqual(self.tagger.calls, [])
+        # Hand tags alone do not count; merge always suggests.
+        b = self.image("b.png", (9, 9, 9))
+        self.saved_set("b.png", b.read_bytes(), ["hand"])
+        status, data = await self.single(
+            {"path": str(b), "existing": "skip", "model_type": "wd14-vit"}
+        )
+        self.assertNotIn("already_tagged", data)
+        self.assertEqual(data["image_tags"], ["hand"])
+        status, data = await self.single(
+            {"path": str(a), "existing": "merge", "model_type": "wd14-vit"}
+        )
+        self.assertNotIn("already_tagged", data)
+
+    async def test_single_uses_the_saved_cap_and_the_refusal_table(self):
+        self.image("a.png", (1, 2, 3))
+        AutotagConfig.SUGGESTION_LIMIT = 3
+        status, data = await self.single(
+            {"path": "a.png", "root_index": 0, "model_type": "wd14-vit"}
+        )
+        self.assertEqual((status, len(data["tags"])), (200, 3))
+        (self.output_dir / "broken.png").write_bytes(b"not an image")
+        await self.relist()
+        status, data = await self.single(
+            {"path": "broken.png", "root_index": 0, "model_type": "wd14-vit"}
+        )
+        self.assertEqual((status, data["code"]), (415, "not-a-still"))
+        self.assertIn(self.locator("broken.png"), self.marked())
+        self.tagger.downloaded["gguf"] = False
+        status, data = await self.single(
+            {"path": "a.png", "root_index": 0, "model_type": "gguf"}
+        )
+        self.assertEqual((status, data["code"]), (409, "model-unavailable"))
+        self.api._capture_store().max_file = 16
+        status, data = await self.single(
+            {"path": "a.png", "root_index": 0, "model_type": "wd14-vit"}
+        )
+        self.assertEqual((status, data["code"]), (413, "too-large"))
+        self.api._capture_store().max_file = 2**20
+        owner = model_gate.new_owner("image-annotations")
+        self.assertTrue(model_gate.try_acquire(owner))
+        try:
+            status, data = await self.single(
+                {"path": "a.png", "root_index": 0, "model_type": "wd14-vit"}
+            )
+        finally:
+            model_gate.release(owner)
+        self.assertEqual((status, data["code"]), (409, "model-busy"))
+
+    async def test_apply_body_and_answer_table(self):
+        a = self.image("a.png", (1, 2, 3))
+        digest = self.digest("a.png")
+        status, data = await self.apply({"prompt_id": 1, "tags": ["a"]})
+        self.assertEqual(
+            (status, data["error"]), (400, "This page is out of date. Reload it.")
+        )
+        status, _ = await self.apply(
+            {"path": "a.png", "root_index": 0, "sha256": "x", "tags": ["a"]}
+        )
+        self.assertEqual(status, 400)
+        status, _ = await self.apply(
+            {"path": "a.png", "root_index": 0, "sha256": digest, "tags": ["bad,name"]}
+        )
+        self.assertEqual(status, 400)
+        status, _ = await self.apply({"path": "a.png", "sha256": digest, "tags": []})
+        self.assertEqual(status, 403)  # a bare relative path is not inside a root
+        # An empty reviewed list only marks the image.
+        status, data = await self.apply({"path": str(a), "sha256": digest, "tags": []})
+        self.assertEqual((status, data["added_tags"]), (200, []))
+        self.assertEqual(self.marked(), {self.locator("a.png")})
+        # The file changed since its tags were generated.
+        status, data = await self.apply(
+            {"path": str(a), "sha256": "0" * 64, "tags": ["x"]}
+        )
+        self.assertEqual((status, data["code"]), (409, "file-changed"))
+        # Too many tags.
+        full = self.image("full.png", (7, 7, 7))
+        self.saved_set("full.png", full.read_bytes(), [f"t{i}" for i in range(100)])
+        status, data = await self.apply(
+            {"path": str(full), "sha256": self.digest("full.png"), "tags": ["one_more"]}
+        )
+        self.assertEqual((status, data["code"]), (409, "tag-limit"))
+        # Gone.
+        status, data = await self.apply(
+            {"path": "gone.png", "root_index": 0, "sha256": digest, "tags": ["x"]}
+        )
+        self.assertIn(status, (403, 404))
+
+    async def test_apply_after_a_restore_writes_nothing(self):
+        a = self.image("a.png", (1, 2, 3))
+        digest = self.digest("a.png")
+        real = self.api.db.get_execution_epoch
+
+        def stale_epoch():
+            epoch = real()
+            conn = sqlite3.connect(self._temp_db.name)
+            try:
+                rotate_history_epoch(conn)
+            finally:
+                conn.close()
+            return epoch
+
+        with patch.object(self.api.db, "get_execution_epoch", side_effect=stale_epoch):
+            status, data = await self.apply(
+                {"path": str(a), "sha256": digest, "tags": ["x"]}
+            )
+        self.assertEqual((status, data["code"]), (409, "storage-changed"))
+        self.assertEqual(self.stored("a.png")["tags"], [])
+
+    async def test_image_id_and_path_bodies_reach_the_same_bytes(self):
+        prompt = self.prompt("p")
+        a = self.image("sub/a.png", (1, 2, 3), sees=["x"])
+        image_id = self.link(prompt, a)
+        _, by_id = await self.single({"image_id": image_id, "model_type": "wd14-vit"})
+        _, by_path = await self.single(
+            {"path": "sub/a.png", "root_index": 0, "model_type": "wd14-vit"}
+        )
+        self.assertEqual(by_id["sha256"], by_path["sha256"])
+        status, _ = await self.apply(
+            {"image_id": image_id, "sha256": by_id["sha256"], "tags": ["x"]}
+        )
+        self.assertEqual(status, 200)
+        status, data = await self.apply(
+            {
+                "path": "sub/a.png",
+                "root_index": 0,
+                "sha256": by_path["sha256"],
+                "tags": ["y"],
+            }
+        )
+        self.assertEqual((status, data["total_tags"]), (200, 2))
+
+
+class TestDialogMarks(LegacyTestCase):
+    """DEC4: a Tag image dialog save after Generate suggestions marks the image."""
+
+    def target(self, path):
+        return {
+            "root_index": 0,
+            "root_scope": self.api._gallery_root_scope(self.output_dir, 0),
+            "path": path,
+        }
+
+    async def observe(self, path):
+        response = await self.client.post(OBSERVE, json={"target": self.target(path)})
+        data = await response.json()
+        self.assertEqual(response.status, 200, data)
+        return data
+
+    async def suggest(self, observed, path):
+        response = await self.client.post(
+            SUGGEST,
+            json={
+                "target": self.target(path),
+                "capture_token": observed["capture"]["token"],
+                "expected_epoch": observed["library_epoch"],
+                "model_type": "wd14-vit",
+                "options": {"general_threshold": 0.35, "character_threshold": 0.85},
+            },
+        )
+        self.assertEqual(response.status, 200, await response.text())
+
+    async def save(self, observed, path, tags, revision=None):
+        response = await self.client.put(
+            TAGS,
+            json={
+                "target": self.target(path),
+                "capture_token": observed["capture"]["token"],
+                "sha256": observed["capture"]["sha256"],
+                "expected_epoch": observed["library_epoch"],
+                "expected_tag_revision": (
+                    observed["tag_revision"] if revision is None else revision
+                ),
+                "tags": tags,
+            },
+        )
+        return response.status, await response.json()
+
+    async def test_save_after_generate_marks_and_a_skip_batch_leaves_it(self):
+        self.image("d.png", (1, 2, 3), sees=["bird", "sky"])
+        observed = await self.observe("d.png")
+        await self.suggest(observed, "d.png")
+        status, _ = await self.save(observed, "d.png", ["sky"])  # bird removed
+        self.assertEqual(status, 200)
+        self.assertEqual(self.marked(), {self.locator("d.png")})
+        job = await self.run_batch(existing="skip")
+        self.assertEqual(self.rows(job, "skipped"), [("d.png", "Already auto-tagged")])
+        self.assertEqual(self.stored("d.png")["tags"], ["sky"])
+
+    async def test_save_without_generate_does_not_mark(self):
+        self.image("e.png", (1, 2, 3))
+        observed = await self.observe("e.png")
+        status, _ = await self.save(observed, "e.png", ["hand"])
+        self.assertEqual(status, 200)
+        self.assertEqual(self.marked(), set())
+
+    async def test_a_conflict_then_a_saved_retry_marks(self):
+        f = self.image("f.png", (1, 2, 3))
+        observed = await self.observe("f.png")
+        await self.suggest(observed, "f.png")
+        self.saved_set("f.png", f.read_bytes(), ["other"])  # another writer
+        status, data = await self.save(observed, "f.png", ["mine"])
+        self.assertEqual((status, data["code"]), (409, "tag-conflict"))
+        self.assertEqual(self.marked(), set())
+        status, _ = await self.save(
+            observed, "f.png", ["mine"], revision=data["tag_revision"]
+        )
+        self.assertEqual(status, 200)
+        self.assertEqual(self.marked(), {self.locator("f.png")})
+
+    async def test_another_capture_does_not_inherit_the_mark(self):
+        self.image("g.png", (1, 2, 3))
+        self.image("h.png", (4, 5, 6))
+        first = await self.observe("g.png")
+        await self.suggest(first, "g.png")
+        second = await self.observe("h.png")
+        status, _ = await self.save(second, "h.png", ["x"])
+        self.assertEqual(status, 200)
+        self.assertEqual(self.marked(), set())
+        self.assertIn(first["capture"]["token"], self.api._suggested_tokens)
+
+    async def test_gone_tokens_are_dropped_on_the_next_insert_without_touching_clocks(
+        self,
+    ):
+        self.image("i.png", (1, 2, 3))
+        self.image("j.png", (4, 5, 6))
+        first = await self.observe("i.png")
+        await self.suggest(first, "i.png")
+        store = self.api._capture_store()
+        store.release(first["capture"]["token"])
+        second = await self.observe("j.png")
+        seen = []
+        real_get = store.get
+        with patch.object(
+            store, "get", side_effect=lambda t: seen.append(t) or real_get(t)
+        ):
+            await self.suggest(second, "j.png")
+        self.assertEqual(seen, [])
+        self.assertEqual(self.api._suggested_tokens, {second["capture"]["token"]})

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_job_admission.py

@@ -535,7 +535,9 @@ class TestHeldJobStates(_LegacyHoldCase):
         self.assertIn("event: error", text)
         self.assertEqual(await self._listed(), [("thumbnails", "failed")])
 
-    async def test_legacy_autotag_that_ends_in_error_is_failed(self):
+    async def test_legacy_autotag_refused_at_start_leaves_no_job(self):
+        # #379: the legacy batch is the autotag job; a model that is not
+        # downloaded refuses the start (one error frame) and registers nothing.
         service = MagicMock()
         service.get_models_status.return_value = {}  # model not downloaded
         with patch("py.autotag.get_autotag_service", return_value=service):
@@ -545,7 +547,7 @@ class TestHeldJobStates(_LegacyHoldCase):
             text = await resp.text()
         self.assertEqual(resp.status, 200)
         self.assertIn('"type": "error"', text)
-        self.assertEqual(await self._listed(), [("autotag", "failed")])
+        self.assertEqual(await self._listed(), [])
 
 
 if __name__ == "__main__":

tests/test_pair_scan.py

@@ -115,7 +115,12 @@ class TestPairScan(AdminAPITestCase):
         self.assertEqual(second["pairs_added"], 0)
 
     def test_legacy_single_prompt_second_pass_not_reported_as_new_link(self):
-        meta = {"prompt": json.dumps({"1": graph()["1"]})}
+        # A sampler-less graph: one encoder wired into a guider (#252).
+        single = {
+            "1": graph()["1"],
+            "2": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}},
+        }
+        meta = {"prompt": json.dumps(single)}
         path = self.output_dir / "old.png"
         self.assertEqual(self.api._ingest_scanned_file(path, meta), "added")
         self.assertEqual(self.api._ingest_scanned_file(path, meta), "unchanged")
@@ -292,3 +297,155 @@ class TestPairScan(AdminAPITestCase):
             self.api.db.get_image_prompt_info(str(path))["workflow_data"], workflow
         )
         self.assertEqual(self.api._ingest_scanned_file(path, metadata), "unchanged")
+
+
+def flux_graph(text="a red fox", encoder="CLIPTextEncode"):
+    """A sampler-less Flux graph: the prompt reaches a guider's conditioning (#252)."""
+    return {
+        "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "flux.safetensors"}},
+        "2": {"class_type": "DualCLIPLoader", "inputs": {"clip_name1": "t5"}},
+        "6": {"class_type": encoder, "inputs": {"text": text, "clip": ["2", 0]}},
+        "22": {
+            "class_type": "BasicGuider",
+            "inputs": {"model": ["1", 0], "conditioning": ["6", 0]},
+        },
+        "13": {
+            "class_type": "SamplerCustomAdvanced",
+            "inputs": {"guider": ["22", 0], "sigmas": ["17", 0]},
+        },
+        "17": {"class_type": "BasicScheduler", "inputs": {"steps": 20}},
+        "9": {"class_type": "SaveImage", "inputs": {"images": ["13", 0]}},
+    }
+
+
+class TestSamplerLessScan(AdminAPITestCase):
+    """Graphs where no node takes a positive or negative input (#252)."""
+
+    def _scanned(self, name, prompt_graph, workflow=None):
+        meta = {"prompt": json.dumps(prompt_graph)}
+        if workflow is not None:
+            meta["workflow"] = json.dumps(workflow)
+        return self.api._ingest_scanned_file(self.output_dir / name, meta)
+
+    def _texts(self):
+        return [p["text"] for p in self.api.db.get_recent_prompts()["prompts"]]
+
+    def test_the_one_wired_prompt_is_linked(self):
+        self.assertEqual(self._scanned("flux.png", flux_graph()), "added")
+        self.assertEqual(self._texts(), ["a red fox"])
+
+    def test_a_text_node_feeding_the_encoder_is_one_prompt(self):
+        g = flux_graph(text=["30", 0])
+        g["30"] = {"class_type": "TextInput", "inputs": {"text": "a red fox"}}
+        self.assertEqual(self._scanned("textinput.png", g), "added")
+        self.assertEqual(self._texts(), ["a red fox"])
+
+    def test_a_display_node_that_feeds_nothing_is_never_the_prompt(self):
+        # A real scan stored a "=== GIT CLONE REPORT ===" display text this way.
+        g = flux_graph()
+        g["40"] = {
+            "class_type": "easy showAnything",
+            "inputs": {"text": "=== GIT CLONE REPORT ===\nTotal repositories: 1"},
+        }
+        self.assertEqual(self._scanned("report.png", g), "added")
+        self.assertEqual(self._texts(), ["a red fox"])
+
+    def test_only_unconsumed_texts_store_nothing(self):
+        g = {
+            "40": {"class_type": "easy showAnything", "inputs": {"text": "report"}},
+            "41": {"class_type": "Textbox", "inputs": {"text": "install note"}},
+        }
+        self.assertEqual(self._scanned("notes.png", g), "found")
+        self.assertEqual(self._texts(), [])
+
+    def test_two_wired_texts_are_ambiguous_and_stay_unlinked(self):
+        # A LoRA loader's text input is wired too: the scan stored "<lora:...>".
+        g = flux_graph()
+        g["50"] = {
+            "class_type": "Lora Loader (LoraManager)",
+            "inputs": {
+                "model": ["1", 0],
+                "clip": ["2", 0],
+                "text": "<lora:style:1.00>",
+            },
+        }
+        g["22"]["inputs"]["model"] = ["50", 0]
+        g["6"]["inputs"]["clip"] = ["50", 1]
+        self.assertEqual(self._scanned("lora.png", g), "unresolved")
+        self.assertEqual(self._texts(), [])
+
+    def test_an_untraceable_wired_text_makes_the_graph_ambiguous(self):
+        # The encoder's text comes from a node no rule reads: never guess the other.
+        g = flux_graph(text=["60", 0])
+        g["60"] = {"class_type": "SomeLLMNode", "inputs": {"seed": 1}}
+        g["50"] = {
+            "class_type": "Lora Loader (LoraManager)",
+            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
+        }
+        g["22"]["inputs"]["model"] = ["50", 0]
+        self.assertEqual(self._scanned("llm.png", g), "unresolved")
+        self.assertEqual(self._texts(), [])
+
+    def test_this_repositorys_prompt_node_is_authoritative(self):
+        g = flux_graph(text="a red fox", encoder="PromptManager")
+        g["50"] = {
+            "class_type": "Lora Loader (LoraManager)",
+            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
+        }
+        g["22"]["inputs"]["model"] = ["50", 0]
+        self.assertEqual(self._scanned("own.png", g), "added")
+        self.assertEqual(self._texts(), ["a red fox"])
+
+    def test_a_numeric_text_is_never_stored_as_a_prompt(self):
+        self.assertEqual(self._scanned("number.png", flux_graph(text="2048")), "found")
+        self.assertEqual(self._texts(), [])
+
+    def test_workflow_widget_values_are_never_read(self):
+        # The API text is linked from a node no rule reads; the UI workflow
+        # still holds a stale widget value, which the old scan stored.
+        g = flux_graph(text=["70", 0])
+        g["70"] = {"class_type": "PromptBuilder", "inputs": {"prompt": "x", "n": 2}}
+        workflow = {
+            "nodes": [
+                {"id": 6, "type": "CLIPTextEncode", "widgets_values": ["stale text"]}
+            ]
+        }
+        self.assertEqual(self._scanned("stale.png", g, workflow), "unresolved")
+        self.assertEqual(self._texts(), [])
+
+    def test_a_lora_loaders_trigger_word_output_is_not_its_text(self):
+        # The encoder reads the loader's trigger-word output (slot 2), not its
+        # text input: the prompt is unknown, never the "<lora:...>" syntax.
+        g = flux_graph(text=["50", 2])
+        g["50"] = {
+            "class_type": "Lora Loader (LoraManager)",
+            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
+        }
+        g["22"]["inputs"]["model"] = ["50", 0]
+        self.assertEqual(self._scanned("trigger.png", g), "unresolved")
+        self.assertEqual(self._texts(), [])
+
+    def test_a_seeded_text_node_holds_a_template_not_the_prompt(self):
+        g = flux_graph(text=["80", 0])
+        g["80"] = {
+            "class_type": "RandomPrompt",
+            "inputs": {"text": "a {red|blue} fox", "seed": 5},
+        }
+        self.assertEqual(self._scanned("random.png", g), "unresolved")
+        self.assertEqual(self._texts(), [])
+
+    def test_a1111_parameters_beside_an_undecided_graph_are_read(self):
+        # Metadata savers write both; the old scan read the A1111 positive.
+        g = flux_graph()
+        g["50"] = {
+            "class_type": "Lora Loader (LoraManager)",
+            "inputs": {"model": ["1", 0], "text": "<lora:style:1.00>"},
+        }
+        g["22"]["inputs"]["model"] = ["50", 0]
+        meta = {
+            "prompt": json.dumps(g),
+            "parameters": "a red fox\nNegative prompt: blur\nSteps: 20",
+        }
+        path = self.output_dir / "saver.png"
+        self.assertEqual(self.api._ingest_scanned_file(path, meta), "added")
+        self.assertEqual(self._texts(), ["a red fox"])

tests/test_sampler_less_prompt.py

@@ -0,0 +1,112 @@
+"""``sampler_less_prompt``: the one wired text of a graph with no sampler (#252)."""
+
+import time
+import unittest
+
+from utils.prompt_pair_resolver import sampler_less_prompt
+
+
+def _guided(**nodes):
+    """``nodes`` plus a guider consuming node ``"1"``."""
+    graph = {"9": {"class_type": "BasicGuider", "inputs": {"conditioning": ["1", 0]}}}
+    graph.update(nodes)
+    return graph
+
+
+class TestSamplerLessPrompt(unittest.TestCase):
+    def test_not_a_graph_or_too_large_is_absent(self):
+        for graph in (None, [], {}, "text"):
+            self.assertEqual(sampler_less_prompt(graph)["state"], "absent")
+        big = {str(i): {"class_type": "X", "inputs": {}} for i in range(3)}
+        self.assertEqual(sampler_less_prompt(big, max_visits=2)["state"], "absent")
+
+    def test_one_literal_text(self):
+        graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": " a fox "}}})
+        self.assertEqual(
+            sampler_less_prompt(graph),
+            {"state": "resolved", "text": "a fox", "texts": ["a fox"]},
+        )
+
+    def test_a_number_literal_is_never_a_prompt(self):
+        for value in (2048, "2048", "1.5", " 7 "):
+            graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": value}}})
+            self.assertEqual(sampler_less_prompt(graph)["state"], "absent", value)
+
+    def test_a_long_digit_run_with_a_letter_is_text_and_fast(self):
+        text = "9" * 50_000 + "x"
+        graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": text}}})
+        started = time.monotonic()
+        self.assertEqual(sampler_less_prompt(graph)["text"], text)
+        self.assertLess(time.monotonic() - started, 1.0)
+
+    def test_number_like_words_are_prompts(self):
+        for value in ("nan", "inf", "Infinity", "1_000"):
+            graph = _guided(**{"1": {"class_type": "Enc", "inputs": {"text": value}}})
+            self.assertEqual(sampler_less_prompt(graph)["text"], value)
+
+    def test_an_own_node_with_unreadable_text_beside_another_text_is_ambiguous(self):
+        graph = _guided(
+            **{
+                "1": {"class_type": "PromptManager", "inputs": {"text": ["5", 0]}},
+                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
+                "2": {"class_type": "Enc", "inputs": {"text": "<lora:x:1>"}},
+                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
+            }
+        )
+        self.assertEqual(sampler_less_prompt(graph)["state"], "ambiguous")
+
+    def test_unhashable_class_type_is_an_unknown_node_not_a_crash(self):
+        graph = _guided(**{"1": {"class_type": ["x"], "inputs": {"text": "a fox"}}})
+        self.assertEqual(sampler_less_prompt(graph)["text"], "a fox")
+
+    def test_own_negative_node_is_not_authoritative(self):
+        graph = _guided(
+            **{
+                "1": {"class_type": "Enc", "inputs": {"text": "a fox"}},
+                "2": {
+                    "class_type": "PromptManagerNegative",
+                    "inputs": {"text": "blur"},
+                },
+                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
+            }
+        )
+        found = sampler_less_prompt(graph)
+        self.assertEqual(found["state"], "ambiguous")
+        self.assertEqual(found["texts"], ["a fox", "blur"])
+
+    def test_own_node_text_wins_over_an_untraceable_text(self):
+        graph = _guided(
+            **{
+                "1": {"class_type": "PromptManagerText", "inputs": {"text": "a fox"}},
+                "2": {"class_type": "Enc", "inputs": {"text": ["5", 0]}},
+                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
+                "6": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
+            }
+        )
+        self.assertEqual(sampler_less_prompt(graph)["text"], "a fox")
+
+    def test_two_own_texts_are_ambiguous(self):
+        graph = _guided(
+            **{
+                "1": {"class_type": "PromptManager", "inputs": {"text": "a fox"}},
+                "2": {"class_type": "PromptManager", "inputs": {"text": "a cat"}},
+                "3": {"class_type": "Sink", "inputs": {"c": ["2", 0]}},
+            }
+        )
+        self.assertEqual(sampler_less_prompt(graph)["state"], "ambiguous")
+
+    def test_only_an_untraceable_text_is_ambiguous_with_nothing_to_show(self):
+        graph = _guided(
+            **{
+                "1": {"class_type": "Enc", "inputs": {"text": ["5", 0]}},
+                "5": {"class_type": "LLM", "inputs": {"seed": 3}},
+            }
+        )
+        self.assertEqual(
+            sampler_less_prompt(graph),
+            {"state": "ambiguous", "text": None, "texts": []},
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/prompt_pair_resolver.py

@@ -2578,3 +2578,115 @@ def resolve_text_input(
         return resolver.text(inputs.get(input_name), "string")[0]
     except _Unresolved:
         return None
+
+
+_NUMBER = re.compile(r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?")
+
+
+def _numeric(text: str) -> bool:
+    """Whether ``text`` is a plain number (a widget value such as ``2048``)."""
+    return _NUMBER.fullmatch(text) is not None
+
+
+def sampler_less_prompt(graph: Any, *, max_visits: int = 500) -> Dict[str, Any]:
+    """The positive prompt of an API graph with no sampler pair, if one (#252).
+
+    For graphs ``_no_sampler`` finds ``absent`` (no node takes a ``positive``
+    or ``negative`` input, such as a Flux guider or a video wrapper). Only the
+    executed API graph is read, never the UI workflow. A candidate is a node
+    with a ``text`` input whose output another node consumes: a text that
+    feeds nothing did not make the image. Its text is traced as a STRING
+    (``resolve_text_input``); a linked text no rule reads is unknown unless
+    it is built from a candidate's text (``_covered``). Blank and
+    numeric texts are never prompts, and a node with a seed input holds a
+    template, not the prompt (unknown). This repository's own positive-text
+    nodes are authoritative: when they give a text, only they count.
+
+    Returns ``{"state", "text", "texts"}``: ``resolved`` with the one distinct
+    text; ``ambiguous`` when several texts or an unknown one could be the
+    prompt (``texts`` lists the readable ones); ``absent`` when none.
+    """
+    absent = {"state": "absent", "text": None, "texts": []}
+    if not isinstance(graph, dict) or not graph or len(graph) > max_visits:
+        return absent
+    nodes = {str(key): value for key, value in graph.items()}
+    consumed = {
+        str(value[0])
+        for node in nodes.values()
+        if isinstance(node, dict) and isinstance(node.get("inputs"), dict)
+        for value in node["inputs"].values()
+        if _link(value)
+    }
+    own: list = []
+    other: list = []
+    unknown = False
+    for node_id, node in nodes.items():
+        inputs = node.get("inputs") if isinstance(node, dict) else None
+        if node_id not in consumed or not _has_text_input(node):
+            continue
+        if _seeded(inputs):
+            # Generated at run time (a wildcard or a language model): its
+            # text input is a template, not the prompt that ran.
+            unknown = True
+            continue
+        value = inputs["text"]
+        text = resolve_text_input(nodes, node_id, "text", max_visits=max_visits)
+        if text is None:
+            # A literal that is not a string (a number) is never a prompt.
+            if _link(value) and not _covered(nodes, value):
+                unknown = True
+            continue
+        text = text.strip()
+        if not text or _numeric(text):
+            continue
+        kind = node.get("class_type")
+        if isinstance(kind, str) and kind in _OWN_CLASSES and "Negative" not in kind:
+            own.append(text)
+        else:
+            other.append(text)
+    texts = list(dict.fromkeys(own or other))
+    if len(texts) == 1 and (own or not unknown):
+        return {"state": "resolved", "text": texts[0], "texts": texts}
+    if texts or unknown:
+        return {"state": "ambiguous", "text": None, "texts": texts}
+    return absent
+
+
+def _has_text_input(node: Any) -> bool:
+    inputs = node.get("inputs") if isinstance(node, dict) else None
+    return isinstance(inputs, dict) and "text" in inputs
+
+
+def _seeded(inputs: dict) -> bool:
+    """A seed input: the node's string output is a run-time value (the
+    resolver's ``runtime-value`` rule)."""
+    return any(isinstance(name, str) and name.endswith("seed") for name in inputs)
+
+
+def _covered(nodes: dict, link: list) -> bool:
+    """Whether an unreadable text link is built from a candidate's text.
+
+    True when a node upstream of ``link`` is read through its first output
+    (slot 0, the legacy encoder rule's text) and has an unseeded ``text``
+    input: that candidate is read on its own, and whatever else is joined to
+    it at run time (a caption, a language model) is no stored prompt to
+    choose. Another output of such a node (a loader's trigger words) is not
+    its text. False when the text comes only from inputs no candidate holds
+    (a builder's ``prompt`` field): the prompt is unknown then.
+    """
+    seen, stack = set(), [(str(link[0]), link[1])]
+    while stack:
+        node_id, slot = stack.pop()
+        if (node_id, slot) in seen:
+            continue
+        seen.add((node_id, slot))
+        node = nodes.get(node_id)
+        inputs = node.get("inputs") if isinstance(node, dict) else None
+        if not isinstance(inputs, dict):
+            continue
+        if "text" in inputs and slot == 0 and not _seeded(inputs):
+            return True
+        stack.extend(
+            (str(value[0]), value[1]) for value in inputs.values() if _link(value)
+        )
+    return False

web/admin.html

@@ -1187,14 +1187,13 @@ No sentences, no commentary, no captions. Only tags. Keep length short but descr
                 <div class="space-y-1.5">
                     <label class="flex items-center p-2.5 bg-pm-input rounded-pm-md cursor-pointer hover:bg-pm-hover border border-pm">
                         <input type="radio" name="autoTagMode" value="skip" checked class="w-3.5 h-3.5 accent-[var(--pm-accent)]">
-                        <span class="ml-2.5 text-pm text-xs">Skip images with existing tags</span>
+                        <span class="ml-2.5 text-pm text-xs">Skip images already auto-tagged</span>
                     </label>
                     <label class="flex items-center p-2.5 bg-pm-input rounded-pm-md cursor-pointer hover:bg-pm-hover border border-pm">
                         <input type="radio" name="autoTagMode" value="retag" class="w-3.5 h-3.5 accent-[var(--pm-accent)]">
                         <span class="ml-2.5 text-pm text-xs">Re-tag all images</span>
                     </label>
                 </div>
-                <p class="text-pm-muted text-[11px] mt-1">Note: "auto-scanned" is not counted as a real tag</p>
             </div>
 
             <!-- Action Buttons -->
@@ -1293,6 +1292,7 @@ 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="autoTagProgressBar" class="bg-pm-accent h-1.5 rounded-full transition-all duration-300" style="width: 0%"></div>
                 </div>
+                <p id="autoTagCloseNote" class="text-pm-muted text-[11px] mt-1.5">Closing this window stops tagging. Tags already added are kept. Prompt Manager's Activity page shows the time left.</p>
             </div>
 
             <div class="grid grid-cols-3 gap-3 mb-4">
@@ -1332,7 +1332,7 @@ No sentences, no commentary, no captions. Only tags. Keep length short but descr
     <!-- Re-tag Confirmation Modal -->
     <div id="retagConfirmModal" class="fixed inset-0 bg-black/60 backdrop-blur-[2px] hidden items-center justify-center z-50">
         <div class="bg-pm-surface rounded-pm-lg p-4 max-w-lg w-full mx-4 border border-pm shadow-pm">
-            <h3 class="text-sm font-semibold text-pm mb-3">Image Already Tagged</h3>
+            <h3 class="text-sm font-semibold text-pm mb-3">Image Already Auto-tagged</h3>
 
             <div class="mb-3">
                 <img id="retagPreviewImage" src="" alt="Preview" class="w-full h-40 object-contain bg-pm-primary rounded-pm-md">
@@ -1345,7 +1345,7 @@ No sentences, no commentary, no captions. Only tags. Keep length short but descr
                 </div>
             </div>
 
-            <p class="text-pm-secondary text-xs mb-4">This image already has tags. Would you like to generate new tags?</p>
+            <p class="text-pm-secondary text-xs mb-4">A tagging model already tagged this image. Generate new tags?</p>
 
             <div class="flex gap-2 justify-end">
                 <button id="retagSkipBtn"

web/gallery.html

@@ -682,6 +682,7 @@ 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="autoTagProgressBar" class="bg-pm-accent h-2 rounded-full transition-all duration-300" style="width: 0%"></div>
                 </div>
+                <p id="autoTagCloseNote" class="text-pm-muted text-xs mt-1.5">Closing this window stops tagging. Tags already added are kept. Prompt Manager's Activity page shows the time left.</p>
             </div>
 
             <!-- Stats -->

web/js/admin.js

@@ -3801,7 +3801,7 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                         } else if (data.type === 'complete') {
                             this.autoTagState.eventSource.close();
                             this.hideModal("autoTagProgressModal");
-                            this.showNotification(`Auto tagging complete! Applied tags to ${data.tagged || 0} prompts.`, 'success');
+                            this.showNotification(ImageHelpers.autotagCompleteMessage(data.tagged), 'success');
                             this.refreshList(); // Refresh the prompt list
                         } else if (data.type === 'error') {
                             this.autoTagState.eventSource.close();
@@ -3819,7 +3819,7 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                         console.error('EventSource readyState:', this.autoTagState.eventSource.readyState);
                         this.autoTagState.eventSource.close();
                         this.hideModal("autoTagProgressModal");
-                        this.showNotification('Connection lost during auto tagging', 'error');
+                        this.showNotification((error && error.serverMessage) || 'Connection lost during auto tagging', 'error');
                     };
                 } catch (error) {
                     console.error('Auto tag error:', error);
@@ -3894,10 +3894,14 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 }
             }
 
-            // Check if tags array has "real" tags (excluding auto-scanned and prepend:* metadata)
-            getRealTags(tags) {
-                if (!tags || !Array.isArray(tags)) return [];
-                return tags.filter(tag => tag !== 'auto-scanned' && !tag.startsWith('prepend:') && !tag.startsWith('append:'));
+            /** POST /autotag/single for `image` (#379: `existing` "skip" answers already_tagged for an auto-tagged image). */
+            async requestReviewTags(image, existing) {
+                const response = await ApiClient.fetchUrl('/prompt_manager/autotag/single', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(ImageHelpers.autotagSingleBody(image, { ...this.autoTagState, existing }))
+                });
+                return response.json();
             }
 
             // Show the re-tag confirmation modal
@@ -3949,26 +3953,48 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 // always provides a servable url; never rebuild it from the path.
                 const imageUrl = this.getImageUrl(image);
 
-                // Check if image already has real tags (excluding auto-scanned)
-                const realTags = this.getRealTags(image.prompt_tags);
+                this.autoTagState.currentImage = image;
+                this.autoTagState.currentSha256 = null;
+                this.autoTagState.tagsExpanded = false;  // Reset accordion for new image
 
-                if (realTags.length > 0) {
-                    // Skip if "Skip All Tagged" was selected
-                    if (this.autoTagState.skipAllTagged) {
-                        this.autoTagState.reviewIndex++;
-                        return this.loadNextReviewImage();
+                let data;
+                try {
+                    // Each image is first asked with "skip": an image a tagging model already tagged answers
+                    // already_tagged (its image tags, never its prompt's) without running the model (#379).
+                    data = await this.requestReviewTags(image, 'skip');
+                    if (data.success && data.already_tagged) {
+                        if (this.autoTagState.skipAllTagged) {
+                            this.autoTagState.reviewIndex++;
+                            return this.loadNextReviewImage();
+                        }
+                        const choice = await this.showRetagConfirmation(image, imageUrl, data.image_tags || []);
+                        if (choice === 'skip' || choice === 'skipAll') {
+                            this.autoTagState.reviewIndex++;
+                            return this.loadNextReviewImage();
+                        }
+                        // choice === 'retag': generate new tags for it
+                        this.showReviewImage(image, imageUrl);
+                        data = await this.requestReviewTags(image, 'merge');
+                    } else {
+                        this.showReviewImage(image, imageUrl);
                     }
-
-                    // Show confirmation modal
-                    const choice = await this.showRetagConfirmation(image, imageUrl, realTags);
-
-                    if (choice === 'skip' || choice === 'skipAll') {
-                        this.autoTagState.reviewIndex++;
-                        return this.loadNextReviewImage();
+                    if (data.success) {
+                        this.autoTagState.currentTags = data.tags;
+                        this.autoTagState.currentSha256 = data.sha256 || null;
+                        this.renderReviewTags();
+                    } else {
+                        document.getElementById('reviewTagsVisible').innerHTML =
+                            `<div class="text-pm-error">Error: ${escapeHtml(data.error)}</div>`;
                     }
-                    // choice === 'retag' - continue with tagging
+                } catch (error) {
+                    console.error('Error generating tags:', error);
+                    this.showReviewImage(image, imageUrl);
+                    document.getElementById('reviewTagsVisible').innerHTML =
+                        '<div class="text-pm-error">Failed to generate tags</div>';
                 }
+            }
 
+            showReviewImage(image, imageUrl) {
                 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();
@@ -3977,37 +4003,6 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 document.getElementById('reviewTagsHidden').innerHTML = '';
                 document.getElementById('reviewTagsAccordion').classList.add('hidden');
                 document.getElementById('reviewTagsToggle').classList.add('hidden');
-
-                // Store prompt_id from database for applying tags later
-                this.autoTagState.currentPromptId = image.prompt_id;
-                this.autoTagState.tagsExpanded = false;  // Reset accordion for new image
-
-                try {
-                    // Review rows come from /images/all (database ids), so this resolves to image_id
-                    const requestBody = ImageHelpers.autotagSingleBody(image, this.autoTagState);
-
-                    const response = await ApiClient.fetchUrl('/prompt_manager/autotag/single', {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify(requestBody)
-                    });
-
-                    const data = await response.json();
-
-                    if (data.success) {
-                        this.autoTagState.currentTags = data.tags;
-                        // Use prompt_id from database, fallback to API response
-                        this.autoTagState.currentPromptId = image.prompt_id || data.prompt_id;
-                        this.renderReviewTags();
-                    } else {
-                        document.getElementById('reviewTagsVisible').innerHTML =
-                            `<div class="text-pm-error">Error: ${escapeHtml(data.error)}</div>`;
-                    }
-                } catch (error) {
-                    console.error('Error generating tags:', error);
-                    document.getElementById('reviewTagsVisible').innerHTML =
-                        '<div class="text-pm-error">Failed to generate tags</div>';
-                }
             }
 
             /** /prompt_manager/images/all is capped per call; collect every page. */
@@ -4126,15 +4121,9 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
             }
 
             async applyReviewTags() {
-                if (this.autoTagState.currentTags.length === 0) {
-                    this.skipReviewImage();
-                    return;
-                }
-
-                const promptId = this.autoTagState.currentPromptId;
-
-                if (!promptId) {
-                    this.showNotification('No linked prompt found for this image', 'warning');
+                // #379: the reviewed tags go to this image (linked or not), never its prompt; an empty
+                // list still marks the image as reviewed by a tagging model.
+                if (!this.autoTagState.currentSha256) {
                     this.skipReviewImage();
                     return;
                 }
@@ -4143,10 +4132,8 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     const response = await ApiClient.fetchUrl('/prompt_manager/autotag/apply', {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            prompt_id: promptId,
-                            tags: this.autoTagState.currentTags
-                        })
+                        body: JSON.stringify(ImageHelpers.autotagApplyBody(
+                            this.autoTagState.currentImage, this.autoTagState.currentSha256, this.autoTagState.currentTags))
                     });
 
                     const data = await response.json();

web/js/gallery.js

@@ -3560,19 +3560,24 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                         } else if (data.type === 'complete') {
                             this.autoTagState.eventSource.close();
                             this.hideModal("autoTagProgressModal");
-                            this.showNotification(`Auto tagging complete! Applied tags to ${data.tagged || 0} prompts.`, 'success');
+                            this.showNotification(ImageHelpers.autotagCompleteMessage(data.tagged), 'success');
                             this.loadImages(); // Refresh the gallery
                         } else if (data.type === 'error') {
                             this.autoTagState.eventSource.close();
                             this.hideModal("autoTagProgressModal");
                             this.showNotification(`Auto tag error: ${data.message}`, 'error');
+                        } else if (data.type === 'cancelled') {
+                            // Cancelled in Prompt Manager's Activity (#379): as its own cancel.
+                            this.autoTagState.eventSource.close();
+                            this.hideModal("autoTagProgressModal");
+                            this.showNotification('Auto tagging cancelled', 'info');
                         }
                     };
 
-                    this.autoTagState.eventSource.onerror = () => {
+                    this.autoTagState.eventSource.onerror = (error) => {
                         this.autoTagState.eventSource.close();
                         this.hideModal("autoTagProgressModal");
-                        this.showNotification('Connection lost during auto tagging', 'error');
+                        this.showNotification((error && error.serverMessage) || 'Connection lost during auto tagging', 'error');
                     };
                 } catch (error) {
                     console.error('Auto tag error:', error);
@@ -3629,6 +3634,8 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 this.reviewRequest = request;
                 this.autoTagState.currentTags = [];
                 this.autoTagState.reviewPromptId = null;
+                this.autoTagState.reviewImage = null;
+                this.autoTagState.reviewSha256 = null;
                 if (this.autoTagState.reviewIndex >= this.autoTagState.reviewImages.length) {
                     this.hideModal("autoTagReviewModal");
                     this.showNotification('Review complete!', 'success');
@@ -3643,8 +3650,9 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                 document.getElementById('reviewTagsContainer').innerHTML = '<div class="text-pm-secondary">Generating tags...</div>';
 
                 try {
-                    // Gallery entries come from /images/output: id is a path digest, so address by path
-                    const requestBody = ImageHelpers.autotagSingleBody(image, this.autoTagState);
+                    // Gallery entries come from /images/output: id is a path digest, so address by path.
+                    // The gallery review always suggests (it never skipped tagged images, #379).
+                    const requestBody = ImageHelpers.autotagSingleBody(image, { ...this.autoTagState, existing: 'merge' });
 
                     const response = await ApiClient.fetchUrl('/prompt_manager/autotag/single', {
                         method: 'POST',
@@ -3657,6 +3665,8 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     if (this.reviewRequest !== request) return;
                     if (data.success) {
                         this.autoTagState.reviewPromptId = data.prompt_id ?? null;
+                        this.autoTagState.reviewImage = image;
+                        this.autoTagState.reviewSha256 = data.sha256 || null;
                         this.autoTagState.currentTags = data.tags;
                         this.renderReviewTags();
                     } else {
@@ -3697,16 +3707,12 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
             }
 
             async applyReviewTags() {
-                if (this.autoTagState.currentTags.length === 0) {
+                // #379: the reviewed tags go to this image (linked or not), never its prompt; an empty
+                // list still marks the image as reviewed by a tagging model.
+                if (!this.autoTagState.reviewSha256) {
                     this.skipReviewImage();
                     return;
                 }
-
-                const promptId = this.autoTagState.reviewPromptId;
-                if (!promptId) {
-                    this.showNotification('This image has no linked prompt. Scan the output folder first.', 'warning');
-                    return;
-                }
                 const request = this.reviewRequest;
                 if (this.reviewApplying === request) return;
                 this.reviewApplying = request;
@@ -3715,10 +3721,8 @@ Seed: ${this.currentMetadata.seed || 'Unknown'}`;
                     const response = await ApiClient.fetchUrl('/prompt_manager/autotag/apply', {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({
-                            prompt_id: promptId,
-                            tags: this.autoTagState.currentTags
-                        })
+                        body: JSON.stringify(ImageHelpers.autotagApplyBody(
+                            this.autoTagState.reviewImage, this.autoTagState.reviewSha256, this.autoTagState.currentTags))
                     });
 
                     const data = await response.json();

web/js/image-helpers.js

@@ -70,10 +70,28 @@
      * path digest as id, which would 404, so those are addressed by path.
      *
      * @param {{id?: unknown, path?: unknown}} image
-     * @param {{modelType: string, generalThreshold?: number, characterThreshold?: number, prompt?: string}} settings
+     * `existing` (#379): "skip" answers `already_tagged` for an image a model
+     * already tagged; anything else is "merge" (always suggest).
+     *
+     * @param {{id?: unknown, path?: unknown}} image
+     * @param {{modelType: string, generalThreshold?: number, characterThreshold?: number, prompt?: string, existing?: string}} settings
      * @returns {object} JSON-serialisable request body
      */
     function autotagSingleBody(image, settings) {
+        const target = autotagTarget(image);
+        const existing = settings.existing === "skip" ? "skip" : "merge";
+        const modelType = String(settings.modelType || "");
+        const params = modelType.startsWith("wd14")
+            ? {
+                  general_threshold: settings.generalThreshold,
+                  character_threshold: settings.characterThreshold,
+              }
+            : { prompt: settings.prompt };
+        return { ...target, model_type: modelType, existing, ...params };
+    }
+
+    /** The image a legacy single/apply body names: its row id, or its path (and root). */
+    function autotagTarget(image) {
         const entry = image || {};
         const target =
             typeof entry.path === "string" && entry.path && !Number.isInteger(entry.id)
@@ -82,14 +100,22 @@
         if ("path" in target && Number.isInteger(entry.root_index)) {
             target.root_index = entry.root_index;
         }
-        const modelType = String(settings.modelType || "");
-        const params = modelType.startsWith("wd14")
-            ? {
-                  general_threshold: settings.generalThreshold,
-                  character_threshold: settings.characterThreshold,
-              }
-            : { prompt: settings.prompt };
-        return { ...target, model_type: modelType, ...params };
+        return target;
+    }
+
+    /**
+     * Body for POST /prompt_manager/autotag/apply (#379): the image, the
+     * `sha256` /autotag/single answered and the reviewed tags. The tags go to
+     * that image only, never to its prompt; an empty list marks it reviewed.
+     */
+    function autotagApplyBody(image, sha256, tags) {
+        return { ...autotagTarget(image), sha256: String(sha256 || ""), tags: Array.isArray(tags) ? [...tags] : [] };
+    }
+
+    /** The legacy batch's completion toast (#379): images, never prompts. */
+    function autotagCompleteMessage(tagged) {
+        const count = Number.isSafeInteger(tagged) && tagged > 0 ? tagged : 0;
+        return `Auto tagging complete! Tagged ${count} ${count === 1 ? "image" : "images"}.`;
     }
 
     /**
@@ -122,7 +148,15 @@
         }
     }
 
-    const api = { formatImageCaption, workflowDocumentHtml, autotagSingleBody, fallbackImageSource, metadataLookupUrl };
+    const api = {
+        formatImageCaption,
+        workflowDocumentHtml,
+        autotagSingleBody,
+        autotagApplyBody,
+        autotagCompleteMessage,
+        fallbackImageSource,
+        metadataLookupUrl,
+    };
     if (typeof module !== "undefined" && module.exports) module.exports = api;
     else root.ImageHelpers = api;
 })(typeof window !== "undefined" ? window : globalThis);

web/js/sse-stream.js

@@ -59,6 +59,20 @@
      * @returns {{onmessage: Function|null, onerror: Function|null, onclose: Function|null,
      *   readyState: number, close: Function, CONNECTING: number, OPEN: number, CLOSED: number}}
      */
+    // A non-2xx answer as an Error carrying its status and, when the body is
+    // the API's JSON {error}, that sentence as serverMessage for the page.
+    async function httpError(response) {
+        const error = new Error(`HTTP ${response.status}`);
+        error.status = response.status;
+        try {
+            const data = await response.json();
+            if (data && typeof data.error === "string" && data.error) error.serverMessage = data.error;
+        } catch (_) {
+            // Not JSON: the status alone.
+        }
+        return error;
+    }
+
     function connect(url, { method = "GET", body, fetchImpl } = {}) {
         const doFetch = fetchImpl || ((...args) => globalThis.fetch(...args));
         const controller = new AbortController();
@@ -103,7 +117,7 @@
                 if (body !== undefined) init.body = body;
                 const requestUrl = root.ApiClient ? root.ApiClient.resolveUrl(url) : url;
                 const response = await doFetch(requestUrl, init);
-                if (!response.ok) throw new Error(`HTTP ${response.status}`);
+                if (!response.ok) throw await httpError(response);
                 if (source.readyState === CLOSED) return;
                 source.readyState = OPEN;