Merge remote-tracking branch 'origin/main' into feat/450-viewer-fullscreen

Frontend coverage for inspect.mjs fell below its floor (branches 91.04 < 92,
functions 92.85 < 93): no spec reached the AVI toast or the open-dialog guard,
and the video wait had a page-end callback no spec reached. The wait now ends
through its own callback at page end, and two specs cover the AVI note and a
selection landing under another dialog.

TESTING.md

@@ -3271,8 +3271,7 @@ until this browser dismissed the 3.2.0 update notice (`pm_update_notice_dismisse
 the legacy admin page's key); Later dismisses it without scanning, and Review scan
 dismisses it as the legacy Scan does. "+ Add source" asks validate-source, then adds
 the folder to the host draft of `gallery_root_paths`; Remove takes one out; "Watch for
-new outputs" (`monitoring_enabled`), "Save prompts from other workflows"
-(`save_foreign_runs`, D158) and Worker threads (`worker_threads`) are host
+new outputs" (`monitoring_enabled`) and Worker threads (`worker_threads`) are host
 drafts too, and Save writes them with the revision. A save the server refuses because a
 scan runs toasts "Another job is running: <title>." with a link to that job (D57) and
 keeps the drafts; a save refused for one source says the server's message as the status
@@ -3521,7 +3520,7 @@ the connection's `total_changes` is 0 at close and the data reads back unchanged
 `-shm` bytes are not compared: every WAL reader rewrites its read marks there, so no
 reader can keep it byte-identical (`test_health_check_never_writes`).
 
-Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107, D109–D110 and D111–D114; D121–D134 and D158 assigned). D94,
+Recorded deviations (plan D60–D75, D79–D82 renumbered D92–D107, D109–D110 and D111–D114; D121–D134 assigned). D94,
 the per-section hand-off panel, was retired by S12 (#329): every section is native.
 
 - **D92** (shell): no "Sample configuration" chip. The Save status is truthful: "No
@@ -4041,26 +4040,6 @@ the per-section hand-off panel, was retired by S12 (#329): every section is nati
   Cancel-only review matches the concept review shell` (system-tagging-concept.spec) and
   the batch tests of workspace-system-tagging.spec; the mutation check renames each grid
   label in turn.
-- **D158** (Sources, #247 D-Q4): the concept has no switch for prompts from workflows
-  without a PromptManager node; the maintainer chose a visible switch over a config key.
-  A `.setting-row` in the concept's toggle markup follows "Watch for new outputs":
-  "Save prompts from other workflows" (`#foreign-runs`, host key `save_foreign_runs`,
-  config.json `gallery.monitoring.save_foreign_runs`, default on), "New outputs of
-  workflows without a PromptManager node add their prompt to the library when it is
-  certain.". It is saved with the revision like the other host rows and applied at once
-  (the monitor reads it for every file), so a save names no restart. While "Watch for
-  new outputs" is drafted off, a `p.small` under the description says "Applies while
-  Watch for new outputs is on." (the switch's `aria-describedby`; the value is kept) and
-  the switch is disabled, except while a source still reads "watching until restart"
-  (D128): the running observer still delivers files then, so the value can be set. The
-  server stores no foreign prompt while `monitoring_enabled` is saved off, whatever the
-  observer does.
-  Pinned by `sources matches the concept` (the mapping inserts the row after the
-  monitoring row), `sources comparison detects mutations` (a missing row and a changed
-  label are caught), `D158: Save prompts from other workflows saves save_foreign_runs
-  live; off while monitoring is off (#247)` (keyboard on desktop, a tap on touch) and
-  `D158: saved off while the monitor still watches until a restart, the foreign row can
-  still be set (D128)` (workspace-system-sources.spec) and the system-sources node test.
 - **D109** (Logs, S12, #329): the concept's Logs surface on the live server. The toolbar
   keeps "Level", Refresh and the download (renamed "Download log": the active log,
   `/logs/download/prompt_manager.log`, through the api client), with all six minimum
@@ -5988,70 +5967,6 @@ Tests: `tests/test_file_prompt.py` (one test per ladder step and junk class),
 saver, a legacy-linked file left as it is, `_BatchHistory.recorded`) and
 `tests/test_recorded_saver_anchor.py` `TestInspectionResolution`.
 
-**In the monitor.** An output whose workflow has no positive PromptManager node
-(`_find_prompt_from_metadata` says `foreign`) used to be logged and skipped. It now
-goes through the same ladder with the `MONITOR` policy (`utils/foreign_runs.py`, the
-handler's `_ingest_foreign`, `_recheck_foreign`, `_store_foreign`):
-
-- **At settle.** The ladder runs without history. Certain (`pair` or `positive`): the
-  prompt is stored and the file linked at once. `history` (an undecided graph inside
-  ComfyUI's output folder): the file is registered in its own waiting set, then the
-  ladder runs again at once with the file's recorded output, because the run may have
-  been sealed before the file settled. When that lookup finds a record, its answer is
-  final: certain is stored, anything else is logged "No certain prompt for <file>;
-  left unlinked" and the file stops waiting (no seal is coming). When it finds none,
-  only the inspector's or the recorded saver's answer is stored; anything else (the
-  legacy floor included) keeps waiting for the re-check. Anything else at the first
-  pass is logged "No certain prompt for <file>; left unlinked".
-- **After the run ends.** When the run's outputs are sealed, each waiting foreign file
-  gets one re-check (`ForeignRecheck(reference)`) with the sealed output reference,
-  so history is asked with the spelling it recorded (a Windows folder whose case
-  differs from the disk still links). Not certain: "No certain prompt for <file>
-  after its run ended; left unlinked". An ambiguous inspector answer is never given
-  the legacy floor in the monitor (D-Q3); an untraceable one still is.
-- **Waiting sets.** `_awaiting_foreign` and `_foreign_due` sit beside the keyless sets
-  with the same bounds (1000 files, one hour) but are separate, so a large foreign run
-  never evicts a waiting keyless file. An expired entry is logged "No recorded run
-  for <file>; left unlinked", an evicted one (waiting or due) "Too many files wait for
-  their run; <file> left unlinked", both after the lock is released. A due re-check
-  is dropped only when it was scheduled, never a newer reference for the same file. `awaiting_foreign()` lists them;
-  `shutdown()` and `close()` clear them, and a closed handler re-checks nothing.
-- **Store.** One write through `survive_switch` (rerun after a Move library): a pair
-  through `ingest_resolved_pair(..., marks=RUN_MARKS)`, a positive through
-  `store_scanned_prompt_or_raise(..., RUN_MARKS)`. A created prompt carries category
-  `scanned`, tag `auto-scanned` and the note `Saved from a workflow run: <file>`; a
-  file linked to another prompt is `conflict` and keeps its link. Logged at info
-  "Foreign run: <status> prompt <id> for <file> (<source>)"; a failure is logged and
-  the file stays unlinked.
-- **Never.** No tracker FIFO entry is read or consumed, nothing is counted (run count
-  stays 0, no `last_used_at`), and nothing is queued for Needs review.
-- **The setting.** `GalleryConfig.SAVE_FOREIGN_RUNS` (`gallery.monitoring.
-  save_foreign_runs`, default true, only a bool applies) is read for every file, at
-  settle, at the re-check and again just before the store, together with
-  `MONITORING_ENABLED`: either saved off stops foreign writes at once (the running
-  observer watches until a restart, D128); off logs "No PromptManager prompt in
-  workflow, skipping image" as before. System › Sources & scans "Save prompts from other workflows" (D158)
-  saves it through `POST /prompt_manager/settings` with no restart field; the
-  diagnostics report lists it.
-
-Tests: `tests/test_run_attribution.py` `TestMonitorForeignRuns` (dataset branches
-linked after the seal, a seal before settle, a name two runs reported, the setting
-off at settle and at the re-check, a plain workflow linked at settle with no run
-count and the tracker queue untouched, the sealed reference's spelling, the separate
-bound, expiry, a seal while the pending set is full, shutdown, a failed store, no
-record at settle keeps waiting, a record without an answer ends the wait, monitoring
-saved off, the setting read before the store, a seal between registering and the
-settle lookup, a newer due reference kept, evictions logged, one link per file),
-`tests/test_image_linking.py` `TestForeignWorkflows`, `tests/test_image_monitor_singleton.py`
-(close drops a foreign re-check), `tests/test_config.py`,
-`tests/test_settings_sources.py` `TestSaveForeignRunsSetting`, and the real-host
-`tests/comfyui/image-attribution.spec.mjs` case "an output of a workflow without a
-PromptManager node creates and links its prompt; a second run reuses it" (ComfyUI's
-own `CLIPTextEncode`, `KSampler` and `SaveImage`), and "each branch of a
-shared-prefix workflow without a PromptManager node links to its own prompt after the
-run" (two branches, one save prefix: the recorded saver names each file's branch).
-The fixture route's GET also lists `foreign`, the waiting foreign files.
-
 ## Linked prompt text (#343)
 
 A link drives `text` on every PromptManager node, and `negative_text` on the Pair,
@@ -6636,16 +6551,15 @@ Deploying this backend needs a ComfyUI restart (Python and route changes).
 
 `#/tags` ("Tags & categories", page title "Tags") is a native workspace route; it no
 longer hands off to the legacy tag manager. That page stays reachable from Overview's
-"Open existing tag manager" card for multi-tag AND/OR browsing (tag search and sort
-and the untagged entry moved here with D149, #444); bulk prompt delete stays on the
-legacy admin page (bulk tags: the Prompt library's selection bar, D151). A
+"Open existing tag manager" card for tag search and sort, the untagged entry and
+multi-tag AND/OR browsing; bulk prompt delete stays on the legacy admin page (bulk tags:
+the Prompt library's selection bar, D151). A
 prompt's category is changed in the Prompt library editor, on many prompts at once with
 the Prompt library's selection bar (D148, #437), or with the legacy admin page's "Set
 Category" (both `POST /prompt_manager/bulk/category`);
 the Images selection bar's Set category sets images' own categories only (D140, #332),
 and Manage category renames a value on prompts, recipes and images together (D144). The screen consumes only the `/prompt_manager/vocabulary/*` routes
-above and adds no route, so PR B needed no ComfyUI restart; D149 (#444) adds read
-parameters to `GET tags` and `GET /prompt_manager/library`, which do.
+above and adds no route, so PR B needs no ComfyUI restart: a browser refresh is enough.
 
 Screen: a `+ Create tag` heading action, a Tag vocabulary table (columns Tag, Prompts,
 Images counting the files that carry the tag (`image_count`, #249 C2), and Actions with Browse and
@@ -6697,36 +6611,6 @@ Apply; "Apply" instead of "Apply in prototype"; Delete tag… inside Rename or m
 Browse sets the exact filter; singular "1 positive prompt"; the production list appends
 fixture-only tags after the concept's sample tags.
 
-- **D149** (#444, cutover #334; the concept's renderTags has neither): the Tag vocabulary
-  surface shows, after its paragraph, an "Untagged prompts" `.operation` row ("N positive
-  prompts", Browse) and then the tag search and sort, drawn as the concept page toolbar's
-  `search.toolbar` > `label.search-field` (search icon, `input#tag-search` "Search tags…",
-  maxlength 200) and a `select#tag-sort` (Oldest first, the default and the old order;
-  Name A–Z; Name Z–A; Most prompts; Fewest prompts). Search is a literal, case-insensitive
-  substring on the server (`GET /prompt_manager/vocabulary/tags?search=&sort=`; ASCII-only
-  case folding, like SQLite `LIKE`/`NOCASE`), debounced 250 ms; it resets only the tag list
-  to page one, keeps through command re-reads, reads "No tags match this search." when
-  empty and is announced in a visually hidden status ("N tags"). Every sort breaks ties by
-  ascending id; a cursor belongs to one search and sort (scope-hashed; another is 400 with
-  "refresh"); a count sort's counts can move between pages only through a write, which
-  re-reads from page one. Each tags page reports `untagged_count` (eligible Library parents
-  with no tag and no active pair carrying one, the complement of every tag's Browse; legacy
-  counted every prompt without `prompt_tags` and hid the entry at 0; this row always
-  shows) and echoes `search` and `sort`. Browse opens the Library with `tag_mode=untagged`
-  (`GET /prompt_manager/library`, echoed as `tag_mode`; with a `tag` it is 400): "Filters ·
-  1", and Refine this view adds **Tag match** after Tags ("All of these tags" / "Prompts
-  without tags", the latter disables Tags and drops them on Apply). A client whose request
-  the server did not echo (an un-restarted older server) shows the read error with Retry,
-  never an unfiltered list. Saved Library views store `tag_mode` (`all|untagged`, default
-  `all`); untagged with tags is refused on write and reads back as `all`; an older build
-  opens an untagged view as the whole Library. The concept comparison holds the row to the
-  concept's first category row, its top to the concept table's offset, the table to that
-  offset plus the additions' height (`d149`) and the toolbar to the concept Library
-  toolbar (`toolbarInventoryOf`), with a mutation check. Tests:
-  `tests/test_vocabulary.py` (`TestVocabularyTagSearchAndSort`, `TestLibraryTagMode`),
-  `test_api_vocabulary.py`, `test_api_library.py`, `test_saved_views.py`, the
-  vocabulary/library/saved-views JS units and `tests/browser/workspace-vocabulary-search.spec.mjs`
-  (behavior plus artifact captures).
 - **D143** (#332): category rows count the images whose own category is the value
   (`image_count`, the stored rows, missing files included): "N positive prompts · M
   images" beside prompts, "M images" for an image-only value, which follows every

database/execution_contexts.py

@@ -7,11 +7,6 @@ from typing import Callable, ContextManager, Iterator
 
 try:
     from ..utils.execution_history_events import RunFinish, encode_command
-    from ..utils.hashing import (
-        generate_prompt_hash,
-        stored_prompt_text,
-        stored_prompt_text_sql,
-    )
     from ..utils.execution_contexts import (
         CAPTURE_REASONS,
         ContextBundle,
@@ -20,11 +15,6 @@ try:
     )
 except ImportError:
     from utils.execution_history_events import RunFinish, encode_command
-    from utils.hashing import (
-        generate_prompt_hash,
-        stored_prompt_text,
-        stored_prompt_text_sql,
-    )
     from utils.execution_contexts import (
         CAPTURE_REASONS,
         ContextBundle,
@@ -144,8 +134,7 @@ def _insert_exact(
 
 def _role_hints(role: str) -> str:
     return (
-        f"SELECT r.{role}_prompt_id, tx.text_value, "
-        f"{stored_prompt_text_sql('tx.text_value')} "
+        f"SELECT r.{role}_prompt_id, tx.text_value "
         "FROM execution_run_contexts r "
         "JOIN execution_contexts c ON c.context_id = r.context_id "
         f"JOIN execution_prompt_snapshots s ON s.snapshot_id = c.{role}_snapshot_id "
@@ -157,78 +146,57 @@ def _role_hints(role: str) -> str:
 
 # Set form of the read-time prompt-hint rule in get_execution_contexts():
 # a stored role hint is live only in the current storage epoch, and only when
-# the hinted prompt is the one match of _prompt_hint: by text (the raw
-# snapshot text or its stored form, outer whitespace stripped, #438), or, only
-# when no prompt has either text, by dedup hash (case folded too, #460).
-# The hash is a fallback, so a hint #438 kept is never made ambiguous.
-# Needs register_prompt_functions (pm_prompt_hash). The hint rows are the
-# outer loop (CROSS JOIN), so each prompts lookup is by index.
+# its exact raw snapshot text matches exactly one prompt, which is the hinted
+# one (_prompt_hint). Evaluated once per statement, never per prompt row.
 # Defines the CTE ``live_hint_prompts(prompt_id)``; prefix it with WITH.
 LIVE_HINT_CTES = (
-    "stored_hints(prompt_id, raw, stored) AS ("
+    "stored_hints(prompt_id, raw) AS ("
     + _role_hints("positive")
     + " UNION "
     + _role_hints("negative")
-    + "), hint_matches(prompt_id, raw, stored, match_id) AS ("
-    "SELECT h.prompt_id, h.raw, h.stored, p.id FROM stored_hints h "
-    "CROSS JOIN prompts p ON p.text COLLATE BINARY IN (h.raw, h.stored) "
-    "UNION ALL "
-    "SELECT h.prompt_id, h.raw, h.stored, p.id FROM stored_hints h "
-    "CROSS JOIN prompts p ON p.hash = pm_prompt_hash(h.raw) "
-    "WHERE NOT EXISTS (SELECT 1 FROM prompts q "
-    "WHERE q.text COLLATE BINARY IN (h.raw, h.stored))"
+    + "), unique_hint_texts(prompt_id, raw) AS ("
+    "SELECT MIN(id), text COLLATE BINARY FROM prompts "
+    "WHERE text COLLATE BINARY IN (SELECT raw FROM stored_hints) "
+    "GROUP BY text COLLATE BINARY HAVING COUNT(*) = 1"
     "), live_hint_prompts(prompt_id) AS ("
-    "SELECT prompt_id FROM hint_matches GROUP BY prompt_id, raw, stored "
-    "HAVING COUNT(*) = 1 AND MIN(match_id) = prompt_id)"
+    "SELECT h.prompt_id FROM stored_hints h JOIN unique_hint_texts u "
+    "ON u.prompt_id = h.prompt_id AND u.raw = h.raw COLLATE BINARY)"
 )
 LIVE_HINT_PROMPT_IDS_SQL = (
     "WITH " + LIVE_HINT_CTES + " SELECT DISTINCT prompt_id FROM live_hint_prompts"
 )
 
-_BY_TEXT = "SELECT id FROM prompts WHERE text COLLATE BINARY IN (?,?) LIMIT 2"
-
-
-def _text_matches(conn: sqlite3.Connection, raw: str) -> list:
-    return [row[0] for row in conn.execute(_BY_TEXT, (raw, stored_prompt_text(raw)))]
-
 
 def _prompt_hint(conn: sqlite3.Connection, raw: str | None) -> int | None:
-    """The one prompt that stores ``raw`` (#438), else the one it counts toward.
-
-    By text first: ``raw`` or ``raw.strip()`` (the exact form keeps hints of
-    older rows that kept outer whitespace). Only when no prompt has either
-    text, by the dedup hash, which also folds case (#460).
-    """
     if raw is None:
         return None
-    matches = _text_matches(conn, raw)
-    if not matches:
-        matches = [
-            row[0]
-            for row in conn.execute(
-                "SELECT id FROM prompts WHERE hash=? LIMIT 2",
-                (generate_prompt_hash(raw),),
-            )
-        ]
-    return matches[0] if len(matches) == 1 else None
+    rows = conn.execute(
+        "SELECT id FROM prompts WHERE text=? COLLATE BINARY LIMIT 2", (raw,)
+    ).fetchall()
+    return rows[0][0] if len(rows) == 1 else None
 
 
 def _hints(
     conn: sqlite3.Connection, positive: str | None, negative: str | None
 ) -> tuple:
     pos_id, neg_id = _prompt_hint(conn, positive), _prompt_hint(conn, negative)
-    stored = None if negative is None else stored_prompt_text(negative)
     pair_id = None
-    # A known negative that names no prompt because several share its text
     negative_ambiguous = (
-        stored is not None and neg_id is None and bool(_text_matches(conn, negative))
+        negative is not None
+        and neg_id is None
+        and conn.execute(
+            "SELECT 1 FROM prompts WHERE text=? COLLATE BINARY LIMIT 1", (negative,)
+        ).fetchone()
+        is not None
     )
-    if pos_id is not None and stored is not None and not negative_ambiguous:
+    if pos_id is not None and negative is not None and not negative_ambiguous:
         rows = conn.execute(
-            "SELECT pp.id FROM prompt_pairs pp "
+            "SELECT pp.id FROM prompt_pairs pp LEFT JOIN prompts n ON "
+            "n.id=pp.negative_prompt_id "
             "WHERE pp.positive_prompt_id=? AND ((pp.negative_prompt_id IS NULL AND "
-            "?='') OR pp.negative_prompt_id=?) LIMIT 2",
-            (pos_id, stored, neg_id),
+            "?='') "
+            "OR (pp.negative_prompt_id=? AND n.text=? COLLATE BINARY)) LIMIT 2",
+            (pos_id, negative, neg_id, negative),
         ).fetchall()
         if len(rows) == 1:
             pair_id = rows[0][0]

database/health.py

@@ -23,10 +23,10 @@ from pathlib import PurePosixPath, PureWindowsPath
 from urllib.parse import quote
 
 try:
-    from ..utils.hashing import register_prompt_functions
+    from ..utils.hashing import generate_prompt_hash
     from .models import normalize_image_path
 except ImportError:
-    from utils.hashing import register_prompt_functions
+    from utils.hashing import generate_prompt_hash
     from database.models import normalize_image_path
 
 logger = logging.getLogger("prompt_manager.database.health")
@@ -125,8 +125,12 @@ def _foreign_keys(conn, _roots):
     )
 
 
+def _prompt_hash(text):
+    return generate_prompt_hash(text) if isinstance(text, str) else None
+
+
 def _canonical_hashes(conn, _roots):
-    register_prompt_functions(conn)  # pm_prompt_hash, shared with history (#460)
+    conn.create_function("pm_prompt_hash", 1, _prompt_hash, deterministic=True)
     return _counted(
         f"Prompt {row[0]}: the stored hash does not match its text"
         for row in conn.execute(

database/history_reads.py

@@ -15,11 +15,6 @@ from .execution_history import HistoryEpochChanged
 from .execution_outputs import _capture, _REFERENCE_COLUMNS
 from .library import _ELIGIBLE
 
-try:
-    from ..utils.hashing import prompt_key, stored_prompt_text
-except ImportError:
-    from utils.hashing import prompt_key, stored_prompt_text
-
 RunKey = tuple[int, str, int, str]
 
 
@@ -105,43 +100,14 @@ _ORDER = (
 )
 # Stale-hint rows a newest-pair lookup inspects before it reports none.
 _PAIR_RUN_CANDIDATES = 16
-# The recorded texts of one scope, as a JSON array parameter (_scope_text_ids).
-_IN_SCOPE = "IN (SELECT value FROM json_each(?))"
 _MATCHING = (
     "SELECT DISTINCT rc.run_id FROM execution_prompt_snapshots s "
     "JOIN execution_contexts c ON c.positive_snapshot_id=s.snapshot_id "
     "JOIN execution_run_contexts rc ON rc.context_id=c.context_id "
-    f"WHERE s.raw_text_id {_IN_SCOPE}"
+    "WHERE s.raw_text_id=?"
 )
 
 
-def _scope_text_ids(conn: sqlite3.Connection, key: str) -> str:
-    """Every recorded raw text whose prompt key is ``key``, as a JSON array.
-
-    A run keeps its exact raw text, while the Library saves and counts it as
-    the prompt with its key (outer whitespace #438, case #460). The values are
-    compared, never only their digests; ``pm_prompt_key`` is Python's key.
-    """
-    return json.dumps(
-        [
-            row[0]
-            for row in conn.execute(
-                # Only snapshot raw texts: effective and affix texts are skipped
-                "SELECT t.text_id FROM (SELECT DISTINCT raw_text_id AS text_id "
-                "FROM execution_prompt_snapshots) s CROSS JOIN "
-                "execution_context_texts t WHERE t.text_id=s.text_id AND "
-                "pm_prompt_key(t.text_value)=? COLLATE BINARY",
-                (key,),
-            )
-        ]
-    )
-
-
-def _scope_text_id(raw: str | None) -> str | None:
-    """The scope digest of a raw text: that of its prompt key."""
-    return None if raw is None else content_digest("text", (prompt_key(raw),))
-
-
 def _limit(limit: int) -> None:
     if type(limit) is not int or not 1 <= limit <= 100:
         raise ValueError("History limit must be an integer from 1 to 100")
@@ -289,15 +255,8 @@ class HistoryReadOperations:
         if saved is None:
             return None
         text = saved["text"]
-        raw_id = _scope_text_id(text)
-        # A position from before #460 names the scope by the stripped text
-        # alone; it is the same scope, so a page open across the upgrade resumes.
-        legacy_id = (
-            None
-            if text is None
-            else content_digest("text", (stored_prompt_text(text),))
-        )
-        if after is not None and after.raw_text_id not in (raw_id, legacy_id):
+        raw_id = None if text is None else content_digest("text", (text,))
+        if after is not None and after.raw_text_id != raw_id:
             raise ValueError("History position text scope changed")
         group = {
             "positive_id": positive_id,
@@ -314,11 +273,18 @@ class HistoryReadOperations:
             next_position=None,
             resume_position=None,
         )
-        if raw_id is None:
+        if (
+            raw_id is None
+            or conn.execute(
+                "SELECT 1 FROM execution_context_texts WHERE text_id=? "
+                "AND text_value=? COLLATE BINARY",
+                (raw_id, text),
+            ).fetchone()
+            is None
+        ):
             return result
-        scope = _scope_text_ids(conn, prompt_key(text))
         where = f"r.run_id IN ({_MATCHING})"
-        params = [scope]
+        params = [raw_id]
         if after is not None:
             where += f" AND {_KEY}<=(?,?,?,?)"
             params.extend(after.upper)
@@ -372,9 +338,9 @@ class HistoryReadOperations:
             "LEFT JOIN execution_prompt_snapshots n "
             "ON n.snapshot_id=c.negative_snapshot_id "
             "LEFT JOIN execution_context_texts t ON t.text_id=n.raw_text_id "
-            f"WHERE rc.run_id IN ({placeholders}) AND p.raw_text_id {_IN_SCOPE} "
+            f"WHERE rc.run_id IN ({placeholders}) AND p.raw_text_id=? "
             "ORDER BY rc.anchor_id COLLATE BINARY,rc.run_id COLLATE BINARY",
-            (*by_run, scope),
+            (*by_run, raw_id),
         )
         summaries = {}
         evidence_by_context = {}
@@ -472,7 +438,6 @@ class HistoryReadOperations:
         if saved["text"] is None:
             return {"run": None}
         epoch = self.get_execution_epoch()
-        key = prompt_key(saved["text"])
         candidates = conn.execute(
             "SELECT r.run_id,rc.anchor_id,rc.context_id,"
             "c.positive_snapshot_id,c.negative_snapshot_id "
@@ -480,11 +445,10 @@ class HistoryReadOperations:
             "ON rc.run_id=r.run_id JOIN execution_contexts c "
             "ON c.context_id=rc.context_id JOIN execution_prompt_snapshots s "
             "ON s.snapshot_id=c.positive_snapshot_id "
-            f"WHERE s.raw_text_id {_IN_SCOPE} AND rc.pair_id=? "
-            "AND rc.reference_epoch=? "
+            "WHERE s.raw_text_id=? AND rc.pair_id=? AND rc.reference_epoch=? "
             f"ORDER BY {_ORDER},rc.anchor_id COLLATE BINARY LIMIT ?",
             (
-                _scope_text_ids(conn, key),
+                content_digest("text", (saved["text"],)),
                 pair_id,
                 epoch,
                 _PAIR_RUN_CANDIDATES,
@@ -493,11 +457,7 @@ class HistoryReadOperations:
         for row in candidates:
             positive = _values(conn, row["positive_snapshot_id"])
             negative = _values(conn, row["negative_snapshot_id"])
-            if (
-                positive is None
-                or positive["raw"] is None
-                or prompt_key(positive["raw"]) != key
-            ):
+            if positive is None or positive["raw"] != saved["text"]:
                 continue
             hints = _hints(conn, positive["raw"], negative["raw"] if negative else None)
             if hints[2] == pair_id:
@@ -517,9 +477,11 @@ class HistoryReadOperations:
         snapshots = {
             row["anchor_id"]: row
             for row in conn.execute(
-                "SELECT rc.anchor_id,c.positive_snapshot_id,c.negative_snapshot_id "
+                "SELECT rc.anchor_id,c.positive_snapshot_id,c.negative_snapshot_id,"
+                "p.raw_text_id AS positive_raw_text_id "
                 "FROM execution_run_contexts rc JOIN execution_contexts c "
-                "ON c.context_id=rc.context_id WHERE rc.run_id=?",
+                "ON c.context_id=rc.context_id LEFT JOIN execution_prompt_snapshots p "
+                "ON p.snapshot_id=c.positive_snapshot_id WHERE rc.run_id=?",
                 (run_id,),
             )
         }
@@ -529,12 +491,12 @@ class HistoryReadOperations:
             context.update(
                 {
                     key: row[key]
-                    for key in ("positive_snapshot_id", "negative_snapshot_id")
-                },
-                # The history scope this context belongs to (#438)
-                positive_raw_text_id=_scope_text_id(
-                    (context["positive"] or {}).get("raw")
-                ),
+                    for key in (
+                        "positive_snapshot_id",
+                        "negative_snapshot_id",
+                        "positive_raw_text_id",
+                    )
+                }
             )
             pair = context["pair_id"]
             context["navigation"] = {

database/library.py

@@ -121,28 +121,7 @@ def _archive(value: str) -> str:
     return ARCHIVE_SCOPES[value]
 
 
-# A parent that no tag's Browse returns (#444 "Untagged prompts"): no tag of its
-# own and no active pair carrying one. The vocabulary's untagged count uses it too.
-UNTAGGED = (
-    "NOT EXISTS(SELECT 1 FROM prompt_tags ut WHERE ut.prompt_id=p.id) "
-    "AND NOT EXISTS(SELECT 1 FROM prompt_pairs up JOIN prompt_pair_tags upt "
-    "ON upt.pair_id=up.id WHERE up.positive_prompt_id=p.id AND up.archived=0)"
-)
-# How the Tags filter matches: every tag (AND), or parents without any tag.
-TAG_MODES = ("all", "untagged")
-
-
-def _tag_mode(tag_mode: object, tags: list[str]) -> str:
-    if not isinstance(tag_mode, str) or tag_mode not in TAG_MODES:
-        raise ValueError("tag_mode must be one of " + ", ".join(TAG_MODES))
-    if tag_mode == "untagged" and tags:
-        raise ValueError("Untagged prompts cannot also filter by tags")
-    return tag_mode
-
-
-def _filter(
-    text: str, category: str | None, tags: list[str], tag_mode: str = "all"
-) -> tuple[str, list]:
+def _filter(text: str, category: str | None, tags: list[str]) -> tuple[str, list]:
     if not isinstance(text, str) or len(text) > 500:
         raise ValueError("Search text must be a string of at most 500 characters")
     if category is not None and (not isinstance(category, str) or len(category) > 200):
@@ -153,7 +132,6 @@ def _filter(
         or any(not isinstance(tag, str) or not tag or len(tag) > 200 for tag in tags)
     ):
         raise ValueError("Invalid library tags")
-    untagged = _tag_mode(tag_mode, tags) == "untagged"
     parent, pair, parent_params, pair_params = [], ["pp.archived=0"], [], []
     if text:
         parent.append("(p.text LIKE ? ESCAPE '\\' OR ls.title LIKE ? ESCAPE '\\')")
@@ -190,10 +168,6 @@ def _filter(
         + " AND ".join(pair)
         + ")"
     )
-    if untagged:
-        # A whole-card condition: inside the parent-or-pair OR an untagged pair
-        # would let a tagged parent through.
-        condition = f"({condition}) AND {UNTAGGED}"
     return f"({_ELIGIBLE}) AND ({condition})", [*parent_params, *pair_params]
 
 
@@ -277,7 +251,6 @@ class LibraryOperations:
         text: str = "",
         category: str | None = None,
         tags: list[str] | None = None,
-        tag_mode: str = "all",
         sort: str = "newest",
         limit: int = 40,
         after: dict | None = None,
@@ -285,7 +258,7 @@ class LibraryOperations:
         _limit(limit)
         if sort not in _ORDERS:
             raise ValueError("Unknown library sort order")
-        where, params = _filter(text, category, [] if tags is None else tags, tag_mode)
+        where, params = _filter(text, category, [] if tags is None else tags)
         if after is not None:
             if (
                 not isinstance(after, dict)
@@ -338,8 +311,6 @@ class LibraryOperations:
             "items": rows,
             "total": total,
             "variant_total": variant_total,
-            # Echoed so a client can tell this read applied its tag match.
-            "tag_mode": tag_mode,
             "has_more": has_more,
             "next_key": next_key,
         }
@@ -350,7 +321,6 @@ class LibraryOperations:
         text: str = "",
         category: str | None = None,
         tags: list[str] | None = None,
-        tag_mode: str = "all",
         sort: str = "newest",
         limit: int = 40,
         after: dict | None = None,
@@ -363,7 +333,6 @@ class LibraryOperations:
                 text=text,
                 category=category,
                 tags=tags,
-                tag_mode=tag_mode,
                 sort=sort,
                 limit=limit,
                 after=after,

database/maintenance.py

@@ -44,11 +44,6 @@ from .health import BATCH_ROWS, link_states, readable_roots, readonly_uri
 from .pairs import PairDependencyError
 from .workflow_documents import documents_of_rows, release_documents
 
-try:
-    from ..utils.hashing import register_prompt_functions
-except ImportError:
-    from utils.hashing import register_prompt_functions
-
 MAINTENANCE_OPERATIONS = (
     "duplicate_prompts",
     "optimize",
@@ -294,7 +289,6 @@ def _read_snapshot(db_path, read):
     conn = sqlite3.connect(readonly_uri(db_path), uri=True)
     try:
         conn.row_factory = sqlite3.Row
-        register_prompt_functions(conn)  # LIVE_HINT_CTES calls them (#460)
         conn.execute("BEGIN")  # one read snapshot for the whole plan
         return read(conn)
     finally:

database/models.py

@@ -38,11 +38,6 @@ from .review_schema import (
     review_without_annotations_error,
 )
 from .saved_views import migrate_saved_views, saved_views_schema_error
-
-try:
-    from ..utils.hashing import register_prompt_functions
-except ImportError:
-    from utils.hashing import register_prompt_functions
 from .image_categories import image_categories_schema_error, migrate_image_categories
 from .workflow_documents import (
     DOCUMENT_ID_COLUMNS,
@@ -158,15 +153,12 @@ def configure_connection(conn: sqlite3.Connection) -> None:
     (common on Windows) let other writers' polling busy handlers starve past
     BUSY_TIMEOUT_SECONDS and fail with "database is locked" (#242). Without
     WAL (for example an in-memory database) SQLite's FULL default is kept.
-    It also registers the prompt-key SQL functions (register_prompt_functions).
     """
     journal_mode = conn.execute("PRAGMA journal_mode = WAL").fetchone()[0]
     conn.execute("PRAGMA foreign_keys = ON")
     conn.execute(f"PRAGMA busy_timeout = {BUSY_TIMEOUT_SECONDS * 1000}")
     if str(journal_mode).lower() == "wal":
         conn.execute("PRAGMA synchronous = NORMAL")
-    # History reads and the live-hint rule call Python's prompt key (#460)
-    register_prompt_functions(conn)
 
 
 class PromptModel:

database/saved_views.py

@@ -33,8 +33,6 @@ MAX_TAG_LENGTH = 50
 _IMAGE_SORTS = ("newest", "oldest", "name", "name-desc", "rating")
 _LIBRARY_SORTS = ("newest", "oldest", "name", "rating")
 _MEDIA = ("all", "image", "video")
-# How a Library view's Tags match (#444): every tag, or parents without tags.
-_TAG_MODES = ("all", "untagged")
 _CONTROL = re.compile(r"[\x00-\x1f\x7f]")
 _SOURCE = re.compile(r"all|0|[1-9][0-9]{0,8}")
 # A collection id as the listing's ``collection`` query takes it (#331): none
@@ -69,8 +67,6 @@ _STATE_FIELDS = {
         "category": ("text", 100, ""),
         "sort": ("choice", _LIBRARY_SORTS, "newest"),
         "tags": ("tags", None, ()),
-        # #444: "untagged" never goes with tags (the listing refuses both).
-        "tag_mode": ("choice", _TAG_MODES, "all"),
     },
 }
 
@@ -156,8 +152,6 @@ def encode_state(page: object, state: object) -> str:
         _validate_value(key, kind, limit, state[key])
     if state.get("favorites") is True and state.get("collection"):
         raise SavedViewInvalid("A view cannot filter by favorites and a collection")
-    if state.get("tag_mode") == "untagged" and state.get("tags"):
-        raise SavedViewInvalid("A view cannot list untagged prompts and filter tags")
     encoded = json.dumps(
         {key: state[key] for key in fields}, ensure_ascii=False, separators=(",", ":")
     )
@@ -201,9 +195,6 @@ def normalize_state(page: str, raw: object) -> dict:
     # as the listing does for a URL with both (#331 D140).
     if state.get("favorites") is True and state.get("collection"):
         state["favorites"] = False
-    # Never written by this build either: the tags win.
-    if state.get("tag_mode") == "untagged" and state.get("tags"):
-        state["tag_mode"] = "all"
     return state
 
 

database/vocabulary.py

@@ -20,7 +20,7 @@ counted, hashed into the token and renamed with the prompts and pairs.
 
 import sqlite3
 
-from .library import _ELIGIBLE, UNTAGGED, _escape, _limit
+from .library import _ELIGIBLE, _limit
 from .library_commands import _TOKEN, LibraryCommandError, _validate_epoch
 from .library_tokens import canonical_token
 from .models import utc_now_iso
@@ -38,7 +38,7 @@ _IMAGE_FILES = (
 )
 
 
-def _tag_rows(page: str, order: str = "page.id") -> str:
+def _tag_rows(page: str) -> str:
     """Count rows for the registry rows selected by ``page`` (id, name)."""
     # Eligible parent components carrying a tag in the page, plus the
     # positive parent of every active pair carrying it (always eligible).
@@ -57,45 +57,11 @@ def _tag_rows(page: str, order: str = "page.id") -> str:
         "COALESCE(MAX(images.n),0) AS image_count "
         "FROM page LEFT JOIN owners ON owners.tag_id=page.id "
         "LEFT JOIN images ON images.tag_id=page.id "
-        "GROUP BY page.id ORDER BY " + order
+        "GROUP BY page.id ORDER BY page.id"
     )
 
 
 _TAG_PAGE = _tag_rows("SELECT id,name FROM tags WHERE id>? ORDER BY id LIMIT ?")
-# #444 tag sorts: sort -> (key expression on tags/counted, direction). Ties and
-# "created" follow the id, so every order is total and keyset pages are exact.
-TAG_SORTS = {
-    "created": (None, "ASC"),
-    "name": ("name COLLATE NOCASE", "ASC"),
-    "name-desc": ("name COLLATE NOCASE", "DESC"),
-    "prompts": ("prompt_count", "DESC"),
-    "prompts-asc": ("prompt_count", "ASC"),
-}
-_MAX_SEARCH = 200
-_TAG_SEARCH = "name LIKE ? ESCAPE '\\'"
-# Every matching tag ranked by the prompt count its row shows (the owners rule
-# of ``_tag_rows``), then one keyset page of it with its image counts.
-_RANKED_TAG_PAGE = (
-    "WITH owners(tag_id,pid) AS ("
-    "SELECT pt.tag_id,p.id FROM prompts p "
-    "JOIN prompt_tags pt ON pt.prompt_id=p.id WHERE " + _ELIGIBLE + " "
-    "UNION SELECT ppt.tag_id,pp.positive_prompt_id FROM prompt_pairs pp "
-    "JOIN prompt_pair_tags ppt ON ppt.pair_id=pp.id WHERE pp.archived=0),"
-    "counted AS (SELECT t.id,t.name,COUNT(DISTINCT o.pid) AS prompt_count "
-    "FROM tags t LEFT JOIN owners o ON o.tag_id=t.id WHERE {search} "
-    "GROUP BY t.id),"
-    "page AS (SELECT id,name,prompt_count FROM counted WHERE {after} "
-    "ORDER BY prompt_count {direction},id LIMIT ?),"
-    "images(tag_id,n) AS (" + _IMAGE_FILES + " "
-    "WHERE mit.tag_id IN (SELECT id FROM page) GROUP BY mit.tag_id) "
-    "SELECT page.id,page.name,page.prompt_count,"
-    "COALESCE(images.n,0) AS image_count FROM page "
-    "LEFT JOIN images ON images.tag_id=page.id "
-    "ORDER BY page.prompt_count {direction},page.id"
-)
-_UNTAGGED_COUNT = (
-    "SELECT COUNT(*) FROM prompts p WHERE (" + _ELIGIBLE + ") AND " + UNTAGGED
-)
 _TAG_ONE = _tag_rows("SELECT id,name FROM tags WHERE id=?")
 # Every owner kind a tag can sit on, for the delete confirmation.
 _TAG_IMPACT = (
@@ -244,28 +210,6 @@ def _tag_after(after: object) -> int:
     return after
 
 
-def _tag_search(search: object) -> str:
-    if not isinstance(search, str) or len(search) > _MAX_SEARCH:
-        raise ValueError(f"Tag search must be text of at most {_MAX_SEARCH} characters")
-    return search.strip()
-
-
-def _sorted_tag_after(after: object, sort: str) -> tuple | None:
-    """The ``[key, id]`` cursor of a name or prompt-count sort."""
-    if after is None:
-        return None
-    key_type = str if sort.startswith("name") else int
-    if (
-        not isinstance(after, list)
-        or len(after) != 2
-        or type(after[0]) is not key_type
-        or type(after[1]) is not int
-        or after[1] <= 0
-    ):
-        raise ValueError("Invalid vocabulary cursor")
-    return after[0], after[1]
-
-
 def _category_after(after: object) -> tuple[int, str] | None:
     if after is None:
         return None
@@ -487,80 +431,22 @@ class VocabularyOperations:
         epoch: str,
         *,
         limit: int = 100,
-        after: object = None,
-        search: str = "",
-        sort: str = "created",
+        after: int | None = None,
     ) -> dict:
-        """One page of tags matching ``search`` (a literal, case-insensitive
-        substring) in ``sort`` order, with the untagged parents' count."""
         _limit(limit)
-        search = _tag_search(search)
-        if not isinstance(sort, str) or sort not in TAG_SORTS:
-            raise ValueError("sort must be one of " + ", ".join(TAG_SORTS))
-        where, params = "1=1", []
-        if search:
-            where, params = _TAG_SEARCH, [f"%{_escape(search)}%"]
-        total, untagged = conn.execute(
-            f"SELECT (SELECT COUNT(*) FROM tags WHERE {where}),({_UNTAGGED_COUNT})",
-            params,
-        ).fetchone()
-        rows = [
-            dict(row) for row in self._tag_page(conn, where, params, sort, after, limit)
-        ]
+        start = _tag_after(after)
+        total = conn.execute("SELECT COUNT(*) FROM tags").fetchone()[0]
+        rows = [dict(row) for row in conn.execute(_TAG_PAGE, (start, limit + 1))]
         has_more = len(rows) > limit
         rows = rows[:limit]
-        key, _direction = TAG_SORTS[sort]
-        next_key = None
-        if has_more:
-            last = rows[-1]
-            next_key = (
-                last["id"]
-                if key is None
-                else [
-                    last["prompt_count" if key == "prompt_count" else "name"],
-                    last["id"],
-                ]
-            )
         return {
             "library_epoch": epoch,
             "tags": rows,
             "total": total,
-            "untagged_count": untagged,
-            # Echoed so a client can tell this read applied its search and sort.
-            "search": search,
-            "sort": sort,
             "has_more": has_more,
-            "next_key": next_key,
+            "next_key": rows[-1]["id"] if has_more else None,
         }
 
-    @staticmethod
-    def _tag_page(conn, where, params, sort, after, limit):
-        key, direction = TAG_SORTS[sort]
-        if key is None:
-            page = (
-                f"SELECT id,name FROM tags WHERE {where} AND id>? ORDER BY id LIMIT ?"
-            )
-            return conn.execute(
-                _tag_rows(page), [*params, _tag_after(after), limit + 1]
-            )
-        cursor = _sorted_tag_after(after, sort)
-        operator = ">" if direction == "ASC" else "<"
-        keyset, keys = "1=1", []
-        if cursor is not None:
-            keyset = f"({key}{operator}? OR ({key}=? AND id>?))"
-            keys = [cursor[0], cursor[0], cursor[1]]
-        if key == "prompt_count":
-            sql = _RANKED_TAG_PAGE.format(
-                search=where, after=keyset, direction=direction
-            )
-            return conn.execute(sql, [*params, *keys, limit + 1])
-        page = (
-            f"SELECT id,name FROM tags WHERE {where} AND {keyset} "
-            f"ORDER BY {key} {direction},id LIMIT ?"
-        )
-        order = f"page.{key} {direction},page.id"
-        return conn.execute(_tag_rows(page, order), [*params, *keys, limit + 1])
-
     def _vocabulary_categories(
         self,
         conn: sqlite3.Connection,
@@ -604,18 +490,9 @@ class VocabularyOperations:
             ),
         }
 
-    def list_vocabulary_tags(
-        self,
-        *,
-        limit: int = 100,
-        after: object = None,
-        search: str = "",
-        sort: str = "created",
-    ):
+    def list_vocabulary_tags(self, *, limit: int = 100, after: int | None = None):
         with self.library_snapshot() as (conn, epoch, _ceiling):
-            return self._vocabulary_tags(
-                conn, epoch, limit=limit, after=after, search=search, sort=sort
-            )
+            return self._vocabulary_tags(conn, epoch, limit=limit, after=after)
 
     def list_vocabulary_categories(
         self, *, limit: int = 100, after: list | None = None

py/api/diagnostics_report.py

@@ -213,8 +213,6 @@ def public_config():
             "max_image_age_days": GalleryConfig.MAX_IMAGE_AGE_DAYS,
             "max_concurrent_processing": GalleryConfig.MAX_CONCURRENT_PROCESSING,
             "metadata_extraction_timeout": GalleryConfig.METADATA_EXTRACTION_TIMEOUT,
-            # config.json gallery.monitoring.save_foreign_runs (#247)
-            "save_foreign_runs": GalleryConfig.SAVE_FOREIGN_RUNS,
         },
         "integrations": {
             "lora_manager_enabled": bool(IntegrationConfig.LORA_MANAGER_ENABLED),

py/api/library.py

@@ -294,7 +294,6 @@ class LibraryRoutesMixin:
             "text": request.query.get("text", ""),
             "category": request.query.get("category"),
             "tags": sorted(set(request.query.getall("tag", []))),
-            "tag_mode": request.query.get("tag_mode", "all"),
             "sort": request.query.get("sort", "newest"),
         }
         limit = _page_limit(request)

py/api/settings_routes.py

@@ -8,8 +8,7 @@ is shared with the LoRA integration's save.
 GET also reports the image sources and the monitor (``sources.py``). A save
 that changes the sources runs as a ``source_change`` registry hold, so it is
 refused while a record-changing job (a scan) runs. ``monitoring_enabled``
-takes effect at the next restart; ``save_foreign_runs`` (#247) at once, since
-the monitor reads it for every file. ``POST /prompt_manager/settings/validate-source``
+takes effect at the next restart. ``POST /prompt_manager/settings/validate-source``
 checks one path and writes nothing.
 """
 
@@ -44,7 +43,6 @@ _SETTINGS_FILE_KEYS = {
     "INFINITE_SCROLL": ("web_ui", "infinite_scroll"),
     "WORKER_THREADS": ("performance", "worker_threads"),
     "MONITORING_ENABLED": ("gallery", "monitoring", "enabled"),
-    "SAVE_FOREIGN_RUNS": ("gallery", "monitoring", "save_foreign_runs"),
     "SAFETY_BACKUP": ("maintenance", "safety_backup"),
     "THUMBNAIL_FORMAT": ("thumbnails", "format"),
     "THUMBNAIL_QUALITY": ("thumbnails", "quality"),
@@ -60,7 +58,7 @@ _SETTINGS_FILE_KEYS = {
 # The thumbnail settings a running Convert outdated job fixes (#317).
 _THUMBNAIL_SETTINGS = ("THUMBNAIL_FORMAT", "THUMBNAIL_QUALITY", "THUMBNAIL_EDGE")
 # Attributes that live on GalleryConfig; the others on PromptManagerConfig.
-_GALLERY_SETTINGS = frozenset({"MONITORING_ENABLED", "SAVE_FOREIGN_RUNS"})
+_GALLERY_SETTINGS = frozenset({"MONITORING_ENABLED"})
 # Attributes that live on AutotagConfig, named without the AUTOTAG_ prefix.
 _AUTOTAG_SETTINGS = frozenset(
     name for name in _SETTINGS_FILE_KEYS if name.startswith("AUTOTAG_")
@@ -266,7 +264,6 @@ class SettingsRoutesMixin:
                     "thumbnail_encoders": encoders,
                     "settings": {
                         "monitoring_enabled": GalleryConfig.MONITORING_ENABLED,
-                        "save_foreign_runs": GalleryConfig.SAVE_FOREIGN_RUNS,
                         "result_timeout": PromptManagerConfig.RESULT_TIMEOUT,
                         "webui_display_mode": PromptManagerConfig.WEBUI_DISPLAY_MODE,
                         "infinite_scroll": PromptManagerConfig.INFINITE_SCROLL,
@@ -629,10 +626,6 @@ class SettingsRoutesMixin:
             if not isinstance(data["monitoring_enabled"], bool):
                 raise ValueError("monitoring_enabled must be true or false")
             updates["MONITORING_ENABLED"] = data["monitoring_enabled"]
-        if "save_foreign_runs" in data:
-            if not isinstance(data["save_foreign_runs"], bool):
-                raise ValueError("save_foreign_runs must be true or false")
-            updates["SAVE_FOREIGN_RUNS"] = data["save_foreign_runs"]
         if "safety_backup" in data:
             if not isinstance(data["safety_backup"], bool):
                 raise ValueError("safety_backup must be true or false")

py/api/vocabulary.py

@@ -61,25 +61,18 @@ class VocabularyRoutesMixin:
         )
 
     async def _vocabulary_page(
-        self,
-        request: web.Request,
-        kind: str,
-        reader_name: str,
-        name: bool,
-        options: dict | None = None,
+        self, request: web.Request, kind: str, reader_name: str, name: bool
     ) -> web.Response:
         limit = _vocabulary_limit(request)
         cursor = request.query.get("cursor")
-        options = options or {}
 
         def read() -> dict:
             # The snapshot stays open while the cursor is decoded and encoded,
-            # so its epoch scope is the epoch the page was read from. A tag
-            # search or sort joins the scope: its cursor fits no other order.
+            # so its epoch scope is the epoch the page was read from.
             with self.db.library_snapshot() as (conn, epoch, _ceiling):
-                scope = _scope({"kind": kind, "epoch": epoch, **options})
+                scope = _scope({"kind": kind, "epoch": epoch})
                 result = getattr(self.db, reader_name)(
-                    conn, epoch, limit=limit, after=_decode(cursor, scope), **options
+                    conn, epoch, limit=limit, after=_decode(cursor, scope)
                 )
                 result["next_cursor"] = _encode(
                     result.pop("next_key"), scope, name=name
@@ -91,14 +84,8 @@ class VocabularyRoutesMixin:
 
     @pair_response
     async def list_vocabulary_tags(self, request: web.Request) -> web.Response:
-        options = {
-            "search": request.query.get("search", "").strip(),
-            "sort": request.query.get("sort", "created"),
-        }
-        # Name keys are text: kept server side so the cursor stays small.
-        name = options["sort"].startswith("name")
         return await self._vocabulary_page(
-            request, "vocabulary-tags", "_vocabulary_tags", name, options
+            request, "vocabulary-tags", "_vocabulary_tags", False
         )
 
     @pair_response

py/config.py

@@ -194,8 +194,6 @@ class GalleryConfig:
 
     Attributes:
         MONITORING_ENABLED (bool): Enable/disable automatic image monitoring
-        SAVE_FOREIGN_RUNS (bool): The monitor stores the certain prompt of an
-            output whose workflow has no PromptManager node (#247)
         MONITORING_DIRECTORIES (List[str]): Directories to monitor for new images
         SUPPORTED_EXTENSIONS (List[str]): Image file extensions to process
         PROCESSING_DELAY (float): Delay in seconds before processing new files
@@ -212,8 +210,6 @@ class GalleryConfig:
 
     # Image monitoring settings
     MONITORING_ENABLED = True
-    # Read by the monitor for every file, so a save applies without a restart
-    SAVE_FOREIGN_RUNS = True
     MONITORING_DIRECTORIES = []  # Auto-detect if empty
     SUPPORTED_EXTENSIONS = [".png", ".jpg", ".jpeg", ".webp", ".gif"]
     PROCESSING_DELAY = 2.0  # Seconds to wait before processing new files
@@ -255,7 +251,6 @@ class GalleryConfig:
         return {
             "monitoring": {
                 "enabled": cls.MONITORING_ENABLED,
-                "save_foreign_runs": cls.SAVE_FOREIGN_RUNS,
                 "directories": cls.MONITORING_DIRECTORIES,
                 "extensions": cls.SUPPORTED_EXTENSIONS,
                 "processing_delay": cls.PROCESSING_DELAY,
@@ -308,14 +303,6 @@ class GalleryConfig:
                 config_logger.warning(
                     "Ignoring gallery monitoring enabled: expected true or false"
                 )
-        if "save_foreign_runs" in monitoring:
-            if isinstance(monitoring["save_foreign_runs"], bool):
-                cls.SAVE_FOREIGN_RUNS = monitoring["save_foreign_runs"]
-            else:
-                config_logger.warning(
-                    "Ignoring gallery monitoring save_foreign_runs: expected true "
-                    "or false"
-                )
         if "directories" in monitoring:
             directories = cls._validated_directories(monitoring["directories"])
             if directories is not None:

tests/browser/system-concept.spec.mjs

@@ -618,21 +618,10 @@ const WATCHED = new Set(['watching', 'stopping']);
 const REFRESH_FILES = { title: 'Refresh files', description: 'Read every source again to find files added or removed outside ComfyUI.',
     label: 'Refresh' };
 
-// D158 (#247): the row production adds directly below "Watch for new outputs", in that row's markup.
-const FOREIGN_RUNS = { id: 'foreign-runs', label: 'Save prompts from other workflows',
-    description: 'New outputs of workflows without a PromptManager node add their prompt to the library when it is certain.' };
-
-/** D158: the concept's "Watch for new outputs" row as the inserted "Save prompts from other workflows" row. */
-function foreignRunsRow(monitoringRow, settings) {
-    return { ...monitoringRow, text: [['label', FOREIGN_RUNS.label, FOREIGN_RUNS.id], ['p', FOREIGN_RUNS.description, null]],
-        control: { ...monitoringRow.control, id: FOREIGN_RUNS.id, checked: settings.save_foreign_runs } };
-}
-
 /** The concept's Sources with the recorded deviations applied, given the server's real settings and sources. */
 function mapSourcesConcept(reference, { settings, sources }) {
     const [sample] = reference.sources;
     const scan = sample.actions[0];
-    const rowAt = reference.surface.tree.indexOf('div.setting-row');
     return {
         ...reference,
         // The real sources replace the two samples (without the "sample path" note). D98: each configured one has Remove,
@@ -640,15 +629,13 @@ function mapSourcesConcept(reference, { settings, sources }) {
         sources: sources.effective.map(source => ({ ...sample, title: source.label,
             description: `${source.path} · ${WATCH_TEXT[source.watch]}`,
             actions: [{ ...scan, text: WATCHED.has(source.watch) ? 'Scan changes' : 'Scan folder' }, { ...scan, text: 'Remove' }] })),
-        rows: reference.rows.flatMap(row => {
-            if (row.control.id === 'monitoring') return [{ ...row, control: { ...row.control, checked: settings.monitoring_enabled } },
-                foreignRunsRow(row, settings)];
+        rows: reference.rows.map(row => {
+            if (row.control.id === 'monitoring') return { ...row, control: { ...row.control, checked: settings.monitoring_enabled } };
             // D113: the range ends at the server's core count (the concept's fixed 16) and shows the real worker count.
-            return [{ ...row, control: { ...row.control, max: String(settings.cpu_count), value: String(settings.worker_threads) } }];
+            return { ...row, control: { ...row.control, max: String(settings.cpu_count), value: String(settings.worker_threads) } };
         }),
-        // D158: the inserted row after the first setting row; D98: "Refresh files" closes the surface.
-        surface: { ...reference.surface, tree: [...reference.surface.tree.slice(0, rowAt + 1), 'div.setting-row',
-            ...reference.surface.tree.slice(rowAt + 1), 'div.operation'] },
+        // D98: "Refresh files" closes the surface.
+        surface: { ...reference.surface, tree: [...reference.surface.tree, 'div.operation'] },
         operations: [...reference.operations, { ...reference.operations[0], title: REFRESH_FILES.title,
             description: REFRESH_FILES.description, actions: [{ ...reference.operations[0].actions[0], text: REFRESH_FILES.label }] }],
     };
@@ -702,12 +689,10 @@ test('sources comparison detects mutations', async ({ page, request }) => {
     const expected = mapSourcesConcept(concept, server);
     const production = await productionSources(page, 'dark', { notice: true });
     expect(diffInventory(expected, production)).toEqual([]);
-    // Unmapped, the concept differs only in the real sources, the D98 operation, the D158 row (which moves the D113
-    // range to the third row) and the D113 range.
+    // Unmapped, the concept differs only in the real sources, the D98 operation and the D113 range.
     expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 2).join('.'))
         .filter((path, index, all) => all.indexOf(path) === index).sort())
-        .toEqual(['operations.2', 'operations.length', 'rows.1', 'rows.2', 'rows.length', 'sources.0', 'sources.1',
-            'surface.tree'].sort());
+        .toEqual(['operations.2', 'operations.length', 'rows.1', 'sources.0', 'sources.1', 'surface.tree'].sort());
     const measure = () => page.evaluate(measureSources, '#workspace-main');
     const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
     // A removed notice and a removed source row.
@@ -721,13 +706,6 @@ test('sources comparison detects mutations', async ({ page, request }) => {
     await page.evaluate(() => { document.querySelector('#workspace-main label[for="monitoring"]').textContent = 'Watch for outputs'; });
     expect(await paths()).toEqual(['rows.0.text.0.1']);
     await page.evaluate(() => { document.querySelector('#workspace-main label[for="monitoring"]').textContent = 'Watch for new outputs'; });
-    // D158: the inserted row is compared too: a missing one and a changed label are caught.
-    const undoForeign = await mutate(page, { remove: ['#workspace-main .setting-row:has(#foreign-runs)'] });
-    expect(await paths()).toEqual(expect.arrayContaining(['rows.length', 'surface.tree.length']));
-    await undoForeign();
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="foreign-runs"]').textContent = 'Save other prompts'; });
-    expect(await paths()).toEqual(['rows.1.text.0.1']);
-    await page.evaluate(() => { document.querySelector('#workspace-main label[for="foreign-runs"]').textContent = 'Save prompts from other workflows'; });
     await page.evaluate(() => { document.querySelector('#workspace-main .panel-heading button').textContent = 'Add source'; });
     expect(await paths()).toEqual(['heading.action.text']);
     await page.evaluate(() => { document.querySelector('#workspace-main .panel-heading button').textContent = '+ Add source'; });

tests/browser/vocabulary-canonical-comparison.mjs

@@ -29,19 +29,6 @@ export function pageInventoryOf(main) {
     const rows=[...table.querySelectorAll('tbody tr')];
     const firstCell=rows[0]?.querySelector('td');
     const operations=[...categorySurface.querySelectorAll('.operation')].filter(visible);
-    const operationOf=row=>{const h3=row.querySelector('h3'),p=row.querySelector('p'),rowActions=row.querySelector('.row-actions');return {
-            ...css(row,'display','flexDirection','justifyContent','alignItems','columnGap','paddingTop','paddingBottom','borderTopWidth','borderTopStyle','borderTopColor'),
-            height:px(row.getBoundingClientRect().height),h3:{text:h3.textContent,...font(h3)},p:{text:p.textContent,...font(p)},
-            actions:{...css(rowActions,'flexShrink','flexWrap','columnGap'),buttons:[...rowActions.querySelectorAll('button')].map(buttonOf)}};};
-    // D149 (#444): production adds the Untagged prompts row and the tag search and sort above the table; the concept has
-    // neither. The toolbar is compared on its own (toolbarInventoryOf) with the concept's page toolbar as donor.
-    const untaggedRow=tagSurface.querySelector(':scope > .operation');
-    const d149=untaggedRow?{untagged:operationOf(untaggedRow),
-        // It starts where the concept's table starts: right after the paragraph.
-        offset:px(untaggedRow.getBoundingClientRect().top-tagSurface.getBoundingClientRect().top),
-        // The vertical space the two additions take: the table starts this much lower than after the paragraph alone.
-        // (Both offsets rounded first, so offset + shift is exactly the table's rounded offset.)
-        shift:px(wrap.getBoundingClientRect().top-tagSurface.getBoundingClientRect().top)-px(untaggedRow.getBoundingClientRect().top-tagSurface.getBoundingClientRect().top)}:null;
     return {
         heading:{...css(heading,'display','flexDirection','justifyContent','alignItems','columnGap','rowGap','marginBottom'),
             h1:{text:h1.textContent,tabIndex:h1.tabIndex,...font(h1)},
@@ -67,26 +54,14 @@ export function pageInventoryOf(main) {
             rows:rows.map(row=>{const cells=[...row.querySelectorAll('td')];return {cells:cells.length,height:px(row.getBoundingClientRect().height),tagLines:lines(cells[0]),tag:cells[0].textContent,prompts:cells[1].textContent,
                 images:shownText(cells[2]),imagesHidden:cells[2].querySelector('.ca-visually-hidden')?.textContent??null,
                 actions:[...cells[3].querySelectorAll('.row-actions button')].map(node=>node.textContent.trim())};})},
-        operations:operations.map(operationOf),
-        d149,
+        operations:operations.map(row=>{const h3=row.querySelector('h3'),p=row.querySelector('p'),rowActions=row.querySelector('.row-actions');return {
+            ...css(row,'display','flexDirection','justifyContent','alignItems','columnGap','paddingTop','paddingBottom','borderTopWidth','borderTopStyle','borderTopColor'),
+            height:px(row.getBoundingClientRect().height),h3:{text:h3.textContent,...font(h3)},p:{text:p.textContent,...font(p)},
+            actions:{...css(rowActions,'flexShrink','flexWrap','columnGap'),buttons:[...rowActions.querySelectorAll('button')].map(buttonOf)}};}),
         noPageScroll:document.documentElement.scrollWidth<=innerWidth+1,
     };
 }
 
-/** A `search.toolbar`'s tokens (D149): runs in the page on the concept's page toolbar and on the tag search and sort. */
-export function toolbarInventoryOf(root) {
-    const css=(node,...keys)=>{const style=getComputedStyle(node);return Object.fromEntries(keys.map(key=>[key,style[key]]));};
-    const px=value=>Math.round(value);
-    const field=root.querySelector('.search-field'),input=field.querySelector('input'),select=root.querySelector('select');
-    return {...css(root,'display','columnGap','rowGap','flexWrap','alignItems','marginBottom'),
-        field:{...css(field,'display','alignItems','columnGap','flexGrow','minWidth','paddingLeft','paddingRight','borderTopWidth','borderTopStyle',
-            'borderTopColor','borderTopLeftRadius','backgroundColor'),icon:Boolean(field.querySelector(':scope > svg')),height:px(field.getBoundingClientRect().height)},
-        input:{type:input.type,...css(input,'fontSize','minHeight','backgroundColor','borderTopWidth','color')},
-        select:{...css(select,'fontSize','minHeight','backgroundColor','color','borderTopColor','borderTopLeftRadius','paddingLeft'),
-            height:px(select.getBoundingClientRect().height)}};
-}
-
-
 const countOf=(count,noun)=>`${count} ${noun}${count===1?'':'s'}`;
 
 /**
@@ -106,17 +81,12 @@ export function withImageCounts(operations,{images={},only=[]}={}) {
 
 // Recorded deviations only (plan "Mock inventory" + decisions D1-D15 + ledger rulings). Everything else must be equal.
 // `imageCategories` (#332 D143) is the fixture's own image categories, none by default.
-export function mapVocabularyConcept(reference,imageCategories={},{untaggedText=null,shift=0}={}) {
+export function mapVocabularyConcept(reference,imageCategories={}) {
     const operations=reference.operations.map(row=>({...row,p:{...row.p,
         // Ledger ruling: "1 positive prompts" -> singular, consistent with the shared plural helper (#238/#243).
         text:row.p.text.replace(/^1 positive prompts$/,'1 positive prompt')}}));
-    // D149 (#444): the Untagged prompts row is drawn as the concept's first category row with its own text and a Browse
-    // action, and the table moves down by the space it and the tag search and sort take.
-    const first=reference.operations[0];
-    const d149=untaggedText===null?null:{untagged:{...first,h3:{...first.h3,text:'Untagged prompts'},p:{...first.p,text:untaggedText}},
-        offset:reference.table.wrap.offset,shift};
-    return {...reference,d149,
-        table:{...reference.table,wrap:{...reference.table.wrap,offset:reference.table.wrap.offset+shift},rows:reference.table.rows.map(row=>({...row,
+    return {...reference,
+        table:{...reference.table,rows:reference.table.rows.map(row=>({...row,
             // Data, not a deviation: the concept tags each sample image with its prompt's tags; the vocabulary fixture
             // tags no image, so every Images count is 0 (#249 C2 retired #245 D3).
             images:'0'}))},
@@ -124,14 +94,9 @@ export function mapVocabularyConcept(reference,imageCategories={},{untaggedText=
     };
 }
 
-/** The D149 mapping inputs: the fixture's Untagged prompts count text (none by default) and production's table shift. */
-export function d149Of(actual,untaggedText='0 positive prompts') {
-    return actual.d149?{untaggedText,shift:actual.d149.shift}:{};
-}
-
 /** The page comparison: concept rows are the concept's sample tags; production appends fixture-only tags (D4). */
 export function compareVocabularyPage(reference,actual,imageCategories={}) {
-    const expected=mapVocabularyConcept(reference,imageCategories,d149Of(actual));
+    const expected=mapVocabularyConcept(reference,imageCategories);
     const shared=expected.table.rows.length;
     return {diff:diffInventory(expected,{...actual,table:{...actual.table,rows:actual.table.rows.slice(0,shared)}}),
         extra:actual.table.rows.slice(shared).map(row=>row.tag)};

tests/browser/workspace-library.spec.mjs

@@ -57,26 +57,6 @@ test('library groups reusable negatives under one positive without exposing nega
     for(const item of rows.items) await expect(page.locator(`article[data-prompt-id="${item.id}"] .card-meta > span`).nth(1)).toHaveText(`${item.run_count} run${item.run_count===1?'':'s'}`);
 });
 
-// #464: a starved renderer (headless WebKit under CPU load, a background tab) can hold animation frames for seconds;
-// a loaded page of prompts is shown without waiting for one.
-test('a held animation frame does not hide a loaded page of prompts, the first or a later one',async({page,request})=>{
-    await expect(await request.post('/__test__/reset',{data:{native_library:true,extra_prompts:45}})).toBeOK();
-    const {total}=await(await request.get('/prompt_manager/library?limit=100')).json();
-    await page.addInitScript(()=>{
-        const request=window.requestAnimationFrame.bind(window),cancel=window.cancelAnimationFrame.bind(window);
-        const held=new Map(),real=new Map();let holding=true,next=0;
-        window.requestAnimationFrame=callback=>{const id=--next;if(holding)held.set(id,callback);else real.set(id,request(callback));return id;};
-        window.cancelAnimationFrame=id=>{held.delete(id);if(real.has(id))cancel(real.get(id));real.delete(id);};
-        window.__releaseAnimationFrames=()=>{holding=false;for(const [id,callback] of held)real.set(id,request(callback));held.clear();};
-    });
-    await page.goto(route);
-    const more=page.getByRole('button',{name:'Load more prompts',exact:true});
-    await expect(more).toHaveAttribute('aria-disabled','false');await expect(cards(page)).toHaveCount(40);
-    await more.evaluate(node=>node.click());await expect(page.locator('.library-status')).toHaveText('You’re all caught up.');
-    await expect(cards(page)).toHaveCount(total);
-    await page.evaluate(()=>window.__releaseAnimationFrames());await nextFrame(page);
-    await expect(cards(page)).toHaveCount(total);await expect(page.locator('.library-row-spacer')).toHaveCount(0);
-});
 test('history displays the selected full negative beneath its positive and filters one shared physical gallery',async({page,request})=>{
     const rows=await(await request.get('/prompt_manager/library')).json();const cat=rows.items.find(item=>item.text==='Cat portrait');
     const data=await(await request.get(`/prompt_manager/library/${cat.id}`)).json();
@@ -200,7 +180,7 @@ test('library toolbar matches the concept and tags live in Refine this view',asy
     // D44: the active Tags filter shows on the button; the category is the toolbar's own and is not counted.
     await expect(toolbar.getByRole('button')).toHaveText(['Save view','Filters · 1']);
     await toolbar.getByRole('button',{name:'Filters · 1',exact:true}).click();
-    await expect(refine(page).locator('.field label')).toHaveText(['Tags','Tag match']);await expect(refine(page).getByRole('textbox',{name:'Tags',exact:true})).toHaveValue('studio');
+    await expect(refine(page).locator('.field label')).toHaveText(['Tags']);await expect(refine(page).getByRole('textbox',{name:'Tags',exact:true})).toHaveValue('studio');
     await refine(page).getByRole('button',{name:'Clear filters',exact:true}).click();await expect(refine(page)).toHaveCount(0);
     await expect(toolbar.getByRole('button',{name:'Filters',exact:true})).toBeFocused();
     await expect(page.getByRole('combobox',{name:'Filter by category',exact:true})).toHaveValue('');await expect(cards(page)).toHaveCount(3);

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

@@ -208,7 +208,7 @@ test('a view stored under older rules still lists and opens with its usable valu
     await raw({ page: 'library', name: '', state: JSON.stringify({ q: 'dog', sort: 'name-desc' }) });
     expect(await listed(request)).toEqual([
         { id: imagesId, page: 'images', name: 'Old cats', state: { ...IMAGE_DEFAULTS, q: 'cat' } },
-        expect.objectContaining({ page: 'library', name: 'Saved view', state: { q: 'dog', category: '', sort: 'newest', tags: [], tag_mode: 'all' } }),
+        expect.objectContaining({ page: 'library', name: 'Saved view', state: { q: 'dog', category: '', sort: 'newest', tags: [] } }),
     ]);
     // A state that is no JSON object is never listed, and its link behaves like a missing view.
     const corruptId = await raw({ page: 'images', name: 'Corrupt', state: '{not json' });
@@ -233,7 +233,7 @@ test('a view stored under older rules still lists and opens with its usable valu
 // D153 (#447): the workspace no longer offers "Highest rated"; the API still stores such a view as it was saved.
 test('a view saved under Highest rated opens on Recently added on Images and the Library', async ({ page, request }) => {
     const images = await create(request, { page: 'images', name: 'Rated cats', state: { ...IMAGE_DEFAULTS, q: 'cat', sort: 'rating' } });
-    const library = await create(request, { page: 'library', name: 'Rated dogs', state: { q: 'dog', category: '', sort: 'rating', tags: [], tag_mode: 'all' } });
+    const library = await create(request, { page: 'library', name: 'Rated dogs', state: { q: 'dog', category: '', sort: 'rating', tags: [] } });
     expect((await listed(request)).map(view => view.state.sort)).toEqual(['rating', 'rating']);
     const listings = [];
     page.on('request', item => {
@@ -257,7 +257,7 @@ test('a view saved under Highest rated opens on Recently added on Images and the
 
 test('leaving a saved view returns Images and the Library to their own last state (#249 M2)', async ({ page, request }) => {
     const dogs = await create(request, { page: 'images', name: 'Dogs', state: { ...IMAGE_DEFAULTS, q: 'dogs' } });
-    const cats = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [], tag_mode: 'all' } });
+    const cats = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [] } });
     await page.goto(`${workspace}#/images`);
     await search(page).fill('cat');
     await expect(imageCards(page)).toHaveCount(1);
@@ -300,7 +300,7 @@ test('a toolbar change while sources load keeps the saved Source and Folder (#24
 });
 
 test('a saved view left while its list or rename is pending leaves the next page alone', async ({ page, request }) => {
-    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [], tag_mode: 'all' } });
+    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [] } });
     let releaseList = () => {};
     const holdList = async () => {
         const held = new Promise(resolve => { releaseList = resolve; });
@@ -348,7 +348,7 @@ test('an unknown saved view opens Images, and a failed listing offers Retry', as
     await expect(page).toHaveURL(/#\/images$/);
     await expect(main(page).getByRole('heading', { level: 1 })).toHaveText('Images');
 
-    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [], tag_mode: 'all' } });
+    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [] } });
     let failing = true;
     await page.route(`**${API}`, route => failing && route.request().method() === 'GET'
         ? route.fulfill({ status: 500, contentType: 'application/json', body: '{"success":false,"error":"down"}' })
@@ -539,7 +539,7 @@ test('Edit renames an open view, and deletes it only after confirming inside the
 });
 
 test('a deleted Library view returns to the Library, and failed edits say so', async ({ page, request }) => {
-    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [], tag_mode: 'all' } });
+    const view = await create(request, { page: 'library', name: 'Cats', state: { q: 'cat', category: '', sort: 'newest', tags: [] } });
     await page.goto(`${workspace}#/saved/${view.id}`);
     await expect(heading(page)).toHaveText('Cats');
     const edit = main(page).locator('.heading-actions > button').first();

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

@@ -268,71 +268,6 @@ test('Watch for new outputs saves monitoring_enabled; a restart applies it', asy
     await expect(sourceList(page).locator('.operation p')).toHaveText(['output · watching', 'input · watching']);
 });
 
-test('D158: Save prompts from other workflows saves save_foreign_runs live; off while monitoring is off (#247)', async ({ page, request }, testInfo) => {
-    try {
-        const layout = await openSources(page);
-        const rows = layout.locator('section.surface > .setting-row');
-        await expect(rows.locator(':scope > div > label')).toHaveText(['Watch for new outputs', 'Save prompts from other workflows', 'Worker threads']);
-        const foreign = layout.getByRole('switch', { name: 'Save prompts from other workflows', exact: true });
-        const foreignRow = rows.filter({ has: page.locator('#foreign-runs') });
-        await expect(foreignRow.locator(':scope > div > p')).toHaveText('New outputs of workflows without a PromptManager node add their prompt to the library when it is certain.');
-        await expect(foreign).toBeChecked();
-        await expect(foreign).toBeEnabled();
-        // Keyboard on desktop, a tap on the touch project.
-        if (testInfo.project.name === 'touch') await foreign.tap();
-        else {
-            await foreign.focus();
-            await page.keyboard.press('Space');
-        }
-        await expect(foreign).not.toBeChecked();
-        await expect(statusOf(page)).toHaveText('Unsaved changes.');
-        const saved = page.waitForResponse(response => response.request().method() === 'POST' && response.url().endsWith(SETTINGS_URL));
-        await saveButton(page).click();
-        const response = await saved;
-        expect(response.request().postDataJSON()).toEqual(expect.objectContaining({ save_foreign_runs: false }));
-        expect((await response.json()).restart_required_fields).toEqual([]);
-        // Applied live: the monitor reads it for every file, so no restart is named.
-        await expect(statusOf(page)).toHaveText('Saved to the server configuration.');
-        expect((await serverJson(request, SETTINGS_URL)).settings.save_foreign_runs).toBe(false);
-        // With Watch for new outputs drafted off nothing is watched: the row is disabled and its note says why.
-        const monitoring = layout.getByRole('switch', { name: 'Watch for new outputs', exact: true });
-        await monitoring.uncheck();
-        await expect(foreign).toBeDisabled();
-        const note = foreignRow.locator('p.small');
-        await expect(note).toHaveText('Applies while Watch for new outputs is on.');
-        await expect(foreign).toHaveAttribute('aria-describedby', await note.getAttribute('id'));
-        await monitoring.check();
-        await expect(foreign).toBeEnabled();
-        await expect(note).toHaveCount(0);
-        await expect(foreign).not.toHaveAttribute('aria-describedby', /./);
-        await expect(statusOf(page)).toHaveText('No unsaved changes.');
-    } finally {
-        // The server is shared by the spec's tests: put the default back whatever happened.
-        await request.post(SETTINGS_URL, { data: { save_foreign_runs: true } });
-    }
-});
-
-test('D158: saved off while the monitor still watches until a restart, the foreign row can still be set (D128)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/system/monitor', { data: { watching: ['output', 'input'] } })).toBeOK();
-    try {
-        const layout = await openSources(page);
-        await layout.getByRole('switch', { name: 'Watch for new outputs', exact: true }).uncheck();
-        await saveButton(page).click();
-        await expect(sourceList(page).locator('.operation p').first()).toHaveText('output · watching until restart');
-        const foreign = layout.getByRole('switch', { name: 'Save prompts from other workflows', exact: true });
-        await expect(foreign).toBeEnabled();
-        await expect(layout.locator('.setting-row').filter({ has: page.locator('#foreign-runs') }).locator('p.small'))
-            .toHaveText('Applies while Watch for new outputs is on.');
-        await foreign.uncheck();
-        const saved = page.waitForRequest(item => item.method() === 'POST' && item.url().endsWith(SETTINGS_URL));
-        await saveButton(page).click();
-        expect((await saved).postDataJSON()).toEqual({ save_foreign_runs: false, expected_revision: expect.any(String) });
-        await expect(statusOf(page)).toHaveText('Saved to the server configuration.');
-    } finally {
-        await request.post(SETTINGS_URL, { data: { save_foreign_runs: true } });
-    }
-});
-
 test('worker range max is cpu_count', async ({ page, request }) => {
     const { settings } = await serverJson(request, SETTINGS_URL);
     const layout = await openSources(page);

tests/browser/workspace-vocabulary-search.spec.mjs

@@ -1,167 +0,0 @@
-// #444 (D149): Tags & categories tag search, tag sort and the Untagged prompts row, against the real server.
-import {startCoverage,saveCoverage} from '../../tools/vendor/browser-coverage.mjs';
-import {test,expect} from './fixtures.mjs';
-import {armUnseenRestores} from './unseen-restore.mjs';
-import {captureCanonicalState} from './history-canonical-comparison.mjs';
-
-const route='/prompt_manager/workspace#/tags';
-const main=page=>page.locator('#workspace-main');
-const tagSurface=page=>main(page).locator('.two-col > section.surface').first();
-const table=page=>main(page).getByRole('table',{name:'Reusable tags',exact:true});
-const rows=page=>table(page).locator('tbody tr');
-const names=page=>rows(page).locator('td:first-child');
-const tagRow=(page,name)=>rows(page).filter({has:page.locator('td:first-child').getByText(name,{exact:true})});
-const search=page=>page.getByRole('searchbox',{name:'Search tags',exact:true});
-const sort=page=>page.getByRole('combobox',{name:'Sort tags',exact:true});
-const untagged=page=>tagSurface(page).locator('.operation').filter({has:page.getByRole('heading',{level:3,name:'Untagged prompts',exact:true})});
-const status=page=>tagSurface(page).locator('search.vocabulary-tools [role="status"]');
-const shelf=page=>page.locator('article[data-prompt-id]');
-const filtersButton=(page,name)=>page.locator('#workspace-main search.toolbar').getByRole('button',{name,exact:true});
-const refine=page=>page.getByRole('dialog',{name:'Refine this view',exact:true});
-
-async function seed(request,data={}) {
-    const response=await request.post('/__test__/vocabulary/reset',{data});await expect(response).toBeOK();return response.json();
-}
-let manifest;
-test.beforeEach(async({page,request,browserName})=>{
-    await startCoverage(page,browserName);await armUnseenRestores(page);
-    // Two minimal recipes without tags (the concept recipes all carry tags).
-    manifest=await seed(request,{extra_categories:2});
-    page.vocabularyErrors=[];page.on('pageerror',error=>page.vocabularyErrors.push(error.message));
-});
-test.afterEach(async({page,browserName})=>{await saveCoverage(page,browserName);expect(page.vocabularyErrors).toEqual([]);});
-
-async function open(page) {
-    await page.goto(route);await expect(rows(page)).toHaveCount(manifest.tags.length);
-}
-
-test('the tag vocabulary surface orders its paragraph, Untagged prompts, the search and sort, then the table',async({page})=>{
-    await open(page);
-    const order=await tagSurface(page).evaluate(node=>[...node.children].map(child=>child.matches('.operation')?'operation':
-        child.matches('search.toolbar')?'toolbar':child.matches('.table-wrap')?'table':child.tagName.toLowerCase()).slice(0,5));
-    expect(order).toEqual(['h2','p','operation','toolbar','table']);
-    await expect(untagged(page).locator('p')).toHaveText('2 positive prompts');
-    await expect(untagged(page).getByRole('button')).toHaveText(['Browse']);
-    await expect(search(page)).toHaveAttribute('placeholder','Search tags…');
-    await expect(search(page)).toHaveAttribute('maxlength','200');
-    await expect(sort(page).locator('option')).toHaveText(['Oldest first','Name A–Z','Name Z–A','Most prompts','Fewest prompts']);
-    await expect(sort(page)).toHaveValue('created');
-    await expect(tagSurface(page).locator('label.search-field svg, label.search-field .ca-icon').first()).toBeVisible();
-});
-
-test('search narrows the tags on the server, says when nothing matches and keeps the categories',async({page})=>{
-    await open(page);
-    const categories=await main(page).locator('.two-col > section.surface').nth(1).locator('.operation h3').allTextContents();
-    const reads=[];page.on('request',request=>{if(request.url().includes('/vocabulary/tags?'))reads.push(new URL(request.url()).searchParams);});
-    await search(page).fill('LIGHT');
-    await expect(names(page)).toHaveText(['warm_light','soft_light']);
-    await expect(status(page)).toHaveText('2 tags');
-    expect(reads.at(-1).get('search')).toBe('LIGHT');
-    // Literal: an underscore is not a wildcard.
-    await search(page).fill('a_c');await expect(rows(page)).toHaveCount(0);
-    await expect(tagSurface(page).locator('p.empty')).toHaveText('No tags match this search.');
-    await expect(status(page)).toHaveText('No tags match this search.');
-    await expect(main(page).locator('.two-col > section.surface').nth(1).locator('.operation h3')).toHaveText(categories);
-    await search(page).fill('');await expect(rows(page)).toHaveCount(manifest.tags.length);
-    await expect(status(page)).toHaveText(`${manifest.tags.length} tags`);
-});
-
-test('sort orders every tag by name or by prompts, ties in creation order',async({page})=>{
-    await open(page);
-    const created=await names(page).allTextContents();
-    await sort(page).selectOption('name');
-    const byName=[...created].sort((a,b)=>a.toLowerCase()<b.toLowerCase()?-1:a.toLowerCase()>b.toLowerCase()?1:0);
-    await expect(names(page)).toHaveText(byName);
-    await sort(page).selectOption('name-desc');await expect(names(page)).toHaveText([...byName].reverse());
-    await sort(page).selectOption('prompts');
-    await expect(rows(page).first().locator('td:first-child')).toHaveText('cinematic');
-    const counts=(await rows(page).locator('td:nth-child(2)').allTextContents()).map(Number);
-    expect(counts).toEqual([...counts].sort((a,b)=>b-a));
-    await sort(page).selectOption('prompts-asc');
-    const ascending=(await rows(page).locator('td:nth-child(2)').allTextContents()).map(Number);
-    expect(ascending).toEqual([...ascending].sort((a,b)=>a-b));
-    await sort(page).selectOption('created');await expect(names(page)).toHaveText(created);
-});
-
-test('a rename while searching re-reads the same search and sort',async({page})=>{
-    await open(page);
-    await sort(page).selectOption('name');await search(page).fill('light');
-    await expect(names(page)).toHaveText(['soft_light','warm_light']);
-    await tagRow(page,'warm_light').getByRole('button',{name:'Rename / merge',exact:true}).click();
-    const box=page.locator('dialog.vocabulary-dialog');
-    await box.getByLabel('New name; existing names merge',{exact:true}).fill('amber_light');
-    await box.getByRole('button',{name:'Apply',exact:true}).click();await expect(box).toHaveCount(0);
-    await expect(names(page)).toHaveText(['amber_light','soft_light']);
-    await expect(tagRow(page,'amber_light').getByRole('button',{name:'Rename / merge',exact:true})).toBeFocused();
-    await expect(search(page)).toHaveValue('light');await expect(sort(page)).toHaveValue('name');
-});
-
-test('Untagged prompts Browse opens the Library on exactly the prompts without tags',async({page})=>{
-    await open(page);
-    await untagged(page).getByRole('button',{name:'Browse',exact:true}).click();
-    await expect(page).toHaveURL(/#\/library$/);
-    await expect(main(page).getByRole('heading',{level:1})).toBeFocused();
-    await expect(shelf(page)).toHaveCount(2);
-    await expect(page.locator('#workspace-main .section-caption > span').first()).toHaveText(/^2 positive prompts · /);
-    for(const card of await shelf(page).all())await expect(card.locator('.tags .chip')).toHaveCount(0);
-    await filtersButton(page,'Filters · 1').click();
-    await expect(refine(page).getByRole('combobox',{name:'Tag match',exact:true})).toHaveValue('untagged');
-    await expect(refine(page).getByRole('textbox',{name:'Tags',exact:true})).toBeDisabled();
-    // Changing only the Tag match applies it: the whole shelf returns.
-    await refine(page).getByRole('combobox',{name:'Tag match',exact:true}).selectOption('all');
-    await expect(refine(page).getByRole('textbox',{name:'Tags',exact:true})).toBeEnabled();
-    await refine(page).getByRole('button',{name:'Apply filters',exact:true}).click();
-    await expect(filtersButton(page,'Filters')).toBeVisible();
-    await expect.poll(()=>shelf(page).count()).toBeGreaterThan(2);
-});
-
-test('Refine › Prompts without tags on the shelf drops typed tags and Clear restores All',async({page})=>{
-    await page.goto('/prompt_manager/workspace#/library');await expect(shelf(page).first()).toBeVisible();
-    await filtersButton(page,'Filters').click();
-    await refine(page).getByRole('textbox',{name:'Tags',exact:true}).fill('cinematic');
-    await refine(page).getByRole('combobox',{name:'Tag match',exact:true}).selectOption('untagged');
-    await refine(page).getByRole('button',{name:'Apply filters',exact:true}).click();
-    await expect(shelf(page)).toHaveCount(2);
-    await filtersButton(page,'Filters · 1').click();
-    await expect(refine(page).getByRole('textbox',{name:'Tags',exact:true})).toHaveValue('');
-    await refine(page).getByRole('button',{name:'Clear filters',exact:true}).click();
-    await expect(filtersButton(page,'Filters')).toBeVisible();await expect.poll(()=>shelf(page).count()).toBeGreaterThan(2);
-});
-
-test('an older server that ignores the search shows an error with Retry, never an unfiltered list',async({page})=>{
-    await open(page);
-    // An un-restarted server answers without the echo.
-    await page.route('**/prompt_manager/vocabulary/tags?*',async route=>{
-        const response=await route.fetch();const body=await response.json();delete body.search;delete body.sort;
-        await route.fulfill({response,json:body});
-    });
-    await search(page).fill('light');
-    await expect(tagSurface(page).locator('.vocabulary-error')).toBeVisible();
-    await expect(rows(page)).toHaveCount(0);
-    await expect(tagSurface(page).getByRole('button',{name:'Retry',exact:true})).toBeVisible();
-});
-
-test('the search and sort fit 390px without a page scroll',async({page})=>{
-    await page.setViewportSize({width:390,height:844});await open(page);
-    const layout=await tagSurface(page).evaluate(node=>{
-        const tools=node.querySelector('search.vocabulary-tools'),field=tools.querySelector('.search-field'),select=tools.querySelector('select');
-        const box=node.getBoundingClientRect(),fieldBox=field.getBoundingClientRect(),selectBox=select.getBoundingClientRect();
-        return {inside:fieldBox.left>=box.left&&selectBox.right<=box.right+0.5,fullField:Math.round(fieldBox.width)===Math.round(tools.getBoundingClientRect().width)};
-    });
-    expect(layout).toEqual({inside:true,fullField:true});
-    expect(await page.evaluate(()=>document.documentElement.scrollWidth-document.documentElement.clientWidth)).toBeLessThanOrEqual(1);
-});
-
-// Artifact-only captures for the maintainer's quick check (no pixel assertions): a search with a sort, the Library on
-// Untagged prompts and its Refine dialog.
-for(const [width,height] of [[1600,1100],[390,844]])for(const theme of ['dark','light'])test(`D149 captures ${width} ${theme}`,async({page},testInfo)=>{
-    await page.setViewportSize({width,height});await open(page);
-    await page.getByRole('combobox',{name:'Theme',exact:true}).selectOption(theme);
-    await sort(page).selectOption('prompts');await search(page).fill('i');await expect(status(page)).toHaveText(/^\d+ tags$/);
-    await page.mouse.move(0,0);
-    await captureCanonicalState(page,testInfo,`production-tags-search-${width}-${theme}`,'#workspace-main');
-    await untagged(page).getByRole('button',{name:'Browse',exact:true}).click();await expect(shelf(page)).toHaveCount(2);
-    await captureCanonicalState(page,testInfo,`production-library-untagged-${width}-${theme}`,'#workspace-main');
-    await filtersButton(page,'Filters · 1').click();await expect(refine(page)).toBeVisible();
-    await captureCanonicalState(page,testInfo,`production-refine-untagged-${width}-${theme}`,'dialog[open]');
-});

tests/browser/workspace-vocabulary.spec.mjs

@@ -3,7 +3,7 @@ import {writeFile} from 'node:fs/promises';
 import {test,expect} from './fixtures.mjs';
 import {armUnseenRestores,unseenRestore,followRestore,SEEN_RESTORE_PILL,SEEN_RESTORE_TOAST} from './unseen-restore.mjs';
 import {captureCanonicalState} from './history-canonical-comparison.mjs';
-import {pageInventoryOf,inventoryOf,diffInventory,mapVocabularyConcept,mapVocabularyDialog,d149Of,toolbarInventoryOf} from './vocabulary-canonical-comparison.mjs';
+import {pageInventoryOf,inventoryOf,diffInventory,mapVocabularyConcept,mapVocabularyDialog} from './vocabulary-canonical-comparison.mjs';
 
 const route='/prompt_manager/workspace#/tags';
 // Prompts per concept tag (app.js:71-165): first appearance order, Library Browse counts.
@@ -786,15 +786,6 @@ async function openProductionTags(page,theme,motion) {
     await expect(rows(page)).toHaveCount(manifest.tags.length);await expect(categoryRow(page,'Landscapes')).toHaveCount(1);
 }
 const pageOf=(page,production)=>page.locator(production?'#workspace-main':'#main').evaluate(pageInventoryOf);
-/** D149 donor: the concept's own page toolbar (Prompt library), whose search field and select the tag search reuses. */
-async function conceptToolbar(page,theme) {
-    await page.goto('about:blank');await page.goto(`${concept}#library`);
-    await page.getByRole('combobox',{name:'Theme',exact:true}).selectOption(theme);
-    const inventory=await page.locator('#main search.toolbar').evaluate(toolbarInventoryOf);
-    await page.goto('about:blank');await page.goto(`${concept}#tags`);await page.getByRole('combobox',{name:'Theme',exact:true}).selectOption(theme);
-    return inventory;
-}
-const tagToolbar=page=>page.locator('#workspace-main .two-col > section.surface:first-child > search.toolbar').evaluate(toolbarInventoryOf);
 /** Breadcrumb, document title (D7: "Tags", only the concept suffix differs) and the keyboard focus ring on a row action. */
 async function chromeOf(page,production) {
     const scope=page.locator(production?'#workspace-main':'#main');
@@ -814,7 +805,7 @@ async function chromeOf(page,production) {
 }
 /** Concept rows are the concept's own sample tags; production appends the fixture-only tags after them (D4 creation order). */
 function comparePage(reference,actual) {
-    const expected=mapVocabularyConcept(reference,{},d149Of(actual));
+    const expected=mapVocabularyConcept(reference);
     const shared=expected.table.rows.length;
     return {diff:diffInventory(expected,{...actual,table:{...actual.table,rows:actual.table.rows.slice(0,shared)}}),
         extra:actual.table.rows.slice(shared).map(row=>row.tag)};
@@ -827,18 +818,13 @@ for(const [width,height] of SIZES)for(const theme of ['dark','light'])test(`tags
         await openConceptTags(page,theme,motion);const reference=await pageOf(page,false);
         if(motion==='no-preference')await captureCanonicalState(page,testInfo,`concept-tags-${width}-${theme}`,'#main');
         const referenceChrome=await chromeOf(page,false);
-        const referenceTools=await conceptToolbar(page,theme);
         await openProductionTags(page,theme,motion);const actual=await pageOf(page,true);
-        const actualTools=await tagToolbar(page);
         if(motion==='no-preference')await captureCanonicalState(page,testInfo,`production-tags-${width}-${theme}`,'#workspace-main');
-        result[motion]={reference,actual,...comparePage(reference,actual),referenceChrome,actualChrome:await chromeOf(page,true),
-            toolbarDiff:diffInventory(referenceTools,actualTools)};
+        result[motion]={reference,actual,...comparePage(reference,actual),referenceChrome,actualChrome:await chromeOf(page,true)};
     }
     const path=testInfo.outputPath('tags-geometry.json');await writeFile(path,JSON.stringify(result,null,2));
     await testInfo.attach('tags-geometry',{path,contentType:'application/json'});
-    for(const [motion,{reference,diff,extra,referenceChrome,actualChrome,toolbarDiff}] of Object.entries(result)) {
-        // D149 (#444): the tag search and sort carry the concept page toolbar's tokens.
-        expect.soft(toolbarDiff,`${motion} tag search and sort against the concept toolbar`).toEqual([]);
+    for(const [motion,{reference,diff,extra,referenceChrome,actualChrome}] of Object.entries(result)) {
         expect.soft(referenceChrome,`${motion} concept chrome`).toMatchObject({breadcrumb:'Tags',title:'Tags',ring:{visible:true},linkRing:{outlineOffset:'3px'}});
         expect.soft(actualChrome,`${motion} breadcrumb, title and focus ring`).toEqual(referenceChrome);
         expect.soft(reference.heading.actions.buttons.map(item=>item.text),`${motion} concept heading actions`).toEqual(['+ Create tag','Auto-tag images']);
@@ -908,13 +894,6 @@ test('mutation check: the comparison reports a changed surface padding and a cha
     expect(paths).toContain('surfaces.1.paddingLeft');
     expect(paths).toContain('table.rows.0.actions.0');
     expect(paths).toContain('table.rowActions.buttons.0.text');
-    // D149: a moved Untagged prompts row and a restyled tag search are reported too.
-    await page.addStyleTag({content:'.vocabulary-main .surface > .operation{margin-top:6px!important}.vocabulary-tools .search-field{border-radius:9px!important}'});
-    const moved=comparePage(reference,await pageOf(page,true)).diff.map(item=>item.path);
-    expect(moved).toContain('d149.offset');
-    const tools=await conceptToolbar(page,'dark');await openProductionTags(page,'dark','no-preference');
-    await page.addStyleTag({content:'.vocabulary-tools .search-field{border-radius:9px!important}'});
-    expect(diffInventory(tools,await tagToolbar(page)).map(item=>item.path)).toContain('field.borderTopLeftRadius');
     // The dialog comparison is not vacuous either: a removed Cancel and a recolored field are reported.
     const donors=await conceptDonors(page,'dark');
     await openConceptTags(page,'dark','no-preference');await conceptDialogs.create(page);

tests/comfyui/execution-history.spec.mjs

@@ -309,21 +309,6 @@ test('fresh registered PM variants preserve exact raw whitespace and known empty
         expect(value.negative.raw).toBe('');
         expect(value.negative.effective).toBe('');
         expect(value.evidence.positive.raw).toMatchObject({ provenance: 'recorded', source: 'runtime_return' });
-        // #438: the Library stores the stripped text; the run is in that prompt's history
-        expect(value.positive_prompt_id, 'the run names the prompt the Library saved').toEqual(expect.any(Number));
-        const runId = (await readExecutionRuns(execution.databasePath, id)).rows[0].run_id;
-        const response = await execution.request.get(`/prompt_manager/library/${value.positive_prompt_id}/history`);expect(response.ok()).toBe(true);
-        expect((await response.json()).items.map(item => item.run_id)).toContain(runId);
-        if (kind !== 'PromptManager') continue;
-        // #460: an upper-case re-queue counts toward the same prompt and joins its history
-        const upper = await submit(execution.request, recipeGraph({ kind, text: `${kind.toUpperCase()} E\u0301` }));
-        await history(execution.request, upper);
-        const variant = (await capture(execution, upper)).contexts[0];
-        expect(variant.positive.raw).toBe(`${kind.toUpperCase()} E\u0301`);
-        expect(variant.positive_prompt_id, 'the case variant names the same prompt').toBe(value.positive_prompt_id);
-        const variantRun = (await readExecutionRuns(execution.databasePath, upper)).rows[0].run_id;
-        const scoped = await execution.request.get(`/prompt_manager/library/${value.positive_prompt_id}/history`);
-        expect((await scoped.json()).items.map(item => item.run_id)).toContain(variantRun);
     }
 });
 

tests/comfyui/fixtures/ledger_nodes.py

@@ -334,15 +334,8 @@ async def image_monitor(request: web.Request) -> web.Response:
 
 @PromptServer.instance.routes.get("/pm_execution_fixture/monitor")
 async def image_monitor_state(request: web.Request) -> web.Response:
-    """File names of images waiting for their run's recorded outputs: keyless
-    ones (``awaiting``) and foreign ones (``foreign``, #247)."""
+    """File names of keyless images waiting for their run's recorded outputs."""
     monitor = _plugin_module("utils.image_monitor")._monitor_instance
     handler = getattr(monitor, "handler", None)
     waiting = handler.awaiting_history() if handler is not None else []
-    foreign = handler.awaiting_foreign() if handler is not None else []
-    return web.json_response(
-        {
-            "awaiting": [os.path.basename(p) for p in waiting],
-            "foreign": [os.path.basename(p) for p in foreign],
-        }
-    )
+    return web.json_response({"awaiting": [os.path.basename(p) for p in waiting]})

tests/comfyui/image-attribution.spec.mjs

@@ -1,7 +1,6 @@
 // #342 on the real pinned host: the image monitor links an output only to a prompt
 // that provably produced it. An unknown node (PMHistoryCached) stands in for the
-// maintainer's LLM; KSampler is the fixture's deterministic stand-in. #247: an output
-// of a workflow without a PromptManager node gets its own prompt.
+// maintainer's LLM; KSampler is the fixture's deterministic stand-in.
 import { randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -142,68 +141,6 @@ test('an output saved without metadata links once its recorded run names a store
     }
 });
 
-// #247: no PromptManager node at all, only ComfyUI's own text encoders, sampler and
-// saver (the fixture's inputs and decoder stand in for the model files).
-function foreignGraph({ text, seed = 1, prefix }) {
-    return {
-        '10': { class_type: 'PMHistoryInputs', inputs: {} },
-        '20': { class_type: 'CLIPTextEncode', inputs: { text, clip: ['10', 0] } },
-        '30': { class_type: 'CLIPTextEncode', inputs: { text: '', clip: ['10', 0] } },
-        '40': { class_type: 'KSampler', inputs: { model: ['10', 1], latent_image: ['10', 2], positive: ['20', 0],
-            negative: ['30', 0], seed, steps: 1, cfg: 1, sampler_name: 'euler', scheduler: 'normal', denoise: 1 } },
-        '60': { class_type: 'PMHistoryImages', inputs: { value: 64, batch: 1, latent: ['40', 0] } },
-        '70': { class_type: 'SaveImage', inputs: { images: ['60', 0], filename_prefix: prefix } },
-    };
-}
-
-test('an output of a workflow without a PromptManager node creates and links its prompt; a second run reuses it', async ({ execution }, testInfo) => {
-    const text = `foreign lighthouse at dusk ${testInfo.project.name} ${randomUUID()}`;
-    const first = await saved(execution.request, foreignGraph({ text, prefix: 'foreign/run' }));
-    await linkedTo(execution, first, text);
-    // Only the seed changes: a new file, the same text, so the same stored prompt.
-    const second = await saved(execution.request, foreignGraph({ text, seed: 2, prefix: 'foreign/run' }));
-    await linkedTo(execution, second, text);
-    const state = await readLinks(execution.databasePath, [first, second], [text]);
-    expect(state).toEqual({ links: { [first]: text, [second]: text }, stored: { [text]: true } });
-    // Decided from the graph at settle: nothing waits for the run's recorded outputs.
-    expect((await (await execution.request.get('/pm_execution_fixture/monitor')).json()).foreign).toEqual([]);
-});
-
-// CUJ 1: two branches saved under one prefix, so neither the graph nor the file name
-// names a file's branch; the run's recorded saver does, once its outputs are sealed.
-function sharedPrefixGraph(texts) {
-    const nodes = {
-        '10': { class_type: 'PMHistoryInputs', inputs: {} },
-        '30': { class_type: 'CLIPTextEncode', inputs: { text: '', clip: ['10', 0] } },
-    };
-    texts.forEach((text, index) => {
-        const base = (index + 1) * 100;
-        nodes[String(base)] = { class_type: 'CLIPTextEncode', inputs: { text, clip: ['10', 0] } };
-        nodes[String(base + 1)] = { class_type: 'KSampler', inputs: { model: ['10', 1], latent_image: ['10', 2],
-            positive: [String(base), 0], negative: ['30', 0], seed: index + 1, steps: 1, cfg: 1, sampler_name: 'euler',
-            scheduler: 'normal', denoise: 1 } };
-        nodes[String(base + 2)] = { class_type: 'PMHistoryImages', inputs: { value: 64, batch: 1, latent: [String(base + 1), 0] } };
-        nodes[String(base + 3)] = { class_type: 'SaveImage', inputs: { images: [String(base + 2), 0], filename_prefix: 'foreign/dataset' } };
-    });
-    return nodes;
-}
-
-test('each branch of a shared-prefix workflow without a PromptManager node links to its own prompt after the run', async ({ execution }, testInfo) => {
-    const tag = `${testInfo.project.name} ${randomUUID()}`;
-    const texts = [`dataset branch one harbor ${tag}`, `dataset branch two meadow ${tag}`];
-    const id = randomUUID();
-    const response = await execution.request.post('/prompt', { data: { prompt: sharedPrefixGraph(texts), prompt_id: id } });
-    expect(response.ok()).toBe(true);
-    let item;
-    await expect.poll(async () => {
-        item = (await (await execution.request.get(`/history/${id}`)).json())[id];
-        return item?.status?.messages?.some(([kind]) => kind === 'execution_success') || false;
-    }, { timeout: 15000 }).toBe(true);
-    const files = ['103', '203'].map(node => item.outputs[node].images[0].filename);
-    for (const [index, file] of files.entries()) await linkedTo(execution, file, texts[index]);
-    expect((await (await execution.request.get('/pm_execution_fixture/monitor')).json()).foreign).toEqual([]);
-});
-
 // #332 on the real host: the migration ran at startup and the image category routes
 // set, list and remove an own category on a generated output.
 test('an output gets its own image category and loses it again', async ({ execution }, testInfo) => {

tests/fixtures/legacy_contract_snapshot.json

@@ -192,7 +192,6 @@
     "settings.monitoring_enabled",
     "settings.result_timeout",
     "settings.safety_backup",
-    "settings.save_foreign_runs",
     "settings.thumbnail_edge",
     "settings.thumbnail_format",
     "settings.thumbnail_quality",

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

@@ -104,17 +104,6 @@ test('archived variant reads use their own scope and cursor without changing the
  const active=[];const plain=createLibraryDetail({api:{get:async url=>{active.push(url);return {positive:item(1),variants:[]};}},onChange:()=>{}});await plain.load(1);assert.equal(new URL(active[0],'https://x').searchParams.has('archive'),false);
  assert.throws(()=>createLibraryDetail({api:{},onChange:()=>{},archive:'parents'}));
 });
-test('tag mode untagged is sent, echoed and never combined with tags (#444)',async()=>{
- const {createLibraryStream}=await source;const calls=[];const pending=[{...page([item(1)]),tag_mode:'untagged'},page([item(2)]),page([item(3)])];
- const s=createLibraryStream({api:{get:async(url)=>{calls.push(url);return pending.shift();}}});
- assert.equal(await s.reset({tagMode:'untagged'}),1);assert.equal(new URL(calls[0],'https://x').searchParams.get('tag_mode'),'untagged');
- // An older server that ignored tag_mode answers without the echo: an error, never the whole Library.
- assert.equal(await s.reset({tagMode:'untagged'}),0);assert.ok(s.state.error instanceof TypeError);assert.deepEqual(s.state.items,[]);
- // The default sends no tag_mode, so it needs no echo.
- assert.equal(await s.reset({tagMode:'all'}),1);assert.equal(new URL(calls[2],'https://x').searchParams.has('tag_mode'),false);
- await assert.rejects(s.reset({tagMode:'untagged',tags:['a']}),TypeError);await assert.rejects(s.reset({tagMode:'none'}),TypeError);
- assert.equal(calls.length,3);s.dispose();
-});
 test('the stream keeps the first page\'s storage epoch and refuses a later page from another one (#437)',async()=>{
  const {createLibraryStream}=await source;const A='11111111-1111-4111-8111-111111111111',B='22222222-2222-4222-8222-222222222222';
  const pending=[{...page([item(1)],'next'),library_epoch:A},{...page([item(2)],'more'),library_epoch:A},{...page([item(3)]),library_epoch:B}];

tests/js/workspace-saved-views.test.js

@@ -5,7 +5,7 @@ const assert = require('node:assert/strict');
 const source = import('../../web/js/workspace/saved-views.mjs');
 
 const IMAGE_DEFAULTS = { q: '', category: '', sort: 'newest', source: 'all', folder: '', media: 'all', tags: [], favorites: false, collection: '' };
-const LIBRARY_DEFAULTS = { q: '', category: '', sort: 'newest', tags: [], tag_mode: 'all' };
+const LIBRARY_DEFAULTS = { q: '', category: '', sort: 'newest', tags: [] };
 
 test('a saved state always holds every page key and keeps only values its page accepts', async () => {
     const { normalizeViewState, SAVED_VIEW_PAGES } = await source;
@@ -32,7 +32,7 @@ test('a saved state always holds every page key and keeps only values its page a
         { ...full, q: '', folder: '', tags: [] });
     assert.deepEqual(normalizeViewState('images', { ...full, category: 'bad\u0007', tags: [' '] }), { ...full, category: '', tags: [] });
     // Library has no source, folder or media, and no Name Z–A.
-    assert.deepEqual(normalizeViewState('library', { ...full, sort: 'name-desc' }), { q: 'castle', category: 'Portraits', sort: 'newest', tags: ['moody', 'fog'], tag_mode: 'all' });
+    assert.deepEqual(normalizeViewState('library', { ...full, sort: 'name-desc' }), { q: 'castle', category: 'Portraits', sort: 'newest', tags: ['moody', 'fog'] });
     assert.deepEqual(normalizeViewState('library', { sort: 'oldest' }), { ...LIBRARY_DEFAULTS, sort: 'oldest' });
     // The returned tags are a copy.
     const tags = ['one'];
@@ -62,7 +62,7 @@ test('the listing keeps usable views in order and normalizes their state', async
         { id: 1, page: 'images', name: 'Videos', state: { media: 'video', source: '9' } },
     ] });
     assert.deepEqual(views, [
-        { id: 3, page: 'library', name: 'Neon', state: { q: 'neon', category: '', sort: 'name', tags: [], tag_mode: 'all' } },
+        { id: 3, page: 'library', name: 'Neon', state: { q: 'neon', category: '', sort: 'name', tags: [] } },
         { id: 1, page: 'images', name: 'Videos', state: { ...IMAGE_DEFAULTS, media: 'video', source: '9' } },
     ]);
     assert.equal(parseSavedView(null), null);
@@ -84,8 +84,8 @@ test('page filters and saved states convert both ways', async () => {
     assert.equal(imagesViewState({ ...filters, collection: undefined }).collection, '');
     assert.equal(imagesViewState({ ...filters, collection: 7 }).collection, '7');
     assert.equal(imagesViewState({ ...filters, favorites: undefined }).favorites, false);
-    const shelf = { text: 'neon', category: 'Cities', sort: 'oldest', tags: ['night'], tagMode: 'all' };
-    assert.deepEqual(libraryViewState(shelf), { q: 'neon', category: 'Cities', sort: 'oldest', tags: ['night'], tag_mode: 'all' });
+    const shelf = { text: 'neon', category: 'Cities', sort: 'oldest', tags: ['night'] };
+    assert.deepEqual(libraryViewState(shelf), { q: 'neon', category: 'Cities', sort: 'oldest', tags: ['night'] });
     assert.deepEqual(libraryFilters(libraryViewState(shelf)), shelf);
 });
 
@@ -216,16 +216,6 @@ test('a state over the API 4 KB cap is refused before anything is sent (#249 M5)
     assert.deepEqual(api.calls, []);
 });
 
-test('a Library view keeps its tag match, and untagged never travels with tags (#444)', async () => {
-    const { normalizeViewState, libraryFilters, libraryViewState } = await source;
-    assert.equal(normalizeViewState('library', { tag_mode: 'untagged' }).tag_mode, 'untagged');
-    assert.equal(normalizeViewState('library', { tag_mode: 'any' }).tag_mode, 'all');
-    assert.deepEqual(normalizeViewState('library', { tags: ['a'], tag_mode: 'untagged' }), { ...LIBRARY_DEFAULTS, tags: ['a'] });
-    const shelf = { text: '', category: '', sort: 'newest', tags: [], tagMode: 'untagged' };
-    assert.equal(libraryViewState(shelf).tag_mode, 'untagged');
-    assert.deepEqual(libraryFilters(libraryViewState(shelf)), shelf);
-});
-
 test('a view saved under the retired Highest rated sort opens on Recently added (D153)', async () => {
     const { normalizeViewState, imagesFilters, libraryFilters } = await source;
     assert.equal(normalizeViewState('images', { sort: 'rating' }).sort, 'newest');

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

@@ -157,20 +157,3 @@ test('a valid configured source missing from the effective list is another spell
     assert.deepEqual(sourceRows({ sources, saved, current: saved }).rows.at(-1), { key: 'output/.', title: 'output',
         description: 'output/. · same folder as another source', scan: null, remove: 'output/.' });
 });
-
-test('D158: "Save prompts from other workflows" drafts save_foreign_runs, disabled while monitoring is off (#247)', async () => {
-    const { FOREIGN_RUNS, foreignRunsState } = await sourcesModule;
-    assert.deepEqual(FOREIGN_RUNS, { id: 'foreign-runs', key: 'save_foreign_runs', label: 'Save prompts from other workflows',
-        description: 'New outputs of workflows without a PromptManager node add their prompt to the library when it is certain.',
-        off: 'Applies while Watch for new outputs is on.' });
-    assert.deepEqual(foreignRunsState({ value: true, monitoring: true }), { disabled: false, checked: true, note: null });
-    assert.deepEqual(foreignRunsState({ value: false, monitoring: true }), { disabled: false, checked: false, note: null });
-    // Monitoring drafted or saved off: nothing is watched, so the row says why it is disabled and keeps its value.
-    assert.deepEqual(foreignRunsState({ value: true, monitoring: false }), { disabled: true, checked: true, note: FOREIGN_RUNS.off });
-    // Not read yet (or the host read failed): disabled without a value, the host rows' own note applies.
-    assert.deepEqual(foreignRunsState({ value: undefined, monitoring: undefined }), { disabled: true, checked: null, note: null });
-    assert.deepEqual(foreignRunsState({ value: undefined, monitoring: false }), { disabled: true, checked: null, note: null });
-    // Saved off while the running monitor still watches until the restart (D128 `stopping`): it can still be set.
-    assert.deepEqual(foreignRunsState({ value: true, monitoring: false, stopping: true }),
-        { disabled: false, checked: true, note: FOREIGN_RUNS.off });
-});

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

@@ -461,57 +461,6 @@ test('after dispose an unconfirmed write invalidates and a failed write does not
     }
 });
 
-test('a tag stream sends its search and sort, replaces them on reset and needs the server to echo them (#444)', async () => {
-    const {createVocabularyStream, TAG_SORTS} = await source;
-    assert.deepEqual(TAG_SORTS.map(([value]) => value), ['created', 'name', 'name-desc', 'prompts', 'prompts-asc']);
-    assert.deepEqual(TAG_SORTS.map(([, label]) => label), ['Oldest first', 'Name A–Z', 'Name Z–A', 'Most prompts', 'Fewest prompts']);
-    const echo = (page, search, sort) => ({...page, search, sort, untagged_count: 4});
-    const {calls, api} = queued([
-        echo(tagPage([tag(1)], 'next'), 'cat', 'name'), echo(tagPage([tag(2)]), 'cat', 'name'),
-        echo(tagPage([tag(3)]), '', 'created'), tagPage([tag(4)]), echo(tagPage([tag(5)]), 'dog', 'created'),
-    ]);
-    const stream = createVocabularyStream({api, kind: 'tags', query: {search: ' cat ', sort: 'name'}});
-    await stream.loadMore();
-    assert.equal(params(calls[0].url).get('search'), 'cat');
-    assert.equal(params(calls[0].url).get('sort'), 'name');
-    assert.equal(stream.state.untaggedCount, 4);
-    await stream.loadMore();
-    assert.equal(params(calls[1].url).get('search'), 'cat');
-    assert.equal(params(calls[1].url).get('cursor'), 'next');
-    assert.deepEqual(stream.state.query, {search: 'cat', sort: 'name'});
-    // The default query sends neither, so an older server answers it unchanged.
-    await stream.reset({search: '', sort: 'created'});
-    assert.equal(params(calls[2].url).has('search'), false);
-    assert.equal(params(calls[2].url).has('sort'), false);
-    assert.deepEqual(stream.state.items.map(row => row.id), [3]);
-    // A server that ignored the search (no echo) is an error, never a wrong list.
-    await stream.reset({search: 'dog', sort: 'created'});
-    assert.deepEqual(stream.state.items, []);
-    assert.ok(stream.state.error instanceof TypeError);
-    assert.equal(stream.state.untaggedCount, 4, 'the last known untagged count survives a reset');
-    await stream.loadMore();
-    assert.deepEqual(stream.state.items.map(row => row.id), [5]);
-    assert.throws(() => stream.reset({search: 'x', sort: 'count'}), TypeError);
-    assert.throws(() => createVocabularyStream({api, kind: 'categories', query: {search: 'x'}}), TypeError);
-    assert.throws(() => createVocabularyStream({api, kind: 'tags', query: {search: 3}}), TypeError);
-    stream.dispose();
-});
-
-test('an invalid untagged_count rejects the page', async () => {
-    const {createVocabularyStream} = await source;
-    for (const untagged_count of [-1, 1.5, '2']) {
-        const stream = createVocabularyStream({api: queued([{...tagPage([tag(1)]), untagged_count}]).api, kind: 'tags'});
-        await stream.loadMore();
-        assert.ok(stream.state.error instanceof TypeError, String(untagged_count));
-        assert.equal(stream.state.untaggedCount, null);
-    }
-});
-
-test('untaggedBrowseFilters opens the Library on prompts without tags (#444)', async () => {
-    const {untaggedBrowseFilters} = await source;
-    assert.deepEqual(untaggedBrowseFilters(), {text: '', category: '', tags: [], sort: 'newest', tagMode: 'untagged'});
-});
-
 test('browseFilters hands Library one exact constraint', async () => {
     const {browseFilters} = await source;
     assert.deepEqual(browseFilters('tags', 'a'), {text: '', category: '', tags: ['a'], sort: 'newest'});

tests/test_api_diagnostics_report.py

@@ -85,7 +85,6 @@ CONFIG = {
         "max_image_age_days",
         "max_concurrent_processing",
         "metadata_extraction_timeout",
-        "save_foreign_runs",
     },
     "integrations": {"lora_manager_enabled", "has_civitai_api_key"},
 }

tests/test_api_history.py

@@ -18,8 +18,6 @@ from unittest.mock import patch
 
 from aiohttp import FormData, web
 
-from utils.hashing import generate_prompt_hash
-
 try:
     from test_api_images import ImageAPITestCase
 except ImportError:
@@ -193,11 +191,7 @@ class HistoryAPITests(ImageAPITestCase):
             context["evidence"]["positive"]["raw"]["provenance"], "recorded"
         )
         with self.api.db.model.get_connection() as conn:
-            # An edit changes the text and its dedup hash together (#460)
-            conn.execute(
-                "UPDATE prompts SET text='edited',hash=? WHERE id=?",
-                (generate_prompt_hash("edited"), positive),
-            )
+            conn.execute("UPDATE prompts SET text='edited' WHERE id=?", (positive,))
         _, changed = await self.detail(start.run_id)
         self.assertEqual(changed["contexts"][0]["positive"], context["positive"])
         self.assertFalse(changed["contexts"][0]["navigation"]["positive_available"])

tests/test_api_library.py

@@ -60,32 +60,6 @@ class TestLibraryAPI(ImageAPITestCase):
             self.assertEqual(response.status, 400)
             self.assertNotIn(str(self.comfy_dir), json.dumps(result))
 
-    async def test_untagged_tag_mode_lists_parents_without_tags(self):
-        self._save_prompt("plain one")
-        self._save_prompt("plain two")
-        self._save_prompt("tagged", tags=["t"])
-        self.api.db.save_prompt_pair("pair tagged", "noise", tags=["p"])
-        _, first = await self.get(limit=1, tag_mode="untagged")
-        self.assertEqual(first["total"], 2)
-        self.assertEqual(first["tag_mode"], "untagged")
-        _, second = await self.get(
-            limit=1, tag_mode="untagged", cursor=first["next_cursor"]
-        )
-        self.assertEqual(
-            sorted([first["items"][0]["text"], second["items"][0]["text"]]),
-            ["plain one", "plain two"],
-        )
-        _, default = await self.get(tag_mode="all")
-        self.assertEqual(default["total"], 4)
-        for params in (
-            {"tag_mode": "untagged", "tag": "t"},
-            {"tag_mode": "sql"},
-            {"cursor": first["next_cursor"]},
-        ):
-            response, result = await self.get(limit=1, **params)
-            self.assertEqual(response.status, 400, params)
-            self.assertEqual(result["success"], False)
-
     async def test_outside_missing_and_unsupported_media_do_not_leak_or_scan(self):
         positive = self._save_prompt("Cat")
         outside = make_png(self.comfy_dir / "outside.png")

tests/test_api_vocabulary.py

@@ -35,17 +35,7 @@ class TestVocabularyAPI(ImageAPITestCase):
         self.assertEqual(response.status, 200)
         self.assertEqual(
             set(first),
-            {
-                "success",
-                "library_epoch",
-                "tags",
-                "total",
-                "untagged_count",
-                "search",
-                "sort",
-                "has_more",
-                "next_cursor",
-            },
+            {"success", "library_epoch", "tags", "total", "has_more", "next_cursor"},
         )
         self.assertEqual(first["library_epoch"], epoch)
         self.assertEqual(first["total"], 3)
@@ -121,41 +111,6 @@ class TestVocabularyAPI(ImageAPITestCase):
         response, _ = await self.get("tags", limit=1, cursor=fresh["next_cursor"])
         self.assertEqual(response.status, 200)
 
-    async def test_tag_search_and_sort_page_with_scoped_cursors(self):
-        self._save_prompt("One", tags=["beta", "alpha"])
-        self._save_prompt("Two", tags=["beta"])
-        self._save_prompt("Plain")
-        self.add_unused("gamma")
-        _, first = await self.get("tags", limit=1, sort="name", search="A")
-        self.assertEqual([row["name"] for row in first["tags"]], ["alpha"])
-        self.assertEqual(first["total"], 3)
-        self.assertEqual(first["untagged_count"], 1)
-        self.assertEqual((first["search"], first["sort"]), ("A", "name"))
-        _, second = await self.get(
-            "tags", limit=1, sort="name", search="A", cursor=first["next_cursor"]
-        )
-        self.assertEqual([row["name"] for row in second["tags"]], ["beta"])
-        _, ranked = await self.get("tags", sort="prompts")
-        self.assertEqual(
-            [(row["name"], row["prompt_count"]) for row in ranked["tags"]],
-            [("beta", 2), ("alpha", 1), ("gamma", 0)],
-        )
-        # A cursor belongs to one search and one sort.
-        for params in (
-            {"sort": "name-desc", "search": "A"},
-            {"sort": "name", "search": "B"},
-            {"sort": "created", "search": "A"},
-        ):
-            response, result = await self.get(
-                "tags", limit=1, cursor=first["next_cursor"], **params
-            )
-            self.assertEqual(response.status, 400, params)
-            self.assertIn("refresh", result["error"])
-        for params in ({"sort": "count"}, {"search": "x" * 201}):
-            response, result = await self.get("tags", **params)
-            self.assertEqual(response.status, 400, params)
-            self.assertEqual(result["success"], False)
-
     async def test_read_failures_keep_the_read_envelope(self):
         with patch.object(
             self.api.db,

tests/test_config.py

@@ -59,28 +59,6 @@ class TestGalleryConfig(unittest.TestCase):
         self.assertFalse(GalleryConfig.MONITORING_ENABLED)
         self.assertEqual(GalleryConfig.PROCESSING_DELAY, 5.0)
 
-    def test_save_foreign_runs_defaults_on_and_only_booleans_apply(self):
-        """#247: gallery.monitoring.save_foreign_runs, default true."""
-        self.assertIs(
-            GalleryConfig.get_config()["monitoring"]["save_foreign_runs"], True
-        )
-        GalleryConfig.update_config({"monitoring": {"save_foreign_runs": False}})
-        self.assertIs(GalleryConfig.SAVE_FOREIGN_RUNS, False)
-        for junk in ("true", 1, None):
-            with self.subTest(value=junk):
-                with self.assertLogs("prompt_manager.config", "WARNING") as logs:
-                    GalleryConfig.update_config(
-                        {"monitoring": {"save_foreign_runs": junk}}
-                    )
-                self.assertIn(
-                    "Ignoring gallery monitoring save_foreign_runs: expected true "
-                    "or false",
-                    "\n".join(logs.output),
-                )
-                self.assertIs(GalleryConfig.SAVE_FOREIGN_RUNS, False)
-        GalleryConfig.update_config({"monitoring": {"save_foreign_runs": True}})
-        self.assertIs(GalleryConfig.SAVE_FOREIGN_RUNS, True)
-
     def test_update_tracking(self):
         GalleryConfig.update_config({"tracking": {"prompt_timeout": 300}})
         self.assertEqual(GalleryConfig.PROMPT_TIMEOUT, 300)

tests/test_execution_context_database.py

@@ -15,7 +15,6 @@ from database import execution_contexts
 from database.execution_history import HistoryEpochChanged
 from database.execution_context_schema import context_schema_error
 from database.execution_contexts import LIVE_HINT_PROMPT_IDS_SQL
-from utils.hashing import generate_prompt_hash
 from database.execution_history_schema import rotate_history_epoch
 from utils.execution_contexts import (
     ContextBundle,
@@ -467,11 +466,7 @@ class ContextDatabaseTests(unittest.TestCase):
         with conn:
             conn.execute("DELETE FROM prompts WHERE id=3")
         self.assertEqual(assert_same(), {1, 2, 4})
-        # A case-only edit keeps the prompt's hash, so the run still counts
-        # toward it (#460); another text drops the hint.
         db.update_prompt_text(4, "Other")
-        self.assertEqual(assert_same(), {1, 2, 4})
-        db.update_prompt_text(4, "another")
         self.assertEqual(assert_same(), {1, 2})
         with conn:
             conn.execute("INSERT INTO prompts(id,text) VALUES(5,'none')")
@@ -479,131 +474,6 @@ class ContextDatabaseTests(unittest.TestCase):
         rotate_history_epoch(conn)
         self.assertEqual(assert_same(), set())
 
-    def test_hints_resolve_the_stored_form_of_outer_whitespace_raw_text(self):
-        # #438: the Library stores text.strip(); the raw run text keeps its spaces.
-        db = self.database()
-        conn = db.model.get_connection()
-        with conn:
-            conn.execute(
-                "INSERT INTO prompts(id,text) VALUES(1,'positive'),(2,'negative')"
-            )
-            conn.execute(
-                "INSERT INTO prompt_pairs(id,positive_prompt_id,negative_prompt_id) "
-                "VALUES(7,1,2)"
-            )
-        start = self.capture(db, 0, bundle(" negative\n", positive="positive\n\t"))
-        context = db.get_execution_contexts(start.run_id)["contexts"][0]
-        self.assertEqual(context["positive"]["raw"], "positive\n\t")
-        self.assertEqual(
-            (
-                context["positive_prompt_id"],
-                context["negative_prompt_id"],
-                context["pair_id"],
-            ),
-            (1, 2, 7),
-        )
-        live = {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        self.assertEqual(live, {1, 2})
-        stored = conn.execute(
-            "SELECT positive_prompt_id FROM execution_run_contexts WHERE run_id=?",
-            (start.run_id,),
-        ).fetchone()[0]
-        self.assertEqual(stored, 1)
-        # A legacy row that kept outer whitespace keeps its exact-text hint and
-        # with it the recorded-run protection from pruning.
-        with conn:
-            conn.execute("INSERT INTO prompts(id,text) VALUES(3,' legacy ')")
-        legacy = self.capture(db, 1, bundle("negative", positive=" legacy "))
-        hinted = db.get_execution_contexts(legacy.run_id)["contexts"][0]
-        self.assertEqual(hinted["positive_prompt_id"], 3)
-        live = {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        self.assertEqual(live, {1, 2, 3})
-        self.assertEqual(db.prune_orphaned_prompts(), 0)
-        # Both forms present make the hint ambiguous, in both rule forms.
-        with conn:
-            conn.execute("INSERT INTO prompts(id,text) VALUES(4,'legacy')")
-        hinted = db.get_execution_contexts(legacy.run_id)["contexts"][0]
-        self.assertIsNone(hinted["positive_prompt_id"])
-        live = {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        self.assertEqual(live, {1, 2})
-
-    def test_hints_follow_the_hash_for_case_variant_raw_text(self):
-        # #460: the run names the prompt the Library counted it toward.
-        db = self.database()
-        first = db.save_prompt(
-            "\u00e9t\u00e9 positive",
-            prompt_hash=generate_prompt_hash("\u00e9t\u00e9 positive"),
-        )
-        second = db.save_prompt(
-            "negative \u03c3", prompt_hash=generate_prompt_hash("negative \u03c3")
-        )
-        with db.model.get_connection() as conn:
-            conn.execute(
-                "INSERT INTO prompt_pairs(id,positive_prompt_id,negative_prompt_id) "
-                "VALUES(7,?,?)",
-                (first, second),
-            )
-        start = self.capture(
-            db, 0, bundle("NEGATIVE \u03a3", positive="\u00c9T\u00c9 Positive")
-        )
-        context = db.get_execution_contexts(start.run_id)["contexts"][0]
-        self.assertEqual(
-            (
-                context["positive_prompt_id"],
-                context["negative_prompt_id"],
-                context["pair_id"],
-            ),
-            (first, second, 7),
-        )
-        conn = db.model.get_connection()
-        live = {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        self.assertEqual(live, {first, second})
-        # A prompt that only shares SQLite's ASCII lower() is not a match
-        other = db.save_prompt("other", prompt_hash=generate_prompt_hash("other"))
-        start = self.capture(db, 1, bundle("x", positive="\u00d6THER"))
-        context = db.get_execution_contexts(start.run_id)["contexts"][0]
-        self.assertIsNone(context["positive_prompt_id"])
-        self.assertNotIn(
-            other, {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        )
-
-    def test_hash_is_only_a_fallback_so_a_text_hint_stays_unambiguous(self):
-        # #460 review: a hash match must never make a #438 text hint ambiguous,
-        # or its prompt would lose the recorded-run prune protection.
-        db = self.database()
-        conn = db.model.get_connection()
-        with conn:
-            # A legacy row without a hash, and a case variant with the hash
-            conn.execute("INSERT INTO prompts(id,text) VALUES(1,'a lighthouse')")
-            conn.execute(
-                "INSERT INTO prompts(id,text,hash) VALUES(2,'A Lighthouse',?)",
-                (generate_prompt_hash("a lighthouse"),),
-            )
-        exact = self.capture(db, 0, bundle("x", positive="a lighthouse"))
-        variant = self.capture(db, 1, bundle("x", positive="A LIGHTHOUSE"))
-        hints = [
-            db.get_execution_contexts(start.run_id)["contexts"][0]["positive_prompt_id"]
-            for start in (exact, variant)
-        ]
-        self.assertEqual(hints, [1, 2])
-        live = {row[0] for row in conn.execute(LIVE_HINT_PROMPT_IDS_SQL)}
-        self.assertEqual(live, {1, 2})
-        self.assertEqual(db.prune_orphaned_prompts(), 0)
-
-    def test_live_hint_prompt_lookups_use_indexes(self):
-        db = self.database()
-        conn = db.model.get_connection()
-        plan = [
-            row[3]
-            for row in conn.execute("EXPLAIN QUERY PLAN " + LIVE_HINT_PROMPT_IDS_SQL)
-        ]
-        prompt_steps = [
-            step for step in plan if " p " in f" {step} " or "TABLE p" in step
-        ]
-        self.assertTrue(prompt_steps, plan)
-        self.assertEqual([step for step in plan if step.startswith("SCAN p")], [])
-        self.assertEqual([step for step in plan if step.startswith("SCAN q")], [])
-
     def test_hints_require_exact_unique_raw_text_and_never_refresh(self):
         db = self.database()
         conn = db.model.get_connection()
@@ -634,13 +504,12 @@ class ContextDatabaseTests(unittest.TestCase):
             db.get_execution_contexts(fresh.run_id)["contexts"][0]["positive_prompt_id"]
         )
 
-    def test_null_negative_pair_only_matches_a_known_stored_empty(self):
+    def test_null_negative_pair_only_matches_known_exact_empty(self):
         db = self.database()
         with db.model.get_connection() as conn:
             conn.execute("INSERT INTO prompts(id,text) VALUES(1,'positive')")
             conn.execute("INSERT INTO prompt_pairs(id,positive_prompt_id) VALUES(7,1)")
-        # A whitespace-only negative is the stored empty one (#438)
-        for item, raw, expected in ((0, "", 7), (1, " \n", 7), (2, None, None)):
+        for item, raw, expected in ((0, "", 7), (1, " ", None), (2, None, None)):
             candidate = bundle(negative=raw or "")
             if raw is None:
                 ctx = candidate.contexts[0]

tests/test_execution_history_hooks.py

@@ -19,7 +19,6 @@ from unittest.mock import patch
 from tests.history_waits import drain_writer
 from database import PromptDatabase
 from utils import usage_tracking
-from utils.hashing import generate_prompt_hash
 from utils.execution_history_writer import HistoryWriter
 
 try:
@@ -917,42 +916,3 @@ class CachedRuntimeHistoryTests(HooksCase):
         from database.run_attribution import named_prompt
 
         self.assertIsNone(named_prompt(self.db, self.rows()[1]["run_id"]))
-
-
-class CachedRuntimeCaseHistoryTests(CachedRuntimeHistoryTests):
-    """Raw text that differs only in case joins the saved prompt's history (#460).
-
-    The hash folds case, so the run counts toward the lower-case prompt saved
-    first; the run keeps its exact raw spelling.
-    """
-
-    TEXT = "\u00c9 LIGHTHOUSE the LLM wrote"
-
-    def setUp(self):
-        super().setUp()
-        self.db.delete_prompt(self.prompt_id)
-        lower = self.TEXT.lower()
-        self.prompt_id = self.db.save_prompt(
-            text=lower, prompt_hash=generate_prompt_hash(lower)
-        )
-
-    def test_the_library_counts_the_case_variant_as_this_prompt(self):
-        self.assertEqual(
-            self.db.get_prompt_by_hash(generate_prompt_hash(self.TEXT))["id"],
-            self.prompt_id,
-        )
-
-
-class CachedRuntimeWhitespaceHistoryTests(CachedRuntimeHistoryTests):
-    """Raw text with outer whitespace joins the history of the prompt it saves (#438).
-
-    The Library stores ``"a lighthouse the LLM wrote"``; the run keeps the exact
-    frozen raw text, newline included, yet is a tracked run of that prompt.
-    """
-
-    TEXT = "\u3000 a lighthouse the LLM wrote\n"
-
-    def test_the_library_stores_the_stripped_text(self):
-        self.assertEqual(
-            self.db.get_prompt_by_id(self.prompt_id)["text"], self.TEXT.strip()
-        )

tests/test_foreign_save_to_library.py

@@ -1,330 +0,0 @@
-"""#247 PR 2 x #90: the monitor's foreign path never stores switched-off text.
-
-A file whose run's prompt has Save to library off is the opted-out path's,
-not the foreign path's; a foreign graph whose ladder decision is
-``not_saved`` (a switched-off node the #90 walk does not reach) stores
-nothing at settle, at the re-check after the seal, or from recorded history,
-and leaves no wait behind.
-"""
-
-import os
-import unittest
-
-from tests import saver_anchor_graphs as shapes
-from tests import test_run_attribution as attribution
-from tests import test_save_to_library as save_tests
-from tests.test_pair_scan import sampled_graph
-from utils.foreign_runs import ForeignRecheck
-from utils.hashing import generate_prompt_hash
-from py.config import GalleryConfig  # after tests: it stubs the host
-
-LOGGER = "prompt_manager.image_monitor"
-OFF_TEXT = "SECRET OFF TEXT"
-SKIPPED = "Save to library is off for this run's prompt, skipping image"
-
-# The class dict, not the class: a TestCase bound here would run again
-Fixture = vars(attribution.TestMonitorForeignRuns)
-
-
-def off_behind(middle="MyNode", key="value"):
-    """A switched-off PromptManagerText reaching a core CLIPTextEncode through
-    ``middle``'s ``key`` input: the #90 walk does not follow ``key``."""
-    graph = save_tests.run_graph()
-    graph["1"] = {
-        "class_type": "PromptManagerText",
-        "inputs": {"text": OFF_TEXT, "save_to_library": False},
-    }
-    graph["7"] = {"class_type": middle, "inputs": {key: ["1", 0]}}
-    graph["8"] = {
-        "class_type": "CLIPTextEncode",
-        "inputs": {"text": ["7", 0], "clip": ["4", 1]},
-    }
-    graph["3"]["inputs"]["positive"] = ["8", 0]
-    return graph
-
-
-def off_text_unwired():
-    """Only history can decide; the legacy answer is a dangling switched-off
-    node's own text (the ladder says ``not_saved`` once it may ask history)."""
-    graph = sampled_graph("unused", "blurry")
-    graph["1"]["inputs"]["text"] = ["30", 0]
-    graph["30"] = {"class_type": "VendorPromptMaker", "inputs": {"prompt": OFF_TEXT}}
-    graph["40"] = {
-        "class_type": "PromptManagerText",
-        "inputs": {"text": OFF_TEXT, "save_to_library": False},
-    }
-    return graph
-
-
-class TestForeignPathKeepsSaveToLibrary(attribution.RecordedRuns, unittest.TestCase):
-    setUp = Fixture["setUp"]
-    close_databases = Fixture["close_databases"]
-    wait_for = Fixture["wait_for"]
-    image = Fixture["image"]
-    linked_text = Fixture["linked_text"]
-    key = Fixture["key"]
-    prompt_count = Fixture["prompt_count"]
-    settled = Fixture["settled"]
-
-    def reference(self, path):
-        return {
-            "folder_type": "output",
-            "subfolder": "dataset",
-            "filename": os.path.basename(path),
-        }
-
-    def seal(self, path, positives=(), nodes=("9",)):
-        """Record one run reporting ``path`` (a new run id for every call)."""
-        self.runs = getattr(self, "runs", -1) + 1
-        self.record_run(
-            self.db,
-            self.output,
-            [("dataset", os.path.basename(path))],
-            list(positives),
-            item=self.runs,
-            nodes=list(nodes),
-        )
-
-    def recheck(self, path):
-        """The re-check the seal schedules, run through the monitor's entry."""
-        with self.assertLogs(LOGGER, "INFO") as logs:
-            self.handler.process_new_image(path, ForeignRecheck(self.reference(path)))
-        return "\n".join(logs.output)
-
-    def assert_nothing_stored(self, path):
-        self.assertIsNone(self.linked_text(path))
-        self.assertEqual(self.prompt_count(), 0)
-        self.assertIsNone(self.db.get_prompt_by_hash(generate_prompt_hash(OFF_TEXT)))
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        self.assertEqual(list(self.handler._foreign_due), [])
-
-    def test_q1_the_only_prompt_manager_node_off_is_opted_out_not_foreign(self):
-        graph = save_tests.run_graph(save=False)
-        # The switched-off positive is the only PromptManager node
-        graph["2"] = {"class_type": "CLIPTextEncode", "inputs": {"text": "blurry"}}
-        sampler_less = {
-            "1": {
-                "class_type": "PromptManagerText",
-                "inputs": {"text": OFF_TEXT, "save_to_library": False},
-            }
-        }
-        for name, graph in (("sampled", graph), ("sampler-less", sampler_less)):
-            with self.subTest(name=name):
-                self.metadata = {"prompt": graph}
-                state, _ = self.handler._find_prompt_from_metadata(self.metadata)
-                self.assertEqual(state, "opted_out")
-                path = self.image(f"IMG_GEN_{name}_00001_.png")
-                with self.assertLogs(LOGGER, "INFO") as logs:
-                    self.handler.process_new_image(path)
-                self.assertIn(SKIPPED, "\n".join(logs.output))
-                self.seal(path)
-                self.assertTrue(self.settled())
-                self.assertIn(SKIPPED, self.recheck(path))
-                self.assert_nothing_stored(path)
-
-    def test_q2_an_off_text_node_behind_a_pass_through_stores_nothing(self):
-        for middle, key in (("MyNode", "value"), ("easy showAnything", "anything")):
-            with self.subTest(middle=middle):
-                self.metadata = {"prompt": off_behind(middle, key)}
-                state, _ = self.handler._find_prompt_from_metadata(self.metadata)
-                self.assertEqual(state, "foreign")
-                path = self.image(f"IMG_GEN_{key}_00001_.png")
-                with self.assertLogs(LOGGER, "INFO") as logs:
-                    self.handler.process_new_image(path)
-                self.assertIn(SKIPPED, "\n".join(logs.output))
-                self.assert_nothing_stored(path)
-                self.seal(path)
-                self.assertTrue(self.settled())
-                self.assertIn(SKIPPED, self.recheck(path))
-                self.assert_nothing_stored(path)
-
-    def test_q2_a_wired_switch_behind_a_pass_through_stores_nothing(self):
-        graph = off_behind()
-        graph["1"]["inputs"]["save_to_library"] = ["20", 0]
-        graph["20"] = {"class_type": "SomeBoolNode", "inputs": {}}
-        self.metadata = {"prompt": graph}
-        path = self.image("IMG_GEN_wired_00001_.png")
-        wired = "Save to library is wired from a node the image cannot show"
-        with self.assertLogs(LOGGER, "INFO") as logs:
-            self.handler.process_new_image(path)
-        self.assertIn(wired, "\n".join(logs.output))
-        self.seal(path)
-        self.assertTrue(self.settled())
-        self.assertIn(wired, self.recheck(path))
-        self.assert_nothing_stored(path)
-
-    def test_q3_an_undecided_not_saved_waits_for_the_record_then_skips(self):
-        """No record yet: a not_saved of the undecided step is not final (a
-        recorded saver may resolve another branch), so the file waits for its
-        run; the decision with the record stores nothing and logs the skip."""
-        wired = off_text_unwired()
-        wired["40"]["inputs"]["save_to_library"] = ["20", 0]
-        wired["20"] = {"class_type": "SomeBoolNode", "inputs": {}}
-        cases = (
-            ("off", off_text_unwired(), SKIPPED),
-            ("wired", wired, "Save to library is wired from a node"),
-        )
-        for name, graph, line in cases:
-            with self.subTest(name=name):
-                self.metadata = {"prompt": graph}
-                path = self.image(f"vendor_{name}_00001_.png")
-                self.handler.process_new_image(path)
-                self.assertIsNone(self.linked_text(path))
-                self.assertEqual(self.handler.awaiting_foreign(), [self.key(path)])
-                with self.assertLogs(LOGGER, "INFO") as logs:
-                    self.seal(path)
-                    self.assertTrue(
-                        self.wait_for(lambda: not self.handler.awaiting_foreign())
-                    )
-                    self.assertTrue(self.settled())
-                self.assertIn(line, "\n".join(logs.output))
-                self.assert_nothing_stored(path)
-
-    def test_q3_an_early_not_saved_never_waits_even_with_a_saver_branch(self):
-        """Review: a switched-off node feeding one branch's positive is the
-        ladder's early, final not_saved (PR 1's #90 rule covers every
-        sampler's positive), so the file never waits and nothing is stored,
-        not even the plain branch the recorded saver names."""
-        graph = shapes.shared_prefix()
-        graph["20"]["inputs"]["text"] = ["50", 0]
-        graph["50"] = {
-            "class_type": "PromptManagerText",
-            "inputs": {"text": OFF_TEXT, "save_to_library": False},
-        }
-        self.metadata = {"prompt": graph}
-        path = self.image("IMG_GEN_00001_.png")
-        with self.assertLogs(LOGGER, "INFO") as logs:
-            self.handler.process_new_image(path)
-        self.assertIn(SKIPPED, "\n".join(logs.output))
-        self.assert_nothing_stored(path)
-        self.seal(path, nodes=("13",))
-        self.assertTrue(self.settled())
-        self.assertIn(SKIPPED, self.recheck(path))
-        self.assert_nothing_stored(path)
-        self.assertIsNone(
-            self.db.get_prompt_by_hash(generate_prompt_hash(shapes.BRANCH_TEXTS[0]))
-        )
-
-    def test_q3_an_off_node_in_the_recorded_saver_branch_is_never_foreign(self):
-        """PR 3's parity case: a switched-off node feeds the very branch the
-        recorded saver names (saver "23" is branch 2). A literal switch is the
-        opted-out path's; a wired one is the node's own run's (#90), never the
-        foreign path's. Nothing is stored at settle or after the run, and no
-        file waits for a foreign re-check."""
-        cases = (
-            ("off", False, "opted_out", SKIPPED),
-            ("wired", ["52", 0], "unknown", "No certain prompt for"),
-        )
-        for name, save, state, line in cases:
-            with self.subTest(name=name):
-                graph = shapes.shared_prefix()
-                graph["50"] = {
-                    "class_type": "PromptManagerText",
-                    "inputs": {"text": OFF_TEXT, "save_to_library": save},
-                }
-                graph["20"]["inputs"]["text"] = ["50", 0]
-                if isinstance(save, list):
-                    graph["52"] = {"class_type": "SomeBoolNode", "inputs": {}}
-                self.metadata = {"prompt": graph}
-                found, _ = self.handler._find_prompt_from_metadata(self.metadata)
-                self.assertEqual(found, state)
-                path = self.image(f"IMG_GEN_{name}_00001_.png")
-                with self.assertLogs(LOGGER, "INFO") as logs:
-                    self.handler.process_new_image(path)
-                self.assertIn(line, "\n".join(logs.output))
-                self.assert_nothing_stored(path)
-                self.seal(path, positives=[OFF_TEXT], nodes=("23",))
-                self.assertTrue(self.settled())
-                self.handler.process_new_image(path)
-                self.assert_nothing_stored(path)
-                self.assertIsNone(
-                    self.db.get_prompt_by_hash(
-                        generate_prompt_hash(shapes.BRANCH_TEXTS[1])
-                    )
-                )
-
-    def test_q4_an_off_node_on_the_negative_only_still_links_the_positive(self):
-        positive = "a lighthouse on a cliff at dusk"
-        plain = sampled_graph(positive, "unused")
-        plain["2"] = {
-            "class_type": "PromptManager",
-            "inputs": {"text": OFF_TEXT, "save_to_library": False},
-        }
-        behind = sampled_graph(positive, "unused")
-        behind["2"]["inputs"]["text"] = ["7", 0]
-        behind["7"] = {
-            "class_type": "PromptManagerText",
-            "inputs": {"text": OFF_TEXT, "save_to_library": False},
-        }
-        for name, graph in (("direct", plain), ("behind an encoder", behind)):
-            with self.subTest(name=name):
-                self.metadata = {"prompt": graph}
-                state, _ = self.handler._find_prompt_from_metadata(self.metadata)
-                self.assertEqual(state, "foreign")
-                path = self.image(f"plain_{len(name)}_00001_.png")
-                self.handler.process_new_image(path)
-                self.assertEqual(self.linked_text(path), positive)
-                self.assertIsNone(
-                    self.db.get_prompt_by_hash(generate_prompt_hash(OFF_TEXT))
-                )
-                pairs = self.db.list_prompt_pairs()["pairs"]
-                self.assertEqual(pairs, [])
-                self.assertEqual(self.handler.awaiting_foreign(), [])
-
-    def test_q5_recorded_history_never_brings_back_switched_off_text(self):
-        """Even a recorded run whose contexts hold the off text (an older
-        history row) cannot name it, at settle or at the re-check."""
-        cases = {"pass-through": off_behind(), "dangling": off_text_unwired()}
-        for name, graph in cases.items():
-            with self.subTest(name=name):
-                self.metadata = {"prompt": graph}
-                path = self.image(f"IMG_GEN_{len(name)}_00001_.png")
-                self.seal(path, positives=[OFF_TEXT], nodes=("9",))
-                self.handler.process_new_image(path)
-                self.assert_nothing_stored(path)
-                self.assertIn(SKIPPED, self.recheck(path))
-                self.assert_nothing_stored(path)
-
-    def test_q6_with_foreign_saving_off_save_to_library_is_unchanged(self):
-        GalleryConfig.SAVE_FOREIGN_RUNS = False
-        opted_out = save_tests.run_graph(save=False)
-        self.metadata = {"prompt": opted_out}
-        skipped = self.image("IMG_GEN_off_00001_.png")
-        with self.assertLogs(LOGGER, "INFO") as logs:
-            self.handler.process_new_image(skipped)
-        self.assertIn(SKIPPED, "\n".join(logs.output))
-        self.metadata = {"prompt": off_behind()}
-        foreign = self.image("IMG_GEN_foreign_00001_.png")
-        with self.assertLogs(LOGGER, "INFO") as logs:
-            self.handler.process_new_image(foreign)
-        self.assertIn("No PromptManager prompt in workflow", "\n".join(logs.output))
-        for path in (skipped, foreign):
-            self.assert_nothing_stored(path)
-        # A switched-on PromptManager positive still links by its metadata
-        stored = self.db.save_prompt(
-            text=save_tests.POSITIVE,
-            prompt_hash=generate_prompt_hash(save_tests.POSITIVE),
-        )
-        self.metadata = {"prompt": save_tests.run_graph(save=True)}
-        on = self.image("IMG_GEN_on_00001_.png")
-        self.handler.process_new_image(on)
-        self.assertEqual(self.linked_text(on), save_tests.POSITIVE)
-        self.assertEqual(
-            self.db.get_prompt_by_hash(generate_prompt_hash(save_tests.POSITIVE))["id"],
-            stored,
-        )
-
-    def test_the_shared_prefix_dataset_still_links_after_the_seal(self):
-        """Regression guard (passes before the fix): the wait still works."""
-        self.metadata = {"prompt": shapes.shared_prefix()}
-        path = self.image("IMG_GEN_00001_.png")
-        self.handler.process_new_image(path)
-        self.assertEqual(self.handler.awaiting_foreign(), [self.key(path)])
-        self.seal(path, nodes=("13",))
-        self.assertTrue(self.wait_for(lambda: self.linked_text(path)))
-        self.assertTrue(self.settled())
-        self.assertEqual(self.linked_text(path), shapes.BRANCH_TEXTS[0])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_hashing.py

@@ -16,11 +16,6 @@ from tests.background_stops import stop_tracker  # noqa: E402
 from utils.hashing import (
     generate_prompt_hash,
     is_duplicate_prompt,
-    STRIPPED_CODE_POINTS,
-    prompt_key,
-    register_prompt_functions,
-    stored_prompt_text,
-    stored_prompt_text_sql,
 )
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -120,96 +115,5 @@ class TestGeneratePromptHashEdgeCases(unittest.TestCase):
         self.assertEqual(len(h), 64)
 
 
-class TestStoredPromptText(unittest.TestCase):
-    """SQLite strips exactly the characters Python's str.strip() does (#438)."""
-
-    WHITESPACE = "".join(c for c in map(chr, range(0x110000)) if c.isspace())
-
-    def sql_strip(self, value):
-        import sqlite3
-
-        conn = sqlite3.connect(":memory:")
-        try:
-            return conn.execute(
-                f"SELECT {stored_prompt_text_sql('?')}", (value,)
-            ).fetchone()[0]
-        finally:
-            conn.close()
-
-    def test_code_points_are_exactly_python_whitespace(self):
-        self.assertEqual("".join(map(chr, STRIPPED_CODE_POINTS)), self.WHITESPACE)
-
-    def test_python_rule_is_the_hash_strip(self):
-        self.assertEqual(stored_prompt_text("  a lighthouse\n"), "a lighthouse")
-        self.assertEqual(
-            generate_prompt_hash(stored_prompt_text(" A b\u3000")),
-            generate_prompt_hash(" A b\u3000"),
-        )
-
-    def test_sql_strips_every_python_whitespace_character(self):
-        for char in self.WHITESPACE:
-            with self.subTest(code=hex(ord(char))):
-                value = f"{char}a{char}b{char}"
-                self.assertEqual(self.sql_strip(value), stored_prompt_text(value))
-        mixed = self.WHITESPACE + "a lighthouse é" + self.WHITESPACE
-        self.assertEqual(self.sql_strip(mixed), "a lighthouse é")
-
-    def test_sql_keeps_what_python_keeps(self):
-        for value in ("\u200ba\u200b", "\ufeffa", "a\u0301", "", "x"):
-            with self.subTest(value=repr(value)):
-                self.assertEqual(self.sql_strip(value), stored_prompt_text(value))
-
-
-class TestPromptKey(unittest.TestCase):
-    """History compares the hash's own key; SQL calls Python for it (#460)."""
-
-    CASES = (
-        "A Lighthouse",
-        " \u00c9t\u00c9\n",
-        "\u03a3\u03a3",
-        "\u0130stanbul",
-        "\u1e9e",
-        "\u212a",
-        "ok",
-    )
-
-    def test_key_is_the_hash_normalization(self):
-        import hashlib
-
-        for value in self.CASES:
-            with self.subTest(value=repr(value)):
-                self.assertEqual(
-                    generate_prompt_hash(value),
-                    hashlib.sha256(prompt_key(value).encode("utf-8")).hexdigest(),
-                )
-        self.assertEqual(prompt_key("  A Lighthouse\n"), "a lighthouse")
-
-    def test_sql_functions_give_pythons_result_where_sql_lower_does_not(self):
-        import sqlite3
-
-        conn = sqlite3.connect(":memory:")
-        try:
-            register_prompt_functions(conn)
-            for value in self.CASES:
-                with self.subTest(value=repr(value)):
-                    key, digest = conn.execute(
-                        "SELECT pm_prompt_key(?), pm_prompt_hash(?)", (value, value)
-                    ).fetchone()
-                    self.assertEqual(key, prompt_key(value))
-                    self.assertEqual(digest, generate_prompt_hash(value))
-            self.assertEqual(
-                conn.execute(
-                    "SELECT pm_prompt_key(1), pm_prompt_hash(NULL)"
-                ).fetchone(),
-                (None, None),
-            )
-            # SQLite's own lower() folds ASCII only
-            self.assertNotEqual(
-                conn.execute("SELECT lower(?)", ("\u00c9",)).fetchone()[0], "\u00e9"
-            )
-        finally:
-            conn.close()
-
-
 if __name__ == "__main__":
     unittest.main()

tests/test_history_reads.py

@@ -9,15 +9,9 @@ from unittest.mock import patch
 
 from database.execution_history import HistoryEpochChanged
 from database.execution_history_schema import history_schema_error
-from utils.execution_contexts import (
-    ContextBundle,
-    RecipeContext,
-    TextEvidence,
-    content_digest,
-)
+from utils.execution_contexts import ContextBundle, RecipeContext, TextEvidence
 from utils.execution_outputs import OutputBundle
 from tests.test_execution_context_database import bundle, snapshot
-from utils.hashing import generate_prompt_hash
 from tests.test_execution_output_database import bundle as outputs
 from tests import test_execution_history_database as history_tests
 
@@ -34,10 +28,6 @@ class HistoryReadTests(unittest.TestCase):
             conn.execute("INSERT INTO prompts(id,text) VALUES(?,?)", (identity, text))
         return identity
 
-    def hashed(self, db, text):
-        """A prompt saved as the nodes save it: with its dedup hash."""
-        return db.save_prompt(text, prompt_hash=generate_prompt_hash(text))
-
     def capture(self, db, item=0, context=None, output=None, time=100):
         start = self.start(db, item, time)
         db.write_execution_start(start)
@@ -156,11 +146,10 @@ class HistoryReadTests(unittest.TestCase):
             )
         self.require_reads(db)
         with db.recorded_history_snapshot():
-            # Outer whitespace (#438) and case (#460) join one scope;
-            # Unicode normalization stays distinct.
-            expected = (5, 5, 5, 5, 1, 1, 2, 2)
-            for i, count in enumerate(expected, 1):
-                self.assertEqual(db.list_history_window(i)["recorded_run_count"], count)
+            for i in range(1, len(values) + 1):
+                self.assertEqual(
+                    db.list_history_window(i)["recorded_run_count"], 2 if i == 1 else 1
+                )
             self.assertIsNone(db.list_history_window(100))
             self.assertIsNone(db.list_history_window(101))
             page = db.list_history_window(99)
@@ -1000,122 +989,3 @@ class HistoryReadTests(unittest.TestCase):
         db.delete_prompt(saved["positive_prompt_id"])
         with db.recorded_history_snapshot():
             self.assertIsNone(db.get_newest_pair_run(saved["positive_prompt_id"], pair))
-
-    def test_outer_whitespace_raw_text_joins_the_stored_prompt_scope(self):
-        # #438: the Library stores text.strip(); the run keeps its raw text.
-        db = self.database()
-        positive = db.save_prompt("a lighthouse")
-        raws = ("a lighthouse\n", "a lighthouse", "　 a lighthouse \t")
-        starts = [
-            self.capture(db, i, bundle(positive=raw), time=100 + i)
-            for i, raw in enumerate(raws)
-        ]
-        self.saved(db, "a lighthouse at dusk", 50)
-        self.capture(db, 9, bundle(positive="a lighthouse at dusk\n"), time=200)
-        with db.recorded_history_snapshot():
-            page = db.list_history_window(positive)
-            first = db.list_history_window(positive, limit=2)
-            rest = db.list_history_window(
-                positive, limit=2, after=first["next_position"]
-            )
-            details = [db.get_history_run(start.run_id) for start in starts]
-        self.assertEqual(page["recorded_run_count"], 3)
-        self.assertEqual(page["group"]["scope_status"], "matched")
-        self.assertEqual(
-            page["group"]["raw_text_id"], content_digest("text", ("a lighthouse",))
-        )
-        self.assertEqual(
-            [r["run_id"] for r in page["items"]], [s.run_id for s in starts]
-        )
-        self.assertTrue(all(r["matching_anchors"] for r in page["items"]))
-        self.assertEqual(len(page["context_summaries"]), 3)
-        self.assertEqual(
-            [r["run_id"] for r in first["items"] + rest["items"]],
-            [s.run_id for s in starts[1:]] + [starts[0].run_id],
-        )
-        for raw, detail in zip(raws, details):
-            context = detail["contexts"][0]
-            self.assertEqual(context["positive"]["raw"], raw)
-            self.assertEqual(
-                context["positive_raw_text_id"], page["group"]["raw_text_id"]
-            )
-            self.assertEqual(context["positive_prompt_id"], positive)
-            self.assertTrue(context["navigation"]["positive_available"])
-
-    def test_newest_pair_run_follows_outer_whitespace_raw_text(self):
-        db = self.database()
-        pair = db.save_prompt_pair("a lighthouse", "fog")
-        positive = db.get_prompt_pair(pair)["positive_prompt_id"]
-        newest = self.capture(
-            db, 0, bundle(" fog\n", positive="a lighthouse\n"), time=100
-        )
-        with db.recorded_history_snapshot():
-            found = db.get_newest_pair_run(positive, pair)
-        self.assertEqual(found["run"]["run_id"], newest.run_id)
-
-    def test_case_variant_raw_text_joins_the_saved_prompt_scope(self):
-        # #460: the hash folds case, so these runs count toward this prompt.
-        db = self.database()
-        positive = self.hashed(db, "\u00e9t\u00e9 lighthouse \u03c3")
-        raws = (
-            "\u00c9T\u00c9 Lighthouse \u03a3\n",
-            "\u00e9t\u00e9 lighthouse \u03c3",
-            " \u00c9t\u00e9 LIGHTHOUSE \u03a3",
-        )
-        starts = [
-            self.capture(db, i, bundle(positive=raw), time=100 + i)
-            for i, raw in enumerate(raws)
-        ]
-        # Unicode normalization and inner text stay distinct
-        self.capture(db, 7, bundle(positive="e\u0301te\u0301 lighthouse \u03c3"))
-        self.capture(db, 8, bundle(positive="\u00e9t\u00e9  lighthouse \u03c3"))
-        dotted = self.hashed(db, "\u0130stanbul")
-        dotted_run = self.capture(db, 9, bundle(positive="\u0130STANBUL"), time=300)
-        with db.recorded_history_snapshot():
-            page = db.list_history_window(positive)
-            details = [db.get_history_run(start.run_id) for start in starts]
-            turkish = db.list_history_window(dotted)
-        self.assertEqual(page["recorded_run_count"], 3)
-        self.assertEqual(
-            [r["run_id"] for r in page["items"]], [s.run_id for s in starts]
-        )
-        for raw, detail in zip(raws, details):
-            context = detail["contexts"][0]
-            self.assertEqual(context["positive"]["raw"], raw)
-            self.assertEqual(
-                context["positive_raw_text_id"], page["group"]["raw_text_id"]
-            )
-            self.assertEqual(context["positive_prompt_id"], positive)
-        self.assertEqual([r["run_id"] for r in turkish["items"]], [dotted_run.run_id])
-
-    def test_newest_pair_run_follows_case_variant_raw_text(self):
-        db = self.database()
-        pair = db.save_prompt_pair("a lighthouse", "fog")
-        positive = db.get_prompt_pair(pair)["positive_prompt_id"]
-        newest = self.capture(db, 0, bundle("FOG", positive="A Lighthouse"), time=100)
-        with db.recorded_history_snapshot():
-            found = db.get_newest_pair_run(positive, pair)
-        self.assertEqual(found["run"]["run_id"], newest.run_id)
-
-    def test_a_position_from_before_460_resumes_the_same_scope(self):
-        db = self.database()
-        positive = self.hashed(db, "A Lighthouse")
-        for i in range(3):
-            self.capture(db, i, bundle(positive="a lighthouse"), time=100 + i)
-        with db.recorded_history_snapshot():
-            first = db.list_history_window(positive, limit=2)
-            position = first["next_position"]
-            legacy = replace(
-                position, raw_text_id=content_digest("text", ("A Lighthouse",))
-            )
-            rest = db.list_history_window(positive, limit=2, after=legacy)
-            with self.assertRaises(ValueError):
-                db.list_history_window(
-                    positive,
-                    after=replace(position, raw_text_id=content_digest("text", ("x",))),
-                )
-        self.assertEqual(first["recorded_run_count"], 3)
-        self.assertEqual(len(rest["items"]), 1)
-        self.assertEqual(
-            rest["group"]["raw_text_id"], content_digest("text", ("a lighthouse",))
-        )

tests/test_image_linking.py

@@ -172,40 +172,17 @@ class TestForeignWorkflows(LinkingTestCase):
         self.tracker.set_current_prompt(text, {"prompt_id": prompt_id})
         return prompt_id
 
-    def _linked_text(self):
-        row = (
-            self.db.model.get_connection()
-            .execute(
-                "SELECT p.text FROM generated_images g "
-                "JOIN prompts p ON p.id = g.prompt_id WHERE g.image_path = ?",
-                (self.image,),
-            )
-            .fetchone()
-        )
-        return row[0] if row else None
-
     def test_foreign_image_leaves_the_batch_queue_aligned(self):
-        """#247: it links to its own prompt and never takes a queue entry."""
         first = self._queue_batch_item("item one")
         self.assertIsNone(self._process({"prompt": foreign_graph()}))
         self.assertEqual(self.linked, [])
         self.assertEqual(self.tracker.pop_next_prompt()["id"], first)
         self.assertIsNone(self.tracker.pop_next_prompt())
-        self.assertEqual(self._linked_text(), "a cat")
-        prompt = self.db.get_prompt_by_hash(generate_prompt_hash("a cat"))
-        self.assertEqual(prompt["run_count"] or 0, 0)
 
-    def test_a_foreign_image_is_linked_only_by_the_ladder(self):
+    def test_foreign_image_is_not_linked_by_the_later_fallbacks_either(self):
         self._queue_batch_item("item one")  # live tracker and recent prompt exist
-        untraceable = foreign_graph()
-        untraceable["9"]["inputs"]["text"] = ["30", 0]
-        untraceable["30"] = {"class_type": "VendorPromptMaker", "inputs": {}}
-        self.assertIsNone(self._process({"prompt": untraceable}))
-        self.assertEqual(self.linked, [])
-        self.assertIsNone(self._linked_text())
         self.assertIsNone(self._process({"prompt": foreign_graph()}))
         self.assertEqual(self.linked, [])
-        self.assertEqual(self._linked_text(), "a cat")
 
     def test_negative_only_workflow_is_foreign(self):
         self._save("blurry")

tests/test_image_monitor_singleton.py

@@ -597,11 +597,6 @@ class TestHandlerScheduling(unittest.TestCase):
             self.handler._schedule_recheck(path)
         self.assertIsNone(self.handler._worker)
         self.assertEqual(list(self.handler._history_due), [])
-        # #247: a foreign file's sealed re-check is dropped the same way
-        self.handler._await_foreign(path)
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        self.handler._schedule_recheck(path, {"filename": "late.png"})
-        self.assertEqual(list(self.handler._foreign_due), [])
         self.assertEqual(self._live_workers() - before, set())
 
     def test_a_sealed_run_starts_a_worker_on_an_open_handler(self):

tests/test_repair_foreign_links.py

@@ -1,951 +0,0 @@
-"""tools/repair_foreign_links.py: the reviewed repair of the #247 dataset links.
-
-The fixture is a library whose foreign (no PromptManager node) dataset run
-wrote shared-prefix files that the old scan linked to the wrong branch text.
-Recorded history names each file's saver, so the ladder (``recorded-run``)
-names the right branch.
-"""
-
-import contextlib
-import hashlib
-import io
-import json
-import os
-import shutil
-import sqlite3
-import tempfile
-import unittest
-import unittest.mock
-from pathlib import Path
-
-from PIL import Image
-from PIL.PngImagePlugin import PngInfo
-
-try:
-    from tests.open_handles import assert_closed
-except ImportError:  # discovered with tests/ as the top-level directory
-    from open_handles import assert_closed
-
-from database.models import PromptModel
-from database.operations import PromptDatabase
-from tests import saver_anchor_graphs as shapes
-from tests.test_run_attribution import RecordedRuns
-from tools import repair_foreign_links as tool
-from utils.file_prompt import Decision
-from utils.hashing import generate_prompt_hash
-
-TEXTS = shapes.BRANCH_TEXTS
-NAME = "IMG_GEN_{:05}_.png"
-
-
-def png(path, graph):
-    info = PngInfo()
-    info.add_text("prompt", json.dumps(graph))
-    Image.new("RGB", (4, 4)).save(path, pnginfo=info)
-
-
-def sha(text):
-    return hashlib.sha256(text.encode("utf-8")).hexdigest()
-
-
-def file_sha(path):
-    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
-
-
-def dump(path):
-    """The database's logical content (independent of WAL checkpoints)."""
-    conn = sqlite3.connect(path)
-    try:
-        return list(conn.iterdump())
-    finally:
-        conn.close()
-
-
-def not_running(_comfyui_dir, _port):
-    return []
-
-
-def no_handles(_database):
-    return []
-
-
-class RepairFixture(RecordedRuns, unittest.TestCase):
-    """Rows: A relink to a new prompt, B relink to a stored prompt (with a
-    pair link), C keep, D file gone, E two savers (skip), F the UNIQUE case
-    (a wrong row beside a correct row), H relink from a rated prompt, G a
-    PromptManager run (not a candidate)."""
-
-    def setUp(self):
-        self.tmp = tempfile.mkdtemp()
-        self.addCleanup(shutil.rmtree, self.tmp, True)
-        self.addCleanup(assert_closed, self, self.tmp)
-        self.addCleanup(PromptModel.reset_schema_cache)
-        self.output = os.path.join(self.tmp, "output")
-        os.makedirs(os.path.join(self.output, "dataset"))
-        self.db_path = os.path.join(self.tmp, "prompts.db")
-        self.plan_path = os.path.join(self.tmp, "plan.json")
-        self.backups = os.path.join(self.tmp, "backups")
-        os.makedirs(self.backups)
-        self.comfy = os.path.join(self.tmp, "comfy")
-        os.makedirs(self.comfy)
-        Path(self.comfy, "main.py").write_text("# ComfyUI\n", encoding="utf-8")
-        self.files = {}
-        for key, number in zip("ABCDEFHG", range(1, 9)):
-            path = os.path.join(self.output, "dataset", NAME.format(number))
-            png(path, shapes.shared_prefix())
-            self.files[key] = path
-        db = PromptDatabase(self.db_path)
-        try:
-            self.build(db)
-        finally:
-            db.close_all()
-        os.remove(self.files["D"])
-
-    def build(self, db):
-        save = lambda text, **kw: db.save_prompt(  # noqa: E731
-            text=text, prompt_hash=generate_prompt_hash(text), **kw
-        )
-        self.p0 = save(TEXTS[0], category="scanned", tags=["auto-scanned"])
-        self.p2 = save(TEXTS[2], category="scanned", tags=["auto-scanned"])
-        self.orphan = save(
-            "an old guess",
-            category="scanned",
-            tags=["auto-scanned"],
-            notes="Auto-scanned from IMG_GEN_00001_.png",
-        )
-        self.rated = save("a rated guess", rating=5)
-        link = lambda prompt, key: db.link_image_to_prompt(  # noqa: E731
-            prompt, self.files[key], metadata={}
-        )
-        self.rows = {
-            "A": link(self.orphan, "A"),
-            "B": link(self.p0, "B"),
-            "C": link(self.p0, "C"),
-            "D": link(self.p0, "D"),
-            "E": link(self.p0, "E"),
-            "F": link(self.p0, "F"),
-            "F_ok": link(self.p2, "F"),
-            "H": link(self.rated, "H"),
-            "G": link(self.p0, "G"),
-        }
-        conn = db.model.get_connection()
-        with conn:
-            pair = conn.execute(
-                "INSERT INTO prompt_pairs(positive_prompt_id) VALUES(?)", (self.p0,)
-            ).lastrowid
-            conn.execute(
-                "INSERT INTO image_prompt_pairs(image_id, pair_id, provenance) "
-                "VALUES(?,?,'{}')",
-                (self.rows["B"], pair),
-            )
-        name = lambda key: ("dataset", os.path.basename(self.files[key]))  # noqa
-        # Savers of the shared-prefix graph: "13", "23", "33", "43" (branches 1-4)
-        self.record_run(
-            db,
-            self.output,
-            [name(k) for k in "CDEAEBFH"],
-            [],
-            nodes=["13", "13", "13", "23", "23", "33", "33", "43"],
-        )
-        self.record_run(db, self.output, [name("G")], [TEXTS[0]], item=1, nodes=["23"])
-
-    def dry_run(self, *args):
-        out = io.StringIO()
-        code = tool.main(
-            [
-                self.db_path,
-                "--output-dir",
-                self.output,
-                "--plan",
-                self.plan_path,
-                *args,
-            ],
-            out=out,
-        )
-        return code, out.getvalue()
-
-    def apply(self, *args, probe=not_running, handles=no_handles):
-        out = io.StringIO()
-        code = tool.main(
-            [
-                self.db_path,
-                "--apply",
-                self.plan_path,
-                "--comfyui-dir",
-                os.path.join(self.tmp, "comfy"),
-                "--backup-dir",
-                self.backups,
-                *args,
-            ],
-            out=out,
-            probe=probe,
-            handles=handles,
-        )
-        return code, out.getvalue()
-
-    def plan(self):
-        with open(self.plan_path, encoding="utf-8") as stream:
-            return json.load(stream)
-
-    def write_plan(self, plan):
-        with open(self.plan_path, "w", encoding="utf-8") as stream:
-            json.dump(plan, stream)
-
-    def query(self, sql, args=()):
-        conn = sqlite3.connect(self.db_path)
-        try:
-            return conn.execute(sql, args).fetchall()
-        finally:
-            conn.close()
-
-    def query_write(self, sql, args):
-        conn = sqlite3.connect(self.db_path)
-        try:
-            with conn:
-                conn.execute(sql, args)
-        finally:
-            conn.close()
-
-    def links(self):
-        return dict(self.query("SELECT id, prompt_id FROM generated_images"))
-
-
-class DryRunTests(RepairFixture):
-    def test_plan_names_relink_keep_and_skip_rows(self):
-        code, out = self.dry_run()
-        self.assertEqual(code, 0, out)
-        items = {item["row_id"]: item for item in self.plan()["rows"]}
-        rows = self.rows
-        self.assertNotIn(rows["G"], items, "a PromptManager run is not foreign")
-        actions = {key: items[rows[key]]["action"] for key in rows if key != "G"}
-        self.assertEqual(
-            actions,
-            {
-                "A": "relink",
-                "B": "relink",
-                "C": "keep",
-                "D": "skip",
-                "E": "skip",
-                "F": "relink",
-                "F_ok": "keep",
-                "H": "relink",
-            },
-        )
-        a = items[rows["A"]]
-        self.assertEqual(a["current_prompt_id"], self.orphan)
-        self.assertEqual(a["current_text_sha256"], sha("an old guess"))
-        self.assertEqual(a["target_text"], TEXTS[1])
-        self.assertEqual(a["target_hash"], generate_prompt_hash(TEXTS[1]))
-        self.assertEqual(a["target_prompt_id"], "new")
-        self.assertEqual(a["file"], self.files["A"])
-        self.assertEqual(items[rows["B"]]["target_prompt_id"], self.p2)
-        self.assertEqual(items[rows["H"]]["target_prompt_id"], "new")
-        self.assertEqual(items[rows["D"]]["reason"], "file gone")
-        self.assertEqual(
-            items[rows["E"]]["reason"], "not decided by the recorded saver"
-        )
-        self.assertIn("relink: 4", out)
-        self.assertIn("keep: 2", out)
-        self.assertIn("skip: 2", out)
-
-    def test_orphan_audit_lists_the_prompts_losing_every_link(self):
-        self.dry_run()
-        plan = self.plan()
-        orphans = {o["id"]: o for o in plan["orphans"]}
-        self.assertEqual(set(orphans), {self.orphan, self.rated})
-        self.assertEqual(orphans[self.orphan]["blockers"], [])
-        self.assertTrue(orphans[self.orphan]["safe"])
-        self.assertEqual(orphans[self.rated]["blockers"], ["usage or rating"])
-        self.assertFalse(orphans[self.rated]["safe"])
-        self.assertFalse(plan["delete_orphans"], "off by default")
-        self.dry_run("--delete-orphans")
-        self.assertTrue(self.plan()["delete_orphans"])
-
-    def test_dry_run_writes_nothing_and_writes_the_markdown_list(self):
-        before = file_sha(self.db_path)
-        listing = sorted(os.listdir(self.tmp))
-        code, out = self.dry_run()
-        self.assertEqual(code, 0)
-        self.assertEqual(file_sha(self.db_path), before)
-        self.assertIn("Dry run: nothing was changed.", out)
-        # A read-only reader of a WAL library may leave its empty side files
-        sidecars = {"prompts.db-shm", "prompts.db-wal"}
-        self.assertEqual(
-            sorted(set(os.listdir(self.tmp)) - sidecars),
-            sorted(set(listing + ["plan.json", "plan.list.md"]) - sidecars),
-        )
-        wal = Path(self.tmp, "prompts.db-wal")
-        self.assertEqual(wal.stat().st_size if wal.exists() else 0, 0)
-        markdown = Path(self.tmp, "plan.list.md").read_text(encoding="utf-8")
-        self.assertIn(f"| {self.rows['A']} |", markdown)
-        long_path = os.path.join("dataset", NAME.format(1))
-        self.assertIn(f"| {long_path} |", markdown, "file paths are never cut")
-        self.assertIn(generate_prompt_hash(TEXTS[1])[:12], markdown)
-        self.assertIn("new", markdown)
-        self.assertIn("would lose every link", markdown)
-
-
-class DryRunReviewTests(RepairFixture):
-    def test_plan_records_its_library_and_fingerprint(self):
-        self.dry_run()
-        plan = self.plan()
-        self.assertEqual(
-            plan["source_db"], os.path.normcase(os.path.realpath(self.db_path))
-        )
-        self.assertEqual(plan["max_row_id"], max(self.links()))
-
-    def test_a_markdown_plan_path_is_refused(self):
-        out = io.StringIO()
-        with (
-            self.assertRaises(SystemExit),
-            contextlib.redirect_stderr(io.StringIO()),
-        ):
-            tool.main(
-                [
-                    self.db_path,
-                    "--output-dir",
-                    self.output,
-                    "--plan",
-                    os.path.join(self.tmp, "plan.md"),
-                ],
-                out=out,
-            )
-        self.assertFalse(os.path.exists(os.path.join(self.tmp, "plan.md")))
-
-    def test_keep_compares_the_linked_text_not_the_stored_hash(self):
-        self.query_write("UPDATE prompts SET hash='stale' WHERE id=?", (self.p0,))
-        self.dry_run()
-        items = {item["row_id"]: item for item in self.plan()["rows"]}
-        self.assertEqual(items[self.rows["C"]]["action"], "keep")
-
-    def test_delete_orphans_is_rehearsed_with_the_deletes(self):
-        code, out = self.dry_run("--delete-orphans")
-        self.assertEqual(code, 0, out)
-        simulated = self.plan()["simulated"]
-        self.assertEqual(simulated["result"]["orphans_deleted"], 1)
-        self.assertEqual(
-            simulated["after"]["prompts"], simulated["before"]["prompts"] + 2 - 1
-        )
-
-    def test_a_file_on_another_drive_is_listed_by_its_full_path(self):
-        self.dry_run()
-        plan = self.plan()
-        with unittest.mock.patch.object(
-            tool.os.path, "relpath", side_effect=ValueError("other drive")
-        ):
-            listing = tool.markdown(plan, {})
-        self.assertIn(self.files["A"], listing)
-
-
-class ApplyTests(RepairFixture):
-    def setUp(self):
-        super().setUp()
-        code, out = self.dry_run()
-        self.assertEqual(code, 0, out)
-
-    def test_apply_relinks_creates_targets_and_drops_pair_links(self):
-        code, out = self.apply()
-        self.assertEqual(code, 0, out)
-        links = self.links()
-        new = dict(self.query("SELECT hash, id FROM prompts"))
-        target_a = new[generate_prompt_hash(TEXTS[1])]
-        target_h = new[generate_prompt_hash(TEXTS[3])]
-        self.assertEqual(links[self.rows["A"]], target_a)
-        self.assertEqual(links[self.rows["B"]], self.p2)
-        self.assertEqual(links[self.rows["H"]], target_h)
-        self.assertEqual(links[self.rows["C"]], self.p0, "keep")
-        self.assertEqual(links[self.rows["E"]], self.p0, "skip")
-        self.assertEqual(links[self.rows["G"]], self.p0, "not foreign")
-        self.assertEqual(
-            self.query(
-                "SELECT COUNT(*) FROM image_prompt_pairs WHERE image_id=?",
-                (self.rows["B"],),
-            ),
-            [(0,)],
-        )
-        category, notes = self.query(
-            "SELECT category, notes FROM prompts WHERE id=?", (target_a,)
-        )[0]
-        self.assertEqual(category, "scanned")
-        self.assertEqual(
-            notes, f"Auto-scanned from {os.path.basename(self.files['A'])}"
-        )
-        tags = self.query(
-            "SELECT t.name FROM prompt_tags pt JOIN tags t ON t.id=pt.tag_id "
-            "WHERE pt.prompt_id=?",
-            (target_a,),
-        )
-        self.assertEqual(tags, [("auto-scanned",)])
-        self.assertIn("integrity_check", out)
-        self.assertIn("foreign_key_check", out)
-        self.assertRegex(out, r"integrity_check\s+ok\s+ok")
-        # Orphans are kept unless the plan chose to delete them
-        self.assertTrue(self.query("SELECT 1 FROM prompts WHERE id=?", (self.orphan,)))
-
-    def test_unique_case_deletes_the_wrong_row(self):
-        code, out = self.apply()
-        self.assertEqual(code, 0, out)
-        links = self.links()
-        self.assertNotIn(self.rows["F"], links)
-        self.assertEqual(links[self.rows["F_ok"]], self.p2)
-        rows = self.query(
-            "SELECT prompt_id FROM generated_images WHERE image_path=?",
-            (self.files["F"],),
-        )
-        self.assertEqual(rows, [(self.p2,)])
-
-    def test_backup_is_taken_before_writing(self):
-        before = self.links()
-        code, out = self.apply()
-        self.assertEqual(code, 0, out)
-        names = os.listdir(self.backups)
-        self.assertEqual(len(names), 1)
-        self.assertRegex(names[0], r"^prompts\.db\.pre-247-repair_\d{8}_\d{6}$")
-        backup = os.path.join(self.backups, names[0])
-        conn = sqlite3.connect(backup)
-        try:
-            saved = dict(conn.execute("SELECT id, prompt_id FROM generated_images"))
-        finally:
-            conn.close()
-        self.assertEqual(saved, before)
-        self.assertIn(f"Backup: {backup}", out)
-
-    def test_backup_beside_the_database_by_default(self):
-        out = io.StringIO()
-        code = tool.main(
-            [
-                self.db_path,
-                "--apply",
-                self.plan_path,
-                "--comfyui-dir",
-                os.path.join(self.tmp, "comfy"),
-            ],
-            out=out,
-            probe=not_running,
-            handles=no_handles,
-        )
-        self.assertEqual(code, 0, out.getvalue())
-        self.assertTrue(
-            any(
-                n.startswith("prompts.db.pre-247-repair_") for n in os.listdir(self.tmp)
-            )
-        )
-
-    def test_refuses_while_comfyui_runs(self):
-        before = file_sha(self.db_path)
-        code, out = self.apply(probe=lambda _d, _p: ["process 42 (main.py)"])
-        self.assertEqual(code, 2)
-        self.assertIn("REFUSED", out)
-        self.assertIn("process 42", out)
-        self.assertEqual(os.listdir(self.backups), [], "no backup either")
-        self.assertEqual(file_sha(self.db_path), before)
-
-    def test_rehearsal_skips_the_running_check_on_a_copy_only(self):
-        code, out = self.apply("--rehearsal", probe=lambda _d, _p: ["port 8188"])
-        self.assertEqual(code, 0, out)
-        self.assertIn("rehearsal", out)
-        # The live library of that ComfyUI folder: --rehearsal is refused
-        live_dir = os.path.join(self.tmp, "comfy", "user", "__promptmanager")
-        os.makedirs(live_dir)
-        live = os.path.join(live_dir, "prompts.db")
-        shutil.copy(self.db_path, live)
-        out = io.StringIO()
-        code = tool.main(
-            [
-                live,
-                "--apply",
-                self.plan_path,
-                "--comfyui-dir",
-                os.path.join(self.tmp, "comfy"),
-                "--rehearsal",
-            ],
-            out=out,
-            probe=lambda _d, _p: [],
-            handles=no_handles,
-        )
-        self.assertEqual(code, 2)
-        self.assertIn("--rehearsal", out.getvalue())
-
-    def test_drift_refuses_and_changes_nothing(self):
-        cases = {
-            "row moved": lambda: self.query_write(
-                "UPDATE generated_images SET prompt_id=? WHERE id=?",
-                (self.p2, self.rows["H"]),
-            ),
-            "text changed": lambda: self.query_write(
-                "UPDATE prompts SET text='an older guess' WHERE id=?", (self.orphan,)
-            ),
-            "file changed": lambda: png(self.files["B"], shapes.branch_bench()),
-            "target stored since": lambda: self.query_write(
-                "INSERT INTO prompts(text, hash) VALUES(?,?)",
-                (TEXTS[1], generate_prompt_hash(TEXTS[1])),
-            ),
-        }
-        pristine = os.path.join(self.tmp, "pristine.db")
-        shutil.copy(self.db_path, pristine)
-        image = Path(self.files["B"]).read_bytes()
-        for name, drift in cases.items():
-            with self.subTest(name):
-                shutil.copy(pristine, self.db_path)
-                Path(self.files["B"]).write_bytes(image)
-                shutil.rmtree(self.backups)
-                os.makedirs(self.backups)
-                drift()
-                before = dump(self.db_path)
-                code, out = self.apply()
-                self.assertEqual(code, 2, out)
-                self.assertIn("REFUSED (rolled back, nothing changed)", out)
-                self.assertEqual(dump(self.db_path), before)
-
-    def test_late_failure_rolls_back_every_write(self):
-        plan = self.plan()
-        plan["delete_orphans"] = True
-        self.write_plan(plan)
-        # The safe orphan gained a user tag after the dry run
-        self.query_write("INSERT INTO tags(name) VALUES('mine')", ())
-        self.query_write(
-            "INSERT INTO prompt_tags(prompt_id, tag_id) "
-            "SELECT ?, id FROM tags WHERE name='mine'",
-            (self.orphan,),
-        )
-        before = self.links()
-        prompts = self.query("SELECT COUNT(*) FROM prompts")
-        code, out = self.apply()
-        self.assertEqual(code, 2, out)
-        self.assertIn(f"prompt {self.orphan}", out)
-        self.assertIn("user tags", out)
-        self.assertEqual(self.links(), before, "the relinks were rolled back")
-        self.assertEqual(self.query("SELECT COUNT(*) FROM prompts"), prompts)
-
-    def test_orphans_are_deleted_only_when_chosen_and_unreferenced(self):
-        plan = self.plan()
-        plan["delete_orphans"] = True
-        self.write_plan(plan)
-        code, out = self.apply()
-        self.assertEqual(code, 0, out)
-        self.assertFalse(self.query("SELECT 1 FROM prompts WHERE id=?", (self.orphan,)))
-        self.assertTrue(
-            self.query("SELECT 1 FROM prompts WHERE id=?", (self.rated,)),
-            "a prompt with a rating is never deleted",
-        )
-        self.assertIn("orphans_deleted", out)
-
-    def test_an_applied_plan_refuses_a_second_time(self):
-        self.assertEqual(self.apply()[0], 0)
-        before = dump(self.db_path)
-        code, out = self.apply()
-        self.assertEqual(code, 2)
-        self.assertIn("REFUSED", out)
-        self.assertEqual(dump(self.db_path), before)
-
-
-class ApplySafetyTests(RepairFixture):
-    def setUp(self):
-        super().setUp()
-        code, out = self.dry_run()
-        self.assertEqual(code, 0, out)
-
-    def assert_unchanged(self, before, code, out):
-        self.assertEqual(code, 2, out)
-        self.assertEqual(dump(self.db_path), before)
-
-    def test_refuses_when_another_process_has_the_library_open(self):
-        before = dump(self.db_path)
-        held = lambda _db: ["process 7 has prompts.db-wal open"]  # noqa: E731
-        for args in ((), ("--rehearsal",)):
-            with self.subTest(args):
-                code, out = self.apply(*args, handles=held)
-                self.assert_unchanged(before, code, out)
-                self.assertIn("process 7", out)
-        self.assertEqual(os.listdir(self.backups), [])
-
-    def test_the_running_check_runs_again_just_before_writing(self):
-        calls = []
-
-        def late(_d, _p):
-            calls.append(1)
-            return [] if len(calls) == 1 else ["something listens on port 8188"]
-
-        before = dump(self.db_path)
-        code, out = self.apply(probe=late)
-        self.assert_unchanged(before, code, out)
-        self.assertEqual(len(calls), 2)
-        self.assertIn("rolled back", out)
-        self.assertIn("Backup:", out)
-
-    def test_without_proc_only_an_explicit_stop_lets_it_through(self):
-        blind = lambda _db: [tool.NO_PROC]  # noqa: E731
-        before = dump(self.db_path)
-        code, out = self.apply(handles=blind)
-        self.assert_unchanged(before, code, out)
-        self.assertIn("--i-stopped-comfyui", out)
-        code, out = self.apply("--i-stopped-comfyui", handles=blind)
-        self.assertEqual(code, 0, out)
-
-    def test_a_folder_without_main_py_is_refused(self):
-        os.remove(os.path.join(self.comfy, "main.py"))
-        before = dump(self.db_path)
-        code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("main.py", out)
-
-    def test_a_plan_for_another_library_is_refused(self):
-        other = os.path.join(self.tmp, "other.db")
-        shutil.copy(self.db_path, other)
-        out = io.StringIO()
-        code = tool.main(
-            [other, "--apply", self.plan_path, "--comfyui-dir", self.comfy],
-            out=out,
-            probe=not_running,
-            handles=no_handles,
-        )
-        self.assertEqual(code, 2)
-        self.assertIn("made for", out.getvalue())
-
-    def test_opening_the_library_must_not_change_its_schema(self):
-        self.query_write("DROP INDEX idx_prompt_pairs_positive_only", ())
-        PromptModel.reset_schema_cache()
-        code, out = self.apply()
-        self.assertEqual(code, 2, out)
-        self.assertIn("schema", out)
-        self.assertIn("live code version", out)
-
-    def test_an_existing_backup_file_is_refused(self):
-        stamp = "20261028_000000"
-        Path(self.backups, f"prompts.db.pre-247-repair_{stamp}").write_bytes(b"x")
-        before = dump(self.db_path)
-        with unittest.mock.patch.object(tool, "_stamp", return_value=stamp):
-            code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("already exists", out)
-
-    def test_a_backup_that_does_not_match_is_refused(self):
-        real = tool.backup_database
-
-        def short(source, target):
-            real(source, target)
-            conn = sqlite3.connect(target)
-            try:
-                with conn:
-                    conn.execute("DELETE FROM image_prompt_pairs")
-            finally:
-                conn.close()
-
-        before = dump(self.db_path)
-        with unittest.mock.patch.object(tool, "backup_database", short):
-            code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("backup", out)
-
-    def test_a_changed_target_text_is_refused(self):
-        plan = self.plan()
-        for item in plan["rows"]:
-            if item["row_id"] == self.rows["A"]:
-                item["target_text"] = "something else"
-        self.write_plan(plan)
-        before = dump(self.db_path)
-        code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("target_text", out)
-
-    def test_an_orphan_gone_or_changed_at_apply_is_refused(self):
-        plan = self.plan()
-        plan["delete_orphans"] = True
-        plan["orphans"][0]["text_sha256"] = "0" * 64
-        self.write_plan(plan)
-        before = dump(self.db_path)
-        code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("gone or text changed", out)
-
-    def test_any_error_rolls_back_and_names_the_backup(self):
-        before = dump(self.db_path)
-        with unittest.mock.patch.object(
-            tool, "_relink", side_effect=RuntimeError("disk on fire")
-        ):
-            code, out = self.apply()
-        self.assert_unchanged(before, code, out)
-        self.assertIn("rolled back", out)
-        self.assertIn("disk on fire", out)
-        self.assertIn(self.backups, out)
-
-    def test_a_failed_integrity_check_after_writing_exits_1(self):
-        real = tool.counts
-        seen = []
-
-        def counts(path, readonly=True):
-            found = real(path, readonly)
-            if path == self.db_path:
-                seen.append(path)
-                if len(seen) > 1:
-                    return {**found, "integrity_check": "corrupt"}
-            return found
-
-        with unittest.mock.patch.object(tool, "counts", counts):
-            code, out = self.apply()
-        self.assertEqual(code, 1, out)
-        self.assertIn("restore", out)
-
-
-class BlockerTests(RepairFixture):
-    """Each reference that keeps a prompt from being deleted."""
-
-    def test_every_blocker(self):
-        pid = self.orphan
-        cases = {
-            "linked images": None,
-            "saved pairs": "INSERT INTO prompt_pairs(positive_prompt_id) VALUES(:id)",
-            "recorded runs": "UPDATE execution_run_contexts "
-            "SET positive_prompt_id=:id",
-            "library state": "INSERT INTO prompt_library_state(prompt_id) "
-            "VALUES(:id)",
-            "user tags": "INSERT INTO prompt_tags(prompt_id, tag_id) "
-            "SELECT :id, id FROM tags WHERE name='mine'",
-            "usage or rating": "UPDATE prompts SET run_count=3 WHERE id=:id",
-            "category": "UPDATE prompts SET category='portraits' WHERE id=:id",
-            "notes": "UPDATE prompts SET notes='mine' WHERE id=:id",
-        }
-        conn = sqlite3.connect(self.db_path)
-        try:
-            conn.execute("INSERT INTO tags(name) VALUES('mine')")
-            conn.commit()
-            for name, sql in cases.items():
-                with self.subTest(name):
-                    conn.execute("SAVEPOINT blocker")
-                    if sql is None:
-                        unused = {pid}
-                    else:
-                        conn.execute(
-                            "DELETE FROM generated_images WHERE prompt_id=?", (pid,)
-                        )
-                        conn.execute(sql, {"id": pid})
-                        unused = {pid}
-                    found = tool.blockers(conn, pid, unused)
-                    self.assertTrue(any(item.startswith(name) for item in found), found)
-                    conn.execute("ROLLBACK TO blocker")
-                    conn.execute("RELEASE blocker")
-            conn.execute("DELETE FROM generated_images WHERE prompt_id=?", (pid,))
-            self.assertEqual(tool.blockers(conn, pid, {pid}), [])
-            self.assertEqual(
-                tool.blockers(conn, pid, set()), ["not unused by the app's rule"]
-            )
-            conn.rollback()
-        finally:
-            conn.close()
-
-
-def _off_text_node(text, save=False):
-    return {
-        "class_type": "PromptManagerText",
-        "inputs": {"text": text, "save_to_library": save},
-    }
-
-
-def _encode_from(source):
-    return {
-        "class_type": "CLIPTextEncode",
-        "inputs": {"text": source, "clip": ["1", 1]},
-    }
-
-
-def off_behind_pass_through(branch=2):
-    """The dataset graph with ``branch``'s text coming from a switched-off
-    PromptManagerText through a pass-through the #90 walk does not follow."""
-    graph = shapes.shared_prefix()
-    graph["50"] = _off_text_node(TEXTS[branch - 1])
-    graph["51"] = {"class_type": "MyNode", "inputs": {"value": ["50", 0]}}
-    graph[str(branch * 10)] = _encode_from(["51", 0])
-    return graph
-
-
-def off_target(branch=2, save=False):
-    """``branch``'s text straight from a PromptManagerText whose switch is
-    ``save`` (False, or a link to a node the graph cannot read)."""
-    graph = shapes.shared_prefix()
-    graph["50"] = _off_text_node(TEXTS[branch - 1], save)
-    graph[str(branch * 10)] = _encode_from(["50", 0])
-    if isinstance(save, list):
-        graph["52"] = {"class_type": "SomeBoolNode", "inputs": {}}
-    return graph
-
-
-def off_negative_only():
-    """Every branch's negative from a switched-off PromptManagerText."""
-    graph = shapes.shared_prefix()
-    graph["50"] = _off_text_node(shapes.NEGATIVE)
-    graph["3"] = _encode_from(["50", 0])
-    return graph
-
-
-class SaveToLibraryTests(RecordedRuns, unittest.TestCase):
-    """#90: the repair never relinks a file to a switched-off node's text.
-
-    The plan decides each file through ``decide_file_prompt``; every answer
-    but a positive from the recorded saver or the inspector is a skip, so a
-    ``not_saved`` or ``not_saved_wired`` file is never written. Each file is
-    reported by a run without contexts (as a cached or unrecorded run is),
-    so only the ladder can stop it. Saver "23" is branch 2.
-    """
-
-    def setUp(self):
-        self.tmp = tempfile.mkdtemp()
-        self.addCleanup(shutil.rmtree, self.tmp, True)
-        self.addCleanup(assert_closed, self, self.tmp)
-        self.addCleanup(PromptModel.reset_schema_cache)
-        self.output = os.path.join(self.tmp, "output")
-        os.makedirs(os.path.join(self.output, "dataset"))
-        self.db_path = os.path.join(self.tmp, "prompts.db")
-
-    def plan_for(self, graph):
-        path = os.path.join(self.output, "dataset", NAME.format(1))
-        png(path, graph)
-        db = PromptDatabase(self.db_path)
-        try:
-            wrong = db.save_prompt(
-                text=TEXTS[0], prompt_hash=generate_prompt_hash(TEXTS[0])
-            )
-            db.link_image_to_prompt(wrong, path, metadata={})
-            self.record_run(
-                db, self.output, [("dataset", NAME.format(1))], [], nodes=["23"]
-            )
-            plan = tool.build_plan(db, self.output, self.db_path)
-        finally:
-            db.close_all()
-        (item,) = plan["rows"]
-        return item
-
-    def test_an_off_node_behind_a_pass_through_is_skipped(self):
-        item = self.plan_for(off_behind_pass_through())
-        self.assertEqual(item["action"], "skip")
-        self.assertEqual(item["decision"], "not_saved/none")
-        self.assertNotIn("target_text", item)
-
-    def test_an_off_node_in_the_recorded_run_target_is_skipped(self):
-        cases = {
-            "off": (False, "not_saved/none"),
-            "wired": (["52", 0], "not_saved_wired/none"),
-        }
-        for name, (save, decision) in cases.items():
-            with self.subTest(name):
-                if os.path.exists(self.db_path):
-                    os.remove(self.db_path)
-                item = self.plan_for(off_target(save=save))
-                self.assertEqual(item["action"], "skip")
-                self.assertEqual(item["decision"], decision)
-
-    def test_an_off_node_on_another_branch_still_skips_the_file(self):
-        """The ladder judges the file's whole graph: any switched-off text
-        upstream of a positive makes the file not saved."""
-        item = self.plan_for(off_target(branch=3))
-        self.assertEqual(item["action"], "skip")
-        self.assertEqual(item["decision"], "not_saved/none")
-
-    def test_an_off_node_wired_only_to_the_negative_still_repairs(self):
-        item = self.plan_for(off_negative_only())
-        self.assertEqual(item["action"], "relink")
-        self.assertEqual(item["source"], "recorded-run")
-        self.assertEqual(item["target_text"], TEXTS[1])
-
-    def test_a_switched_on_node_in_the_target_still_repairs(self):
-        """Regression guard: a switch that is on is no reason to skip."""
-        item = self.plan_for(off_target(save=True))
-        self.assertEqual(item["action"], "relink")
-        self.assertEqual(item["target_text"], TEXTS[1])
-
-
-class ActionTests(unittest.TestCase):
-    """Only the recorded saver relinks; a certain step naming the linked
-    prompt keeps it; the legacy floor and the rest are skipped."""
-
-    def test_action_by_decision(self):
-        linked = generate_prompt_hash("linked")
-        cases = [
-            (Decision("positive", "other", source="recorded-run"), "relink"),
-            (Decision("positive", "linked", source="recorded-run"), "keep"),
-            (Decision("positive", "linked", source="inspector"), "keep"),
-            (Decision("positive", "other", source="inspector"), "skip"),
-            (Decision("positive", "linked", source="legacy-parser"), "skip"),
-            (Decision("pair", "linked", source="resolver"), "skip"),
-            (Decision("never"), "skip"),
-            (Decision("not_saved"), "skip"),
-            (Decision("not_saved_wired"), "skip"),
-            (Decision("positive", "other", source="opted-out-negative"), "skip"),
-        ]
-        for decision, action in cases:
-            with self.subTest(decision.source, text=decision.text):
-                self.assertEqual(tool.action_of(decision, linked), action)
-
-
-class CommandLineTests(unittest.TestCase):
-    def test_running_probe_reports_a_listening_port(self):
-        import socket
-
-        with socket.socket() as server:
-            server.bind(("127.0.0.1", 0))
-            server.listen(1)
-            port = server.getsockname()[1]
-            found = tool.comfyui_running("/nonexistent/comfy", port)
-        self.assertTrue(any(str(port) in item for item in found))
-
-    def test_running_probe_is_quiet_when_nothing_runs(self):
-        import socket
-
-        with socket.socket() as probe:
-            probe.bind(("127.0.0.1", 0))
-            port = probe.getsockname()[1]
-        self.assertEqual(tool.comfyui_running("/nonexistent/comfy", port), [])
-
-    def fake_proc(self, tmp):
-        proc = Path(tmp, "proc")
-        db = Path(tmp, "prompts.db")
-        db.write_bytes(b"")
-        Path(tmp, "prompts.db-wal").write_bytes(b"")
-        comfy = Path(tmp, "comfy")
-        comfy.mkdir()
-        holder = proc / "125" / "fd"
-        holder.mkdir(parents=True)
-        os.symlink(Path(tmp, "prompts.db-wal"), holder / "3")
-        (proc / "125" / "cmdline").write_bytes(b"python\0main.py\0")
-        os.symlink(comfy, proc / "125" / "cwd")
-        (proc / "123").mkdir()  # unreadable: no fd, cmdline or cwd
-        (proc / "self").mkdir()  # not a pid
-        return proc, db, comfy
-
-    @unittest.skipIf(os.name == "nt", "symlinks need privileges on Windows")
-    def test_proc_scan_finds_holders_and_skips_unreadable_entries(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            proc, db, comfy = self.fake_proc(tmp)
-            found = tool.open_by_others(str(db), proc=str(proc), own_pid=1)
-            self.assertEqual(len(found), 1)
-            self.assertIn("125", found[0])
-            self.assertEqual(
-                tool.open_by_others(str(db), proc=str(proc), own_pid=125), []
-            )
-            running = tool.comfyui_running(str(comfy), 1, proc=str(proc))
-            self.assertTrue(any("125" in item for item in running), running)
-
-    def test_without_proc_the_scan_says_it_cannot_tell(self):
-        self.assertEqual(
-            tool.open_by_others("/x/prompts.db", proc="/nonexistent/proc"),
-            [tool.NO_PROC],
-        )
-
-    def test_missing_database_is_an_argument_error(self):
-        with self.assertRaises(SystemExit), contextlib.redirect_stderr(io.StringIO()):
-            tool.main(
-                ["/nonexistent/prompts.db", "--output-dir", "/tmp"], out=io.StringIO()
-            )
-
-    def test_apply_needs_the_comfyui_folder(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            db = os.path.join(tmp, "prompts.db")
-            Path(db).write_bytes(b"")
-            with (
-                self.assertRaises(SystemExit),
-                contextlib.redirect_stderr(io.StringIO()),
-            ):
-                tool.main([db, "--apply", "plan.json"], out=io.StringIO())
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_run_attribution.py

@@ -33,7 +33,6 @@ from utils.execution_outputs import (
     snapshot_output_roots,
 )
 from utils.hashing import generate_prompt_hash
-from py.config import GalleryConfig
 from utils.image_monitor import ImageGenerationHandler
 
 STYLE = "windows" if os.name == "nt" else "posix"
@@ -772,470 +771,6 @@ class TestMonitorHistoryRecheck(RecordedRuns, unittest.TestCase):
         run_attribution.notify_outputs_sealed("run", [])  # no dead callback raises
 
 
-class TestMonitorForeignRuns(RecordedRuns, unittest.TestCase):
-    """#247: outputs of workflows without a PromptManager node, in the monitor."""
-
-    def setUp(self):
-        history_tests.HistoryDatabaseTests.setUp(self)
-        self.db = history_tests.HistoryDatabaseTests.database(self)
-        self.output = str(Path(self.temp.name) / "output")
-        os.makedirs(os.path.join(self.output, "dataset"))
-        self.tracker = make_tracker(self.db)
-        self.handler = ImageGenerationHandler(self.db, self.tracker)
-        self.handler.processing_delay = 0
-        self.handler.settle_interval = 0.01
-        self.addCleanup(close_handler, self, self.handler)
-        self.metadata = {"prompt": shapes.shared_prefix()}
-        saved = GalleryConfig.SAVE_FOREIGN_RUNS
-        self.addCleanup(setattr, GalleryConfig, "SAVE_FOREIGN_RUNS", saved)
-        GalleryConfig.SAVE_FOREIGN_RUNS = True
-        patches = (
-            mock.patch(
-                "utils.image_monitor.host_output_directory", return_value=self.output
-            ),
-            mock.patch(
-                "database.run_attribution.host_output_directory",
-                return_value=self.output,
-            ),
-            mock.patch.object(
-                self.handler.metadata_extractor,
-                "extract_metadata",
-                side_effect=lambda path: self.metadata,
-            ),
-        )
-        for patch in patches:
-            patch.start()
-            self.addCleanup(patch.stop)
-
-    close_databases = history_tests.HistoryDatabaseTests.close_databases
-    wait_for = TestMonitorHistoryRecheck.wait_for
-
-    def image(self, name, subfolder="dataset"):
-        path = os.path.join(self.output, subfolder, name)
-        Path(path).write_bytes(b"png")
-        return path
-
-    def linked_text(self, path):
-        row = (
-            self.db.model.get_connection()
-            .execute(
-                "SELECT p.text FROM generated_images g "
-                "JOIN prompts p ON p.id = g.prompt_id WHERE g.image_path = ?",
-                (str(path),),
-            )
-            .fetchone()
-        )
-        return row[0] if row else None
-
-    def key(self, path):
-        return self.handler._awaiting_key(path)
-
-    def prompt_count(self):
-        connection = self.db.model.get_connection()
-        return connection.execute("SELECT COUNT(*) FROM prompts").fetchone()[0]
-
-    def settled(self):
-        return self.wait_for(lambda: self.handler.pending_count() == 0)
-
-    def test_each_dataset_file_links_to_its_branch_once_the_run_ends(self):
-        """CUJ 1: unlinked while the run is open, its own branch after the seal."""
-        paths = [self.image(f"IMG_GEN_0000{n}_.png") for n in (1, 2)]
-        for path in paths:
-            self.handler.process_new_image(path)
-        self.assertEqual([self.linked_text(path) for path in paths], [None, None])
-        self.assertEqual(
-            self.handler.awaiting_foreign(), [self.key(path) for path in paths]
-        )
-        self.assertEqual(self.handler.awaiting_history(), [])
-        self.record_run(
-            self.db,
-            self.output,
-            [("dataset", os.path.basename(path)) for path in paths],
-            [],
-            nodes=["13", "23"],
-        )
-        self.assertTrue(self.wait_for(lambda: all(map(self.linked_text, paths))))
-        self.assertTrue(self.settled())
-        self.assertEqual(
-            [self.linked_text(path) for path in paths], list(shapes.BRANCH_TEXTS[:2])
-        )
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        prompt = self.db.get_prompt_by_hash(
-            generate_prompt_hash(shapes.BRANCH_TEXTS[0])
-        )
-        self.assertEqual(prompt["category"], "scanned")
-        self.assertIn("Saved from a workflow run: IMG_GEN_00001_.png", prompt["notes"])
-
-    def test_a_run_sealed_before_the_file_settles_links_it_at_once(self):
-        path = self.image("IMG_GEN_00003_.png")
-        self.record_run(
-            self.db, self.output, [("dataset", "IMG_GEN_00003_.png")], [], nodes=["33"]
-        )
-        self.handler.process_new_image(path)
-        self.assertEqual(self.linked_text(path), shapes.BRANCH_TEXTS[2])
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-
-    def test_a_name_two_runs_reported_stays_unlinked(self):
-        """CUJ 3: the file was overwritten; no run proves its saver."""
-        path = self.image("IMG_GEN_00004_.png")
-        reported = [("dataset", "IMG_GEN_00004_.png")]
-        self.record_run(self.db, self.output, reported, [], nodes=["13"])
-        self.record_run(self.db, self.output, reported, [], item=1, nodes=["23"])
-        self.handler.process_new_image(path)
-        self.assertIsNone(self.linked_text(path))
-        reference = {"folder_type": "output", "subfolder": "dataset"}
-        reference["filename"] = "IMG_GEN_00004_.png"
-        with self.assertLogs("prompt_manager.image_monitor", "INFO") as logs:
-            self.handler._recheck_foreign(path, reference)
-        self.assertIn(
-            "No certain prompt for IMG_GEN_00004_.png after its run ended; "
-            "left unlinked",
-            "\n".join(logs.output),
-        )
-        self.assertIsNone(self.linked_text(path))
-        self.assertEqual(self.prompt_count(), 0)
-
-    def test_the_setting_off_stores_nothing_at_settle_or_after_the_run(self):
-        """CUJ 4: read for every file, so it applies without a restart."""
-        GalleryConfig.SAVE_FOREIGN_RUNS = False
-        skipped = self.image("IMG_GEN_00005_.png")
-        with self.assertLogs("prompt_manager.image_monitor", "INFO") as logs:
-            self.handler.process_new_image(skipped)
-        self.assertIn(
-            "No PromptManager prompt in workflow, skipping image",
-            "\n".join(logs.output),
-        )
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        GalleryConfig.SAVE_FOREIGN_RUNS = True
-        waiting = self.image("IMG_GEN_00006_.png")
-        self.handler.process_new_image(waiting)
-        self.assertEqual(self.handler.awaiting_foreign(), [self.key(waiting)])
-        GalleryConfig.SAVE_FOREIGN_RUNS = False
-        self.record_run(
-            self.db, self.output, [("dataset", "IMG_GEN_00006_.png")], [], nodes=["13"]
-        )
-        self.assertTrue(self.wait_for(lambda: not self.handler.awaiting_foreign()))
-        self.assertTrue(self.settled())
-        self.assertEqual(
-            [self.linked_text(p) for p in (skipped, waiting)], [None, None]
-        )
-        self.assertEqual(self.prompt_count(), 0)
-
-    def test_a_plain_foreign_workflow_links_at_settle_and_counts_no_run(self):
-        """CUJ 2: the default profile decides; the tracker queue is untouched."""
-        text = "a lighthouse on a cliff at dusk"
-        self.metadata = {"prompt": sampled_graph(text, "blurry")}
-        queued = self.db.save_prompt(
-            text="queued item", prompt_hash=generate_prompt_hash("queued item")
-        )
-        self.tracker.set_current_prompt("queued item", {"prompt_id": queued})
-        first, second = self.image("plain_00001_.png"), self.image("plain_00002_.png")
-        self.handler.process_new_image(first)
-        self.handler.process_new_image(second)
-        self.assertEqual(
-            [self.linked_text(first), self.linked_text(second)], [text, text]
-        )
-        prompt = self.db.get_prompt_by_hash(generate_prompt_hash(text))
-        self.assertEqual(prompt["run_count"] or 0, 0)
-        self.assertIsNone(prompt.get("last_used_at"))
-        self.assertEqual(self.tracker.pop_next_prompt()["id"], queued)
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-
-    def test_the_sealed_reference_spells_the_file_as_history_recorded_it(self):
-        """Windows: the watcher's spelling differs in case from the run's report."""
-        Path(self.output, "Dataset").mkdir()
-        recorded = self.image("IMG_GEN_00007_.png", subfolder="Dataset")
-        seen = os.path.join(self.output, "dataset", "img_gen_00007_.png")
-        Path(seen).write_bytes(b"png")
-        folded = staticmethod(lambda path: os.path.realpath(path).lower())
-        with mock.patch.object(ImageGenerationHandler, "_awaiting_key", folded):
-            self.handler.process_new_image(seen)
-            self.assertIsNone(self.linked_text(seen))
-            self.record_run(
-                self.db,
-                self.output,
-                [("Dataset", os.path.basename(recorded))],
-                [],
-                nodes=["43"],
-            )
-            self.assertTrue(self.wait_for(lambda: self.linked_text(seen)))
-            self.assertTrue(self.settled())
-        self.assertEqual(self.linked_text(seen), shapes.BRANCH_TEXTS[3])
-
-    def test_a_full_foreign_set_never_evicts_a_waiting_keyless_file(self):
-        from utils import image_monitor
-
-        keyless = self.image("bare_00001_.png", subfolder="")
-        with mock.patch.object(
-            self.handler.metadata_extractor, "extract_metadata", return_value=None
-        ):
-            self.handler.process_new_image(keyless)
-        paths = [self.image(f"IMG_GEN_1000{n}_.png") for n in range(3)]
-        with (
-            mock.patch.object(image_monitor, "MAX_AWAITING_HISTORY", 2),
-            self.assertLogs("prompt_manager.image_monitor", "INFO") as logs,
-        ):
-            for path in paths:
-                self.handler.process_new_image(path)
-            self.assertEqual(
-                self.handler.awaiting_foreign(), [self.key(p) for p in paths[1:]]
-            )
-        self.assertEqual(self.handler.awaiting_history(), [self.key(keyless)])
-        self.assertIn(
-            "Too many files wait for their run; IMG_GEN_10000_.png left unlinked",
-            "\n".join(logs.output),
-        )
-
-    def test_an_expired_foreign_entry_is_logged_and_left_unlinked(self):
-        from utils import image_monitor
-
-        path = self.image("IMG_GEN_00008_.png")
-        self.handler.process_new_image(path)
-        later = time.monotonic() + image_monitor.AWAIT_HISTORY_SECONDS + 1
-        with (
-            mock.patch.object(image_monitor.time, "monotonic", return_value=later),
-            self.assertLogs("prompt_manager.image_monitor", "INFO") as logs,
-        ):
-            self.assertEqual(self.handler.awaiting_foreign(), [])
-        self.assertIn(
-            "No recorded run for IMG_GEN_00008_.png; left unlinked",
-            "\n".join(logs.output),
-        )
-        self.assertIsNone(self.linked_text(path))
-
-    def test_a_seal_while_the_pending_set_is_full_is_rechecked_later(self):
-        from utils import image_monitor
-
-        path = self.image("IMG_GEN_00009_.png")
-        self.handler.process_new_image(path)
-        blocker = self.image("blocker.png", subfolder="")
-        release = threading.Event()
-        original = self.handler.process_new_image
-
-        def slow(image_path, prompt_snapshot=None):
-            if image_path == blocker:
-                release.wait(5)
-                return None
-            return original(image_path, prompt_snapshot=prompt_snapshot)
-
-        self.handler.process_new_image = slow
-        with mock.patch.object(image_monitor, "MAX_PENDING_IMAGES", 1):
-            self.assertTrue(self.handler.schedule(blocker))
-            self.assertTrue(self.wait_for(lambda: self.handler.pending_count() == 1))
-            self.record_run(
-                self.db,
-                self.output,
-                [("dataset", "IMG_GEN_00009_.png")],
-                [],
-                nodes=["13"],
-            )
-            self.assertEqual(list(self.handler._foreign_due), [path])
-            release.set()
-            self.assertTrue(self.wait_for(lambda: self.linked_text(path)))
-        self.assertTrue(self.settled())
-        self.assertEqual(self.linked_text(path), shapes.BRANCH_TEXTS[0])
-
-    def test_shutdown_forgets_waiting_and_due_foreign_files(self):
-        path = self.image("IMG_GEN_00010_.png")
-        self.handler.process_new_image(path)
-        self.handler._foreign_due[path] = {"filename": "IMG_GEN_00010_.png"}
-        self.handler.shutdown()
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        self.assertEqual(list(self.handler._foreign_due), [])
-
-    def link_count(self, path):
-        connection = self.db.model.get_connection()
-        return connection.execute(
-            "SELECT COUNT(*) FROM generated_images WHERE image_path = ?", (str(path),)
-        ).fetchone()[0]
-
-    def test_a_file_linked_to_another_prompt_never_gets_a_second_link(self):
-        """One prompt per file: the pair path and the positive path both refuse."""
-        other = self.db.save_prompt(
-            "an earlier prompt", generate_prompt_hash("an earlier prompt")
-        )
-        plain = self.image("plain_00004_.png")
-        self.db.link_image_to_prompt(other, plain)
-        self.metadata = {"prompt": sampled_graph("a quiet harbor", "blurry")}
-        with self.assertLogs("prompt_manager.image_monitor", "INFO") as logs:
-            self.handler.process_new_image(plain)
-        self.assertIn("Foreign run: conflict", "\n".join(logs.output))
-        dataset = self.image("IMG_GEN_00011_.png")
-        self.db.link_image_to_prompt(other, dataset)
-        self.metadata = {"prompt": shapes.shared_prefix()}
-        self.record_run(
-            self.db, self.output, [("dataset", "IMG_GEN_00011_.png")], [], nodes=["13"]
-        )
-        self.handler.process_new_image(dataset)
-        for path in (plain, dataset):
-            self.assertEqual(self.linked_text(path), "an earlier prompt")
-            self.assertEqual(self.link_count(path), 1)
-        for text in ("a quiet harbor", shapes.BRANCH_TEXTS[0]):
-            self.assertIsNone(self.db.get_prompt_by_hash(generate_prompt_hash(text)))
-
-    def test_the_file_size_is_read_only_when_the_ladder_needs_it(self):
-        """PR 1's lazy size: a foreign file decided without a store reads none."""
-        # Foreign (a core encoder only) and no API graph: never, at step 3
-        encoder = {"type": "CLIPTextEncode", "inputs": [], "widgets_values": ["x"]}
-        self.metadata = {"text_encoder_nodes": [encoder]}
-        path = self.image("bare_00002_.png", subfolder="")
-        with mock.patch("utils.foreign_runs.os.path.getsize") as size:
-            self.handler.process_new_image(path)
-        size.assert_not_called()
-
-    def untraceable(self):
-        """Unresolved and only the legacy parser names a text (an unknown node)."""
-        graph = sampled_graph("unused", "blurry")
-        graph["1"]["inputs"]["text"] = ["30", 0]
-        graph["30"] = {
-            "class_type": "VendorPromptMaker",
-            "inputs": {"prompt": "a misty valley at dawn"},
-        }
-        return {"prompt": graph}
-
-    def test_no_record_at_settle_keeps_the_file_waiting_for_the_legacy_floor(self):
-        """Review: a lookup that found no record is not the run's answer yet."""
-        self.metadata = self.untraceable()
-        path = self.image("vendor_00001_.png")
-        self.handler.process_new_image(path)
-        self.assertIsNone(self.linked_text(path))
-        self.assertEqual(self.handler.awaiting_foreign(), [self.key(path)])
-        self.record_run(self.db, self.output, [("dataset", "vendor_00001_.png")], [])
-        self.assertTrue(self.wait_for(lambda: self.linked_text(path)))
-        self.assertTrue(self.settled())
-        self.assertEqual(self.linked_text(path), "a misty valley at dawn")
-
-    def test_a_record_found_at_settle_without_a_certain_prompt_ends_the_wait(self):
-        """Review: sealed before settle, still ambiguous: no seal is coming."""
-        path = self.image("IMG_GEN_00012_.png")
-        # One run reported it from two savers: a record, but no saver
-        reported = [("dataset", "IMG_GEN_00012_.png")] * 2
-        self.record_run(self.db, self.output, reported, [], nodes=["13", "23"])
-        with self.assertLogs("prompt_manager.image_monitor", "INFO") as logs:
-            self.handler.process_new_image(path)
-        self.assertIn(
-            "No certain prompt for IMG_GEN_00012_.png; left unlinked",
-            "\n".join(logs.output),
-        )
-        self.assertEqual(self.handler.awaiting_foreign(), [])
-        self.assertIsNone(self.linked_text(path))
-
-    def test_monitoring_saved_off_stops_foreign_writes_at_settle_and_recheck(self):
-        """Review: the observer runs until a restart; nothing is written."""
-        enabled = GalleryConfig.MONITORING_ENABLED
-        self.addCleanup(setattr, GalleryConfig, "MONITORING_ENABLED", enabled)
-        GalleryConfig.MONITORING_ENABLED = False
-        self.metadata = {"prompt": sampled_graph("a quiet harbor", "blurry")}
-        plain = self.image("plain_00005_.png")
-        self.handler.process_new_image(plain)
-        self.assertIsNone(self.linked_text(plain))
-        GalleryConfig.MONITORING_ENABLED = True
-        self.metadata = {"prompt": shapes.shared_prefix()}
-        waiting = self.image("IMG_GEN_00013_.png")
-        self.handler.process_new_image(waiting)
-        GalleryConfig.MONITORING_ENABLED = False
-        reference = {"folder_type": "output", "subfolder": "dataset"}
-        reference["filename"] = "IMG_GEN_00013_.png"
-        self.record_run(
-            self.db, self.output, [("dataset", reference["filename"])], [], nodes=["13"]
-        )
-        self.assertTrue(self.wait_for(lambda: not self.handler.awaiting_foreign()))
-        self.assertTrue(self.settled())
-        self.handler._recheck_foreign(waiting, reference)
-        self.assertIsNone(self.linked_text(waiting))
-        self.assertEqual(self.prompt_count(), 0)
-
-    def test_the_setting_is_read_again_just_before_the_store(self):
-        self.metadata = {"prompt": sampled_graph("a quiet harbor", "blurry")}
-        path = self.image("plain_00006_.png")
-        real = __import__("utils.foreign_runs", fromlist=["x"]).decide_foreign
-
-        def decide_then_switch_off(*args, **kwargs):
-            decision = real(*args, **kwargs)
-            GalleryConfig.SAVE_FOREIGN_RUNS = False
-            return decision
-
-        with mock.patch(
-            "utils.image_monitor.decide_foreign", side_effect=decide_then_switch_off
-        ):
-            self.handler.process_new_image(path)
-        self.assertIsNone(self.linked_text(path))
-        self.assertEqual(self.prompt_count(), 0)
-
-    def test_a_seal_between_registering_and_the_settle_lookup_links_once(self):
-        """Regression guard (passes before the review fixes): one link only."""
-        path = self.image("IMG_GEN_00014_.png")
-        real = __import__("utils.foreign_runs", fromlist=["x"]).history_lookup
-
-        def sealed_first(db, image_path, reference=None):
-            lookup = real(db, image_path, reference)
-
-            def run_then_look():
-                if reference is None:  # the settle lookup: the run seals now
-                    self.record_run(
-                        self.db,
-                        self.output,
-                        [("dataset", "IMG_GEN_00014_.png")],
-                        [],
-                        nodes=["13"],
-                    )
-                return lookup()
-
-            return run_then_look
-
-        with mock.patch("utils.image_monitor.history_lookup", side_effect=sealed_first):
-            self.assertTrue(self.handler.schedule(path))
-            self.assertTrue(self.wait_for(lambda: self.linked_text(path)))
-            self.assertTrue(self.settled())
-        self.assertEqual(self.linked_text(path), shapes.BRANCH_TEXTS[0])
-        self.assertEqual(self.link_count(path), 1)
-        self.assertEqual(list(self.handler._foreign_due), [])
-
-    def test_a_drained_recheck_never_drops_a_newer_reference(self):
-        path = self.image("IMG_GEN_00015_.png")
-        older, newer = {"filename": "old"}, {"filename": "new"}
-        self.handler._foreign_due[path] = older
-        real = self.handler.schedule
-
-        def schedule(image_path, snapshot=None):
-            # The run is sealed again while the older one is scheduled
-            self.handler._foreign_due[image_path] = newer
-            return real(image_path, snapshot)
-
-        self.handler.schedule = schedule
-        with mock.patch.object(self.handler, "process_new_image"):
-            self.handler._drain_history_due()
-        self.assertIs(self.handler._foreign_due[path], newer)
-
-    def test_an_evicted_due_recheck_is_logged(self):
-        from utils import image_monitor
-
-        self.handler.schedule = lambda *args, **kwargs: False
-        with (
-            mock.patch.object(image_monitor, "MAX_AWAITING_HISTORY", 1),
-            self.assertLogs("prompt_manager.image_monitor", "INFO") as logs,
-        ):
-            for name in ("a_00001_.png", "b_00001_.png"):
-                self.handler._schedule_recheck(self.image(name), {"filename": name})
-        self.assertIn(
-            "Too many files wait for their run; a_00001_.png left unlinked",
-            "\n".join(logs.output),
-        )
-
-    def test_a_failed_store_is_logged_and_leaves_the_file_unlinked(self):
-        self.metadata = {"prompt": sampled_graph("a quiet harbor", "blurry")}
-        path = self.image("plain_00003_.png")
-        with (
-            mock.patch(
-                "utils.foreign_runs.ingest_resolved_pair",
-                side_effect=sqlite3.OperationalError("locked"),
-            ),
-            self.assertLogs("prompt_manager.image_monitor", "ERROR"),
-        ):
-            self.handler.process_new_image(path)
-        self.assertIsNone(self.linked_text(path))
-
-
 class TestBoundedLookup(RecordedRuns, unittest.TestCase):
     """M5: history lookups are batched, and the history schema is unchanged."""
 

tests/test_saved_views.py

@@ -42,13 +42,7 @@ IMAGES_STATE = {
     "favorites": False,
     "collection": "",
 }
-LIBRARY_STATE = {
-    "q": "",
-    "category": "",
-    "sort": "rating",
-    "tags": [],
-    "tag_mode": "untagged",
-}
+LIBRARY_STATE = {"q": "", "category": "", "sort": "rating", "tags": []}
 IMAGES_DEFAULTS = {
     "q": "",
     "category": "",
@@ -60,13 +54,7 @@ IMAGES_DEFAULTS = {
     "favorites": False,
     "collection": "",
 }
-LIBRARY_DEFAULTS = {
-    "q": "",
-    "category": "",
-    "sort": "newest",
-    "tags": [],
-    "tag_mode": "all",
-}
+LIBRARY_DEFAULTS = {"q": "", "category": "", "sort": "newest", "tags": []}
 # A row saved by an older build: no favorites key, a retired key, a sort
 # that is no longer offered and an over-long folder.
 OLD_IMAGES_STATE = json.dumps(
@@ -240,16 +228,9 @@ class TestSavedViewsApi(ImageAPITestCase):
         favorite = await self.create(state={"favorites": True})
         self.assertIs(favorite["state"]["favorites"], True)
         for sort in ("newest", "oldest", "name", "rating"):
-            await self.create(
-                page="library",
-                state={"sort": sort, "tags": ["a b"], "tag_mode": "all"},
-            )
-        untagged = await self.create(
-            page="library", state={"tags": [], "tag_mode": "untagged"}
-        )
-        self.assertEqual(untagged["state"]["tag_mode"], "untagged")
+            await self.create(page="library", state={"sort": sort, "tags": ["a b"]})
         _, listed = await self.send("GET")
-        self.assertEqual(len(listed["views"]), 21)
+        self.assertEqual(len(listed["views"]), 20)
 
     async def test_write_requires_the_collection_key(self):
         # #331 D140: a view saved on a collection page keeps the collection id.
@@ -694,23 +675,6 @@ class TestSavedViewsSchema(unittest.TestCase):
                 )
         self.assertEqual(normalize_state("history", {}), {})
 
-    def test_library_tag_mode_is_kept_and_never_paired_with_tags(self):
-        # A row from before #444 has no tag_mode: it opens matching every tag.
-        old = {"q": "", "category": "", "sort": "rating", "tags": ["a"]}
-        self.assertEqual(normalize_state("library", old), {**LIBRARY_DEFAULTS, **old})
-        self.assertEqual(
-            normalize_state("library", {"tag_mode": "any"}), LIBRARY_DEFAULTS
-        )
-        # Never written by this build: the tags win, as the listing refuses both.
-        self.assertEqual(
-            normalize_state("library", {"tags": ["a"], "tag_mode": "untagged"}),
-            {**LIBRARY_DEFAULTS, "tags": ["a"]},
-        )
-        with self.assertRaises(SavedViewInvalid):
-            encode_state("library", {**LIBRARY_STATE, "tags": ["a"]})
-        with self.assertRaises(SavedViewInvalid):
-            encode_state("library", {**LIBRARY_STATE, "tag_mode": "none"})
-
     def test_validation_errors_are_saved_view_invalid(self):
         for call in (
             lambda: validate_name(""),

tests/test_settings_sources.py

@@ -323,43 +323,6 @@ class TestMonitoringSetting(SourcesTestCase):
         self.assertIs(GalleryConfig.MONITORING_ENABLED, False)
 
 
-class TestSaveForeignRunsSetting(SourcesTestCase):
-    """#247 D-Q4: "Save prompts from other workflows", applied live."""
-
-    async def asyncSetUp(self):
-        await super().asyncSetUp()
-        saved = GalleryConfig.SAVE_FOREIGN_RUNS
-        self.addCleanup(setattr, GalleryConfig, "SAVE_FOREIGN_RUNS", saved)
-        GalleryConfig.SAVE_FOREIGN_RUNS = True
-
-    async def test_read_and_write_published_live_without_a_restart(self):
-        self.assertIs((await self._get())["settings"]["save_foreign_runs"], True)
-        self._install_monitor(FakeMonitor([self.output_dir]))
-        status, data = await self._post(
-            "/prompt_manager/settings", {"save_foreign_runs": False}
-        )
-        self.assertEqual(status, 200, data)
-        self.assertTrue(data["persisted"])
-        self.assertEqual(data["restart_required_fields"], [])
-        saved = self._read_config()
-        self.assertIs(saved["gallery"]["monitoring"]["save_foreign_runs"], False)
-        self.assertIs(GalleryConfig.SAVE_FOREIGN_RUNS, False)
-        self.assertIs((await self._get())["settings"]["save_foreign_runs"], False)
-
-    async def test_only_true_or_false_is_accepted(self):
-        self._write_config({"custom": {"keep": True}})
-        before = self._config_bytes()
-        for value in ("false", 0, None, []):
-            with self.subTest(value=value):
-                status, data = await self._post(
-                    "/prompt_manager/settings", {"save_foreign_runs": value}
-                )
-                self.assertEqual(status, 400, data)
-                self.assertIn("save_foreign_runs must be true or false", data["error"])
-                self.assertEqual(self._config_bytes(), before)
-                self.assertIs(GalleryConfig.SAVE_FOREIGN_RUNS, True)
-
-
 class TestSourceChangeHold(SourcesTestCase):
     async def test_root_save_refused_while_scan_job_runs(self):
         GalleryConfig.MONITORING_DIRECTORIES = [self._root(self.a)]

tests/test_vocabulary.py

@@ -364,162 +364,6 @@ class TestVocabularyReads(unittest.TestCase):
             self.assertTrue(conn.in_transaction)
 
 
-class _ReadFixture(unittest.TestCase):
-    """TestVocabularyReads' database and helpers, without re-running its tests."""
-
-    setUp = TestVocabularyReads.setUp
-    tearDown = TestVocabularyReads.tearDown
-    save = TestVocabularyReads.save
-    read = TestVocabularyReads.read
-    add_unused = TestVocabularyReads.add_unused
-    all_tags = TestVocabularyReads.all_tags
-
-
-class TestVocabularyTagSearchAndSort(_ReadFixture):
-    """#444: tag search, tag sort and the untagged prompts count."""
-
-    def names(self, **options):
-        rows, after = [], None
-        while True:
-            page = self.read("list_vocabulary_tags", limit=2, after=after, **options)
-            rows.extend(row["name"] for row in page["tags"])
-            if not page["has_more"]:
-                return rows
-            after = page["next_key"]
-
-    def seed_counts(self):
-        self.save("One", tags=["beta", "Alpha"])
-        self.save("Two", tags=["beta", "gamma"])
-        self.save("Three", tags=["beta"])
-        self.add_unused("delta", "100%_off", "100x-off")
-
-    def test_search_is_a_case_insensitive_literal_substring(self):
-        self.seed_counts()
-        self.assertEqual(self.names(search="ALP"), ["Alpha"])
-        self.assertEqual(self.names(search="%"), ["100%_off"])
-        self.assertEqual(self.names(search="_"), ["100%_off"])
-        self.assertEqual(
-            self.names(search="  a  "), ["beta", "Alpha", "gamma", "delta"]
-        )
-        page = self.read("list_vocabulary_tags", search="a")
-        self.assertEqual(page["total"], 4)
-        self.assertEqual(self.read("list_vocabulary_tags", search="")["total"], 6)
-
-    def test_each_sort_orders_rows_and_continues_without_gaps(self):
-        self.seed_counts()
-        self.assertEqual(
-            self.names(), ["beta", "Alpha", "gamma", "delta", "100%_off", "100x-off"]
-        )
-        self.assertEqual(self.names(sort="created"), self.names())
-        self.assertEqual(
-            self.names(sort="name"),
-            ["100%_off", "100x-off", "Alpha", "beta", "delta", "gamma"],
-        )
-        self.assertEqual(
-            self.names(sort="name-desc"),
-            ["gamma", "delta", "beta", "Alpha", "100x-off", "100%_off"],
-        )
-        # Ties keep creation order: Alpha and gamma (1), then the unused tags (0).
-        self.assertEqual(
-            self.names(sort="prompts"),
-            ["beta", "Alpha", "gamma", "delta", "100%_off", "100x-off"],
-        )
-        self.assertEqual(
-            self.names(sort="prompts-asc"),
-            ["delta", "100%_off", "100x-off", "Alpha", "gamma", "beta"],
-        )
-        self.assertEqual(
-            self.names(sort="name", search="a"), ["Alpha", "beta", "delta", "gamma"]
-        )
-
-    def test_count_sort_uses_the_row_counts(self):
-        self.save("Parent", tags=["direct"])
-        self.db.save_prompt_pair("Owner", "Noise", tags=["pair"])
-        self.db.save_prompt_pair("Owner two", "Noise two", tags=["pair"])
-        archived = self.db.save_prompt_pair("Gone", "Gone noise", tags=["archived"])
-        self.db.archive_prompt_pair(archived)
-        page = self.read("list_vocabulary_tags", sort="prompts")
-        self.assertEqual(
-            [(row["name"], row["prompt_count"]) for row in page["tags"]],
-            [("pair", 2), ("direct", 1), ("archived", 0)],
-        )
-
-    def test_invalid_search_sort_and_keys_are_refused(self):
-        self.seed_counts()
-        for options in (
-            {"sort": "count"},
-            {"sort": None},
-            {"search": "x" * 201},
-            {"search": 3},
-            {"sort": "name", "after": 3},
-            {"sort": "name", "after": ["a"]},
-            {"sort": "prompts", "after": ["a", 1]},
-            {"sort": "created", "after": ["a", 1]},
-        ):
-            with self.assertRaises(ValueError, msg=options):
-                self.read("list_vocabulary_tags", **options)
-
-    def test_untagged_count_is_every_parent_no_tag_browse_returns(self):
-        self.save("Plain")
-        self.save("Tagged", tags=["t"])
-        self.db.save_prompt_pair("Pair tagged", "Noise", tags=["p"])
-        self.db.save_prompt_pair("Pair plain", "Noise plain")
-        archived = self.db.save_prompt_pair("Archived tag", "Old", tags=["old"])
-        self.db.archive_prompt_pair(archived)
-        self.add_unused("unused")
-        page = self.read("list_vocabulary_tags", search="zzz")
-        untagged = self.db.list_library(tag_mode="untagged")
-        self.assertEqual(
-            sorted(item["text"] for item in untagged["items"]),
-            ["Archived tag", "Pair plain", "Plain"],
-        )
-        self.assertEqual(page["untagged_count"], untagged["total"])
-        self.assertEqual(page["untagged_count"], 3)
-        tagged = set()
-        for row in self.all_tags():
-            tagged |= {
-                item["id"] for item in self.db.list_library(tags=[row["name"]])["items"]
-            }
-        everyone = {item["id"] for item in self.db.list_library()["items"]}
-        self.assertEqual({item["id"] for item in untagged["items"]}, everyone - tagged)
-
-
-class TestLibraryTagMode(_ReadFixture):
-    def test_untagged_mode_combines_with_text_and_category(self):
-        self.save("Red plain", category="Colors")
-        self.save("Blue plain")
-        self.save("Red tagged", category="Colors", tags=["red"])
-        self.assertEqual(
-            [
-                i["text"]
-                for i in self.db.list_library(text="red", tag_mode="untagged")["items"]
-            ],
-            ["Red plain"],
-        )
-        self.assertEqual(
-            [
-                i["text"]
-                for i in self.db.list_library(category="Colors", tag_mode="untagged")[
-                    "items"
-                ]
-            ],
-            ["Red plain"],
-        )
-        self.assertEqual(
-            self.db.list_library(tag_mode="all")["total"],
-            self.db.list_library()["total"],
-        )
-
-    def test_untagged_mode_refuses_tags_and_unknown_modes(self):
-        for options in (
-            {"tag_mode": "untagged", "tags": ["x"]},
-            {"tag_mode": "none"},
-            {"tag_mode": None},
-        ):
-            with self.assertRaises(ValueError, msg=options):
-                self.db.list_library(**options)
-
-
 _TAG_TABLES = ('"tags"', '"prompt_tags"', '"prompt_pair_tags"', '"sqlite_sequence"')
 
 

tests/vendor/comfyui-config.test.mjs

@@ -36,14 +36,14 @@ test('execution script discovers only the new matrix and preserves all 78 origin
     // + the fresh-host library location case, + #342 image attribution, + #343 linked text,
     // + #332 image category routes on a generated output (image-attribution.spec.mjs, 2 projects),
     // + #347 cached runtime-linked runs: five node kinds and eight one-renderer cases (execution-text-link.spec.mjs, 2 projects),
-    // + #90 Save to library off (five node types), + #247 foreign workflows (image-attribution.spec.mjs, 2 tests x 2 projects)
-    assert.match(executions, /Total: 132 tests in 5 files/);
+    // + #90 Save to library off (five node types)
+    assert.match(executions, /Total: 128 tests in 5 files/);
     for (const project of ['classic-start', 'nodes2-start']) {
         const cases = executions.split('\n').filter(line => line.includes(`[${project}]`));
         assert.equal(cases.filter(line => line.includes('execution-history.spec.mjs')).length, 15);
         assert.equal(cases.filter(line => line.includes('execution-outputs.spec.mjs')).length, 8);
         assert.equal(cases.filter(line => line.includes('library-location.spec.mjs')).length, 1);
-        assert.equal(cases.filter(line => line.includes('image-attribution.spec.mjs')).length, 5);
+        assert.equal(cases.filter(line => line.includes('image-attribution.spec.mjs')).length, 3);
         assert.equal(cases.filter(line => line.includes('execution-text-link.spec.mjs')).length, 37);
     }
     assert.doesNotMatch(executions, /prompt-manager.spec/);

tools/comfyui_stopped.py

@@ -1,81 +0,0 @@
-"""Is ComfyUI stopped? The checks a library repair runs before writing (#247).
-
-``comfyui_running`` looks for ``main.py`` processes of one ComfyUI folder
-and a listener on its port. ``open_by_others`` lists the processes that hold
-the library file, its ``-wal`` or its ``-shm`` open. Both read ``/proc``
-(Linux); without it ``open_by_others`` answers ``[NO_PROC]``: it cannot
-tell, and the caller refuses unless the user says ComfyUI is stopped.
-Entries that cannot be read (another user's process, one that just exited)
-are skipped.
-"""
-
-import os
-import socket
-
-NO_PROC = (
-    "cannot list the processes that hold the library open (no /proc): stop "
-    "ComfyUI and pass --i-stopped-comfyui"
-)
-
-
-def _same(path):
-    return os.path.normcase(os.path.realpath(path))
-
-
-def _pids(proc, own_pid=None):
-    try:
-        names = os.listdir(proc)
-    except OSError:
-        return []
-    return [name for name in names if name.isdigit() and name != str(own_pid)]
-
-
-def comfyui_running(comfyui_dir, port, proc="/proc"):
-    """``main.py`` processes running from ``comfyui_dir`` and a listener on
-    ``port`` (127.0.0.1), each as one line; empty when none is found."""
-    found = []
-    folder = _same(comfyui_dir)
-    for pid in _pids(proc):
-        try:
-            with open(os.path.join(proc, pid, "cmdline"), "rb") as stream:
-                parts = stream.read().split(b"\0")
-            cwd = _same(os.readlink(os.path.join(proc, pid, "cwd")))
-        except OSError:
-            continue
-        if any(part.endswith(b"main.py") for part in parts) and (
-            cwd == folder or any(folder.encode() in part for part in parts)
-        ):
-            found.append(f"process {pid} (main.py in {cwd})")
-    with socket.socket() as probe:
-        probe.settimeout(1)
-        if probe.connect_ex(("127.0.0.1", port)) == 0:
-            found.append(f"something listens on port {port}")
-    return found
-
-
-def open_by_others(database, proc="/proc", own_pid=None):
-    """Processes other than ``own_pid`` (default: this one) holding
-    ``database``, its ``-wal`` or ``-shm`` open; ``[NO_PROC]`` without /proc."""
-    if not os.path.isdir(proc):
-        return [NO_PROC]
-    own_pid = os.getpid() if own_pid is None else own_pid
-    targets = {_same(database + suffix): suffix for suffix in ("", "-wal", "-shm")}
-    found = []
-    for pid in _pids(proc, own_pid):
-        fd_dir = os.path.join(proc, pid, "fd")
-        try:
-            fds = os.listdir(fd_dir)
-        except OSError:
-            continue
-        held = set()
-        for fd in fds:
-            try:
-                target = os.readlink(os.path.join(fd_dir, fd))
-            except OSError:
-                continue
-            target = target.replace(" (deleted)", "")
-            if os.path.isabs(target) and _same(target) in targets:
-                held.add(os.path.basename(database) + targets[_same(target)])
-        if held:
-            found.append(f"process {pid} has {', '.join(sorted(held))} open")
-    return found

tools/repair_foreign_links.py

@@ -1,776 +0,0 @@
-"""Repair the links the old scan gave foreign dataset files (#247), on review.
-
-Before #247 the output scan linked each file of a foreign run (a workflow
-with no PromptManager node) through the legacy parser, so every file of a
-shared-prefix dataset run got the first branch's text. Recorded history
-knows which save node wrote each file; the shared ladder
-(``utils.file_prompt.decide_file_prompt``, scan policy) uses it
-(``recorded-run``) to name the right branch. This tool judges every
-``generated_images`` row of a file whose recording runs all have no
-PromptManager context:
-
-``relink``  the ladder names a positive by the recorded saver, and its text
-            is not the linked prompt's
-``keep``    the recorded saver or the inspector names the linked prompt
-``skip``    anything else (file gone, no single recorded saver, ambiguous,
-            the legacy floor or another step decided)
-
-Dry run (the default) judges a copy of the database (SQLite backup from a
-read-only connection) and writes a JSON plan and a Markdown list beside it
-(``<plan stem>.list.md``). It also rehearses the apply on a second copy, to
-list the prompts that would lose every link with their remaining
-references. Deleting those is OFF unless the dry run is given
-``--delete-orphans``; the choice is recorded in the plan and rehearsed on a
-third copy. The library is never written.
-
-``--apply <plan.json>`` (ComfyUI stopped), only on the library the plan was
-made from (its real path, recorded in the plan):
-
-1. refuses unless ``--comfyui-dir`` holds ``main.py``; refuses while a
-   ``main.py`` runs from it, anything listens on ``--port``, or any other
-   process holds the library, its ``-wal`` or ``-shm`` open
-   (``tools/comfyui_stopped.py``; without /proc only with
-   ``--i-stopped-comfyui``). ``--rehearsal`` skips the process and port
-   check, never the open-file check, and never for that folder's library;
-2. saves ``<db>.pre-247-repair_<stamp>`` (or into ``--backup-dir``), never
-   over an existing file, and refuses unless the backup passes
-   ``integrity_check`` with the library's counts. Opening the library must
-   not change its schema (a newer checkout's migration): run the tool from a
-   checkout at the live code version. The running check runs once more just
-   before writing;
-3. in ONE ``BEGIN IMMEDIATE`` transaction: re-judges every planned row and
-   refuses on any drift (row moved, prompt text changed, file changed, target
-   stored since), creates the target prompts that do not exist (category
-   ``scanned``, tag ``auto-scanned``, note ``Auto-scanned from <first file>``),
-   points each row at its target and drops its pair links (they named the old
-   positive). A file that already has a row for the target keeps that row and
-   loses the wrong one (UNIQUE(prompt_id, file_path)). Orphans are deleted only
-   when the plan chose it and each is still unreferenced.
-
-Any failed check rolls everything back and exits 2. Before/after table
-counts, ``integrity_check`` and ``foreign_key_check`` are printed.
-
-    python3 tools/repair_foreign_links.py <db> --output-dir <ComfyUI output> \\
-        --plan repair_plan.json
-    python3 tools/repair_foreign_links.py <db> --apply repair_plan.json \\
-        --comfyui-dir <ComfyUI folder>
-
-Run from a checkout at the live code version (after the merge: main) with
-its venv.
-"""
-
-import argparse
-import datetime
-import hashlib
-import json
-import logging
-import os
-import sqlite3
-import sys
-import tempfile
-from pathlib import Path
-from types import SimpleNamespace
-
-_ROOT = Path(__file__).resolve().parents[1]
-if str(_ROOT) not in sys.path:
-    sys.path.insert(0, str(_ROOT))
-
-from database.maintenance import ORPHANED_PROMPTS_SQL, _delete_ids  # noqa: E402
-from database.operations import PromptDatabase  # noqa: E402
-from database.pair_ingestion import (  # noqa: E402
-    SCAN_MARKS,
-    file_link_rows,
-    mark_created,
-)
-from database.run_attribution import recorded_output  # noqa: E402
-from py.api import PromptManagerAPI  # noqa: E402
-from tools.comfyui_stopped import (  # noqa: E402
-    NO_PROC,
-    comfyui_running,
-    open_by_others,
-)
-from tools.review_image_links import backup_database  # noqa: E402
-from utils.execution_outputs import snapshot_output_roots  # noqa: E402
-from utils.file_prompt import POSITIVE, Policy, decide_file_prompt  # noqa: E402
-from utils.hashing import generate_prompt_hash  # noqa: E402
-
-PLAN_VERSION = 1
-COMFY_PORT = 8188
-LIVE_LIBRARY = ("user", "__promptmanager", "prompts.db")
-EXCERPT = 80
-COUNTED = (
-    "prompts",
-    "generated_images",
-    "prompt_tags",
-    "image_prompt_pairs",
-    "workflow_documents",
-    "prompt_pairs",
-    "prompt_library_state",
-    "execution_run_contexts",
-    "tags",
-)
-# The ladder steps whose answer is certain enough to keep a link.
-KEEP_SOURCES = ("recorded-run", "inspector")
-# What must be unchanged since the dry run for a row to be written.
-DRIFT_KEYS = (
-    "action",
-    "file",
-    "current_prompt_id",
-    "current_text_sha256",
-    "file_size",
-    "file_mtime_ns",
-    "target_text",
-    "target_hash",
-    "target_prompt_id",
-)
-# Locations reported only by runs without any PromptManager context.
-_FOREIGN_LOCATIONS = (
-    "SELECT o.subfolder, o.filename FROM execution_run_outputs o "
-    "WHERE o.folder_type = 'output' AND o.root_key = ? AND o.path_style = ? "
-    "GROUP BY o.subfolder, o.filename "
-    "HAVING SUM(EXISTS (SELECT 1 FROM execution_run_contexts c "
-    "WHERE c.run_id = o.run_id)) = 0 "
-    "ORDER BY o.subfolder, o.filename"
-)
-
-
-class Refused(Exception):
-    """A check failed: nothing is written."""
-
-
-def sha256(text):
-    return hashlib.sha256(text.encode("utf-8")).hexdigest()
-
-
-def metadata_reader():
-    """The scan's metadata extraction (PNG text chunks, ffprobe for videos)."""
-    api = SimpleNamespace(logger=logging.getLogger("prompt_manager.repair_247"))
-    return lambda path: PromptManagerAPI._extract_comfyui_metadata(api, path) or {}
-
-
-def foreign_rows(db, output_dir):
-    """The link rows of every file only foreign runs reported, by id."""
-    style = "windows" if os.name == "nt" else "posix"
-    root_key = snapshot_output_roots(style, output_dir, output_dir).output_key
-    conn = db.model.get_connection()
-    rows = {}
-    for subfolder, filename in conn.execute(_FOREIGN_LOCATIONS, (root_key, style)):
-        path = os.path.join(output_dir, subfolder, filename)
-        rows.update((row["id"], row) for row in file_link_rows(conn, path))
-    return [rows[key] for key in sorted(rows)]
-
-
-class Judge:
-    """One file's decision per path, for all of its rows."""
-
-    def __init__(self, db, output_dir, read=None):
-        self.db = db
-        self.output_dir = output_dir
-        self.read = read or metadata_reader()
-        self.decisions = {}
-
-    def decide(self, path, size):
-        if path not in self.decisions:
-            self.decisions[path] = decide_file_prompt(
-                self.read(path),
-                file_name=os.path.basename(path),
-                file_size=size,
-                in_output=True,
-                lookup=lambda: recorded_output(self.db, path, self.output_dir),
-                policy=Policy.SCAN,
-            )
-        return self.decisions[path]
-
-    def row(self, row):
-        """The plan entry of one ``generated_images`` row."""
-        conn = self.db.model.get_connection()
-        path = row["image_path"]
-        (text,) = conn.execute(
-            "SELECT text FROM prompts WHERE id = ?", (row["prompt_id"],)
-        ).fetchone()
-        prompt_hash = generate_prompt_hash(text)
-        item = {
-            "row_id": row["id"],
-            "file": path,
-            "current_prompt_id": row["prompt_id"],
-            "current_text_sha256": sha256(text),
-        }
-        try:
-            stat = os.stat(path)
-        except OSError:
-            return {**item, "action": "skip", "reason": "file gone"}
-        item.update(file_size=stat.st_size, file_mtime_ns=stat.st_mtime_ns)
-        decision = self.decide(path, stat.st_size)
-        action = action_of(decision, prompt_hash)
-        if action == "skip":
-            return {
-                **item,
-                "action": "skip",
-                "reason": "not decided by the recorded saver",
-                "decision": f"{decision.kind}/{decision.source}",
-            }
-        target_hash = generate_prompt_hash(decision.text)
-        stored = conn.execute(
-            "SELECT id FROM prompts WHERE hash = ?", (target_hash,)
-        ).fetchone()
-        item.update(
-            target_text=decision.text,
-            target_hash=target_hash,
-            target_prompt_id=stored[0] if stored else "new",
-            action=action,
-            source=decision.source,
-        )
-        return item
-
-
-def action_of(decision, linked_hash):
-    """``relink``, ``keep`` or ``skip`` for a row linked to ``linked_hash``.
-
-    Only the recorded saver (``recorded-run``) names a new target. A certain
-    step (the recorded saver or the inspector) naming the linked prompt keeps
-    it; the legacy floor and every other answer are skipped.
-    """
-    if decision.kind != POSITIVE or decision.source not in KEEP_SOURCES:
-        return "skip"
-    if generate_prompt_hash(decision.text) == linked_hash:
-        return "keep"
-    return "relink" if decision.source == "recorded-run" else "skip"
-
-
-def library_identity(path):
-    """How a plan names its library: the case-normalized real path."""
-    return os.path.normcase(os.path.realpath(path))
-
-
-def build_plan(db, output_dir, source_db, read=None):
-    """The plan for ``db`` (a copy of ``source_db``)."""
-    judge = Judge(db, output_dir, read)
-    conn = db.model.get_connection()
-    (max_row_id,) = conn.execute("SELECT MAX(id) FROM generated_images").fetchone()
-    return {
-        "version": PLAN_VERSION,
-        "created": datetime.datetime.now().isoformat(timespec="seconds"),
-        "source_db": library_identity(source_db),
-        "max_row_id": max_row_id,
-        "output_dir": output_dir,
-        "rows": [judge.row(row) for row in foreign_rows(db, output_dir)],
-        "orphans": [],
-        "delete_orphans": False,
-    }
-
-
-def blockers(conn, prompt_id, unused):
-    """Why ``prompt_id`` must not be deleted (empty: nothing references it)."""
-    found = []
-    values = {"id": prompt_id, "tag": SCAN_MARKS.tags[0]}
-    checks = {
-        "linked images": "SELECT COUNT(*) FROM generated_images WHERE prompt_id=:id",
-        "saved pairs": "SELECT COUNT(*) FROM prompt_pairs "
-        "WHERE positive_prompt_id=:id OR negative_prompt_id=:id",
-        "recorded runs": "SELECT COUNT(*) FROM execution_run_contexts "
-        "WHERE positive_prompt_id=:id OR negative_prompt_id=:id",
-        "library state": "SELECT COUNT(*) FROM prompt_library_state "
-        "WHERE prompt_id=:id",
-        "user tags": "SELECT COUNT(*) FROM prompt_tags pt JOIN tags t "
-        "ON t.id=pt.tag_id WHERE pt.prompt_id=:id AND t.name != :tag",
-    }
-    for name, sql in checks.items():
-        count = conn.execute(sql, values).fetchone()[0]
-        if count:
-            found.append(f"{name}: {count}")
-    run_count, last_used, rating, category, notes = conn.execute(
-        "SELECT run_count, last_used_at, rating, category, notes FROM prompts "
-        "WHERE id=?",
-        (prompt_id,),
-    ).fetchone()
-    if run_count or last_used or rating:
-        found.append("usage or rating")
-    if category not in (None, SCAN_MARKS.category):
-        found.append(f"category {category}")
-    if notes and not notes.startswith("Auto-scanned from "):
-        found.append("notes")
-    if prompt_id not in unused:
-        found.append("not unused by the app's rule")
-    return found
-
-
-def _rejudge(conn, judge, plan):
-    for item in plan["rows"]:
-        if item["action"] == "skip":
-            continue
-        row = conn.execute(
-            "SELECT * FROM generated_images WHERE id = ?", (item["row_id"],)
-        ).fetchone()
-        if row is None:
-            raise Refused(f"row {item['row_id']}: gone")
-        if generate_prompt_hash(item.get("target_text") or "") != item.get(
-            "target_hash"
-        ):
-            raise Refused(f"row {item['row_id']}: target_text does not match its hash")
-        fresh = judge.row(row)
-        for key in DRIFT_KEYS:
-            if fresh.get(key) != item.get(key):
-                raise Refused(
-                    f"row {item['row_id']}: {key} changed "
-                    f"({item.get(key)!r} -> {fresh.get(key)!r})"
-                )
-
-
-def _targets(conn, db, relinks):
-    """``{target hash: prompt id}``, creating each "new" target once."""
-    targets = {}
-    for item in relinks:
-        digest = item["target_hash"]
-        if digest in targets:
-            continue
-        if item["target_prompt_id"] != "new":
-            targets[digest] = item["target_prompt_id"]
-            continue
-        prompt_id, created = db._pair_component_outcome(conn, item["target_text"])
-        if not created:
-            raise Refused(f"row {item['row_id']}: target prompt already stored")
-        mark_created(conn, db, prompt_id, SCAN_MARKS, os.path.basename(item["file"]))
-        targets[digest] = prompt_id
-    return targets
-
-
-def _relink(conn, item, target):
-    """Point the row at ``target``; True when the wrong row was deleted instead."""
-    row_id = item["row_id"]
-    correct = [
-        row
-        for row in file_link_rows(conn, item["file"])
-        if row["prompt_id"] == target and row["id"] != row_id
-    ]
-    if correct:  # UNIQUE(prompt_id, file_path): the correct row stays alone
-        if _delete_ids(conn, "generated_images", [row_id]) != 1:
-            raise Refused(f"row {row_id}: delete touched no row")
-        return True
-    # A pair link records the old positive: it goes with the old link
-    conn.execute("DELETE FROM image_prompt_pairs WHERE image_id = ?", (row_id,))
-    cursor = conn.execute(
-        "UPDATE generated_images SET prompt_id = ? WHERE id = ? AND prompt_id = ?",
-        (target, row_id, item["current_prompt_id"]),
-    )
-    if cursor.rowcount != 1:
-        raise Refused(f"row {row_id}: relink touched {cursor.rowcount} rows")
-    return False
-
-
-def _audit(conn, relinks):
-    """The prompts the relinks leave without any link, with their blockers."""
-    sources = {}
-    for item in relinks:
-        sources.setdefault(item["current_prompt_id"], []).append(item)
-    unused = {row[0] for row in conn.execute(ORPHANED_PROMPTS_SQL)}
-    audit = []
-    for prompt_id in sorted(sources):
-        if conn.execute(
-            "SELECT 1 FROM generated_images WHERE prompt_id = ?", (prompt_id,)
-        ).fetchone():
-            continue
-        (text,) = conn.execute(
-            "SELECT text FROM prompts WHERE id = ?", (prompt_id,)
-        ).fetchone()
-        found = blockers(conn, prompt_id, unused)
-        audit.append(
-            {
-                "id": prompt_id,
-                "text_excerpt": " ".join(text.split())[:EXCERPT],
-                "text_sha256": sha256(text),
-                "images_before": len(sources[prompt_id]),
-                "blockers": found,
-                "safe": not found,
-            }
-        )
-    return audit
-
-
-def _delete_orphans(conn, plan):
-    chosen = [orphan for orphan in plan["orphans"] if orphan["safe"]]
-    unused = {row[0] for row in conn.execute(ORPHANED_PROMPTS_SQL)}
-    for orphan in chosen:
-        row = conn.execute(
-            "SELECT text FROM prompts WHERE id = ?", (orphan["id"],)
-        ).fetchone()
-        if row is None or sha256(row[0]) != orphan["text_sha256"]:
-            raise Refused(f"prompt {orphan['id']}: gone or text changed")
-        found = blockers(conn, orphan["id"], unused)
-        if found:
-            raise Refused(f"prompt {orphan['id']}: {', '.join(found)}")
-    ids = [orphan["id"] for orphan in chosen]
-    if _delete_ids(conn, "prompts", ids) != len(ids):
-        raise Refused("an orphan prompt was not deleted")
-    return len(ids)
-
-
-def apply_plan(db, plan, read=None, before_write=None):
-    """Write ``plan`` in one transaction; returns ``(result, orphan audit)``.
-
-    ``before_write()`` runs just before ``BEGIN IMMEDIATE`` (the running
-    check). Raises ``Refused`` (and rolls back) on any drift or failed check.
-    """
-    judge = Judge(db, plan["output_dir"], read)
-    relinks = [item for item in plan["rows"] if item["action"] == "relink"]
-    if before_write is not None:
-        before_write()
-    with db._pair_transaction() as conn:
-        _rejudge(conn, judge, plan)
-        targets = _targets(conn, db, relinks)
-        dropped = sum(
-            _relink(conn, item, targets[item["target_hash"]]) for item in relinks
-        )
-        audit = _audit(conn, relinks)
-        deleted = _delete_orphans(conn, plan) if plan.get("delete_orphans") else 0
-    created = sum(1 for item in relinks if item["target_prompt_id"] == "new")
-    result = {
-        "relinked": len(relinks) - dropped,
-        "duplicates_dropped": dropped,
-        "prompts_created": len(
-            {i["target_hash"] for i in relinks if i["target_prompt_id"] == "new"}
-        ),
-        "rows_to_new_prompts": created,
-        "kept": sum(1 for item in plan["rows"] if item["action"] == "keep"),
-        "orphans_deleted": deleted,
-    }
-    return result, audit
-
-
-def counts(path, readonly=True):
-    """Table counts plus the integrity and foreign-key checks.
-
-    Read-only for a library; the tool's own backup is opened read-write so
-    a WAL file leaves no side files behind once it closes.
-    """
-    uri = Path(os.path.abspath(path)).as_uri() + ("?mode=ro" if readonly else "")
-    conn = sqlite3.connect(uri, uri=True)
-    try:
-        found = {
-            table: conn.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()[0]
-            for table in COUNTED  # nosec B608 - fixed table names
-        }
-        found["integrity_check"] = conn.execute("PRAGMA integrity_check").fetchone()[0]
-        found["foreign_key_check"] = len(
-            conn.execute("PRAGMA foreign_key_check").fetchall()
-        )
-        return found
-    finally:
-        conn.close()
-
-
-def _print_counts(before, after, out):
-    out.write(f"{'':24}{'before':>12}{'after':>12}\n")
-    for key in before:
-        out.write(f"{key:24}{before[key]!s:>12}{after[key]!s:>12}\n")
-
-
-def _summary(plan):
-    actions = [item["action"] for item in plan["rows"]]
-    return "  ".join(
-        f"{name}: {actions.count(name)}" for name in ("relink", "keep", "skip")
-    )
-
-
-def _cell(text, limit=EXCERPT):
-    """One table cell: whitespace folded, cut to ``limit`` (None: whole)."""
-    folded = " ".join(str(text).split())
-    return (folded if limit is None else folded[:limit]).replace("|", "\\|")
-
-
-def _relative(path, root):
-    try:
-        return os.path.relpath(path, root)
-    except ValueError:  # another drive on Windows
-        return path
-
-
-def markdown(plan, prompt_texts):
-    """The maintainer's list of the plan."""
-    root = plan["output_dir"]
-    rel = lambda path: _relative(path, root)  # noqa: E731
-    rows = plan["rows"]
-    lines = [
-        "# #247 repair plan (dry run)",
-        "",
-        f"Created {plan['created']}; output folder `{root}`. {_summary(plan)}.",
-        "",
-        f"## Relink ({sum(i['action'] == 'relink' for i in rows)})",
-        "",
-        "| row | file | linked prompt | linked text | target | target hash "
-        "| target text |",
-        "|---:|---|---:|---|---|---|---|",
-    ]
-    for item in (i for i in rows if i["action"] == "relink"):
-        lines.append(
-            f"| {item['row_id']} | {_cell(rel(item['file']), None)} | "
-            f"{item['current_prompt_id']} | "
-            f"{_cell(prompt_texts.get(item['current_prompt_id'], ''))} | "
-            f"{item['target_prompt_id']} | `{item['target_hash'][:12]}` | "
-            f"{_cell(item['target_text'])} |"
-        )
-    lines += ["", f"## Keep ({sum(i['action'] == 'keep' for i in rows)})", ""]
-    lines += ["| row | file | prompt |", "|---:|---|---:|"]
-    for item in (i for i in rows if i["action"] == "keep"):
-        lines.append(
-            f"| {item['row_id']} | {_cell(rel(item['file']), None)} | "
-            f"{item['current_prompt_id']} |"
-        )
-    lines += ["", f"## Skip ({sum(i['action'] == 'skip' for i in rows)})", ""]
-    lines += ["| row | file | prompt | reason |", "|---:|---|---:|---|"]
-    for item in (i for i in rows if i["action"] == "skip"):
-        reason = item["reason"] + (
-            f" ({item['decision']})" if item.get("decision") else ""
-        )
-        lines.append(
-            f"| {item['row_id']} | {_cell(rel(item['file']), None)} | "
-            f"{item['current_prompt_id']} | {reason} |"
-        )
-    choice = "ON (--delete-orphans)" if plan["delete_orphans"] else "OFF"
-    lines += [
-        "",
-        f"## Prompts that would lose every link ({len(plan['orphans'])})",
-        "",
-        f"Deleting the safe ones: {choice}.",
-        "",
-        "| id | text | images before | blockers | safe to delete |",
-        "|---:|---|---:|---|---|",
-    ]
-    for orphan in plan["orphans"]:
-        lines.append(
-            f"| {orphan['id']} | {_cell(orphan['text_excerpt'])} | "
-            f"{orphan['images_before']} | {', '.join(orphan['blockers']) or 'none'} | "
-            f"{'yes' if orphan['safe'] else 'no'} |"
-        )
-    simulated = plan.get("simulated")
-    if simulated:
-        lines += ["", "## Rehearsed on the dry run's copy", ""]
-        lines += ["| table | before | after |", "|---|---:|---:|"]
-        for key, value in simulated["before"].items():
-            lines.append(f"| {key} | {value} | {simulated['after'][key]} |")
-    return "\n".join(lines) + "\n"
-
-
-def _texts(db):
-    return dict(
-        db.model.get_connection().execute(
-            "SELECT id, text FROM prompts WHERE id IN (SELECT prompt_id "
-            "FROM generated_images)"
-        )
-    )
-
-
-def _rehearse(source, scratch, name, plan):
-    """``apply_plan`` on a fresh backup of ``source``: (counts, result, audit)."""
-    copy = os.path.join(scratch, name)
-    backup_database(source, copy)
-    db = PromptDatabase(copy)
-    try:
-        before = counts(copy)
-        result, audit = apply_plan(db, plan)
-    finally:
-        db.close_all()
-    return {"before": before, "after": counts(copy), "result": result}, audit
-
-
-def dry_run(args, out):
-    with tempfile.TemporaryDirectory() as scratch:
-        copy = os.path.join(scratch, "judge.db")
-        backup_database(args.database, copy)
-        db = PromptDatabase(copy)
-        try:
-            plan = build_plan(db, os.path.abspath(args.output_dir), args.database)
-            texts = _texts(db)
-        finally:
-            db.close_all()
-        simulated, audit = _rehearse(args.database, scratch, "relinks.db", plan)
-        plan.update(orphans=audit, delete_orphans=bool(args.delete_orphans))
-        if plan["delete_orphans"]:
-            # The plan as the apply will write it, deletes included
-            simulated, _audit = _rehearse(args.database, scratch, "deletes.db", plan)
-    plan["simulated"] = simulated
-    plan_path = Path(args.plan)
-    plan_path.write_text(
-        json.dumps(plan, indent=1, ensure_ascii=False) + "\n", encoding="utf-8"
-    )
-    list_path = plan_path.with_name(plan_path.stem + ".list.md")
-    list_path.write_text(markdown(plan, texts), encoding="utf-8")
-    out.write(f"{_summary(plan)}\n")
-    out.write(
-        f"Prompts that would lose every link: {len(audit)} "
-        f"({sum(o['safe'] for o in audit)} safe to delete; deleting "
-        f"{'ON' if plan['delete_orphans'] else 'OFF'})\n"
-    )
-    out.write(f"Plan: {plan_path}\nList: {list_path}\n")
-    out.write("Dry run: nothing was changed.\n")
-    return 0
-
-
-def _is_live(database, comfyui_dir):
-    live = os.path.join(comfyui_dir, *LIVE_LIBRARY)
-    return library_identity(database) == library_identity(live)
-
-
-def _stamp():
-    return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-
-
-def schema_of(path):
-    """``sqlite_master`` and ``user_version`` from a read-only connection."""
-    uri = Path(os.path.abspath(path)).as_uri() + "?mode=ro"
-    conn = sqlite3.connect(uri, uri=True)
-    try:
-        master = conn.execute(
-            "SELECT type, name, tbl_name, sql FROM sqlite_master ORDER BY type, name"
-        ).fetchall()
-        return master, conn.execute("PRAGMA user_version").fetchone()[0]
-    finally:
-        conn.close()
-
-
-def running_reasons(args, probe, handles):
-    """Why writing must not start now (empty: go ahead).
-
-    Another process holding the library open always counts, also in a
-    rehearsal; ComfyUI's processes and port count unless rehearsing.
-    """
-    held = [
-        reason
-        for reason in handles(args.database)
-        if not (reason == NO_PROC and args.i_stopped_comfyui)
-    ]
-    return held + ([] if args.rehearsal else probe(args.comfyui_dir, args.port))
-
-
-def _preflight(args, plan, probe, handles):
-    """The refusals before any backup or write, as a message (None: go on)."""
-    if plan.get("version") != PLAN_VERSION:
-        return "not a plan of this tool"
-    if args.rehearsal and _is_live(args.database, args.comfyui_dir):
-        return f"--rehearsal is for a copy; this is the library of {args.comfyui_dir}"
-    if plan.get("source_db") != library_identity(args.database):
-        return f"this plan was made for {plan.get('source_db')}"
-    if not os.path.isfile(os.path.join(args.comfyui_dir, "main.py")):
-        return f"no main.py in {args.comfyui_dir}: not a ComfyUI folder"
-    reasons = running_reasons(args, probe, handles)
-    if reasons:
-        return "ComfyUI may be running: " + "; ".join(reasons)
-    return None
-
-
-def _backup(args, before):
-    """The verified backup's path; raises ``Refused``."""
-    folder = args.backup_dir or os.path.dirname(os.path.abspath(args.database))
-    name = f"{os.path.basename(args.database)}.pre-247-repair_{_stamp()}"
-    backup = os.path.join(folder, name)
-    if os.path.exists(backup):
-        raise Refused(f"the backup {backup} already exists")
-    backup_database(args.database, backup)
-    saved = counts(backup, readonly=False)
-    if saved != before or saved["integrity_check"] != "ok":
-        raise Refused(f"the backup {backup} does not match the library")
-    return backup
-
-
-def _open_unchanged(path):
-    """``PromptDatabase(path)``; raises ``Refused`` when opening it changed
-    its schema (a migration of a newer checkout, committed on open)."""
-    schema = schema_of(path)
-    db = PromptDatabase(path)
-    db.model.get_connection()
-    if schema_of(path) != schema:
-        db.close_all()
-        raise Refused(
-            "opening the library with this checkout changed its schema (that "
-            "change is committed); run the tool from a checkout at the live "
-            "code version"
-        )
-    return db
-
-
-def apply(args, out, probe, handles):
-    with open(args.apply, encoding="utf-8") as stream:
-        plan = json.load(stream)
-    refusal = _preflight(args, plan, probe, handles)
-    if refusal:
-        out.write(f"REFUSED: {refusal}\n")
-        return 2
-    if args.rehearsal:
-        out.write("(rehearsal on a copy: ComfyUI's process and port not checked)\n")
-    before = counts(args.database)
-    try:
-        backup = _backup(args, before)
-    except Refused as error:
-        out.write(f"REFUSED: {error}\n")
-        return 2
-    out.write(f"Backup: {backup}\n")
-
-    def still_stopped():
-        reasons = running_reasons(args, probe, handles)
-        if reasons:
-            raise Refused("ComfyUI may be running: " + "; ".join(reasons))
-
-    try:
-        db = _open_unchanged(args.database)
-    except Refused as error:
-        out.write(f"REFUSED: {error}. Backup: {backup}\n")
-        return 2
-    try:
-        result, _audit = apply_plan(db, plan, before_write=still_stopped)
-    except Exception as error:
-        out.write(
-            f"REFUSED (rolled back, nothing changed): {error}. Backup: {backup}\n"
-        )
-        return 2
-    finally:
-        db.close_all()
-    after = counts(args.database)
-    _print_counts(before, after, out)
-    out.write(f"Applied: {json.dumps(result, sort_keys=True)}\n")
-    if after["integrity_check"] != "ok" or after["foreign_key_check"]:
-        out.write(f"WARNING: integrity or foreign-key check failed; restore {backup}\n")
-        return 1
-    return 0
-
-
-def main(argv=None, out=sys.stdout, probe=comfyui_running, handles=open_by_others):
-    parser = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
-    parser.add_argument("database", help="the library database (prompts.db)")
-    parser.add_argument("--output-dir", help="ComfyUI's output folder (dry run)")
-    parser.add_argument(
-        "--plan", default="repair_foreign_links_plan.json", help="plan to write"
-    )
-    parser.add_argument(
-        "--delete-orphans",
-        action="store_true",
-        help="record in the plan that the safe orphan prompts are deleted",
-    )
-    parser.add_argument("--apply", metavar="PLAN", help="write this reviewed plan")
-    parser.add_argument("--comfyui-dir", help="the ComfyUI folder (apply)")
-    parser.add_argument("--backup-dir", help="where the backup goes (apply)")
-    parser.add_argument("--port", type=int, default=COMFY_PORT)
-    parser.add_argument(
-        "--rehearsal",
-        action="store_true",
-        help="apply to a copy while ComfyUI runs (never its own library)",
-    )
-    parser.add_argument(
-        "--i-stopped-comfyui",
-        action="store_true",
-        help="without /proc: say ComfyUI is stopped (the port is still checked)",
-    )
-    args = parser.parse_args(argv)
-    if not os.path.isfile(args.database):
-        parser.error(f"no database at {args.database}")
-    if args.apply:
-        if not args.comfyui_dir:
-            parser.error("--apply needs --comfyui-dir (the running check)")
-        return apply(args, out, probe, handles)
-    if not args.output_dir:
-        parser.error("the dry run needs --output-dir")
-    if Path(args.plan).suffix.lower() == ".md":
-        parser.error("--plan is the JSON plan; the list is written beside it")
-    return dry_run(args, out)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

utils/foreign_runs.py

@@ -1,142 +0,0 @@
-"""The monitor's path for outputs of workflows without a PromptManager node (#247).
-
-A foreign output (no positive PromptManager node in its graph) is decided by
-the ladder the output scan uses (``utils.file_prompt.decide_file_prompt``)
-with the ``MONITOR`` policy: certain files are stored at once, files only
-recorded history can decide wait for their run's outputs to be sealed, and
-everything else stays unlinked. This module holds the parts that do not
-need the monitor's waiting sets: the setting, the decision call and the
-store. The waiting and the re-check stay on ``ImageGenerationHandler``.
-"""
-
-import os
-from dataclasses import dataclass
-from typing import Any, Callable, Mapping, Optional, Tuple
-
-from .file_prompt import (
-    NOT_SAVED,
-    NOT_SAVED_WIRED,
-    PAIR,
-    POSITIVE,
-    Decision,
-    Policy,
-    decide_file_prompt,
-)
-from .hashing import generate_prompt_hash
-from .usage_tracking import survive_switch
-
-try:
-    from ..database.pair_ingestion import RUN_MARKS, ingest_resolved_pair
-    from ..database.run_attribution import recorded_output_lookup
-    from ..database.scanned_prompts import store_scanned_prompt_or_raise
-except ImportError:
-    from database.pair_ingestion import RUN_MARKS, ingest_resolved_pair
-    from database.run_attribution import recorded_output_lookup
-    from database.scanned_prompts import store_scanned_prompt_or_raise
-
-# Decisions that name a prompt to store
-CERTAIN = (PAIR, POSITIVE)
-# Decisions of a run whose prompt has Save to library off, or wired from a
-# node the file cannot show (#90): final, nothing is stored, nothing waits
-NOT_SAVED_KINDS = (NOT_SAVED, NOT_SAVED_WIRED)
-# Sources certain without a recorded run: the graph alone, or its recorded saver
-ANCHORED_SOURCES = ("inspector", "recorded-run")
-
-
-@dataclass(frozen=True)
-class ForeignRecheck:
-    """``schedule`` snapshot: the one re-check of a foreign output after its
-    run's outputs were sealed. ``reference`` is the sealed output reference,
-    the spelling history recorded (``recorded_output_lookup(reference=)``)."""
-
-    reference: Mapping[str, Any]
-
-
-def save_foreign_runs() -> bool:
-    """Whether a foreign output may be stored now, read for every file.
-
-    ``GalleryConfig.SAVE_FOREIGN_RUNS`` and ``MONITORING_ENABLED``: a
-    monitoring switch saved off stops foreign writes at once, although the
-    running observer watches until a restart. True when the configuration
-    cannot be imported (the defaults).
-    """
-    try:
-        from ..py.config import GalleryConfig
-    except ImportError:
-        try:
-            from py.config import GalleryConfig
-        except ImportError:
-            return True
-    return (
-        GalleryConfig.SAVE_FOREIGN_RUNS is not False
-        and GalleryConfig.MONITORING_ENABLED is not False
-    )
-
-
-def history_lookup(
-    db: Any, image_path: str, reference: Optional[Mapping[str, Any]] = None
-) -> Callable[[], Any]:
-    """The ladder's ``lookup`` for one file: its ``RecordedOutput`` or None.
-
-    With ``reference`` the file is spelled as history recorded it. Failures
-    are logged by ``recorded_output_lookup`` and name nothing.
-    """
-    lookup = recorded_output_lookup(
-        db, reference=dict(reference) if reference is not None else None
-    )
-    return lambda: lookup(image_path)
-
-
-def decide_foreign(
-    image_path: str,
-    metadata: Any,
-    *,
-    in_output: bool,
-    lookup: Optional[Callable[[], Any]],
-) -> Decision:
-    """The ``MONITOR`` ladder for one foreign output (the size is read only
-    when the ladder needs it)."""
-
-    def file_size() -> Optional[int]:
-        try:
-            return os.path.getsize(image_path)
-        except OSError:
-            return None
-
-    return decide_file_prompt(
-        metadata,
-        file_name=os.path.basename(image_path),
-        file_size=file_size,
-        in_output=in_output,
-        lookup=lookup,
-        policy=Policy.MONITOR,
-    )
-
-
-def store_foreign(
-    db: Any, image_path: str, decision: Decision
-) -> Tuple[str, Optional[int]]:
-    """Store a certain decision: ``(status, prompt id)``.
-
-    One write through ``survive_switch``, so it runs again on the moved
-    library when a Move library switched while it waited (#249 S6b). Created
-    prompts carry ``RUN_MARKS``. A file linked to another prompt is a
-    ``conflict`` and nothing is written. Database errors are raised.
-    """
-
-    def store():
-        if decision.kind == PAIR:
-            result = ingest_resolved_pair(
-                db, image_path, decision.canonical, decision.resolution, marks=RUN_MARKS
-            )
-            return result["status"], result.get("image_id")
-        return store_scanned_prompt_or_raise(
-            db, image_path, decision.canonical, decision.text, RUN_MARKS
-        )
-
-    status, linked = survive_switch(db, store)
-    if decision.kind != PAIR or linked is None:
-        return status, linked
-    # The pair ingester reports the image row; its prompt is the positive's.
-    prompt = db.get_prompt_by_hash(generate_prompt_hash(decision.text))
-    return status, prompt["id"] if prompt else None

utils/hashing.py

@@ -58,72 +58,11 @@ def generate_prompt_hash(text: str) -> str:
     if not isinstance(text, str):
         raise TypeError("Text must be a string")
 
-    return hashlib.sha256(prompt_key(text).encode("utf-8")).hexdigest()
+    # Normalize the text by stripping whitespace and converting to lowercase
+    # for consistent hashing regardless of minor formatting differences
+    normalized_text = text.strip().lower()
 
-
-def stored_prompt_text(text: str) -> str:
-    """The text the Library stores for raw node text: outer whitespace removed.
-
-    Every prompt writer stores ``text.strip()`` and the hash above strips too,
-    so this is the form recorded raw run text is compared in (#438). Case and
-    inner whitespace stay significant.
-    """
-    return text.strip()
-
-
-# The code points str.strip() removes (every str.isspace() character), for
-# SQLite's char(); tests/test_hashing.py pins it to the running Python.
-STRIPPED_CODE_POINTS = (
-    *range(0x09, 0x0E),
-    *range(0x1C, 0x21),
-    0x85,
-    0xA0,
-    0x1680,
-    *range(0x2000, 0x200B),
-    0x2028,
-    0x2029,
-    0x202F,
-    0x205F,
-    0x3000,
-)
-_STRIP_CODES = ",".join(map(str, STRIPPED_CODE_POINTS))
-
-
-def prompt_key(text: str) -> str:
-    """The dedup key: the stored text with case folded by ``str.lower()``.
-
-    Two texts with one key are one prompt (the hash is sha256 of the key), so
-    a run belongs to the history of the prompt with its key (#460).
-    """
-    return stored_prompt_text(text).lower()
-
-
-def _sql_key(value):
-    return prompt_key(value) if isinstance(value, str) else None
-
-
-def _sql_hash(value):
-    return generate_prompt_hash(value) if isinstance(value, str) else None
-
-
-def register_prompt_functions(conn) -> None:
-    """Give ``conn`` ``pm_prompt_key(x)`` and ``pm_prompt_hash(x)`` (#460).
-
-    SQLite's lower() folds ASCII only; these call Python, so SQL gets exactly
-    ``prompt_key`` / ``generate_prompt_hash`` (NULL for a non-text value).
-    Never used in schema objects, so the file stays readable without them.
-    """
-    conn.create_function("pm_prompt_key", 1, _sql_key, deterministic=True)
-    conn.create_function("pm_prompt_hash", 1, _sql_hash, deterministic=True)
-
-
-def stored_prompt_text_sql(expression: str) -> str:
-    """``stored_prompt_text`` as an SQLite expression over ``expression``.
-
-    SQLite's one-argument trim() removes spaces only; trim(X, Y) removes every
-    character of Y, multi-byte ones included, so it strips what Python does.
-    """
-    return f"trim({expression}, char({_STRIP_CODES}))"
+    return hashlib.sha256(normalized_text.encode("utf-8")).hexdigest()
 
 
 def is_duplicate_prompt(text1: str, text2: str, threshold: float = 0.95) -> bool:

utils/image_monitor.py

@@ -33,17 +33,6 @@ from typing import Callable, Optional, Dict, Any, List, Tuple
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
-from .file_prompt import HISTORY, NOT_SAVED, NOT_SAVED_WIRED
-from .foreign_runs import (
-    ANCHORED_SOURCES,
-    CERTAIN,
-    NOT_SAVED_KINDS,
-    ForeignRecheck,
-    decide_foreign,
-    history_lookup,
-    save_foreign_runs,
-    store_foreign,
-)
 from .hashing import generate_prompt_hash
 from .metadata_extractor import ComfyUIMetadataExtractor
 from .parallel import note_refusal, refused_at_shutdown
@@ -164,11 +153,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
         # Sealed re-checks ``schedule`` refused (the path still pending, or the
         # pending set full): retried each time a pending image finishes.
         self._history_due: "OrderedDict[str, None]" = OrderedDict()
-        # The same two sets for foreign outputs (#247), apart so a large
-        # foreign run never evicts a waiting keyless file; the due set keeps
-        # each file's sealed output reference.
-        self._awaiting_foreign: "OrderedDict[str, Tuple[str, float]]" = OrderedDict()
-        self._foreign_due: "OrderedDict[str, dict]" = OrderedDict()
         self._awaiting_lock = threading.Lock()
         self._sealed_subscribed = False
         # Set by ``close``: no new work, no new worker, ever (#302).
@@ -269,8 +253,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
         with self._awaiting_lock:
             self._awaiting.clear()
             self._history_due.clear()
-            self._awaiting_foreign.clear()
-            self._foreign_due.clear()
         with self._pending_lock:
             self._pending.clear()
             worker, self._worker = self._worker, None
@@ -456,9 +438,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
             if prompt_snapshot is HISTORY_ONLY:
                 self._recheck_history(image_path)
                 return
-            if isinstance(prompt_snapshot, ForeignRecheck):
-                self._recheck_foreign(image_path, prompt_snapshot.reference)
-                return
             self.logger.info(f"Processing image: {image_path}")
 
             if not os.path.exists(image_path):
@@ -478,12 +457,17 @@ class ImageGenerationHandler(FileSystemEventHandler):
             # negative-prompt PromptManager nodes in the workflow.
             state, current_prompt = self._find_prompt_from_metadata(metadata)
             if state == "opted_out":
-                self._log_not_saved(image_path)
+                self.logger.info(
+                    "Save to library is off for this run's prompt, skipping image: "
+                    f"{image_path}"
+                )
                 return
             if state == "foreign":
-                # Another workflow saved this image: never a batch queue entry
-                # of ours; its own graph may name its prompt (#247).
-                self._ingest_foreign(image_path, metadata)
+                # Another workflow saved this image: it belongs to no prompt of
+                # ours, and must not consume a batch queue entry.
+                self.logger.info(
+                    f"No PromptManager prompt in workflow, skipping image: {image_path}"
+                )
                 return
             if current_prompt:
                 self.logger.info(
@@ -605,55 +589,36 @@ class ImageGenerationHandler(FileSystemEventHandler):
             resolved = os.path.abspath(image_path)
         return os.path.normcase(resolved)
 
-    def _prune_awaiting(self, store=None) -> List[Tuple[str, bool]]:
-        """Drop expired and surplus entries of ``store`` (the keyless set by
-        default; ``_awaiting_lock`` held). Returns the dropped foreign files
-        as ``(path, evicted)`` for ``_log_dropped`` after the lock."""
-        store = self._awaiting if store is None else store
+    def _prune_awaiting(self) -> None:
+        """Drop expired and surplus entries (``_awaiting_lock`` held)."""
         now = time.monotonic()
-        expired = [k for k, (_p, due) in store.items() if due <= now]
-        dropped = [(store.pop(key)[0], False) for key in expired]
-        while len(store) > MAX_AWAITING_HISTORY:
-            dropped.append((store.popitem(last=False)[1][0], True))
-        return dropped if store is self._awaiting_foreign else []
+        for key in [k for k, (_p, due) in self._awaiting.items() if due <= now]:
+            del self._awaiting[key]
+        while len(self._awaiting) > MAX_AWAITING_HISTORY:
+            self._awaiting.popitem(last=False)
 
-    def _log_dropped(self, dropped: List[Tuple[str, bool]]) -> None:
-        """Log foreign files that stopped waiting (outside ``_awaiting_lock``)."""
-        for image_path, evicted in dropped:
-            name = os.path.basename(image_path)
-            if evicted:
-                self.logger.info(
-                    f"Too many files wait for their run; {name} left unlinked"
-                )
-            else:
-                self.logger.info(f"No recorded run for {name}; left unlinked")
-
-    def _await_history(self, image_path: str, store=None) -> None:
+    def _await_history(self, image_path: str) -> None:
         """Re-check ``image_path`` once, history only, when its run is sealed.
 
-        ``store`` is the waiting set (``_awaiting_foreign`` for a foreign
-        output). A closed handler re-checks nothing.
+        A closed handler re-checks nothing.
         """
         if self._closed:
             return
         if not self._sealed_subscribed:
             subscribe_outputs_sealed(self._on_outputs_sealed)
             self._sealed_subscribed = True
-        store = self._awaiting if store is None else store
         key = self._awaiting_key(image_path)
         with self._awaiting_lock:
-            store.pop(key, None)
-            store[key] = (image_path, time.monotonic() + AWAIT_HISTORY_SECONDS)
-            dropped = self._prune_awaiting(store)
-        self._log_dropped(dropped)
+            self._awaiting.pop(key, None)
+            self._awaiting[key] = (
+                image_path,
+                time.monotonic() + AWAIT_HISTORY_SECONDS,
+            )
+            self._prune_awaiting()
 
-    def _await_foreign(self, image_path: str) -> None:
-        self._await_history(image_path, self._awaiting_foreign)
-
-    def _stop_awaiting(self, image_path: str, store=None) -> None:
-        store = self._awaiting if store is None else store
+    def _stop_awaiting(self, image_path: str) -> None:
         with self._awaiting_lock:
-            store.pop(self._awaiting_key(image_path), None)
+            self._awaiting.pop(self._awaiting_key(image_path), None)
 
     def awaiting_history(self) -> List[str]:
         """Normalized paths still waiting for their run's recorded outputs."""
@@ -661,14 +626,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
             self._prune_awaiting()
             return list(self._awaiting)
 
-    def awaiting_foreign(self) -> List[str]:
-        """Normalized paths of foreign outputs waiting for their run (#247)."""
-        with self._awaiting_lock:
-            dropped = self._prune_awaiting(self._awaiting_foreign)
-            waiting = list(self._awaiting_foreign)
-        self._log_dropped(dropped)
-        return waiting
-
     def _on_outputs_sealed(self, run_id: str, references: List[dict]) -> None:
         """A run's outputs were recorded: re-check its waiting images once.
 
@@ -680,7 +637,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
         due = []
         with self._awaiting_lock:
             self._prune_awaiting()
-            dropped = self._prune_awaiting(self._awaiting_foreign)
             for reference in references:
                 if reference.get("folder_type") != "output":
                     continue
@@ -691,53 +647,39 @@ class ImageGenerationHandler(FileSystemEventHandler):
                 )
                 waiting = self._awaiting.pop(key, None)
                 if waiting is not None:
-                    due.append((waiting[0], None))
-                waiting = self._awaiting_foreign.pop(key, None)
-                if waiting is not None:
-                    due.append((waiting[0], dict(reference)))
-        self._log_dropped(dropped)
-        for image_path, reference in due:
-            self._schedule_recheck(image_path, reference)
+                    due.append(waiting[0])
+        for image_path in due:
+            self._schedule_recheck(image_path)
 
-    @staticmethod
-    def _recheck_snapshot(reference):
-        return HISTORY_ONLY if reference is None else ForeignRecheck(reference)
-
-    def _schedule_recheck(self, image_path: str, reference=None) -> None:
-        """Schedule the history-only re-check (with the sealed ``reference``:
-        a foreign output's), or keep it due for later.
+    def _schedule_recheck(self, image_path: str) -> None:
+        """Schedule the history-only re-check, or keep it due for later.
 
         A closed handler drops it.
         """
         if self._closed:
             return
-        if self.schedule(image_path, self._recheck_snapshot(reference)):
+        if self.schedule(image_path, HISTORY_ONLY):
             return
         with self._awaiting_lock:
             # ``close`` sets the flag before ``shutdown`` clears this set, so
             # a close that raced the refusal above is seen here.
             if self._closed:
                 return
-            due = self._history_due if reference is None else self._foreign_due
-            due.pop(image_path, None)
-            due[image_path] = reference
-            evicted = []
-            while len(due) > MAX_AWAITING_HISTORY:
-                evicted.append(due.popitem(last=False)[0])
-        if reference is not None:
-            self._log_dropped([(path, True) for path in evicted])
+            self._history_due.pop(image_path, None)
+            self._history_due[image_path] = None
+            while len(self._history_due) > MAX_AWAITING_HISTORY:
+                self._history_due.popitem(last=False)
 
     def _drain_history_due(self) -> None:
         """Schedule due re-checks now that a pending slot or path is free."""
         with self._awaiting_lock:
-            due = [(self._history_due, p, None) for p in self._history_due]
-            due += [(self._foreign_due, *item) for item in self._foreign_due.items()]
-        for store, image_path, reference in due:
-            if self.schedule(image_path, self._recheck_snapshot(reference)):
+            if not self._history_due:
+                return
+            due = list(self._history_due)
+        for image_path in due:
+            if self.schedule(image_path, HISTORY_ONLY):
                 with self._awaiting_lock:
-                    # A newer seal may have replaced it meanwhile: keep that one
-                    if image_path in store and store[image_path] is reference:
-                        del store[image_path]
+                    self._history_due.pop(image_path, None)
 
     def _recheck_history(self, image_path: str) -> None:
         """The one history-only re-check of a keyless image (#342)."""
@@ -761,108 +703,6 @@ class ImageGenerationHandler(FileSystemEventHandler):
             metadata or {"file_info": self.get_basic_file_info(image_path)},
         )
 
-    def _ingest_foreign(self, image_path: str, metadata) -> None:
-        """A foreign output at settle: store its certain prompt, or wait for
-        its run's recorded outputs when only history can decide (#247)."""
-        name = os.path.basename(image_path)
-        if not save_foreign_runs():
-            self.logger.info(
-                f"No PromptManager prompt in workflow, skipping image: {image_path}"
-            )
-            return
-        in_output = in_output_folder(image_path, host_output_directory())
-        decision = decide_foreign(
-            image_path, metadata, in_output=in_output, lookup=None
-        )
-        if decision.kind == HISTORY:
-            decision = self._settle_lookup(image_path, metadata)
-            if decision is None:
-                self.logger.debug(f"{name} waits for its run to end")
-                return
-            self._stop_awaiting(image_path, self._awaiting_foreign)
-        if decision.kind in NOT_SAVED_KINDS:
-            self._log_not_saved(image_path, decision.kind)
-        elif decision.kind in CERTAIN:
-            self._store_foreign(image_path, decision)
-        else:
-            self.logger.info(f"No certain prompt for {name}; left unlinked")
-
-    def _log_not_saved(self, image_path: str, kind: str = NOT_SAVED) -> None:
-        """The log line of a file whose run's prompt does not save (#90)."""
-        if kind == NOT_SAVED_WIRED:
-            reason = "is wired from a node the image cannot show"
-        else:
-            reason = "is off"
-        self.logger.info(
-            f"Save to library {reason} for this run's prompt, skipping image: "
-            f"{image_path}"
-        )
-
-    def _settle_lookup(self, image_path: str, metadata):
-        """The settle-time history lookup of a file only history can decide.
-
-        Registered first, so a run sealed before this lookup is not missed.
-        Returns None to keep waiting: no record yet, and the answer is not
-        the inspector's or the recorded saver's (the legacy floor waits for
-        the re-check). With a record, any decision ends the wait. A
-        ``not_saved`` here is the undecided step's (an early one never asks
-        history, so it never reaches this lookup): a recorded saver may still
-        resolve another branch, so without a record it waits too (#90).
-        """
-        self._await_foreign(image_path)
-        found = []
-        lookup = history_lookup(self.db_manager, image_path)
-
-        def recorded():
-            found.append(lookup())
-            return found[-1]
-
-        decision = decide_foreign(image_path, metadata, in_output=True, lookup=recorded)
-        if any(record is not None for record in found):
-            return decision
-        if decision.kind in CERTAIN and decision.source in ANCHORED_SOURCES:
-            return decision
-        return None
-
-    def _recheck_foreign(self, image_path: str, reference) -> None:
-        """The one re-check of a foreign output after its run ended (#247)."""
-        name = os.path.basename(image_path)
-        if not os.path.exists(image_path):
-            return
-        if not save_foreign_runs():
-            self.logger.info(f"Saving prompts from other workflows is off: {name}")
-            return
-        try:
-            metadata = self.metadata_extractor.extract_metadata(image_path)
-        except Exception as error:
-            self.logger.warning(f"Metadata of {name} could not be read: {error}")
-            return
-        lookup = history_lookup(self.db_manager, image_path, reference)
-        decision = decide_foreign(image_path, metadata, in_output=True, lookup=lookup)
-        if decision.kind in NOT_SAVED_KINDS:
-            self._log_not_saved(image_path, decision.kind)
-            return
-        if decision.kind in CERTAIN:
-            self._store_foreign(image_path, decision)
-            return
-        self.logger.info(
-            f"No certain prompt for {name} after its run ended; left unlinked"
-        )
-
-    def _store_foreign(self, image_path: str, decision) -> None:
-        name = os.path.basename(image_path)
-        if not save_foreign_runs():  # switched off while this file was decided
-            self.logger.info(f"Saving prompts from other workflows is off: {name}")
-            return
-        try:
-            status, prompt_id = store_foreign(self.db_manager, image_path, decision)
-        except Exception as error:
-            self.logger.error(f"Failed to store the prompt of {name}: {error}")
-            return
-        self.logger.info(
-            f"Foreign run: {status} prompt {prompt_id} for {name} ({decision.source})"
-        )
-
     def _history_prompt(self, image_path: str) -> Optional[int]:
         """The stored prompt recorded history attributes to this file, if one."""
         try:

web/js/workspace/history.mjs

@@ -173,7 +173,7 @@ export function mountRecordedHistory(container, {api, positiveId, parentScope, s
         }
         count.textContent = window.group ? `${countOf(window.recorded_run_count, 'distinct recorded run')} as of this read · ${window.items.length} loaded positions` : '';
         const group = window.group;
-        scopeText.textContent = group?.scope_status === 'uncapturable_text' ? 'This saved positive cannot be matched within frozen-text capture limits.' : 'Runs are grouped by frozen positive raw text that is this saved text apart from outer whitespace, independently of saved pairs. Effective text, prepend/append composition and evidence can differ. Reported output locations do not establish context membership or historical file identity.';
+        scopeText.textContent = group?.scope_status === 'uncapturable_text' ? 'This saved positive cannot be matched within frozen-text capture limits.' : 'Runs are grouped by exact frozen positive raw text, independently of saved pairs. Effective text, prepend/append composition and evidence can differ. Reported output locations do not establish context membership or historical file identity.';
         status.setAttribute('role', window.error || next.run.error ? 'alert' : 'status');
         status.textContent = next.validating ? 'Revalidating recorded history…' : window.loading ? 'Loading recorded history…' : window.error ? 'Recorded history could not be loaded.' : next.refreshRequired ? 'Recorded evidence changed. Reload before using these actions.' : !items.length ? 'No matching recorded executions.' : window.has_more ? 'Newest bounded window · displayed in chronological order.' : 'All matching recorded runs in this window are loaded.';
         if (next.run.error && !next.selection.run_id && !next.refreshRequired) status.textContent += ' The previous recorded selection could not be restored.';

web/js/workspace/library-state.mjs

@@ -12,18 +12,10 @@ function parameters(filters,limit) {
     for(const tag of filters.tags || []) if(tag.trim()) query.append('tag',tag.trim());
     const sort=filters.sort || 'newest';
     if(!['newest','oldest','name'].includes(sort)) throw new TypeError('Invalid library sort');
-    // #444: how Tags match; `untagged` lists parents no tag's Browse returns and never goes with tags.
-    const tagMode=filters.tagMode ?? 'all';
-    if(!LIBRARY_TAG_MODES.includes(tagMode) || (tagMode==='untagged' && query.has('tag'))) throw new TypeError('Invalid library tag mode');
-    if(tagMode!=='all') query.set('tag_mode',tagMode);
     query.set('sort',sort);return query;
 }
-/** The Library's tag match values (#444); the first is the default, sent as no parameter. */
-export const LIBRARY_TAG_MODES=Object.freeze(['all','untagged']);
 // `variant_total` is the filtered parents' active negative variants (the concept caption's "M negative variants").
-function validatePage(page,cursor,query) {
-    // A tag match the server did not echo was not applied (an older server): never show the whole shelf as filtered.
-    if(query?.has('tag_mode') && page?.tag_mode!==query.get('tag_mode')) throw new TypeError('Unconfirmed library tag mode');
+function validatePage(page,cursor) {
     if(!page || !Array.isArray(page.items) || page.items.some(item=>!parent(item)) || !Number.isSafeInteger(page.total) || page.total<0 || !Number.isSafeInteger(page.variant_total) || page.variant_total<0 || typeof page.has_more!=='boolean' || !(page.next_cursor===null || (typeof page.next_cursor==='string' && page.next_cursor.length)) || page.has_more!==(page.next_cursor!==null) || (page.has_more && cursor===page.next_cursor)) throw new TypeError('Invalid library page');
 }
 export function createLibraryStream({api,onChange=()=>{},restore}) {
@@ -45,7 +37,7 @@ export function createLibraryStream({api,onChange=()=>{},restore}) {
         try {
             const page=await api.get(`/prompt_manager/library?${params}`,{signal:current.signal});
             if(disposed || current!==request) return 0;
-            validatePage(page,cursor,query);
+            validatePage(page,cursor);
             // #437: the storage epoch the shelf's items were read under, which a bulk write sends as its fence; a later
             // page from a restored storage is refused (its items would belong to another database).
             const epoch=typeof page.library_epoch==='string'?page.library_epoch:null;

web/js/workspace/library.mjs

@@ -2,7 +2,7 @@ import {createScope,createButton} from '../shared/toolkit/core.js';
 import {createPromptSender} from './prompt-sender.mjs';
 import {mountPromptBlocks} from './prompt-inspector.mjs';
 import {mountImages} from './images.mjs';
-import {createLibraryStream,createLibraryDetail,libraryPromptRoles,LIBRARY_TAG_MODES} from './library-state.mjs';
+import {createLibraryStream,createLibraryDetail,libraryPromptRoles} from './library-state.mjs';
 import {promptRoles} from './prompt-blocks.mjs';
 import {createLibraryEditor,showWorkspaceToast} from './library-editor.mjs';
 import {createLibraryEditorController} from './library-editor-state.mjs';
@@ -31,8 +31,6 @@ const metadataDrafts=new Map();
 const archivedVisible=new Map();
 // The concept's sorts first, then the Library's appended Oldest first (D14); D153 (#447) drops "Highest rated".
 const LIBRARY_SORTS=Object.freeze([['newest','Recently added'],['name','Name A–Z'],['oldest','Oldest first']]);
-// Refine › Tag match (#444 D149), in LIBRARY_TAG_MODES order.
-const TAG_MATCH_OPTIONS=Object.freeze([['all','All of these tags'],['untagged','Prompts without tags']]);
 // A card's focusable controls in order: the D148 selection checkbox, then its buttons (#437).
 const CARD_CONTROLS='button, input[type="checkbox"]';
 const CATEGORIES_FAILED='Categories could not be loaded. Open the Prompt library again to retry.';
@@ -85,9 +83,9 @@ export function onLibraryWrite(listener) {
  * with the existing Library filters, and the heading takes focus as after a save.
  */
 export function browseLibrary(filters) {
-    const {text='',category='',tags=[],sort='newest',tagMode='all'}=filters || {};
-    if(typeof text!=='string' || typeof category!=='string' || !Array.isArray(tags) || tags.some(tag=>typeof tag!=='string') || typeof sort!=='string' || !LIBRARY_TAG_MODES.includes(tagMode)) throw new TypeError('Invalid Library filters');
-    shelfVisit={filters:{text,category,tags:[...tags],sort,tagMode},anchor:null};
+    const {text='',category='',tags=[],sort='newest'}=filters || {};
+    if(typeof text!=='string' || typeof category!=='string' || !Array.isArray(tags) || tags.some(tag=>typeof tag!=='string') || typeof sort!=='string') throw new TypeError('Invalid Library filters');
+    shelfVisit={filters:{text,category,tags:[...tags],sort},anchor:null};
     focusHeadingOnMount=true;window.location.hash='#/library';
 }
 /** Remember the selection a reconciled save names, so the destination history opens on it once. */
@@ -160,16 +158,15 @@ export function mountLibrary(main,api,parentScope,{positiveId,savedState=null,on
         const visit=saved?null:shelfVisit, mountedGeneration=writeGeneration;
         // An invalidated visit keeps only filters and anchor: the stream restarts and heights are measured again.
         const restorable=visit?.state?visit:null;
-        const filters={text:'',category:'',tags:[],sort:'newest',tagMode:'all',...visit?.filters,...saved};
+        const filters={text:'',category:'',tags:[],sort:'newest',...visit?.filters,...saved};
         // D153: a sort the shelf no longer offers (an older "Highest rated" visit) reads as Recently added.
         if(!LIBRARY_SORTS.some(([value])=>value===filters.sort)) filters.sort='newest';
         const section=el('section',undefined,'library-shelf');section.setAttribute('aria-label','Prompt library');
         // The shared concept toolbar (app.js toolbar(), a347–360): Tags live in "Refine this view" (D14), no Refresh (D15).
         // Its own scope, disposed after the visit is saved: removing it first would shorten the page and clamp scrollY.
         const toolbarScope=createScope();
-        // D44: Filters reads "Filters · N" while Refine filters (from Refine or a Browse) narrow the shelf: Tags, and a
-        // Tag match other than All (#444 D149).
-        const refinements=()=>(filters.tags.length?1:0)+(filters.tagMode!=='all'?1:0);
+        // D44: Filters reads "Filters · 1" while a Tags filter (from Refine or a Browse) narrows the shelf.
+        const refinements=()=>filters.tags.length?1:0;
         const toolbar=mountToolbar(section,{scope:toolbarScope,categories:filters.category?[filters.category]:[],sorts:LIBRARY_SORTS,
             value:{q:filters.text,category:filters.category,sort:filters.sort},activeFilters:refinements(),onChange:applyToolbar,onFilters:openFilters,
             onSaveView:trigger=>{const value=toolbar.value();onSaveView(trigger,libraryViewState({...filters,text:value.q.trim(),category:value.category,sort:value.sort}));}});
@@ -397,10 +394,7 @@ export function mountLibrary(main,api,parentScope,{positiveId,savedState=null,on
             const hidden=hiddenSave!==null && !next.loading && !next.error && !next.hasMore && !next.items.some(item=>item.id===hiddenSave)?' The saved prompt is hidden by the current filters.':'';
             message.textContent=(next.error?'Prompt library could not be loaded. Retry.':next.loading?'Loading prompt library…':!next.items.length?'No matching prompts. Try changing the filters.':!next.hasMore?'You’re all caught up.':'')+hidden;
             message.setAttribute('role',next.error?'alert':'status');retry.hidden=!next.error;more.hidden=!next.hasMore || !!next.error;more.setAttribute('aria-disabled',String(next.loading));
-            // #464: a loaded page is laid out now, not on the next frame: a starved renderer (a background tab, headless
-            // WebKit under load) can hold frames for seconds, which left a loaded shelf empty. Measurements still flush per frame.
-            if(batch && grid.isConnected) {cancelAnimationFrame(frame);flush();} else schedule();
-            scheduleLoad();
+            schedule();scheduleLoad();
         }
         const stream=createLibraryStream({api,onChange:render,restore:restorable?{filters,state:restorable.state}:undefined});
         function maybeLoad() {
@@ -423,17 +417,15 @@ export function mountLibrary(main,api,parentScope,{positiveId,savedState=null,on
             if(Object.entries(next).every(([key,item])=>filters[key]===item)) return;
             Object.assign(filters,next);reset();
         }
-        /** "Refine this view" with the Library's extra filters, Tags (D14) and Tag match (D149); Clear also clears the toolbar category. */
+        /** "Refine this view" with the Library's one extra filter, Tags (D14); Clear also clears the toolbar category. */
         function openFilters(trigger) {
-            openRefineDialog({scope,trigger,fields:[{key:'tags'},{key:'tagMode',options:TAG_MATCH_OPTIONS}],
-                values:{tags:filters.tags.join(', '),tagMode:filters.tagMode},onApply:applyRefinement,
+            openRefineDialog({scope,trigger,fields:[{key:'tags'}],values:{tags:filters.tags.join(', ')},onApply:applyRefinement,
                 onClear:cleared=>{toolbar.setValue({category:cleared.category});applyRefinement(cleared);}});
         }
-        function applyRefinement({tags,tagMode='all',category=filters.category}) {
-            // "Prompts without tags" takes no Tags (the dialog disables them).
-            const next=tagMode==='untagged'?[]:[...new Set(tags.split(',').map(tag=>tag.trim()).filter(Boolean))];
-            if(category===filters.category && tagMode===filters.tagMode && next.length===filters.tags.length && next.every((tag,index)=>tag===filters.tags[index])) return;
-            filters.category=category;filters.tags=next;filters.tagMode=tagMode;reset();
+        function applyRefinement({tags,category=filters.category}) {
+            const next=[...new Set(tags.split(',').map(tag=>tag.trim()).filter(Boolean))];
+            if(category===filters.category && next.length===filters.tags.length && next.every((tag,index)=>tag===filters.tags[index])) return;
+            filters.category=category;filters.tags=next;reset();
         }
         scope.listen(more,'click',()=>stream.loadMore());
         // Retry also re-reads a category list that failed (D15: Refresh is gone).

web/js/workspace/saved-views.mjs

@@ -47,8 +47,6 @@ const FIELDS = Object.freeze({
     }),
     library: Object.freeze({
         q: text(500), category: text(100), sort: choice(['newest', 'oldest', 'name'], 'newest'), tags,
-        // #444: how the Tags match; 'untagged' never goes with tags (the listing refuses both).
-        tag_mode: choice(['all', 'untagged'], 'all'),
     }),
 });
 
@@ -65,8 +63,6 @@ export function normalizeViewState(page, state) {
     }));
     // Favorites and a collection are never both a view's filter: the collection wins, as the listing does (D140).
     if (normalized.favorites === true && normalized.collection) normalized.favorites = false;
-    // Untagged and tags are never both a view's filter either: the tags win, as the server's normalizer does.
-    if (normalized.tag_mode === 'untagged' && normalized.tags.length) normalized.tag_mode = 'all';
     return normalized;
 }
 
@@ -117,11 +113,10 @@ export function imagesViewState(filters) {
 /** Library shelf filters (library.mjs `filters`) from a saved state, and the state of the current filters. */
 export function libraryFilters(state) {
     const view = normalizeViewState('library', state);
-    return { text: view.q, category: view.category, sort: view.sort, tags: view.tags, tagMode: view.tag_mode };
+    return { text: view.q, category: view.category, sort: view.sort, tags: view.tags };
 }
 export function libraryViewState(filters) {
-    return normalizeViewState('library', { q: filters.text, category: filters.category, sort: filters.sort, tags: filters.tags,
-        tag_mode: filters.tagMode ?? 'all' });
+    return normalizeViewState('library', { q: filters.text, category: filters.category, sort: filters.sort, tags: filters.tags });
 }
 
 /**

web/js/workspace/system-sources.mjs

@@ -14,9 +14,6 @@
  *   it to the host draft of `gallery_root_paths`; Remove takes one out. Both wait for the one Save row.
  * - "Watch for new outputs" (`monitoring_enabled`) and "Worker threads" (`worker_threads`, a range up to the server's
  *   `cpu_count`, D113) are host drafts too. "Enrich existing metadata" reviews a scan of every source.
- * - D158 (#247): "Save prompts from other workflows" (`save_foreign_runs`), a host draft below "Watch for new outputs",
- *   applied by the server at once (the monitor reads it for every file); disabled, saying why, while monitoring is off,
- *   unless the running monitor still watches until a restart (D128 `stopping`): then it can still be set.
  * - "Thumbnail generation → Review options" opens "Thumbnail maintenance" (thumbnail-review.mjs, S5 Task 14), which
  *   starts the thumbnail Activity job.
  *
@@ -66,21 +63,6 @@ export const LOAD_FAILED_TEXT = 'Sources could not be loaded. Your saved data ha
 export const DUPLICATE_TEXT = 'This folder is already a source.';
 export const VALIDATE_FAILED_TEXT = 'The folder could not be checked. Try again.';
 export const REFRESH_FAILED_TEXT = 'Files could not be refreshed. Try again.';
-/** D158 (#247): the row the concept does not draw, below "Watch for new outputs". */
-export const FOREIGN_RUNS = Object.freeze({ id: 'foreign-runs', key: 'save_foreign_runs', label: 'Save prompts from other workflows',
-    description: 'New outputs of workflows without a PromptManager node add their prompt to the library when it is certain.',
-    off: 'Applies while Watch for new outputs is on.' });
-
-/**
- * D158: the row for the drafted `save_foreign_runs` (`value`) and `monitoring_enabled` (`monitoring`): disabled until
- * read, and while monitoring is off, when `note` says why (the value is kept and saved as it is). `stopping`: a source
- * is still watched until the restart (D128), so the value can still be set; the note stays.
- */
-export function foreignRunsState({ value, monitoring, stopping = false }) {
-    if (value === undefined) return { disabled: true, checked: null, note: null };
-    const off = monitoring === false;
-    return { disabled: off && !stopping, checked: value === true, note: off ? FOREIGN_RUNS.off : null };
-}
 
 // Labels of the sources added in this page session (validate-source answers them), for the rows not saved yet.
 const addedLabels = new Map();
@@ -285,16 +267,13 @@ export function mountSources(container, { api, activity, scope, drafts, notify =
     const monitoring = settingRow({ id: 'monitoring', label: 'Watch for new outputs',
         description: 'New files enter the same library. Existing scans do not count as new runs.', control: { type: 'toggle' },
         scope, onChange: value => drafts.set('host', 'monitoring_enabled', value) });
-    const foreign = settingRow({ id: FOREIGN_RUNS.id, label: FOREIGN_RUNS.label, description: FOREIGN_RUNS.description,
-        control: { type: 'toggle' }, scope, onChange: value => drafts.set('host', FOREIGN_RUNS.key, value) });
     const workers = settingRow({ id: 'workers', label: 'Worker threads',
         description: 'Balance background scans and thumbnail work against generation.', control: { type: 'range', value: 4 },
         scope, onChange: value => drafts.set('host', 'worker_threads', value) });
-    const hostRows = [[monitoring, 'monitoring', 'monitoring_enabled'], [foreign, FOREIGN_RUNS.id, FOREIGN_RUNS.key],
-        [workers, 'workers', 'worker_threads']]
+    const hostRows = [[monitoring, 'monitoring', 'monitoring_enabled'], [workers, 'workers', 'worker_threads']]
         .map(([row, id, key]) => ({ input: controlOf(row, id), key, text: row.children[0], note: null }));
     for (const row of hostRows) row.input.dataset.key = row.key;
-    surface.append(monitoring, foreign, workers,
+    surface.append(monitoring, workers,
         operationRow({ scope, title: 'Enrich existing metadata', description: 'Resolve both prompts, deduplicate recipes, preserve uncertain links.',
             label: 'Review scan', onClick: scanAll }),
         operationRow({ scope, title: 'Thumbnail generation', description: 'Generate missing previews; rebuilding all is a separate explicit option.',
@@ -369,10 +348,6 @@ export function mountSources(container, { api, activity, scope, drafts, notify =
         for (const row of hostRows) {
             const value = drafts.get('host', row.key);
             row.input.disabled = value === undefined;
-            if (row.key === FOREIGN_RUNS.key) {
-                paintForeign(row, value, unavailable);
-                continue;
-            }
             if (row.key === 'worker_threads') {
                 // D113: the range ends at the server's core count (the concept's fixed 16).
                 const cpus = drafts.get('host', 'cpu_count');
@@ -385,24 +360,6 @@ export function mountSources(container, { api, activity, scope, drafts, notify =
         }
     }
 
-    // D158: disabled while monitoring is drafted off, with the reason under the description.
-    function paintForeign(row, value, unavailable) {
-        const stopping = sources?.effective?.some(source => source.watch === 'stopping') === true;
-        const state = foreignRunsState({ value, monitoring: drafts.get('host', 'monitoring_enabled'), stopping });
-        row.input.disabled = state.disabled;
-        if (state.checked !== null) row.input.checked = state.checked;
-        const note = unavailable && value === undefined ? HOST_UNAVAILABLE : state.note;
-        if (note && row.note?.textContent !== note) {
-            row.note?.remove();
-            row.note = el('p', note, 'small');
-            row.note.id = `${FOREIGN_RUNS.id}-note`;
-            row.text.append(row.note);
-        } else if (!note && row.note) { row.note.remove(); row.note = null; }
-        // The note is the switch's description, so a screen reader says why it is disabled.
-        if (row.note) row.input.setAttribute('aria-describedby', row.note.id);
-        else row.input.removeAttribute('aria-describedby');
-    }
-
     // The sources changed since this page read them (a refused per-source scan): read them and the saved values again.
     function reread() {
         load();
@@ -421,7 +378,6 @@ export function mountSources(container, { api, activity, scope, drafts, notify =
         if (answer === STALE || scope.signal.aborted) return;
         sources = answer?.sources ?? null;
         paintList();
-        paintControls();
     }
 
     // A save (or a reread after a conflict) changed the saved sources or monitoring: read their state again. The first

web/js/workspace/vocabulary-state.mjs

@@ -26,12 +26,6 @@ const UNCONFIRMED_STATUS = new Set([502, 503, 504]);
 // Phases that may send a command; done, storage-changed and unknown-outcome need reset().
 const READY = new Set(['idle', 'previewed', 'write-error', 'conflict']);
 const IMPACT_FIELDS = ['positive_prompts', 'other_prompts', 'negative_variants', 'archived_negative_variants'];
-/** #444 tag sorts as [value, label]: `created` (today's order) first, then the legacy tag manager's four. */
-export const TAG_SORTS = Object.freeze([['created', 'Oldest first'], ['name', 'Name A–Z'], ['name-desc', 'Name Z–A'],
-    ['prompts', 'Most prompts'], ['prompts-asc', 'Fewest prompts']].map(pair => Object.freeze(pair)));
-// The route's cap on a tag search (database/vocabulary.py _MAX_SEARCH).
-export const TAG_SEARCH_MAX = 200;
-const DEFAULT_QUERY = Object.freeze({search: '', sort: 'created'});
 
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 const id = value => Number.isSafeInteger(value) && value > 0;
@@ -51,23 +45,9 @@ function storageChanged() {
 // Duck-typed by name: this ES module cannot import the UMD api-client.js.
 function isApiError(error) {return error instanceof Error && error.name === 'ApiError' && Number.isInteger(error.status);}
 
-/** A tags query, trimmed; categories take none. Throws on anything the route would refuse. */
-function tagQuery(kind, query) {
-    if (query === undefined) return DEFAULT_QUERY;
-    requireValue(kind === 'tags' && object(query), 'Only tags take a search and sort');
-    const {search = '', sort = 'created'} = query;
-    requireValue(typeof search === 'string' && search.trim().length <= TAG_SEARCH_MAX, 'Invalid tag search');
-    requireValue(TAG_SORTS.some(([value]) => value === sort), 'Invalid tag sort');
-    return Object.freeze({search: search.trim(), sort});
-}
-
-function validatePage(page, kind, cursor, query) {
+function validatePage(page, kind, cursor) {
     const rows = page?.[kind];
     const {key, valid} = KINDS[kind];
-    // A search or sort the server did not echo was not applied (an older server): never show that list as filtered.
-    const plain = query.search === '' && query.sort === 'created' && page?.search === undefined && page?.sort === undefined;
-    const applied = plain || (page?.search === query.search && page?.sort === query.sort);
-    requireValue(applied && optionalCount(page?.untagged_count), `Unconfirmed ${kind} search`);
     requireValue(object(page) && page.success === true && epochOf(page.library_epoch) && Array.isArray(rows) &&
         rows.every(row => object(row) && valid(row) && count(row.prompt_count)) &&
         new Set(rows.map(key)).size === rows.length && count(page.total) && typeof page.has_more === 'boolean' &&
@@ -77,18 +57,12 @@ function validatePage(page, kind, cursor, query) {
 }
 
 /** One bounded, append-only list of tags or categories. */
-/**
- * One bounded, append-only list of tags or categories. A tags stream takes `query` (`{search, sort}`, #444) and
- * `reset(query)` replaces it; `state.untaggedCount` is the last count a tags page reported (kept across resets so the
- * Untagged prompts row does not flicker), `null` before any.
- */
-export function createVocabularyStream({api, kind, onChange = () => {}, query: initialQuery}) {
+export function createVocabularyStream({api, kind, onChange = () => {}}) {
     requireValue(Object.hasOwn(KINDS, kind), 'Unknown vocabulary kind');
     const {key} = KINDS[kind];
-    let query = tagQuery(kind, initialQuery);
-    const initial = untaggedCount => ({items: Object.freeze([]), total: 0, cursor: null, hasMore: true, loading: false, error: null,
-        epoch: null, resetRequired: false, query, untaggedCount});
-    let state = Object.freeze(initial(null));
+    const initial = () => ({items: Object.freeze([]), total: 0, cursor: null, hasMore: true, loading: false, error: null,
+        epoch: null, resetRequired: false});
+    let state = Object.freeze(initial());
     let request = null, disposed = false, seen = new Set();
     const emit = patch => {state = Object.freeze({...state, ...patch}); onChange(state);};
 
@@ -96,16 +70,13 @@ export function createVocabularyStream({api, kind, onChange = () => {}, query: i
         if (disposed || state.loading || !state.hasMore || state.resetRequired) return 0;
         const current = request = new AbortController();
         const cursor = state.cursor;
-        const asked = query;
-        const params = new URLSearchParams({limit: String(LIMIT)});
-        if (asked.search) params.set('search', asked.search);
-        if (asked.sort !== 'created') params.set('sort', asked.sort);
-        if (cursor !== null) params.set('cursor', cursor);
+        const query = new URLSearchParams({limit: String(LIMIT)});
+        if (cursor !== null) query.set('cursor', cursor);
         emit({loading: true, error: null});
         try {
-            const page = await api.get(`${BASE}/${kind}?${params}`, {signal: current.signal, cache: 'no-store'});
+            const page = await api.get(`${BASE}/${kind}?${query}`, {signal: current.signal, cache: 'no-store'});
             if (disposed || current !== request) return 0;
-            validatePage(page, kind, cursor, asked);
+            validatePage(page, kind, cursor);
             request = null;
             if (state.epoch !== null && page.library_epoch !== state.epoch) {
                 emit({loading: false, error: storageChanged(), resetRequired: true});
@@ -114,8 +85,7 @@ export function createVocabularyStream({api, kind, onChange = () => {}, query: i
             const incoming = page[kind].filter(row => !seen.has(key(row))).map(row => Object.freeze({...row}));
             incoming.forEach(row => seen.add(key(row)));
             emit({items: incoming.length ? Object.freeze([...state.items, ...incoming]) : state.items, total: page.total,
-                cursor: page.next_cursor, hasMore: page.has_more, loading: false, error: null, epoch: page.library_epoch,
-                untaggedCount: page.untagged_count ?? state.untaggedCount});
+                cursor: page.next_cursor, hasMore: page.has_more, loading: false, error: null, epoch: page.library_epoch});
             return incoming.length;
         } catch (error) {
             if (!disposed && current === request) {request = null; emit({loading: false, error});}
@@ -126,14 +96,13 @@ export function createVocabularyStream({api, kind, onChange = () => {}, query: i
     return {
         get state() {return state;},
         loadMore,
-        /** Drop every loaded row and read again from the first page, with `next` as the new query when given. */
-        reset(next) {
-            if (next !== undefined) query = tagQuery(kind, next);
+        /** Drop every loaded row and read again from the first page. */
+        reset() {
             if (disposed) return Promise.resolve(0);
             request?.abort();
             request = null;
             seen = new Set();
-            emit(initial(state.untaggedCount));
+            emit(initial());
             return loadMore();
         },
         dispose() {disposed = true; request?.abort(); request = null;},
@@ -285,11 +254,6 @@ export function browseFilters(kind, value) {
         : {text: '', category: value, tags: [], sort: 'newest'};
 }
 
-/** Library filters for the Untagged prompts row's Browse (#444): parents that no tag's Browse returns. */
-export function untaggedBrowseFilters() {
-    return {text: '', category: '', tags: [], sort: 'newest', tagMode: 'untagged'};
-}
-
 /**
  * A category row's count (#332 D143): "N positive prompts" when no image holds it as its own category, "N positive
  * prompts · M images" when both do, "M images" when only images do (stored rows, files on disk or not).

web/js/workspace/vocabulary.mjs

@@ -4,18 +4,12 @@
  * Composition, labels and order follow the approved concept: Auto-tag images
  * opens the Tag image dialog for the image selected in Images (aria-disabled
  * without one, D115) and the Images cells count the files carrying each tag
- * (#249 C2). The recorded deviations are bounded lists with Load more and (D149,
- * #444) the Tag vocabulary's Untagged prompts row and its tag search and sort,
- * drawn with the concept's `.operation` and toolbar tokens. Rows are real
- * vocabulary pages from vocabulary-state.mjs; Browse hands the exact constraint
- * to the existing Library filters.
+ * (#249 C2). The recorded deviation left is bounded lists with Load more. Rows
+ * are real vocabulary pages from vocabulary-state.mjs; Browse hands the exact
+ * constraint to the existing Library filters.
  */
 import { createButton } from '../shared/toolkit/core.js';
-import { TAG_SEARCH_MAX, TAG_SORTS, browseFilters, categoryBrowseTarget, categoryRowText, createVocabularyCommand, createVocabularyStream,
-    untaggedBrowseFilters } from './vocabulary-state.mjs';
-import { SEARCH_DELAY } from './toolbar.mjs';
-import { createWorkspaceIcon } from './icons.mjs';
-import { countOf } from './plural.mjs';
+import { browseFilters, categoryBrowseTarget, categoryRowText, createVocabularyCommand, createVocabularyStream } from './vocabulary-state.mjs';
 import { browseLibrary, invalidateLibraryAfterWrite } from './library.mjs';
 import { createVocabularyDialog } from './vocabulary-dialog.mjs';
 import { pageHeading } from './heading.mjs';
@@ -26,9 +20,6 @@ import { showWorkspaceToast } from './toast.mjs';
 /** D115: why Auto-tag images (and System › Auto-tagging's Preview tagging review) only explains without a selection. */
 export const NO_SELECTION = 'Select an image in Images first.';
 
-const NO_MATCH = 'No tags match this search.';
-// The Untagged prompts row before the first tags page reports its count.
-const UNTAGGED_PENDING = 'Positive prompts without a tag';
 const COPY = {
     tags: {empty: 'No tags yet.', error: 'Tags could not be loaded. Nothing was changed.', more: 'Load more tags'},
     categories: {empty: 'No categories yet.', error: 'Categories could not be loaded. Nothing was changed.', more: 'Load more categories'},
@@ -84,7 +75,7 @@ function categoryRow(category) {
  * in view (stacked layout below 700px), pages do not chain on their own. Before any row arrives (loading, failed) the list shows no rows, so a
  * failed read never looks like zero counts.
  */
-function mountList(scope, api, kind, {content, rowsHost, renderRow, after, query}) {
+function mountList(scope, api, kind, {content, rowsHost, renderRow, after}) {
     const copy = COPY[kind];
     const empty = el('p', copy.empty, 'empty');
     const continuation = el('div', undefined, 'vocabulary-continuation');
@@ -124,7 +115,6 @@ function mountList(scope, api, kind, {content, rowsHost, renderRow, after, query
         const failed = Boolean(state.error);
         content.hidden = !rendered;
         empty.hidden = Boolean(rendered || state.loading || failed || state.hasMore);
-        empty.textContent = state.query?.search ? NO_MATCH : copy.empty;
         status.textContent = state.loading ? 'Loading…' : '';
         status.hidden = !state.loading;
         alert.hidden = !failed;
@@ -139,7 +129,7 @@ function mountList(scope, api, kind, {content, rowsHost, renderRow, after, query
         continuation.hidden = !(state.loading || failed || state.hasMore);
         for (const listener of listeners) listener(state);
     }
-    const stream = createVocabularyStream({api, kind, onChange: render, query});
+    const stream = createVocabularyStream({api, kind, onChange: render});
     scope.listen(more, 'click', () => stream.loadMore());
     scope.listen(retry, 'click', () => (stream.state.resetRequired ? stream.reset() : stream.loadMore()));
     let observer = null;
@@ -166,38 +156,6 @@ function mountList(scope, api, kind, {content, rowsHost, renderRow, after, query
     return {stream, itemOf: row => items.get(row), rowFor, subscribe};
 }
 
-/**
- * The tag search and sort (D149): the concept toolbar's `search.toolbar` > `label.search-field` (search icon and a
- * search input) and a `select`, built here because the shared toolbar owns the page-level ids. A visually hidden
- * status announces the result of a changed search or sort.
- */
-function tagTools() {
-    const root = document.createElement('search');
-    root.className = 'toolbar vocabulary-tools';
-    const label = el('label', undefined, 'search-field');
-    label.htmlFor = 'tag-search';
-    const search = document.createElement('input');
-    search.id = 'tag-search';
-    search.type = 'search';
-    search.placeholder = 'Search tags…';
-    search.maxLength = TAG_SEARCH_MAX;
-    search.setAttribute('aria-label', 'Search tags');
-    label.append(createWorkspaceIcon('search'), search);
-    const sort = document.createElement('select');
-    sort.id = 'tag-sort';
-    sort.setAttribute('aria-label', 'Sort tags');
-    for (const [value, text] of TAG_SORTS) {
-        const option = el('option', text);
-        option.value = value;
-        sort.append(option);
-    }
-    const status = el('span', '', 'ca-visually-hidden');
-    status.setAttribute('role', 'status');
-    root.append(label, sort, status);
-    return {root, search, sort, read: () => ({search: search.value, sort: sort.value}),
-        announce: text => { if (status.textContent !== text) status.textContent = text; }};
-}
-
 /** Mount the screen into `main` below the shell's heading; `scope` owns every request, listener and observer. */
 export function mountVocabulary(main, api, scope) {
     main.classList.add('vocabulary-main');
@@ -230,11 +188,8 @@ export function mountVocabulary(main, api, scope) {
     const body = el('tbody');
     table.append(el('caption', 'Reusable tags'), head, body);
     wrap.append(table);
-    // D149 (#444): the parents no tag's Browse returns, as a concept `.operation` row, then the tag search and sort.
-    const untagged = operation('Untagged prompts', UNTAGGED_PENDING, 'Browse');
-    const tools = tagTools();
     tagSurface.append(el('h2', 'Tag vocabulary'),
-        el('p', 'Category/tag autocomplete uses this same vocabulary across nodes and dialogs.'), untagged.row, tools.root, wrap);
+        el('p', 'Category/tag autocomplete uses this same vocabulary across nodes and dialogs.'), wrap);
 
     const categorySurface = el('section', undefined, 'surface');
     const categoryRows = el('div', undefined, 'vocabulary-categories');
@@ -245,17 +200,7 @@ export function mountVocabulary(main, api, scope) {
     grid.append(tagSurface, categorySurface);
     main.append(grid);
 
-    const tags = mountList(scope, api, 'tags', {content: wrap, rowsHost: body, renderRow: tagRow, after: wrap, query: tools.read()});
-    let announcing = false;
-    tags.subscribe(state => {
-        if (state.untaggedCount !== null) untagged.row.querySelector('p').textContent = countOf(state.untaggedCount, 'positive prompt');
-        // A search or sort the person changed is announced once its first page lands (or fails, which the alert says).
-        // A reset first emits its empty initial state (no epoch yet), then the read: wait for the page or the failure.
-        if (!announcing || state.loading || (state.epoch === null && !state.error)) return;
-        announcing = false;
-        if (!state.error) tools.announce(state.total ? countOf(state.total, 'tag') : state.query.search ? NO_MATCH : COPY.tags.empty);
-    });
-    scope.listen(untagged.button, 'click', () => browseLibrary(untaggedBrowseFilters()));
+    const tags = mountList(scope, api, 'tags', {content: wrap, rowsHost: body, renderRow: tagRow, after: wrap});
     const categories = mountList(scope, api, 'categories', {content: categoryRows, rowsHost: categoryRows, renderRow: categoryRow, after: categoryRows});
     scope.listen(body, 'click', event => {
         const button = event.target.closest('button[data-action="browse"]');
@@ -272,20 +217,11 @@ export function mountVocabulary(main, api, scope) {
     });
 
     let settled = Promise.resolve();
-    /** Re-read both lists from page one: after any command, rows can move between pages. The tag search and sort stay. */
+    /** Re-read both lists from page one: after any command, rows can move between pages. */
     function reload() {
         settled = Promise.all([tags.stream.reset(), categories.stream.reset()]).then(() => undefined);
         return settled;
     }
-    /** A changed tag search or sort reads the tags from page one; the categories are not affected. */
-    function searchTags() {
-        const next = tools.read(), current = tags.stream.state.query;
-        if (next.search.trim() === current.search && next.sort === current.sort) return;
-        announcing = true;
-        settled = tags.stream.reset(next).then(() => undefined);
-    }
-    scope.listen(tools.search, 'input', scope.debounce(searchTags, SEARCH_DELAY));
-    scope.listen(tools.sort, 'change', searchTags);
     /** A guarded command for one dialog; any outcome that may have changed storage re-reads the lists and the Library shelf. */
     function createCommand(onChange) {
         return createVocabularyCommand({api, onChange, onInvalidate: event => {

web/js/workspace/workspace-dialogs.mjs

@@ -24,8 +24,7 @@
 import { createButton, createSwitch } from '../shared/toolkit/core.js';
 import { noun } from './plural.mjs';
 
-// `tagMode` (#444, D149): the Library's Tag match select after Tags; its `untagged` value disables Tags.
-const FIELD_LABELS = Object.freeze({ source: 'Source', folder: 'Folder', media: 'Media', tags: 'Tags', tagMode: 'Tag match' });
+const FIELD_LABELS = Object.freeze({ source: 'Source', folder: 'Folder', media: 'Media', tags: 'Tags' });
 const FIELD_ORDER = Object.keys(FIELD_LABELS);
 
 let shell = null;
@@ -180,7 +179,7 @@ export function openRefineDialog({ scope, fields, values = {}, onApply, onClear,
     requireScope(scope);
     requireCallbacks({ onApply, onClear });
     if (!Array.isArray(fields) || fields.some(item => !FIELD_ORDER.includes(item?.key))) {
-        throw new TypeError('Refine fields are source, folder, media, tags and tagMode');
+        throw new TypeError('Refine fields are source, folder, media and tags');
     }
     const controls = FIELD_ORDER.flatMap(key => {
         const item = fields.find(candidate => candidate.key === key);
@@ -200,12 +199,6 @@ export function openRefineDialog({ scope, fields, values = {}, onApply, onClear,
     for (const { key, control } of controls) {
         if (key !== 'tags') control.addEventListener('change', () => wanted.set(key, control.value));
     }
-    // "Prompts without tags" takes no Tags: the field is disabled (and Apply reports it empty) while it is chosen.
-    const tagsField = controls.find(item => item.key === 'tags');
-    const tagMode = controls.find(item => item.key === 'tagMode');
-    const followTagMode = () => { if (tagsField && tagMode) tagsField.control.disabled = tagMode.control.value === 'untagged'; };
-    tagMode?.control.addEventListener('change', followTagMode);
-    followTagMode();
     const source = controls.find(item => item.key === 'source');
     const folder = controls.find(item => item.key === 'folder' && typeof item.optionsFor === 'function');
     const followSource = (chosen = folder.control.value) => {
@@ -218,7 +211,7 @@ export function openRefineDialog({ scope, fields, values = {}, onApply, onClear,
         source.control.addEventListener('change', () => { followSource(); wanted.set('folder', folder.control.value); });
     }
     const read = () => Object.fromEntries(controls.map(({ key, control }) =>
-        [key, key === 'tags' ? (control.disabled ? '' : control.value.trim()) : control.value]));
+        [key, key === 'tags' ? control.value.trim() : control.value]));
 
     const clear = createButton('Clear filters');
     const apply = createButton('Apply filters', 'ca-primary');
@@ -226,7 +219,6 @@ export function openRefineDialog({ scope, fields, values = {}, onApply, onClear,
         // The cleared Source's folders first, so the cleared Folder value is one of them.
         if (source && folder) { source.control.value = source.cleared; followSource(); }
         for (const { control, cleared } of controls) control.value = cleared;
-        followTagMode();
         const reset = read();
         finish();
         onClear({ ...reset, category: '' });