fix(tagging): keep focus on the instructions select after a pick (#431)

A pick re-renders the dialog's fields; the select it was made with gets
focus back. The one-off note describes the textarea while it shows.

.github/workflows/portability.yml

@@ -1,9 +1,9 @@
-name: Windows and macOS
+name: Windows
 
 permissions:
   contents: read
 
-# Non-blocking portability runs (#420): never on pull requests or in the merge queue, and no context
+# Non-blocking Windows runs (#420; macOS dropped from CI in #571): never on pull requests or in the merge queue, and no context
 # here is a required check. A red run is fixed at its cause before the workspace cutover (#334).
 on:
   push:
@@ -25,10 +25,7 @@ env:
 # run counts (tests/vendor/ci-workflow.test.mjs recomputes it, #493).
 # Measured 2026-10-29 on main runs 40935337099 (dd247e3), 40938407252 (dd247e3), 40941240624 (dd247e3):
 #   slowest leg: 7m24s (py3.12 windows) / 7m31s (py3.13 windows) / 7m32s (py3.14 windows) -> 15 min
-#     (windows 4m56s-7m32s, macos 4m39s-6m14s)
-#   native-trash (#499) has no green main runs yet: its probe, run 40949370943 (2026-10-29), took
-#     about 1 minute per macOS leg, so ceil(1.5 x 2) + 3 gives it 6 minutes (step 4). Recalibrate
-#     after three green runs.
+#     (windows 4m56s-7m32s)
 #   native-trash-linux (#543) has no green main runs yet: it installs the dev requirements and runs
 #     one test module, about 1 minute by the same estimate, so ceil(1.5 x 2) + 3 gives it 6 minutes.
 #     Recalibrate after three green runs.
@@ -40,7 +37,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, macos-latest]
+        os: [windows-latest]
         python-version: ["3.12", "3.13", "3.14"]
 
     steps:
@@ -60,7 +57,7 @@ jobs:
 
       # The runner's TEMP is on C:, the OS disk, where a flush took about 6 ms
       # and a test database's create-to-delete about 111 ms; on the D: work
-      # disk the same took 0.5 ms and 23 ms (macOS: 19 ms). Tests write their
+      # disk the same took 0.5 ms and 23 ms. Tests write their
       # databases under TEMP, so it moves to a folder on D: (measured in #487,
       # run 40915866444). The runner's TEMP was an 8.3 short name
       # (C:\Users\RUNNER~1\...), so the new one is spelled by its short name too
@@ -83,31 +80,6 @@ jobs:
           PM_TEST_SLOWEST: "40"
         run: python -m tests.run_suite -v
 
-  # The real Trash on both macOS CPUs (#499 design §10.2). It runs apart from the suite, so a red
-  # suite never skips the native proof.
-  native-trash:
-    name: native trash on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 6
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-latest, macos-15-intel]
-
-    steps:
-      - uses: actions/checkout@v7
-
-      - name: Set up Python
-        uses: actions/setup-python@v7
-        with:
-          python-version: "3.12"
-
-      - name: Native trash proof
-        timeout-minutes: 4
-        env:
-          PM_NATIVE_TRASH: macos
-        run: python -m unittest tests.test_trash_macos_native tests.test_trash_macos -v
-
   # The same tests as the fake mount table, on a real ext4 mount used as the output root (#543). A
   # runner can mount with sudo; the tests run as the normal user, so owner and mode checks are real.
   native-trash-linux:

.github/workflows/test.yml

@@ -28,7 +28,7 @@ env:
 #   py matrix, slowest py3.10 on windows-latest: 12m43s / 15m54s / 14m53s -> 27 min
 #     (ubuntu 5m27s-6m27s, macos 6m14s-8m30s, windows 11m42s-15m54s)
 #     3.10 and 3.11 left the matrix and 3.14 joined it in #356; re-measure after three green main runs.
-#     Windows and macOS moved to portability.yml (#420), which has its own measured limit (#493);
+#     Windows moved to portability.yml (#420; macOS left CI in #571), which has its own measured limit (#493);
 #     this Linux-only matrix keeps 27 minutes until it is re-measured.
 #   real ComfyUI compatibility: 13m32s / 8m55s / 11m46s -> 24 min
 #   coverage gate (85%): 7m26s / 7m22s / 7m54s -> 15 min
@@ -39,7 +39,7 @@ env:
 # Pull requests run a fast subset (#420): Python 3.12 on ubuntu-latest, coverage, lint and frontend
 # modules. The merge queue (merge_group), pushes to main and manual runs add Python 3.13 and 3.14 on
 # Linux and the real ComfyUI job. "all tests" is the required gate that holds the queue to that set.
-# Windows and macOS run in portability.yml (push to main, nightly, on demand) and never gate a merge.
+# Windows runs in portability.yml (push to main, nightly, on demand) and never gate a merge.
 jobs:
   test:
     name: py${{ matrix.python-version }} on ${{ matrix.os }}

.github/workflows/viewerjs-check.yml

@@ -41,9 +41,13 @@ concurrency:
 # 7.3m-12.2m), because --shard splits by test count and the slow concept specs sort into shard 1. The page
 # workflows now run in three shards per browser with the limits unchanged; the per-shard times are
 # re-measured after three green main runs.
+# #563: coverage shards reached their 18-minute step limit three times on 2026-10-31 with no failing
+# test (PR #560 shard 2/3: 814 passed in 17.9m; queue run 41206495451 shard 1/3: 827 passed; PR #564
+# shard 2/3 twice), against recent green shards of 11m-17m. Coverage now runs in four shards with the
+# limits unchanged; the per-shard times are re-measured after three green main runs.
 jobs:
   frontend-coverage:
-    name: frontend coverage (shard ${{ matrix.shard }}/3)
+    name: frontend coverage (shard ${{ matrix.shard }}/4)
     runs-on: ubuntu-latest
     # Layout comparisons depend on the fonts each browser falls back to, so browser jobs run in the
     # same pinned Playwright image as local runs (tag = @playwright/test in tools/vendor/package-lock.json;
@@ -59,7 +63,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        shard: [1, 2, 3]
+        shard: [1, 2, 3, 4]
     steps:
       - uses: actions/checkout@v7
       # The image's own Python 3.12 and Node 24: setup-python/setup-node install the runner's toolcache
@@ -88,13 +92,13 @@ jobs:
       - run: npm ci --prefix tools/vendor --ignore-scripts
       # Shard 1 also runs the node units and the viewer suite, so the vendor pins and the tooling tests
       # run on the lightest shard instead.
-      - if: matrix.shard == 3
+      - if: matrix.shard == 4
         run: npm run --prefix tools/vendor check
-      - if: matrix.shard == 3
+      - if: matrix.shard == 4
         run: npm run --prefix tools/vendor test
-      - name: Page workflows with coverage, shard ${{ matrix.shard }}/3
+      - name: Page workflows with coverage, shard ${{ matrix.shard }}/4
         timeout-minutes: 18
-        run: npm run --prefix tools/vendor test:coverage:shard -- ${{ matrix.shard }}/3
+        run: npm run --prefix tools/vendor test:coverage:shard -- ${{ matrix.shard }}/4
       - name: Upload raw coverage
         uses: actions/upload-artifact@v7
         with:
@@ -136,13 +140,13 @@ jobs:
         with:
           pattern: coverage-raw-*
           path: ${{ runner.temp }}/coverage-raw
-      # coverage:merge only checks that raw files exist; merging two of three shards would report
+      # coverage:merge only checks that raw files exist; merging three of four shards would report
       # partial coverage, so a missing or empty shard artifact fails here.
       - name: Verify every shard's raw coverage arrived
         shell: bash
         env:
           STAGED_RAW: ${{ runner.temp }}/coverage-raw
-          EXPECTED_SHARDS: 3
+          EXPECTED_SHARDS: 4
         run: |
           found=0
           for shard in $(seq 1 "$EXPECTED_SHARDS"); do

README.md

@@ -167,6 +167,8 @@ Searches your library by text, category, tags and minimum rating, then outputs t
 
 ![Prompt Search List node producing three images](assets/readme/node-search.webp)
 
+To get the images of a Search List batch linked to their prompts, wire the Search List output into a Prompt Manager Text node, not straight into CLIP Text Encode. Wired straight in, the images stay unlinked: the search text is never saved as a prompt.
+
 ## Install
 
 **Requirements:** ComfyUI and Python 3.12 or newer. `watchdog` and `Pillow` are the only dependencies of their own; the rest comes with ComfyUI.
@@ -236,12 +238,12 @@ The documentation for those pages is in [README-legacy.md](README-legacy.md).
 
 | Layer | What runs |
 | --- | --- |
-| Python | Over 200 test files on Linux, Windows and macOS with Python 3.12 to 3.14, with an 85% coverage gate |
+| Python | Over 200 test files on Linux and Windows with Python 3.12 to 3.14, with an 85% coverage gate |
 | Frontend | About 100 unit test files, with coverage floors per file |
 | Browser | Over 60 Playwright spec files in Chromium, Firefox, WebKit and touch emulation |
 | Real ComfyUI | A pinned CPU ComfyUI, started in Classic and Nodes 2.0, running real workflows |
 
-Linux runs on every pull request and in the merge queue. Windows and macOS run on every push to main and nightly. To run the tests yourself, see [TESTING.md](TESTING.md).
+Linux runs on every pull request and in the merge queue. Windows runs on every push to main and nightly. macOS is not tested; it should work, but support is best-effort. To run the tests yourself, see [TESTING.md](TESTING.md).
 
 ## License
 

TESTING.md

@@ -74,14 +74,14 @@ V8 files it writes under `coverage/js/raw`:
 
 ```sh
 PM_TEST_WORKERS=8 npm run --prefix tools/vendor test:coverage            # whole run, one report
-npm run --prefix tools/vendor test:coverage:shard -- 1/3                 # node units, viewer suite, workflows 1/3
-npm run --prefix tools/vendor test:coverage:shard -- 2/3                 # workflows 2/3 (likewise 3/3)
+npm run --prefix tools/vendor test:coverage:shard -- 1/4                 # node units, viewer suite, workflows 1/4
+npm run --prefix tools/vendor test:coverage:shard -- 2/4                 # workflows 2/4 (likewise 3/4, 4/4)
 npm run --prefix tools/vendor coverage:merge                             # report and baseline check of every raw file
 npm run --prefix tools/vendor test:workflows -- --project webkit --shard 2/2
 ```
 
 `coverage:merge` refuses an empty raw directory; it does not count shards, so run
-every shard first (CI's merge job checks all three arrived). Measured on a 32-CPU
+every shard first (CI's merge job checks all four arrived). Measured on a 32-CPU
 machine in the pinned image (2026-10-21): `test:coverage` takes about 5 minutes
 with 8 workers and 24 minutes with 1; all four projects, 8 workers, each test 3
 times (6132 tests), 24 minutes. A CI-sized run (`docker run --cpus=4`,
@@ -189,14 +189,14 @@ check, so run it before pushing a new or deleted frontend file instead of
 waiting for the `frontend coverage` jobs.
 
 The `viewerjs` check runs on every PR, including backend-only changes. It is an
-aggregate job. It requires the three `frontend coverage (shard N/3)` jobs and
+aggregate job. It requires the four `frontend coverage (shard N/4)` jobs and
 `frontend coverage (merge)` to succeed on every event. The four
 `page workflows (firefox|webkit, shard N/2)` jobs run only in the merge queue,
 on `main` and on `workflow_dispatch` (see "Pull requests and the merge queue").
 `viewerjs` requires them to be skipped on a pull request and to succeed
 everywhere else. Any other failed, cancelled or skipped job fails it. Every browser job runs with `PM_TEST_WORKERS: 3` (the public
-runners have 4 vCPUs). Each coverage shard runs `test:coverage:shard -- N/3`
-(shard 1 also runs the node units and the viewer suite, shard 3 the vendor pins
+runners have 4 vCPUs). Each coverage shard runs `test:coverage:shard -- N/4`
+(shard 1 also runs the node units and the viewer suite, shard 4 the vendor pins
 and tooling tests) and uploads its raw V8 files as `coverage-raw-N` (kept 3
 days). The merge job downloads them, fails unless all three arrived with raw
 files and without clashing names, then runs `coverage:merge` (report plus
@@ -261,7 +261,7 @@ the process exits non-zero.
   job fails anyway and the dump is what matters.
 - `PM_TEST_SLOWEST=N` (off by default) lists the N slowest tests after the
   summary, each timed from its `start:` line to the next one like the hang
-  limit. The Windows and macOS jobs (`portability.yml`) set it to 40, so every
+  limit. The Windows jobs (`portability.yml`) set it to 40, so every
   run shows where its time went (#487). The list prints only when the run
   ends: a job GitHub cancels or a watchdog exit prints none, so read the
   timestamps between `start:` lines instead.
@@ -327,7 +327,7 @@ Python 3.13/3.14, real ComfyUI and Firefox/WebKit failures first show up in the
 merge queue, on the merge-group commit rather than the
 pushed one. Find that run with `gh run list --event merge_group --workflow test.yml`
 (or `viewerjs-check.yml`) and match its head branch
-(`gh-readonly-queue/main/pr-<N>-...`). Windows and macOS failures show up only
+(`gh-readonly-queue/main/pr-<N>-...`). Windows failures show up only
 after the merge, in `gh run list --workflow portability.yml`.
 
 Start fixing as soon as a failed log shows the cause, but push the fix only after
@@ -345,8 +345,10 @@ and the time left. The steps, in order:
    monitor's callbacks (Needs review recorder, preview queue, Images listing
    listener).
 2. `ImageMonitor.stop_monitoring` works against one 5 s deadline. Closing the
-   image handler joins the image worker; watchdog's `observer.stop()` (not
-   bounded here) and the observer join get what is left, which can be 0 s.
+   image handler joins the image worker; watchdog's `observer.stop()` and the
+   observer join get what is left, which can be 0 s. `stop()` joins watchdog's
+   emitters without a limit, so it runs on a daemon thread and is waited for
+   only until the deadline; a later stop waits for that same call (#561).
 3. `close_auto_thumbnails(final=True)` stops the preview worker (30 s) and
    kills ffmpeg.
 4. `PromptTracker.shutdown` stops the prompt cleanup thread (2 s).
@@ -361,6 +363,15 @@ stored, with the parts not reached False, and the `atexit` callback is
 removed: the later steps are skipped, no summary line is logged, and a later
 call returns that result and runs nothing.
 
+The observer is started from a short-lived daemon thread, so every thread it
+creates is a daemon (a thread inherits that flag from the thread that creates
+it). watchdog 7 on Windows starts a plain `threading.Thread` per watch for its
+`ReadDirectoryChangesW` reader; created from ComfyUI's main thread it would not
+be a daemon, and the interpreter waits for every such thread before it runs any
+`atexit` callback, so the teardown would never start (#561).
+`tests/test_package_exit.py` runs a child whose observer does both (a plain
+reader thread, a `stop()` that never returns) and requires its exit.
+
 ComfyUI never runs aiohttp's `on_cleanup` hooks, because it never calls
 `runner.cleanup()`. So `atexit` is the live host's path. It runs on Ctrl+C
 (`main.py` catches `KeyboardInterrupt` and returns) and on a normal exit.
@@ -450,7 +461,7 @@ measurement: `ubuntu-latest`, one Python, no coverage, only the wall-clock tests
 It runs on every push to `main` and on `workflow_dispatch`, never on pull
 requests, because shared-runner timing must not block a merge. Dispatch it on a
 branch to measure before merging.
-Shared Windows and macOS runners do not run them; the structural tests cover
+Shared Windows runners do not run them; the structural tests cover
 portability. Run it locally with
 `PROMPTMANAGER_PERF_BUDGET=1 python -m unittest tests.test_api_workspace_images.TestWorkspaceImages.test_filter_budget`
 and quote the printed p95 in the PR body.
@@ -646,10 +657,10 @@ Before changing paths, SQLite, streams, restore or cleanup:
   ordinary busy timeout; cross-thread handoffs wait on events with generous
   ceilings, never a short wall clock (#242).
 - Run native Windows CI early for these changes. Pull requests and the merge
-  queue run only Linux, so start Windows and macOS on the branch with
+  queue run only Linux, so start Windows on the branch with
   `gh workflow run portability.yml --ref <branch>`.
-  Include a Windows impact and evidence note in the PR. All six Windows/macOS
-  combinations in that run, every Linux leg and every applicable
+  Include a Windows impact and evidence note in the PR. All three Windows
+  legs in that run, every Linux leg and every applicable
   exact-head check must pass before merge. Portable `ntpath`/`PureWindowsPath`
   controls do not establish native filesystem, locking or cleanup success.
 
@@ -664,11 +675,11 @@ what runs:
 | `py3.13 on ubuntu-latest`, `py3.14 on ubuntu-latest` | not created | run |
 | `real ComfyUI compatibility` | skipped | runs |
 | `coverage gate (85%)`, `black and flake8`, `frontend modules`, `bandit (high severity)` | run | run |
-| `frontend coverage (shard N/3)`, `frontend coverage (merge)` (vendor pins and tooling tests on shard 3) | run | run |
+| `frontend coverage (shard N/4)`, `frontend coverage (merge)` (vendor pins and tooling tests on shard 4) | run | run |
 | `page workflows (firefox\|webkit, shard N/2)` | skipped | run |
 | `all tests`, `viewerjs` (gates) | run | run |
 | `perf budget` | skipped | push and dispatch only (not in the queue) |
-| `py3.12-3.14 on windows-latest/macos-latest` (`portability.yml`) | not run | push to `main`, nightly, `workflow_dispatch` only; never required |
+| `py3.12-3.14 on windows-latest` (`portability.yml`) | not run | push to `main`, nightly, `workflow_dispatch` only; never required |
 
 GitHub has one required set for pull requests and the queue. A job skipped by
 its `if:` reports Success. A dropped matrix leg never reports, so it would stay
@@ -681,8 +692,9 @@ guarantee:
 So a merge group cannot turn green unless all three Linux Python legs, real
 ComfyUI and the four browser shards passed.
 
-Windows and macOS (Python 3.12-3.14) are out of the blocking path for now
-(maintainer, 2026-10-28). They run in `portability.yml` on every push to `main`,
+Windows (Python 3.12-3.14) is out of the blocking path for now
+(maintainer, 2026-10-28). macOS is not tested in CI (maintainer, 2026-10-31, #571);
+its code stays and support is best-effort. They run in `portability.yml` on every push to `main`,
 nightly and on demand, and no context there is required. A red portability run
 is still a failure: fix it at its cause, not by rerunning, and have every one
 green before the workspace cutover (#334). `tests/vendor/ci-workflow.test.mjs` pins the
@@ -1407,6 +1419,8 @@ is shorter than the row it reserves.
 Each Overview card is the count of the page it names: the shell's Library, Images and Tags sidebar counts, one source,
 so a card and its badge cannot differ. `/prompt_manager/stats` is for the legacy page and counts raw rows. A visit re-reads
 the three unless a read is in flight. An unread or failed card shows a dash; Retry re-reads only the failed counts.
+System › Overview's Images metric reads the same shell count (#555), so it, the Overview card and the Images badge show
+one number; its Statistics dialog labels the legacy row counts as "Database records".
 Tests: `tests/js/workspace-state.test.js`, `tests/browser/workspace.spec.mjs`, `tests/comfyui/workspace.spec.mjs`.
 
 ### Images page controls and recorded deviations (#249 PR C)
@@ -1837,7 +1851,8 @@ Inspect plan keeps D60–D66 (plan D60 → D83, D61 → D84, D65 → D88, D68
   engines in the mock's order with legacy labels and sizes (`WD14 SwinV2 · ~400
   MB`, `WD14 ViT · ~400 MB`, `GGUF JoyCaption (Recommended) · ~4.5 GB` in the
   mock's Ollama slot, `HuggingFace JoyCaption · ~16 GB`); the instructions start
-  from the server's `default_prompt`.
+  from the chosen engine's default saved instructions (#431, D204; before, the
+  server's `default_prompt`).
 - **D91** (plan D68, ruling T3-bulk): a **Suggestions** number field (1–100) for
   every model, prefilled from `autotag.defaults.suggestion_limit` (10); a model
   change keeps it.
@@ -2549,8 +2564,8 @@ files to the system trash. **No code path unlinks or overwrites a media file.**
   ("Moving files to the Recycle Bin isn't available on Windows: files larger than the bin's
   capacity would be deleted permanently."). Library-only removal works everywhere. Tests use `tests/fake_trash.py`; the
   browser test server installs it, so no test touches a real trash. The native proof,
-  `tests/test_trash_macos_native.py`, runs only with `PM_NATIVE_TRASH=macos` in
-  portability.yml's `native-trash` job (`macos-latest` and `macos-15-intel`): the startup
+  `tests/test_trash_macos_native.py`, runs only with `PM_NATIVE_TRASH=macos` on a Mac, by hand
+  (CI dropped its `native-trash` macOS job in #571; it last passed on `macos-latest` and `macos-15-intel`): the startup
   volume, a name clash, fresh APFS and FAT32 disk images, an image used as an output root,
   a read-only image and an unwritable folder (design and probe:
   `docs/egm/499-macos-trash/`, local).
@@ -4006,7 +4021,11 @@ the per-section hand-off panel, was retired by S12 (#329): every section is nati
   "Save preferences" is `aria-disabled` (opacity .55, `not-allowed`) while clean or
   saving; a setting the last save could not save gets a red outline. CSS under D92.
 - **D93** (Overview): real values. The metrics are the Library's eligible positives
-  and active saved negatives and the indexed `generated_images` rows (Q2). "Database
+  and active saved negatives and the Images count (#555, amending Q2's indexed
+  `generated_images` rows): the shell's Images sidebar count, the Images page's own
+  total, which also lists files no row links, as the concept's `images.length` is
+  both. A visit re-reads it unless a read is in flight; "–" until read or after a
+  failed read. `images.indexed` stays in the API and is not shown. "Database
   integrity" is "Not checked" until a check ran this session, then "N issues" (checks
   that found issues, even beside a check that could not run), "Passed" or "Incomplete".
   The review row is "N ambiguous image links" (the Needs review queue's pending count,
@@ -4044,10 +4063,11 @@ the per-section hand-off panel, was retired by S12 (#329): every section is nati
 - **D96** (Statistics; amended by D153): "Usage statistics" without the sample note: the
   concept's "Runs by category" table without its Avg. rating column (Category / Runs)
   with the real runs of eligible parents per category ("Uncategorized"), then a second
-  table "Library totals" (Total / Count: Prompts, Tags, Images from the legacy
-  statistics; no Rated images). The API still reports `average_rating` and
+  table "Database records" (Total / Count: Prompt records, Tags on prompts, Image
+  records: the raw row counts of the legacy statistics, labelled as rows so they never
+  read as the Library or Images page counts, #555; no Rated images). The API still reports `average_rating` and
   `rated_images`; the workspace does not show them.
-  The Overview row says "Runs by category, with library totals." because
+  The Overview row says "Runs by category, with database record counts." because
   that is what the dialog shows (the concept's own dialog shows only "Runs by
   category"); per-prompt run counts, prompt tags and dated runs are recorded, but no
   table of them exists yet. A failed read toasts "Statistics could not
@@ -4535,9 +4555,9 @@ the per-section hand-off panel, was retired by S12 (#329): every section is nati
   engine and policy (read-only) and opens "Review tag output images" in the concept's
   record-changing review (its `maintenancePlan` shell): `h3` "Tag output images", the
   `dl.meta-grid` Model, Existing tags, Images, Already auto-tagged, Images to tag
-  ("about N"), Time, Settings ("General <g> · Character <c>" or "Template of N
-  characters", then " · up to L tags per image" with the preview's saved
-  `suggestion_limit`) and Backup, the estimate sentence ("Nothing is written until you
+  ("about N"), Time, Settings ("General <g> · Character <c>", then " · up to L tags
+  per image" with the preview's saved `suggestion_limit`; for a language model, since
+  D205, an "Instructions" row and "Up to L tags per image") and Backup, the estimate sentence ("Nothing is written until you
   start. The number to tag is an estimate: images changed since they were tagged are
   tagged again, and missing files are skipped. Activity reports what was tagged.") in the
   `p.small`, the D55 backup box and Cancel / "Start tagging", which starts the
@@ -4559,6 +4579,71 @@ 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.
+- **D202** (Auto-tagging, #431, beyond the concept): a "Skipped tags" block
+  (`.setting-block`, `data-setting="tag-skipped"`, `data-key="autotag_skipped_tags"`)
+  follows "Suggestions per image": the label and description in the concept's
+  setting-row tokens ("Suggested tags that contain one of these words are hidden.
+  Words are separated by spaces, _ or -; other characters such as ( ) belong to the
+  word."), an "Add a word or words" input (`#tag-skipped-input`) with Add (Enter adds
+  too), the entries as removable chips in the Tag image dialog's D83 chip markup (each
+  with its count, title "Hides N tags", or muted "none" with "Hides no known tag"), and
+  a `role="status"` preview line: "**Hides N tags from suggestions**: <up to 12>[ and K
+  more]. Tags already on images are not changed." ("Checked against library tags only;
+  no WD14 label list is downloaded." before the last sentence without a label list;
+  "No tags are skipped." for an empty list; "Checking…" while waiting; "The preview
+  could not be read." on failure). The client refuses an entry with "Enter a word.",
+  "No commas or line breaks.", "At most 50 characters.", "Already in the list." or "The
+  list is full (200)." under the input. The Tag image dialog's chip hint adds "N skipped
+  tags were not suggested." when the server hid any (the static mock's copy). Pinned by
+  the comparison's mapping (system-tagging-concept.spec: the block's tokens are the
+  concept row's), `skipped tags add, preview, remove, save and reload (D202)`, `skipped
+  tags preview checks library tags only …` (workspace-system-tagging.spec) and
+  `suggestions omit skipped tags and say how many were hidden` (workspace-tagging.spec).
+- **D203** (Auto-tagging, #431, beyond the concept): "Saved instructions" replaces the
+  concept's "LLM tag template" field (the mock's state 2): a `.setting-block`
+  (`data-setting="tag-instructions"`, `data-key="autotag_instructions"`) with the label,
+  "Instructions for the language-model engines. Built-in can’t be changed; duplicate it
+  to make your own. N of 20 saved · Built‑in is not counted.", a `role="listbox"` list
+  (Built-in first with a "Read-only" chip, then the saved entries; "Default for GGUF" /
+  "Default for HuggingFace" chips), "+ New" ("New instructions", "(2)" if taken),
+  "Duplicate" ("<name> copy"), "Delete" (`.danger`, disabled for Built-in), "At most 20
+  saved instructions." at the cap, and the editor beside the list (under it below 700px):
+  "Name" ("N of 60") and "Text" ("N of 4,000 characters"), read-only for Built-in with
+  "Built-in instructions can’t be changed. Duplicate them to make your own.", else the
+  entry's problem ("The name “X” is already used.", "The text must not be empty."…).
+  Then two concept select rows, "Default for GGUF JoyCaption" and "Default for
+  HuggingFace JoyCaption" ("The Tag image dialog and batches start from this.",
+  `data-key="autotag_default_instructions"`), and the note a deleted default leaves
+  ("GGUF now uses Built-in."; nothing is written until Save preferences). Pinned by the
+  comparison's mapping (system-tagging-concept.spec: the block in the concept row's
+  tokens, the two rows on the concept's select row) and `saved instructions: new, edit,
+  per-engine default, delete, save and reload (D203)`, `a refused instructions save names
+  the entry and highlights the block (D203)` (workspace-system-tagging.spec).
+- **D204** (Tag image and Auto-tag selected dialogs, #431, beyond the concept): for a
+  language-model engine a "Saved instructions" select (`#image-tag-instructions-pick`,
+  `#bulk-tag-instructions-pick`) sits above "Tagging instructions" (the mock's state 3),
+  on the concept's select field: Built-in, then the saved entries (`GET /autotag/models`
+  `instructions`, full text), the engine's default marked "<name> · default". It starts
+  at that default; a pick replaces the text. The text stays editable for the run: while
+  it differs from the picked entry the select shows a disabled "Edited for this run" and
+  a muted line under the textarea reads "Edits apply to this run only. Manage saved
+  instructions in System › Auto-tagging." Choosing an entry again replaces the edit.
+  Switching between GGUF and HF starts from the new engine's default and drops an edit;
+  WD14 hides both. A preset (Preview tagging review, the bulk review) shows the entry
+  with its text, else "Edited for this run". When the read fails the select holds only
+  Built-in with the client's copy (`BUILTIN_INSTRUCTIONS`, pinned equal to
+  `DEFAULT_TAG_TEMPLATE` by workspace-image-tagging-state.test). Request bodies are
+  unchanged (`options.instructions` is the textarea's text); there is no "Save as new".
+  The workspace no longer reads `default_prompt`. Pinned by the tagging comparison's
+  mapping (tagging-canonical-comparison.mjs: the select before the instructions),
+  `the saved instructions picker fills, edits one-off and resets per engine (D204)`
+  (workspace-tagging.spec) and `Auto-tag selected picks saved instructions and sends the
+  text shown (D204)` (workspace-tagging-bulk.spec).
+- **D205** (Auto-tagging, #431; amends D134): for a language-model engine the batch
+  review adds a read-only "Instructions" row with the drafted engine default's name
+  before "Settings", which reads "Up to L tags per image"; the batch and Preview tagging
+  review send that entry's text. WD14 is unchanged. Pinned by `the batch review names the
+  language model's default instructions (D205)` (workspace-system-tagging.spec).
 - **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":
@@ -5144,16 +5229,16 @@ server-side tagging configuration, `autotag.defaults` in config.json: `model_typ
 (`wd14-swinv2`, `wd14-vit`, `gguf`, `hf`), `existing` (`skip`, `merge`,
 `replace_after_review`), `general_threshold` and `character_threshold` (0–1 in
 steps of 0.05, #369),
-`template` (non-blank, at most 4,000 characters and 16 KiB) and `suggestion_limit`
-(1–100). They are host drafts (`autotag_model_type`, `autotag_existing`,
-`autotag_general_threshold`, `autotag_character_threshold`, `autotag_template`,
-`autotag_suggestion_limit`) saved by the one Save row through `POST
+`suggestion_limit` (1–100), and since #431 `skipped_tags`, `instructions` and
+`default_instructions` (below). They are host drafts (`autotag_model_type`, `autotag_existing`,
+`autotag_general_threshold`, `autotag_character_threshold`, `autotag_suggestion_limit`,
+`autotag_skipped_tags`, `autotag_instructions`, `autotag_default_instructions`) saved by the one Save row through `POST
 /prompt_manager/settings` with `expected_revision`; a bad value is refused with a 400
 naming the setting by its row label ("General-tag confidence must be between 0 and
 1."), nothing is written, the Save row shows that sentence (`invalid-setting`, set by
 `settingRefusal` in system.mjs only for a save that carried `autotag_*` keys; every
 other section's plain 400 keeps the generic status) and the control is highlighted.
-The template's limit counts code points, as Python's `len` does. A hand-edited bad value
+Instruction text limits count code points, as Python's `len` does. A hand-edited bad value
 falls back to its default on load, one key at a time. Every page shows the thresholds in
 steps of 0.05 (the System rows, the Tag image dialogs, the legacy sliders), so a saved
 threshold off that grid is refused ("General-tag confidence must be a multiple of
@@ -5164,8 +5249,70 @@ stored exactly on the grid (#369). A per-request threshold keeps its own check:
 `validate_options` and starts the `autotag` job titled "Tag output images (legacy page)";
 the legacy `/autotag/single` only requires a number. `GET /autotag/models` reports the
 saved values (`wd14_general_threshold`, `wd14_character_threshold`, `suggestion_limit`,
-`default_prompt`, `model_type`, `existing`), so the Tag image and Auto-tag selected
-dialogs start from them; a preset (the bulk review, Preview tagging review) wins.
+`default_prompt`, `model_type`, `existing`, and since #431 `instructions` and
+`default_instructions`), so the Tag image and Auto-tag selected dialogs start from them;
+a preset (the bulk review, Preview tagging review) wins.
+
+**Saved instructions** (#431, D203, D205): `autotag.defaults.instructions` holds the
+saved entries `[{id, name, text}]` in order (at most 20; `id` 12 lowercase hex made by
+the client, unique, `builtin` reserved; `name` trimmed, 1–60 characters, no control
+character, unique case-folded, not "Built-in"; `text` as `validate_template`), and
+`autotag.defaults.default_instructions` is `{gguf, hf}`, each `builtin` or a saved id.
+Built-in (`{id: "builtin", name: "Built-in", text: DEFAULT_TAG_TEMPLATE}`) is never
+stored; readers put it first (`AutotagConfig.all_instructions`), so a later release's
+built-in text reaches everyone who uses it. Refusals (400, the Save row shows them and
+highlights the editor): "Saved instructions: at most 20 entries besides Built-in.",
+"Saved instructions: entry N has an invalid id.", "… repeats the id of entry M.", "…
+needs a name.", "… name must be at most 60 characters.", "… name must not contain a line
+break.", "… name “X” is already used.", "Saved instructions: the name “Built-in” is
+reserved.", "Saved instructions: entry N text must be …", "Default for GGUF JoyCaption
+must be one of the saved instructions." (and HuggingFace). A save carrying either key
+without `expected_revision` is refused ("Reload the page and try again."); a save
+carrying one is paired with the other from the running configuration and both are
+written, plus the old `template` key as the GGUF default's text (deleted when that
+default is Built-in), so an older build reads that default as its one template. `POST`
+with `autotag_template` is refused ("LLM tag template was replaced by Saved instructions.
+Reload the page."); `GET` keeps returning it (the GGUF default's text, read-only) for one
+release and adds `autotag_builtin_instructions` (Built-in's text, read-only). Load: each
+key alone (a damaged list → Built-in only, a default naming nothing → Built-in, each with
+one warning), then the in-memory migration of the old `template`: with no `instructions`
+key, a template other than Built-in becomes "Custom template" (id = first 12 hex of its
+SHA-256), the default of both engines unless `default_instructions` is stored; with the
+key, a template matching no entry (edited on an older build) is appended as "Custom
+template (n)" with one INFO line (a full list: one WARNING, nothing imported). Nothing is
+written at load; the next save that carries either key writes the list.
+`AutotagConfig.default_instructions_text(engine)` feeds the legacy batch and single
+blank-prompt fallbacks (by the request's engine) and `default_prompt`. Tests:
+`tests/test_saved_instructions.py`, `tests/test_saved_instructions_routes.py`,
+`tests/js/workspace-system-instructions.test.js`.
+
+**Skipped tags** (#431, D202): `autotag.defaults.skipped_tags`, host draft
+`autotag_skipped_tags`, a list of at most 200 entries, each trimmed, 1–50 code points,
+no comma or control character, at least one word, no two with the same words (refused
+with "Skipped tags: at most 200 entries.", "Skipped tags: entry N is empty.", "… must be
+at most 50 characters.", "… must not contain a comma or a line break.", "… repeats entry
+M."); a save carrying it without `expected_revision` is refused ("Reload the page and try
+again."). A damaged saved list falls back to none with one warning. Words are the
+NFC, case-folded text split on runs of space, `_` and `-` (`tag_words`); an entry hides
+a suggested tag whose words contain the entry's words consecutively (`SkipMatcher`:
+`blurry` hides `very_blurry` and `blurry_background`, not `unblurry`; `(fate)` hides
+`saber_(fate)`, `fate` does not). `generate_tag_suggestions(skip=)` drops a match after
+the name check and before the dedupe and the limit, so skipped tags use up no slot
+(WD14 fills from lower scores; a language model may return fewer). Every path filters:
+`/image-annotations/suggest` (compiled per request; the answer adds `skipped`, the
+number of distinct names it hid), `/autotag/single`, and the `image-tags` (Auto-tag
+selected) and `autotag` (System batch, legacy `/autotag/start`) jobs, which snapshot the
+list at their start and log "Skipped tags: N entries" or "Skipped tags: none"; a save
+during a run does not change it. Hand-typed and stored tags are never filtered; the
+language models' hard-coded exclude list (`_parse_tags`) runs first. `POST
+/prompt_manager/autotag/skipped-tags/preview {entries}` (validated as a save) answers
+`count`, `sample` (12, library tags first, each part sorted case-folded),
+`sample_limit`, `per_entry [{entry, count}]` and `sources {library, wd14}` over the
+library's tags plus the category 0/4 names of each downloaded WD14 `selected_tags.csv`
+(read as UTF-8, cached by mtime and size; a missing list is skipped). It loads no model,
+opens no image, writes nothing and is `409 busy` while an exclusive job runs. Tests:
+`tests/test_skipped_tags.py`, `tests/test_skipped_tags_routes.py`, the settings and
+config tests, `tests/js/workspace-system-skipped-tags.test.js`.
 
 `GET /prompt_manager/autotag/models` reads the disk in the executor, never loads or
 downloads a model and carries no absolute path: per engine `name`, `label`,
@@ -5413,7 +5560,7 @@ list stay unscoped: any row's control proves them.
 | Worker threads | `admin.html:437–445` | S4 Sources | covered | `sources` · slider · "Worker threads" | worker range max is cpu_count (workspace-system-sources.spec.mjs) |
 | LoraManager badge, enable, path, trigger words, CivitAI key, clear key | `admin.html:448–490`; `admin.js:1052–1156` | S10 Integrations | covered | `integrations` · switch · "LoraManager integration" | LoRA rows show detected / enabled / cache-loaded separately (workspace-system-integrations.spec.mjs) |
 | LoRA data import with progress | `admin.html:492–498,517–541`; `admin.js:1157` | S10 Integrations | covered | `integrations` · button · "Review import" | Review import shows replacement, blocked items and network effects with the backup box; Start opens the job (D107) (workspace-system-integrations.spec.mjs) |
-| Statistics | `admin.html:159`; `admin.js:1627` | S2 Overview | covered | `overview` · button · "Explore" | statistics dialog lists runs by category and library totals (workspace-system.spec.mjs) |
+| Statistics | `admin.html:159`; `admin.js:1627` | S2 Overview | covered | `overview` · button · "Explore" | statistics dialog lists runs by category and database record counts (workspace-system.spec.mjs) |
 | Export components JSON `/export` | `admin.html:163`; `admin.js:1607`; `py/api/prompts.py:238` | S9 Backup & export | covered | `backups` · button · "Export all prompts JSON" | Export JSON downloads /library/export; secondary buttons download all prompts (/export) and /pairs/export (D103) (workspace-system-backups.spec.mjs) |
 | Saved pairs export | `py/api/pairs.py:84` | S9 Backup & export | covered | `backups` · button · "Export saved pairs JSON" | Export JSON downloads /library/export; secondary buttons download all prompts (/export) and /pairs/export (D103) (workspace-system-backups.spec.mjs) |
 | Library export | `py/api/library.py:223` | S9 Backup & export | covered | `backups` · button · "Export JSON" | Export JSON downloads /library/export; secondary buttons download all prompts (/export) and /pairs/export (D103) (workspace-system-backups.spec.mjs) |

__init__.py

@@ -435,12 +435,9 @@ except Exception as e:
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
 
-# Print startup message with loaded tools
-print()
-print(f"\033[94m[ComfyUI-PromptManager] Version:\033[0m {get_version()}")
-for node_key, display_name in NODE_DISPLAY_NAME_MAPPINGS.items():
-    # ASCII only: a Windows console using a legacy code page cannot print emoji,
-    # and a UnicodeEncodeError here would abort loading the whole node.
-    print(f"  \033[94mLoaded:\033[0m {display_name}")
-print(f"\033[94mTotal: {len(NODE_CLASS_MAPPINGS)} tools loaded\033[0m")
-print()
+# One startup line. ASCII only: a Windows console using a legacy code page
+# cannot print emoji, and a UnicodeEncodeError here would abort loading the node.
+print(
+    f"\033[94m[ComfyUI-PromptManager] Version:\033[0m {get_version()}"
+    f" - {len(NODE_CLASS_MAPPINGS)} tools loaded"
+)

py/api/annotation_suggest.py

@@ -102,11 +102,14 @@ def model_refusal(status: dict, model_type: str, model_name: str):
     return None
 
 
-def run_suggestions(service, capture_path: str, model_type: str, options: dict):
+def run_suggestions(
+    service, capture_path: str, model_type: str, options: dict, skip=None
+):
     """Blocking: load (or swap to) *model_type*, then suggest for the capture.
 
     The caller holds the model gate for the whole call; nothing is ever
-    downloaded (``load_model`` refuses a model that is not on disk).
+    downloaded (``load_model`` refuses a model that is not on disk). ``skip``
+    is the request's or job's compiled Skipped tags (#431).
     """
     if not service.is_model_loaded() or service.get_loaded_model_type() != model_type:
         service.load_model(model_type, options["use_gpu"])
@@ -116,6 +119,7 @@ def run_suggestions(service, capture_path: str, model_type: str, options: dict):
         prompt=options.get("instructions"),
         general_threshold=options.get("general_threshold"),
         character_threshold=options.get("character_threshold"),
+        skip=skip,
     )
 
 

py/api/annotations.py

@@ -35,6 +35,7 @@ from .media_target import media_target as _target
 from .images import _unavailable_link, _verified_title
 from .prompts import bad_request
 from .. import model_gate
+from ..tagging_defaults import SkipMatcher
 
 try:
     from ...database.annotations import (
@@ -640,6 +641,8 @@ class AnnotationRoutesMixin:
             owner = model_gate.new_owner("image-annotations")
             if not model_gate.try_acquire(owner):
                 return model_busy_response()
+            # #431: the Skipped tags as they are when the request is accepted.
+            skip = SkipMatcher(AutotagConfig.SKIPPED_TAGS).counting()
             try:
                 # From here the pin is the gate's to end: the worker ends it,
                 # or ``on_skipped`` does when the worker never starts.
@@ -653,6 +656,7 @@ class AnnotationRoutesMixin:
                     capture,
                     model_type,
                     options,
+                    skip,
                     on_skipped=functools.partial(store.release_use, token),
                 )
             except MissingBackendPackages as exc:
@@ -677,6 +681,8 @@ class AnnotationRoutesMixin:
                 "model_type": model_type,
                 "options": options,
                 "suggestions": suggestion_rows(pairs),
+                # How many distinct suggestions the Skipped tags hid (#431).
+                "skipped": len(skip.hidden),
             },
             headers={"Cache-Control": "no-store"},
         )
@@ -732,10 +738,10 @@ def _byte_range(request: web.Request, size: int):
     return start, stop
 
 
-def _pinned_suggestions(store, token, service, capture, model_type, options):
+def _pinned_suggestions(store, token, service, capture, model_type, options, skip=None):
     """Worker thread: infer on the capture, then end its pin (even on error)."""
     try:
-        return run_suggestions(service, capture.path, model_type, options)
+        return run_suggestions(service, capture.path, model_type, options, skip)
     finally:
         store.release_use(token)
 

py/api/autotag_routes.py

@@ -40,6 +40,12 @@ BATCH_PREVIEW_BODY_MAX = 1024
 APPLY_BODY_MAX = 64 * 1024  # POST /autotag/apply: one image and its tags
 _HEX64 = re.compile(r"[0-9a-f]{64}")
 BATCH_JOB_BODY_MAX = 32 * 1024
+# Skipped tags preview (#431): 200 entries of 50 characters, with room for JSON.
+SKIPPED_PREVIEW_BODY_MAX = 64 * 1024
+SKIPPED_PREVIEW_LEASE = "Skipped tags preview"
+SKIPPED_PREVIEW_SAMPLE = 12
+# WD14 label lists the preview found missing or unreadable (logged once each).
+_MISSING_LABEL_LISTS = set()
 REVIEW_REQUIRED = (
     "Replacing tags needs a review of each image. Use Preview tagging review, "
     "or choose Skip or Merge for a batch run."
@@ -72,6 +78,12 @@ MODEL_DOWNLOAD_BODY_MAX = 1024
 _download_titles = {}
 
 
+def _instruction_engine(model_type: str) -> str:
+    """The language-model engine whose default instructions ``model_type``
+    reads: itself, or GGUF for a WD14 engine (which takes none)."""
+    return model_type if model_type in ("gguf", "hf") else "gguf"
+
+
 def _holder_label(holder: Optional[str]) -> str:
     if not holder:
         return ANOTHER_OPERATION
@@ -247,6 +259,10 @@ class AutotagRoutesMixin:
         async def preview_autotag_batch_route(request):
             return await self.preview_autotag_batch(request)
 
+        @routes.post("/prompt_manager/autotag/skipped-tags/preview")
+        async def preview_skipped_tags_route(request):
+            return await self.preview_skipped_tags(request)
+
         @routes.post("/prompt_manager/autotag/start")
         async def start_autotag_route(request):
             return await self.start_autotag(request)
@@ -284,7 +300,15 @@ class AutotagRoutesMixin:
                     "success": True,
                     "models": public_models(status, loaded_type),
                     # The saved tagging defaults (#328, System › Auto-tagging).
-                    "default_prompt": AutotagConfig.TEMPLATE,
+                    # The saved engine's default instructions (GGUF for a
+                    # WD14 engine); kept one release for cached pages (#431).
+                    "default_prompt": AutotagConfig.default_instructions_text(
+                        _instruction_engine(AutotagConfig.MODEL_TYPE)
+                    ),
+                    # #431: Built-in first, with every text, and each
+                    # language-model engine's default.
+                    "instructions": AutotagConfig.all_instructions(),
+                    "default_instructions": dict(AutotagConfig.DEFAULT_INSTRUCTIONS),
                     "model_loaded": loaded,
                     "loaded_model_type": loaded_type,
                     "wd14_general_threshold": AutotagConfig.GENERAL_THRESHOLD,
@@ -539,7 +563,10 @@ class AutotagRoutesMixin:
         else:
             prompt = params.get("prompt")
             template = prompt if isinstance(prompt, str) and prompt.strip() else None
-            options = {"instructions": template or AutotagConfig.TEMPLATE}
+            options = {
+                "instructions": template
+                or AutotagConfig.default_instructions_text(model_type)
+            }
         try:
             _model, options = validate_options(
                 model_type,
@@ -699,6 +726,86 @@ class AutotagRoutesMixin:
             return None, "existing must be one of " + ", ".join(EXISTING_POLICIES)
         return MODELS[model_type], None
 
+    async def preview_skipped_tags(self, request):
+        """Which known tags a Skipped tags list would hide (#431); no write.
+
+        ``{entries}`` is checked as a save checks it (the same 400 sentence).
+        The known tags are the library's plus the general and character names
+        of each downloaded WD14 label list; no model is loaded and no image is
+        opened. Refused (409 ``busy``) while an exclusive job runs.
+        """
+        from ..tagging_defaults import validate_skipped_tags
+
+        data, error = await self._batch_body(
+            request, ("entries",), SKIPPED_PREVIEW_BODY_MAX
+        )
+        if error is not None:
+            return error
+        try:
+            entries = validate_skipped_tags(data["entries"])
+        except ValueError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=400)
+        try:
+            async with self._jobs.lease(SKIPPED_PREVIEW_LEASE):
+                result = await self._run_in_executor(self._skipped_preview, entries)
+        except JobBusy as busy:
+            return busy_response(busy)
+        except Exception:
+            self.logger.exception("The Skipped tags preview failed")
+            return web.json_response(
+                {"success": False, "error": _INTERNAL_ERROR}, status=500
+            )
+        return web.json_response({"success": True, **result})
+
+    def _skipped_preview(self, entries):
+        """Worker thread: the preview's counts over the known tags."""
+        from ..autotag import MODELS, get_autotag_service
+        from ..tagging_defaults import (
+            WD14_MODEL_TYPES,
+            SkipMatcher,
+            wd14_label_names,
+        )
+
+        library = self.db.get_all_tags()
+        known = {}  # case-folded -> (0 library / 1 label list, spelling)
+        for name in library:
+            known.setdefault(name.casefold(), (0, name))
+        lists = []
+        models_dir = getattr(get_autotag_service(), "models_dir", None)
+        for model_type in sorted(WD14_MODEL_TYPES, key=lambda t: MODELS[t]["name"]):
+            if models_dir is None:
+                break
+            path = Path(models_dir) / MODELS[model_type]["subdir"] / "selected_tags.csv"
+            try:
+                names = wd14_label_names(path)
+            except (OSError, ValueError) as exc:
+                if path not in _MISSING_LABEL_LISTS:  # logged once per list
+                    _MISSING_LABEL_LISTS.add(path)
+                    self.logger.debug(f"No WD14 label list for {model_type}: {exc}")
+                continue
+            _MISSING_LABEL_LISTS.discard(path)
+            lists.append(MODELS[model_type]["name"])
+            for name in names:
+                known.setdefault(name.casefold(), (1, name))
+        matchers = [(entry, SkipMatcher([entry])) for entry in entries]
+        whole = SkipMatcher(entries)
+        hidden = [item for item in known.values() if whole.matches(item[1])]
+        hidden.sort(key=lambda item: (item[0], item[1].casefold()))
+        per_entry = [
+            {
+                "entry": entry,
+                "count": sum(1 for _, name in hidden if matcher.matches(name)),
+            }
+            for entry, matcher in matchers
+        ]
+        return {
+            "count": len(hidden),
+            "sample": [name for _, name in hidden[:SKIPPED_PREVIEW_SAMPLE]],
+            "sample_limit": SKIPPED_PREVIEW_SAMPLE,
+            "per_entry": per_entry,
+            "sources": {"library": len(library), "wd14": lists},
+        }
+
     async def preview_autotag_batch(self, request):
         """Review Tag output images: counts, model, backup and disk; no write.
 
@@ -1002,7 +1109,10 @@ class AutotagRoutesMixin:
         else:
             prompt = data.get("prompt")
             template = prompt if isinstance(prompt, str) and prompt.strip() else None
-            options = {"instructions": template or AutotagConfig.TEMPLATE}
+            options = {
+                "instructions": template
+                or AutotagConfig.default_instructions_text(model_type)
+            }
         use_gpu = data.get("use_gpu", True)
         options["use_gpu"] = use_gpu if isinstance(use_gpu, bool) else True
         return validate_options(
@@ -1096,6 +1206,8 @@ class AutotagRoutesMixin:
 
     async def _suggest_single(self, target, model_type, options, base):
         from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
+        from ..config import AutotagConfig
+        from ..tagging_defaults import SkipMatcher
         from .annotation_suggest import model_refusal
         from .annotations import _pinned_suggestions, _settled, _submit
 
@@ -1112,6 +1224,8 @@ class AutotagRoutesMixin:
         owner = model_gate.new_owner("legacy-single")
         if not model_gate.try_acquire(owner):
             return model_busy_response()
+        # #431: the legacy review hides the Skipped tags too (19A).
+        skip = SkipMatcher(AutotagConfig.SKIPPED_TAGS)
         store = self._capture_store()
         try:
             epoch = await self._run_in_executor(self.db.get_execution_epoch)
@@ -1151,6 +1265,7 @@ class AutotagRoutesMixin:
                     capture,
                     model_type,
                     options,
+                    skip,
                     on_skipped=functools.partial(store.release_use, capture.token),
                 )
             except MissingBackendPackages as exc:

py/api/image_tag_jobs.py

@@ -39,6 +39,7 @@ from typing import NamedTuple
 from aiohttp import web
 
 from .. import model_gate
+from ..tagging_defaults import SkipMatcher
 from .admin import _plural, _time_left
 from .annotation_suggest import (
     OptionError,
@@ -170,6 +171,8 @@ class _Run:
     owner: object
     service: object = None
     roots: dict = field(default_factory=dict)
+    # The job's Skipped tags, compiled once at its start (#431).
+    skip: object = None
 
 
 @dataclass(frozen=True)
@@ -183,6 +186,9 @@ class _Spec:
     options: dict | None = None
     # A listing filter the start resolves into ``targets`` (#392).
     filter: dict | None = None
+    # The Skipped tags when the job was requested (#431); a later save does
+    # not change a running job.
+    skip: tuple = ()
 
     @property
     def title(self) -> str:
@@ -238,7 +244,11 @@ def _parse_auto(targets, data):
         )
     except OptionError as exc:
         return None, bad_request(str(exc))
-    return _Spec("auto", targets, model_type=model_type, options=options), None
+    skip = tuple(AutotagConfig.SKIPPED_TAGS)
+    return (
+        _Spec("auto", targets, model_type=model_type, options=options, skip=skip),
+        None,
+    )
 
 
 def parse_image_tag_request(data: dict):
@@ -329,6 +339,8 @@ class AutotagRun:
     keep_in_memory: bool
     backup_on: bool
     owner: object
+    # The Skipped tags when the job was started (#431).
+    skip: tuple = ()
 
 
 @dataclass(frozen=True)
@@ -400,6 +412,14 @@ def _load_model(service, model_type: str, use_gpu: bool) -> None:
         raise RuntimeError(f"{model_type} could not be loaded")
 
 
+def _skipped_tags_line(entries: tuple) -> str:
+    """The job log's one line about the Skipped tags it runs with (#431)."""
+    if not entries:
+        return "Skipped tags: none"
+    count = len(entries)
+    return f"Skipped tags: {count} {'entry' if count == 1 else 'entries'}"
+
+
 def _refusal(status: int, code: str, message: str) -> Refusal:
     response = web.json_response(
         {"success": False, "code": code, "error": message}, status=status
@@ -507,6 +527,7 @@ class ImageTagJobsMixin:
         released when the task ends, also before its runner ever starts.
         """
         from ..autotag import MODELS, get_autotag_service
+        from ..config import AutotagConfig
 
         backup_on = self._safety_backup_policy() == "on"
         status = await self._run_in_executor(get_autotag_service().get_models_status)
@@ -529,7 +550,13 @@ class ImageTagJobsMixin:
             response = model_busy_response()
             return None, Refusal(409, "model-busy", MODEL_BUSY_ERROR, response)
         run = AutotagRun(
-            model_type, existing, options, keep_in_memory, backup_on, owner
+            model_type,
+            existing,
+            options,
+            keep_in_memory,
+            backup_on,
+            owner,
+            skip=tuple(AutotagConfig.SKIPPED_TAGS),
         )
         admitted = False
         try:
@@ -598,7 +625,9 @@ class ImageTagJobsMixin:
             return _batch_cancelled(job)
         job.publish({"type": "phase", "phase": "model"})
         job.update(status_line="Loading the tagging model")
-        spec = _Spec("auto", (), model_type=run.model_type, options=run.options)
+        spec = _Spec(
+            "auto", (), model_type=run.model_type, options=run.options, skip=run.skip
+        )
         service = await self._prepare_tagging_model(job, spec, run.owner)
         if service is None:
             return "failed"
@@ -624,6 +653,7 @@ class ImageTagJobsMixin:
             f"Tagging started · {job.scope.get('label') or run.model_type} · "
             f"{_plural(total, 'image')} · {policy}"
         )
+        job.log_line(_skipped_tags_line(spec.skip))
         if job.cancelled:
             return _batch_cancelled(job)
         remaining = await self._autotag_prepass(job, targets, run.existing == "skip")
@@ -633,7 +663,9 @@ class ImageTagJobsMixin:
         spec = dataclasses.replace(
             spec, targets=tuple(item.target for item in remaining)
         )
-        loop_run = _Run(job, spec, epoch, run.owner, service)
+        loop_run = _Run(
+            job, spec, epoch, run.owner, service, skip=SkipMatcher(spec.skip)
+        )
         if not await self._tag_each_file(loop_run, done_before=done):
             job.update(status_line=STORAGE_RESTORED)
             job.log_line(f"Tagging stopped · {STORAGE_RESTORED}")
@@ -739,6 +771,9 @@ class ImageTagJobsMixin:
             started += f" · {spec.model_type}"
         job.log_line(started)
         run = _Run(job, spec, epoch, owner)
+        if spec.mode == "auto":
+            job.log_line(_skipped_tags_line(spec.skip))
+            run.skip = SkipMatcher(spec.skip)
         try:
             if spec.mode == "auto":
                 run.service = await self._prepare_tagging_model(job, spec, owner)
@@ -894,6 +929,7 @@ class ImageTagJobsMixin:
                 capture,
                 spec.model_type,
                 spec.options,
+                run.skip,
                 on_skipped=functools.partial(store.release_use, capture.token),
             )
         except Exception:

py/api/lora_integration.py

@@ -44,6 +44,7 @@ _FILES_CHANGED = (
     "The LoRA metadata files changed during the scan; the previous imports "
     "were kept. Run the scan again."
 )
+_LORA_SCAN_FAILED = "The LoRA import failed. Check the server log for details."
 _IMPORTS_CHANGED = (
     "The imported LoRA prompts changed during the scan; the previous imports "
     "were kept. Run the scan again."
@@ -407,10 +408,21 @@ class LoraIntegrationMixin:
             return
         if isinstance(error, PlanChanged):
             message = _IMPORTS_CHANGED
-        elif isinstance(error, (LoraFilesChanged, LoraSettingsUnusable)):
+        elif isinstance(
+            error,
+            (
+                LoraFilesChanged,
+                LoraSettingsUnusable,
+                EmptyReplacement,
+                PairDependencyError,
+            ),
+        ):
             message = str(error)
-        else:
+        elif isinstance(error, OSError):
+            # Reduced to its reason and the file's basename.
             message = self._public_error(error)
+        else:
+            message = _LORA_SCAN_FAILED
         if isinstance(
             error,
             (

py/api/settings_routes.py

@@ -54,9 +54,25 @@ _SETTINGS_FILE_KEYS = {
     "AUTOTAG_EXISTING": ("autotag", "defaults", "existing"),
     "AUTOTAG_GENERAL_THRESHOLD": ("autotag", "defaults", "general_threshold"),
     "AUTOTAG_CHARACTER_THRESHOLD": ("autotag", "defaults", "character_threshold"),
-    "AUTOTAG_TEMPLATE": ("autotag", "defaults", "template"),
     "AUTOTAG_SUGGESTION_LIMIT": ("autotag", "defaults", "suggestion_limit"),
+    "AUTOTAG_SKIPPED_TAGS": ("autotag", "defaults", "skipped_tags"),
+    # #431: the saved instructions and each engine's default, always written
+    # together (server-side pairing).
+    "AUTOTAG_INSTRUCTIONS": ("autotag", "defaults", "instructions"),
+    "AUTOTAG_DEFAULT_INSTRUCTIONS": ("autotag", "defaults", "default_instructions"),
 }
+# The old single template: written only as the GGUF default's mirror for a
+# downgrade (#431 B1.1), deleted when that default is Built-in.
+_TEMPLATE_MIRROR_KEY = ("autotag", "defaults", "template")
+TEMPLATE_REPLACED_ERROR = (
+    "LLM tag template was replaced by Saved instructions. Reload the page."
+)
+# Whole-list settings (#431): a save without ``expected_revision`` would merge
+# a stale copy over a list changed elsewhere, so it is refused.
+_REVISION_REQUIRED = frozenset(
+    {"autotag_skipped_tags", "autotag_instructions", "autotag_default_instructions"}
+)
+REVISION_REQUIRED_ERROR = "Reload the page and try again."
 # 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.
@@ -137,13 +153,20 @@ def _settings_mutation(updates, new_roots):
     """The config commit for a settings save: only the submitted keys change.
 
     Every other section and key (integrations and the CivitAI key, database,
-    unknown sections) is kept as it is on disk.
+    unknown sections) is kept as it is on disk. A save of the instructions
+    also writes the old ``template`` key as the GGUF default's mirror.
     """
 
     def mutate(config):
         for name, value in updates.items():
             *sections, key = _SETTINGS_FILE_KEYS[name]
-            _set_nested(config, sections, key, value)
+            _set_nested(config, sections, key, _jsonable(value))
+        if "AUTOTAG_INSTRUCTIONS" in updates:
+            *sections, key = _TEMPLATE_MIRROR_KEY
+            mirror = _mirror_text(
+                updates["AUTOTAG_INSTRUCTIONS"], updates["AUTOTAG_DEFAULT_INSTRUCTIONS"]
+            )
+            _set_nested(config, sections, key, _DELETE if mirror is None else mirror)
         if new_roots is not None:
             gallery = _section(config, "gallery")
             monitoring = _section(gallery, "monitoring")
@@ -155,10 +178,37 @@ def _settings_mutation(updates, new_roots):
     return mutate
 
 
+# ``_set_nested``'s value that removes the key instead of setting it.
+_DELETE = object()
+
+
+def _jsonable(value):
+    """A runtime value as config.json holds it (tuples become lists)."""
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _jsonable(item) for key, item in value.items()}
+    return value
+
+
+def _mirror_text(entries, defaults):
+    """The GGUF default's text, or None when it is Built-in (#431 B1.1)."""
+    from ..tagging_defaults import BUILTIN_INSTRUCTIONS_ID
+
+    for item in entries:
+        if item["id"] == defaults["gguf"] != BUILTIN_INSTRUCTIONS_ID:
+            return item["text"]
+    return None
+
+
 def _set_nested(config, sections, key, value):
-    """``config[s1][s2]...[key] = value``, each section a fresh dict."""
+    """``config[s1][s2]...[key] = value``, each section a fresh dict;
+    ``_DELETE`` removes the key."""
     if not sections:
-        config[key] = value
+        if value is _DELETE:
+            config.pop(key, None)
+        else:
+            config[key] = value
         return
     merged = _section(config, sections[0])
     _set_nested(merged, sections[1:], key, value)
@@ -176,7 +226,7 @@ def _validate_autotag_settings(data):
         MAX_SUGGESTION_LIMIT,
         MODEL_TYPES,
         validate_saved_threshold,
-        validate_template,
+        validate_skipped_tags,
     )
 
     updates = {}
@@ -205,12 +255,7 @@ def _validate_autotag_settings(data):
                 raise ValueError(f"{error}.") from None
             updates[key.upper()] = value
     if "autotag_template" in data:
-        try:
-            updates["AUTOTAG_TEMPLATE"] = validate_template(
-                data["autotag_template"], "LLM tag template"
-            )
-        except ValueError as error:
-            raise ValueError(f"{error}.") from None
+        raise ValueError(TEMPLATE_REPLACED_ERROR)
     if "autotag_suggestion_limit" in data:
         value = data["autotag_suggestion_limit"]
         if type(value) is not int or not 1 <= value <= MAX_SUGGESTION_LIMIT:
@@ -219,9 +264,41 @@ def _validate_autotag_settings(data):
                 f"{MAX_SUGGESTION_LIMIT}."
             )
         updates["AUTOTAG_SUGGESTION_LIMIT"] = value
+    if "autotag_skipped_tags" in data:
+        updates["AUTOTAG_SKIPPED_TAGS"] = tuple(
+            validate_skipped_tags(data["autotag_skipped_tags"])
+        )
+    updates.update(_validate_instruction_settings(data))
     return updates
 
 
+def _validate_instruction_settings(data):
+    """Server-side pairing (#431): a save that carries either instruction key
+    gets the other from the running configuration (which holds the migrated
+    list), the defaults are checked against the merged list, and both are
+    written. Empty when the save carries neither."""
+    from ..config import AutotagConfig
+    from ..tagging_defaults import (
+        validate_default_instructions,
+        validate_instructions,
+    )
+
+    if not {"autotag_instructions", "autotag_default_instructions"} & set(data):
+        return {}
+    if "autotag_instructions" in data:
+        entries = validate_instructions(data["autotag_instructions"])
+    else:
+        entries = [dict(item) for item in AutotagConfig.INSTRUCTIONS]
+    defaults = data.get(
+        "autotag_default_instructions", dict(AutotagConfig.DEFAULT_INSTRUCTIONS)
+    )
+    defaults = validate_default_instructions(defaults, entries)
+    return {
+        "AUTOTAG_INSTRUCTIONS": tuple(entries),
+        "AUTOTAG_DEFAULT_INSTRUCTIONS": defaults,
+    }
+
+
 async def _read_json(request):
     """Parse a JSON object body through the package's capped reader."""
     from . import _read_json_body
@@ -249,6 +326,7 @@ class SettingsRoutesMixin:
         """Get current settings."""
         try:
             from ..config import AutotagConfig, PromptManagerConfig, GalleryConfig
+            from ..tagging_defaults import DEFAULT_TAG_TEMPLATE
 
             root_paths = [
                 self._public_path(d) for d in GalleryConfig.MONITORING_DIRECTORIES
@@ -281,8 +359,21 @@ class SettingsRoutesMixin:
                         "autotag_character_threshold": (
                             AutotagConfig.CHARACTER_THRESHOLD
                         ),
-                        "autotag_template": AutotagConfig.TEMPLATE,
+                        # Read-only for one release (#431): a page cached
+                        # from before the upgrade still renders.
+                        "autotag_template": AutotagConfig.default_instructions_text(
+                            "gguf"
+                        ),
+                        "autotag_instructions": [
+                            dict(item) for item in AutotagConfig.INSTRUCTIONS
+                        ],
+                        "autotag_default_instructions": dict(
+                            AutotagConfig.DEFAULT_INSTRUCTIONS
+                        ),
+                        # Built-in's text, which System shows read-only.
+                        "autotag_builtin_instructions": DEFAULT_TAG_TEMPLATE,
                         "autotag_suggestion_limit": AutotagConfig.SUGGESTION_LIMIT,
+                        "autotag_skipped_tags": list(AutotagConfig.SKIPPED_TAGS),
                         "cpu_count": PromptManagerConfig.max_worker_threads(),
                         "gallery_root_paths": root_paths,
                         "gallery_root_path": root_paths[0] if root_paths else "",
@@ -383,6 +474,10 @@ class SettingsRoutesMixin:
                     {"success": False, "error": "expected_revision must be a string"},
                     status=400,
                 )
+            if expected_revision is None and _REVISION_REQUIRED & set(data):
+                return web.json_response(
+                    {"success": False, "error": REVISION_REQUIRED_ERROR}, status=400
+                )
             try:
                 updates = self._validate_settings(data)
             except ValueError as ve:
@@ -511,6 +606,12 @@ class SettingsRoutesMixin:
             if name in _AUTOTAG_SETTINGS:
                 setattr(AutotagConfig, name[len(_AUTOTAG_PREFIX) :], value)
                 continue
+        if "AUTOTAG_INSTRUCTIONS" in updates:
+            # What config.json now holds as the old key (the mirror).
+            AutotagConfig._LEGACY_TEMPLATE = AutotagConfig.mirror_template()
+        for name, value in updates.items():
+            if name in _AUTOTAG_SETTINGS:
+                continue
             owner = GalleryConfig if name in _GALLERY_SETTINGS else PromptManagerConfig
             setattr(owner, name, value)
         restart_fields = []

py/autotag.py

@@ -30,9 +30,9 @@ except ImportError:
 # The tag template and thresholds live with the saved tagging defaults
 # (#328), so config.py never imports PIL.
 try:
-    from .tagging_defaults import DEFAULT_TAG_TEMPLATE
+    from .tagging_defaults import DEFAULT_TAG_TEMPLATE, read_wd14_label_rows
 except ImportError:
-    from py.tagging_defaults import DEFAULT_TAG_TEMPLATE
+    from py.tagging_defaults import DEFAULT_TAG_TEMPLATE, read_wd14_label_rows
 
 try:
     from ..utils import exit_signal
@@ -559,7 +559,6 @@ class AutoTagService:
         # A missing onnxruntime is refused by load_model before this runs
         # (#424); a ModuleNotFoundError here becomes the same refusal.
         import onnxruntime as ort
-        import csv
 
         config = MODELS[model_type]
         model_dir = self.models_dir / config["subdir"]
@@ -576,12 +575,8 @@ class AutoTagService:
 
         session = ort.InferenceSession(str(model_path), providers=providers)
 
-        # Read tag list from CSV
-        tags_list = []
-        with open(tags_path, "r", encoding="utf-8") as f:
-            reader = csv.DictReader(f)
-            for row in reader:
-                tags_list.append(row)
+        # Read tag list from CSV (the reader the Skipped tags preview shares)
+        tags_list = read_wd14_label_rows(tags_path)
 
         self.logger.info(
             f"WD14 model loaded ({len(tags_list)} tags, "
@@ -992,6 +987,7 @@ class AutoTagService:
         prompt: Optional[str] = None,
         general_threshold: Optional[float] = None,
         character_threshold: Optional[float] = None,
+        skip: Any = None,
     ) -> List[Tuple[str, Optional[float]]]:
         """The top ``limit`` suggestions as ``(name, confidence)`` pairs.
 
@@ -1000,7 +996,9 @@ class AutoTagService:
         ``None``. Names are distinct case-insensitively (first one wins).
         A name Save would reject (over 50 characters, a control character
         such as a newline, a comma) is skipped before the dedupe and the
-        ``limit`` count. ``prompt`` is used for this call only;
+        ``limit`` count. A name ``skip`` matches (a ``SkipMatcher``, the
+        Skipped tags compiled for this request or job, #431) is dropped next,
+        so it uses up no slot. ``prompt`` is used for this call only;
         ``custom_prompt`` is never changed.
         """
         if type(limit) is not int or not 1 <= limit <= MAX_SUGGESTION_LIMIT:
@@ -1017,6 +1015,8 @@ class AutoTagService:
                 name = validate_vocabulary_tag_name(raw)
             except ValueError:
                 continue
+            if skip is not None and skip.matches(name):
+                continue
             key = name.casefold()
             if key in seen:
                 continue

py/config.py

@@ -30,6 +30,7 @@ routes = server_instance.routes
 # Extension info
 extension_uri = None  # Will be set in __init__.py
 
+import hashlib  # noqa: E402
 import os  # noqa: E402
 from typing import Any, Dict, List, Optional, Tuple  # noqa: E402
 
@@ -587,8 +588,15 @@ try:
         MODEL_TYPES,
         WD14_MODEL_TYPES,
         validate_saved_threshold,
+        validate_skipped_tags,
         validate_template,
         validate_threshold,
+        BUILTIN_INSTRUCTIONS_ID,
+        INSTRUCTION_ENGINES,
+        MAX_SAVED_INSTRUCTIONS,
+        builtin_instructions,
+        validate_default_instructions,
+        validate_instructions,
     )
 except ImportError:
     from py.tagging_defaults import (  # noqa: F401 - re-exported
@@ -600,8 +608,15 @@ except ImportError:
         MODEL_TYPES,
         WD14_MODEL_TYPES,
         validate_saved_threshold,
+        validate_skipped_tags,
         validate_template,
         validate_threshold,
+        BUILTIN_INSTRUCTIONS_ID,
+        INSTRUCTION_ENGINES,
+        MAX_SAVED_INSTRUCTIONS,
+        builtin_instructions,
+        validate_default_instructions,
+        validate_instructions,
     )
 
 
@@ -617,6 +632,31 @@ def _valid_existing(value: Any) -> str:
     return value
 
 
+def _valid_skipped_tags(value: Any) -> Tuple[str, ...]:
+    return tuple(validate_skipped_tags(value))
+
+
+def _reason(error: ValueError) -> str:
+    """A settings sentence as a load warning's reason ("entry 2 is empty")."""
+    text = str(error).rstrip(".")
+    for prefix in ("Skipped tags", "Saved instructions"):
+        if text.startswith(prefix):
+            return text.removeprefix(prefix).lstrip(": ")
+    return text
+
+
+def _text_id(text: str) -> str:
+    """A migrated entry's id: deterministic, so every load gives the same."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]
+
+
+def _fallback_warning(key: str, error: ValueError, default: Any) -> str:
+    """The one load warning of a saved tagging default that fails its check."""
+    if key == "skipped_tags":
+        return f"autotag.defaults.skipped_tags {_reason(error)}; using no skipped tags"
+    return f"autotag.defaults.{key} {error}; using {default!r}"
+
+
 def _valid_suggestion_limit(value: Any) -> int:
     if type(value) is not int or not 1 <= value <= MAX_SUGGESTION_LIMIT:
         raise ValueError(f"must be an integer from 1 to {MAX_SUGGESTION_LIMIT}")
@@ -637,8 +677,18 @@ class AutotagConfig:
     EXISTING = "skip"
     GENERAL_THRESHOLD = 0.35
     CHARACTER_THRESHOLD = 0.85
-    TEMPLATE = DEFAULT_TAG_TEMPLATE
     SUGGESTION_LIMIT = DEFAULT_SUGGESTION_LIMIT
+    SKIPPED_TAGS: Tuple[str, ...] = ()
+    # #431: the saved instructions (Built-in is never stored) and the default
+    # of each language-model engine, by id.
+    INSTRUCTIONS: Tuple[Dict[str, str], ...] = ()
+    DEFAULT_INSTRUCTIONS: Dict[str, str] = {
+        "gguf": BUILTIN_INSTRUCTIONS_ID,
+        "hf": BUILTIN_INSTRUCTIONS_ID,
+    }
+    # The old single template as read at load (None when absent or invalid);
+    # only the migration reads it. Saves keep it as the GGUF default's mirror.
+    _LEGACY_TEMPLATE: Optional[str] = None
 
     # config.json key -> (attribute, validator, default)
     _KEYS = {
@@ -654,12 +704,13 @@ class AutotagConfig:
             lambda v: validate_saved_threshold("value", v),
             0.85,
         ),
-        "template": ("TEMPLATE", validate_template, DEFAULT_TAG_TEMPLATE),
         "suggestion_limit": (
             "SUGGESTION_LIMIT",
             _valid_suggestion_limit,
             DEFAULT_SUGGESTION_LIMIT,
         ),
+        # #431: words whose suggested tags are never offered.
+        "skipped_tags": ("SKIPPED_TAGS", _valid_skipped_tags, ()),
     }
 
     @classmethod
@@ -672,17 +723,142 @@ class AutotagConfig:
             type(value) is int and 1 <= value <= MAX_SUGGESTION_LIMIT
         )  # bool, float and str are rejected
 
+    @classmethod
+    def all_instructions(cls) -> List[Dict[str, str]]:
+        """Built-in first, then the saved entries (copies)."""
+        return [builtin_instructions()] + [dict(item) for item in cls.INSTRUCTIONS]
+
+    @classmethod
+    def default_instructions_text(cls, engine: str) -> str:
+        """The text of ``engine``'s (``gguf`` or ``hf``) default instructions."""
+        if engine not in INSTRUCTION_ENGINES:
+            raise ValueError(f"{engine} takes no instructions")
+        wanted = cls.DEFAULT_INSTRUCTIONS.get(engine, BUILTIN_INSTRUCTIONS_ID)
+        for item in cls.INSTRUCTIONS:
+            if item["id"] == wanted:
+                return item["text"]
+        return DEFAULT_TAG_TEMPLATE
+
+    @classmethod
+    def mirror_template(cls) -> Optional[str]:
+        """What an older build reads as its one template (#431 B1.1): the
+        GGUF default's text, or None (no key) when that default is Built-in."""
+        if cls.DEFAULT_INSTRUCTIONS.get("gguf") == BUILTIN_INSTRUCTIONS_ID:
+            return None
+        return cls.default_instructions_text("gguf")
+
     @classmethod
     def get_config(cls) -> Dict[str, Any]:
-        """The saved defaults; the template only when it is not the built-in
-        one, so a later built-in template still reaches who never set one."""
+        """The saved defaults; ``template`` only as the GGUF default's mirror."""
         defaults = {
             key: getattr(cls, attr) for key, (attr, _v, _d) in cls._KEYS.items()
         }
-        if defaults["template"] == DEFAULT_TAG_TEMPLATE:
-            del defaults["template"]
+        defaults["skipped_tags"] = list(defaults["skipped_tags"])
+        defaults["instructions"] = [dict(item) for item in cls.INSTRUCTIONS]
+        defaults["default_instructions"] = dict(cls.DEFAULT_INSTRUCTIONS)
+        mirror = cls.mirror_template()
+        if mirror is not None:
+            defaults["template"] = mirror
         return {"defaults": defaults}
 
+    @classmethod
+    def _load_instructions(cls, defaults: Dict[str, Any]) -> None:
+        """Each instruction key alone, then the cross-key default check, then
+        the in-memory migration of the old template (#431). Nothing is
+        written here, so the revision never changes at load."""
+        cls._LEGACY_TEMPLATE = None
+        if "template" in defaults:
+            try:
+                cls._LEGACY_TEMPLATE = validate_template(defaults["template"])
+            except ValueError as error:
+                config_logger.warning(
+                    f"autotag.defaults.template {error}; using the built-in one"
+                )
+        entries: List[Dict[str, str]] = []
+        damaged = False
+        if "instructions" in defaults:
+            try:
+                entries = validate_instructions(defaults["instructions"])
+            except ValueError as error:
+                damaged = True
+                config_logger.warning(
+                    f"autotag.defaults.instructions {_reason(error)}; "
+                    "using Built-in only"
+                )
+        chosen = {engine: BUILTIN_INSTRUCTIONS_ID for engine in INSTRUCTION_ENGINES}
+        stored = defaults.get("default_instructions")
+        if damaged:
+            # Both defaults fall back with the list (its one warning says so);
+            # the old template is migrated as on a first upgrade.
+            pass
+        elif "default_instructions" in defaults and (
+            not isinstance(stored, dict) or set(stored) != set(INSTRUCTION_ENGINES)
+        ):
+            config_logger.warning(
+                "autotag.defaults.default_instructions must name gguf and hf; "
+                "using Built-in"
+            )
+        elif isinstance(stored, dict):
+            ids = {item["id"] for item in entries}
+            for engine in INSTRUCTION_ENGINES:
+                value = stored[engine]
+                if isinstance(value, str) and (
+                    value == BUILTIN_INSTRUCTIONS_ID or value in ids
+                ):
+                    chosen[engine] = value
+                else:
+                    config_logger.warning(
+                        f"autotag.defaults.default_instructions.{engine} names no "
+                        "saved instructions; using Built-in"
+                    )
+        cls._migrate_template(
+            entries,
+            chosen,
+            first=damaged or "instructions" not in defaults,
+            keep_defaults=not damaged and "default_instructions" in defaults,
+        )
+        cls.INSTRUCTIONS = tuple(entries)
+        cls.DEFAULT_INSTRUCTIONS = chosen
+
+    @classmethod
+    def _migrate_template(cls, entries, chosen, *, first, keep_defaults) -> None:
+        """Bring a template saved by an older build in as a named entry."""
+        legacy = cls._LEGACY_TEMPLATE
+        if legacy is None or legacy == DEFAULT_TAG_TEMPLATE:
+            return
+        if first:
+            # The first upgrade: it becomes "Custom template", the default for
+            # both engines unless defaults are stored already (20A).
+            entries.append(
+                {"id": _text_id(legacy), "name": "Custom template", "text": legacy}
+            )
+            if not keep_defaults:
+                for engine in INSTRUCTION_ENGINES:
+                    chosen[engine] = entries[-1]["id"]
+            return
+        if any(item["text"] == legacy for item in entries):
+            return  # the mirror of a saved default
+        # Edited on an older build after an upgrade (B1.2): import it.
+        if len(entries) >= MAX_SAVED_INSTRUCTIONS:
+            config_logger.warning(
+                "The tagging template edited on an older version was not imported: "
+                f"the saved instructions are full ({MAX_SAVED_INSTRUCTIONS})"
+            )
+            return
+        names = {item["name"].casefold() for item in entries}
+        number = 2
+        while f"custom template ({number})" in names:
+            number += 1
+        name = f"Custom template ({number})"
+        ids = {item["id"] for item in entries}
+        new_id, n = _text_id(legacy), 2
+        while new_id in ids:
+            new_id, n = _text_id(f"{legacy}\n{n}"), n + 1
+        entries.append({"id": new_id, "name": name, "text": legacy})
+        config_logger.info(
+            "Imported the tagging template edited on an older version as " f"'{name}'"
+        )
+
     @classmethod
     def update_config(cls, new_config: Any) -> None:
         if not isinstance(new_config, dict):
@@ -698,12 +874,9 @@ class AutotagConfig:
             try:
                 setattr(cls, attr, validate(defaults[key]))
             except ValueError as error:
-                config_logger.warning(
-                    f"autotag.defaults.{key} {error}; using {default!r}"
-                    if key != "template"
-                    else f"autotag.defaults.template {error}; using the built-in one"
-                )
+                config_logger.warning(_fallback_warning(key, error, default))
                 setattr(cls, attr, default)
+        cls._load_instructions(defaults)
 
 
 class PromptManagerConfig:

py/tagging_defaults.py

@@ -4,8 +4,13 @@ Server-free on purpose: ``py.api`` must import without ComfyUI's ``server``
 module, which ``py/config.py`` needs; config re-exports all of this.
 """
 
+import csv
 import math
-from typing import Any
+import os
+import re
+import threading
+import unicodedata
+from typing import Any, Dict, Iterable, List, Set, Tuple
 
 # The tagging engines (``py/autotag.py`` MODELS) and the options they take.
 WD14_MODEL_TYPES = frozenset({"wd14-swinv2", "wd14-vit"})
@@ -88,3 +93,230 @@ def validate_template(value: Any, name: str = "instructions") -> str:
     if len(encoded) > MAX_INSTRUCTION_BYTES:
         raise ValueError(f"{name} {'are' if name == 'instructions' else 'is'} too long")
     return value
+
+
+# Skipped tags (#431): words whose suggested tags are never offered.
+MAX_SKIPPED_TAGS = 200
+MAX_SKIPPED_TAG_CHARS = 50
+_WORD_SEPARATORS = re.compile(r"[ _-]+")
+_FORBIDDEN_IN_ENTRY = re.compile(r"[,\x00-\x1f\x7f-\x9f\u2028\u2029]")
+
+
+def tag_words(text: str) -> Tuple[str, ...]:
+    """The words of a tag or a skipped entry: NFC, case-folded, split on runs
+    of space, ``_`` and ``-``. Every other character belongs to a word."""
+    folded = unicodedata.normalize("NFC", text).casefold()
+    return tuple(word for word in _WORD_SEPARATORS.split(folded) if word)
+
+
+def validate_skipped_tags(value: Any) -> List[str]:
+    """The Skipped tags list, each entry trimmed, or ValueError with the
+    sentence the System page shows (entries are numbered from 1)."""
+    if not isinstance(value, list):
+        raise ValueError("Skipped tags must be a list of words.")
+    if len(value) > MAX_SKIPPED_TAGS:
+        raise ValueError(f"Skipped tags: at most {MAX_SKIPPED_TAGS} entries.")
+    entries: List[str] = []
+    seen: Dict[Tuple[str, ...], int] = {}
+    for number, raw in enumerate(value, 1):
+        if not isinstance(raw, str):
+            raise ValueError(f"Skipped tags: entry {number} must be text.")
+        entry = raw.strip()
+        if not entry:
+            raise ValueError(f"Skipped tags: entry {number} is empty.")
+        if len(entry) > MAX_SKIPPED_TAG_CHARS:
+            raise ValueError(
+                f"Skipped tags: entry {number} must be at most "
+                f"{MAX_SKIPPED_TAG_CHARS} characters."
+            )
+        if _FORBIDDEN_IN_ENTRY.search(entry):
+            raise ValueError(
+                f"Skipped tags: entry {number} must not contain a comma "
+                "or a line break."
+            )
+        words = tag_words(entry)
+        if not words:
+            raise ValueError(f"Skipped tags: entry {number} is empty.")
+        if words in seen:
+            raise ValueError(
+                f"Skipped tags: entry {number} repeats entry {seen[words]}."
+            )
+        seen[words] = number
+        entries.append(entry)
+    return entries
+
+
+class SkipMatcher:
+    """Whether a suggested tag contains a skipped entry's words, consecutive
+    and whole (#431, 17B). Compiled once per request or job; the cost of a
+    check depends on the tag's words, not on the number of entries."""
+
+    def __init__(self, entries: Iterable[str] = ()):
+        self._entries = frozenset(filter(None, (tag_words(e) for e in entries)))
+        self._longest = max((len(words) for words in self._entries), default=0)
+
+    def __bool__(self) -> bool:
+        return bool(self._entries)
+
+    def matches(self, name: str) -> bool:
+        if not self._entries:
+            return False
+        words = tag_words(name)
+        for start in range(len(words)):
+            stop = min(len(words), start + self._longest)
+            for end in range(start + 1, stop + 1):
+                if words[start:end] in self._entries:
+                    return True
+        return False
+
+    def counting(self) -> "CountingSkip":
+        """A per-request view that also remembers which names it hid."""
+        return CountingSkip(self)
+
+
+class CountingSkip:
+    """A :class:`SkipMatcher` that records the distinct names it hid, so the
+    Tag image dialog can say how many skipped tags were not suggested."""
+
+    def __init__(self, matcher: SkipMatcher):
+        self._matcher = matcher
+        self.hidden: Set[str] = set()
+
+    def matches(self, name: str) -> bool:
+        if self._matcher.matches(name):
+            self.hidden.add(name.casefold())
+            return True
+        return False
+
+
+# A WD14 label list's tags the engine can suggest: general (0) and character (4).
+WD14_SUGGESTED_CATEGORIES = frozenset({"0", "4"})
+_label_cache: Dict[str, Tuple[Tuple[int, int], Tuple[str, ...]]] = {}
+_label_cache_lock = threading.Lock()
+
+
+def read_wd14_label_rows(path) -> List[Dict[str, str]]:
+    """Every row of a WD14 ``selected_tags.csv``, read as UTF-8 and closed
+    before returning (the handle never outlives the call, for Windows)."""
+    with open(path, "r", encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+def wd14_label_names(path) -> Tuple[str, ...]:
+    """The names a WD14 label list can suggest (categories 0 and 4), cached
+    by ``(mtime_ns, size)``. OSError (missing) and ValueError (unreadable)
+    propagate; the caller skips that list."""
+    key = os.fspath(path)
+    stat = os.stat(key)
+    stamp = (stat.st_mtime_ns, stat.st_size)
+    with _label_cache_lock:
+        cached = _label_cache.get(key)
+    if cached is not None and cached[0] == stamp:
+        return cached[1]
+    try:
+        rows = read_wd14_label_rows(key)
+    except csv.Error as exc:  # a damaged list (a NUL byte, an oversized field)
+        raise ValueError(f"unreadable label list: {exc}") from None
+    names = tuple(
+        name
+        for row in rows
+        if row.get("category", "0") in WD14_SUGGESTED_CATEGORIES
+        and (name := (row.get("name") or "").strip())
+    )
+    with _label_cache_lock:
+        _label_cache[key] = (stamp, names)
+    return names
+
+
+# Saved instructions (#431): named language-model instructions with a default
+# per engine. Built-in is never stored; readers put it first.
+BUILTIN_INSTRUCTIONS_ID = "builtin"
+BUILTIN_INSTRUCTIONS_NAME = "Built-in"
+MAX_SAVED_INSTRUCTIONS = 20
+MAX_INSTRUCTION_NAME_CHARS = 60
+INSTRUCTION_ENGINES = ("gguf", "hf")
+ENGINE_LABELS = {"gguf": "GGUF JoyCaption", "hf": "HuggingFace JoyCaption"}
+_INSTRUCTION_ID = re.compile(r"[0-9a-f]{12}")
+_CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f

]")
+
+
+def builtin_instructions() -> Dict[str, str]:
+    """The read-only Built-in entry, always the shipped template."""
+    return {
+        "id": BUILTIN_INSTRUCTIONS_ID,
+        "name": BUILTIN_INSTRUCTIONS_NAME,
+        "text": DEFAULT_TAG_TEMPLATE,
+    }
+
+
+def _instruction_entry(raw: Any, number: int) -> Dict[str, str]:
+    prefix = f"Saved instructions: entry {number}"
+    if (
+        not isinstance(raw, dict)
+        or set(raw) != {"id", "name", "text"}
+        or not isinstance(raw["id"], str)
+        or _INSTRUCTION_ID.fullmatch(raw["id"]) is None
+    ):
+        raise ValueError(f"{prefix} has an invalid id.")
+    name = raw["name"].strip() if isinstance(raw["name"], str) else ""
+    if not name:
+        raise ValueError(f"{prefix} needs a name.")
+    if len(name) > MAX_INSTRUCTION_NAME_CHARS:
+        raise ValueError(
+            f"{prefix} name must be at most {MAX_INSTRUCTION_NAME_CHARS} characters."
+        )
+    if _CONTROL.search(name):
+        raise ValueError(f"{prefix} name must not contain a line break.")
+    if name.casefold() == BUILTIN_INSTRUCTIONS_NAME.casefold():
+        raise ValueError("Saved instructions: the name “Built-in” is reserved.")
+    try:
+        text = validate_template(raw["text"], f"{prefix} text")
+    except ValueError as error:
+        raise ValueError(f"{error}.") from None
+    return {"id": raw["id"], "name": name, "text": text}
+
+
+def validate_instructions(value: Any) -> List[Dict[str, str]]:
+    """The saved entries ``[{id, name, text}]`` in order (names trimmed), or
+    ValueError with the sentence System shows (Built-in is not counted)."""
+    if not isinstance(value, list):
+        raise ValueError("Saved instructions must be a list.")
+    if len(value) > MAX_SAVED_INSTRUCTIONS:
+        raise ValueError(
+            f"Saved instructions: at most {MAX_SAVED_INSTRUCTIONS} entries besides "
+            "Built-in."
+        )
+    entries: List[Dict[str, str]] = []
+    ids: Dict[str, int] = {}
+    names: Dict[str, int] = {}
+    for number, raw in enumerate(value, 1):
+        item = _instruction_entry(raw, number)
+        if item["id"] in ids:
+            raise ValueError(
+                f"Saved instructions: entry {number} repeats the id of entry "
+                f"{ids[item['id']]}."
+            )
+        key = item["name"].casefold()
+        if key in names:
+            raise ValueError(
+                f"Saved instructions: entry {number} name “{item['name']}” is "
+                "already used."
+            )
+        ids[item["id"]] = number
+        names[key] = number
+        entries.append(item)
+    return entries
+
+
+def validate_default_instructions(value: Any, entries) -> Dict[str, str]:
+    """``{gguf: id, hf: id}``, each Built-in or an id of ``entries``."""
+    if not isinstance(value, dict) or set(value) != set(INSTRUCTION_ENGINES):
+        raise ValueError("Default instructions must name GGUF and HuggingFace.")
+    ids = {BUILTIN_INSTRUCTIONS_ID} | {item["id"] for item in entries}
+    for engine in INSTRUCTION_ENGINES:
+        if not isinstance(value[engine], str) or value[engine] not in ids:
+            raise ValueError(
+                f"Default for {ENGINE_LABELS[engine]} must be one of the saved "
+                "instructions."
+            )
+    return {engine: value[engine] for engine in INSTRUCTION_ENGINES}

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "promptmanager"
 description = "A powerful ComfyUI custom node that extends the standard text encoder with persistent prompt storage, advanced search capabilities, and an automatic image gallery system using SQLite."
-version = "3.4.0"
+version = "3.4.1"
 license = {file = "LICENSE"}
 requires-python = ">=3.12"
 dependencies = ["watchdog>=2.1.0", "Pillow>=8.0.0"]

requirements.txt

@@ -1,4 +1,4 @@
 # Runtime dependencies for PromptManager.
 # aiohttp, numpy and torch come from ComfyUI itself and are not listed here.
-watchdog>=2.1.0              # Output directory monitoring
+watchdog>=2.1.0               # Output directory monitoring
 Pillow>=8.0.0                # Image metadata extraction and thumbnails

tests/browser/server.py

@@ -85,6 +85,9 @@ class TestModel:
     suggestions: list | None = None
     # The engine's model table (``py/autotag.py`` MODELS), set at startup.
     models_config: dict = {}
+    # Where the WD14 label lists live (the Skipped tags preview, #431), set at
+    # startup; the tagging fixture writes or removes a small list there.
+    models_dir = None
 
     def get_models_status(self) -> dict:
         from py.autotag import package_fields
@@ -115,21 +118,26 @@ class TestModel:
         return ["generated", Path(image_path).parent.parent.name]
 
     def generate_tag_suggestions(
-        self, image_path: str, *, limit: int, **kwargs: object
+        self, image_path: str, *, limit: int, skip=None, **kwargs: object
     ) -> list[tuple[str, float | None]]:
-        """Fixed scored suggestions (WD14) or unscored ones (language models)."""
+        """Fixed scored suggestions (WD14) or unscored ones (language models),
+        without the ones ``skip`` hides before the limit, as the engine does
+        (#431)."""
         scored = self.loaded is not None and self.loaded.startswith("wd14")
         if self.suggestions is not None:
-            return [
+            pairs = [
                 (name, confidence if scored else None)
-                for name, confidence in self.suggestions[:limit]
+                for name, confidence in self.suggestions
             ]
-        names = ["sandstone", "desert", "arch", "sky", "rock", "dune", "canyon"]
-        names += [f"tag_{index:02d}" for index in range(100)]
-        return [
-            (name, round(0.98 - index * 0.008, 3) if scored else None)
-            for index, name in enumerate(names[:limit])
-        ]
+        else:
+            names = ["sandstone", "desert", "arch", "sky", "rock", "dune", "canyon"]
+            names += [f"tag_{index:02d}" for index in range(100)]
+            pairs = [
+                (name, round(0.98 - index * 0.008, 3) if scored else None)
+                for index, name in enumerate(names)
+            ]
+        kept = [pair for pair in pairs if skip is None or not skip.matches(pair[0])]
+        return kept[:limit]
 
     def download_model(self, model_type: str, progress_callback=None) -> bool:
         raise AssertionError("browser tests never download a model")
@@ -233,6 +241,7 @@ def create_app(root: Path) -> web.Application:
 
     TestModel.models_config = autotag.MODELS
     model = TestModel()
+    model.models_dir = root / "models"
     autotag.get_autotag_service = lambda: model
     api = PromptManagerAPI()
     api.add_routes(routes)

tests/browser/system-concept.spec.mjs

@@ -162,13 +162,15 @@ async function serverJson(request, url) {
 }
 
 const number = value => value.toLocaleString('en-US');
+// The sidebar's Images count (state.mjs), which System's Images metric shows (#555).
+const IMAGES_COUNT_URL = '/prompt_manager/images/output?mode=workspace&limit=1';
 
 /** The concept's shell and Overview with the recorded deviations applied, given the server's real overview. */
-function mapOverviewConcept(reference, overview) {
+function mapOverviewConcept(reference, overview, images) {
     // D165: the discreet legacy-pages line follows the settings layout.
     reference = { ...reference, tree: [...reference.tree, 'p.legacy-pages.small'] };
     const relabel = { 'Database integrity': 'Not checked', 'Positive prompts': number(overview.library.positive_prompts),
-        'Negative variants': number(overview.library.negative_variants), Images: number(overview.images.indexed) };
+        'Negative variants': number(overview.library.negative_variants), Images: number(images) };
     const rows = {
         // D93: the real pending count; Review metadata opens Needs review (the concept's go-review).
         '3 ambiguous image links': row => ({ ...row,
@@ -179,8 +181,9 @@ function mapOverviewConcept(reference, overview) {
         'One display configuration': row => ({ ...row, description: 'Grid and density settings are shared across views.' }),
         // D93: the real sources, not samples.
         '2 sample output sources': row => ({ ...row, title: `${number(overview.sources.effective)} output sources` }),
-        // D96: the dialog shows runs by category and library totals, not prompt, tag or date usage (D153: no ratings).
-        Statistics: row => ({ ...row, description: 'Runs by category, with library totals.' }),
+        // D96: the dialog shows runs by category and database record counts, not prompt, tag or date usage (D153: no
+        // ratings; #555: the counts are labelled as records, not as the Library or Images page counts).
+        Statistics: row => ({ ...row, description: 'Runs by category, with database record counts.' }),
     };
     const surfaces = reference.columns.surfaces.map(surface => ({ ...surface,
         rows: surface.rows.map(row => (rows[row.title] ?? (value => value))(row)) }));
@@ -218,6 +221,8 @@ async function conceptOverview(page, theme) {
 async function productionOverview(page, theme) {
     await openProduction(page, 'system/overview', theme);
     await expect(page.locator('#workspace-main .summary-metrics')).toBeVisible();
+    // #555: the Images metric is the shell's Images count: compare once it was read.
+    await expect(page.locator('#workspace-main .summary-metrics > .metric:nth-child(3) strong')).toHaveText(/^[\d,]+$/);
     // The thumbnail row is its own read (I2): compare once it answered.
     await expect(page.locator('#workspace-main .operation h3').filter({ hasText: 'thumbnails' })).toHaveText('No missing thumbnails');
     // So is the backup row (S9).
@@ -231,6 +236,7 @@ for (const theme of THEMES) for (const [width, height] of SIZES) {
     test(`system shell and overview match the concept ${theme} ${width}x${height}`, async ({ page, request }, testInfo) => {
         await page.setViewportSize({ width, height });
         const overview = await serverJson(request, '/prompt_manager/system/overview');
+        const images = (await serverJson(request, IMAGES_COUNT_URL)).total;
         // The fixture's thumbnails all exist, so the concept's "No missing thumbnails" is also the real title.
         expect((await serverJson(request, '/prompt_manager/images/thumbnails/status')).pending).toBe(0);
         const concept = await conceptOverview(page, theme);
@@ -239,7 +245,7 @@ for (const theme of THEMES) for (const [width, height] of SIZES) {
         await page.screenshot({ path: testInfo.outputPath(`concept-system-${theme}-${width}.png`), fullPage: true });
         const production = await productionOverview(page, theme);
         await page.screenshot({ path: testInfo.outputPath(`production-system-${theme}-${width}.png`), fullPage: true });
-        expect(diffInventory(mapOverviewConcept(concept, overview), production)).toEqual([]);
+        expect(diffInventory(mapOverviewConcept(concept, overview, images), production)).toEqual([]);
         expect(production.pageScroll).toBe(false);
     });
 }
@@ -265,8 +271,9 @@ const UNMAPPED_PATHS = [
 test('system comparison detects mutations', async ({ page, request }) => {
     await page.setViewportSize({ width: 1600, height: 1100 });
     const overview = await serverJson(request, '/prompt_manager/system/overview');
+    const images = (await serverJson(request, IMAGES_COUNT_URL)).total;
     const concept = await conceptOverview(page, 'dark');
-    const expected = mapOverviewConcept(concept, overview);
+    const expected = mapOverviewConcept(concept, overview, images);
     const production = await productionOverview(page, 'dark');
     expect(diffInventory(expected, production)).toEqual([]);
     // Unmapped, the concept differs exactly where a deviation is recorded, and nowhere else.
@@ -290,7 +297,7 @@ test('system comparison detects mutations', async ({ page, request }) => {
 });
 
 /**
- * D96: the concept's table, its rows the real ones; then "Library totals" in the same table markup. D153 (#447): the
+ * D96: the concept's table, its rows the real ones; then "Database records" (#555) in the same table markup. D153 (#447): the
  * concept's "Avg. rating" column and a "Rated images" total are not drawn.
  */
 function mapStatisticsConcept(reference, statistics) {
@@ -302,9 +309,10 @@ function mapStatisticsConcept(reference, statistics) {
         tables: [
             { ...runs, head: runs.head.filter(([, , text]) => text !== 'Avg. rating'),
                 rows: statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs)]) },
-            { caption: 'Library totals', head: [['th', 'col', 'Total'], ['th', 'col', 'Count']],
-                rows: [['Prompts', number(statistics.totals.total_prompts)], ['Tags', number(statistics.totals.total_tags)],
-                    ['Images', number(statistics.totals.total_images)]] },
+            { caption: 'Database records', head: [['th', 'col', 'Total'], ['th', 'col', 'Count']],
+                rows: [['Prompt records', number(statistics.totals.total_prompts)],
+                    ['Tags on prompts', number(statistics.totals.total_tags)],
+                    ['Image records', number(statistics.totals.total_images)]] },
         ],
     };
 }
@@ -420,7 +428,7 @@ for (const theme of THEMES) test(`statistics and health dialogs match the concep
     expect(diffInventory(mapHealthConcept(concept.health), await page.evaluate(measureDialog)).map(item => item.path))
         .toEqual(['operations.rows.0.title']);
     await page.evaluate(() => { document.querySelector('#modal .operation h3').textContent = 'Integrity check'; });
-    // And a removed "Library totals" table and a changed caption in the statistics dialog.
+    // And a removed "Database records" table and a changed caption in the statistics dialog.
     await page.keyboard.press('Escape');
     await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Overview', exact: true }).click();
     await page.locator('#workspace-main').getByRole('button', { name: 'Explore', exact: true }).click();

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

@@ -33,6 +33,10 @@ test.afterEach(async ({ page, request, browserName }) => {
 const PREVIEW_URL = '/prompt_manager/autotag/batch/preview';
 const MODEL_OPTIONS = ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB'];
 const SUGGESTIONS = 'From 1 to 100: the most suggestions Generate shows for one image.';
+const SKIPPED_DESCRIPTION = 'Suggested tags that contain one of these words are hidden. Words are separated by spaces, _ or -; '
+    + 'other characters such as ( ) belong to the word.';
+const DEFAULT_DESCRIPTION = 'The Tag image dialog and batches start from this.';
+const INSTRUCTIONS_DESCRIPTION = 'Instructions for the language-model engines. Built-in can’t be changed; duplicate it to make your own.';
 const BATCH = 'Tag each output image from its own pixels with the model above. Prompts are not changed. Review the scope first.';
 
 /** Runs in the page: Auto-tagging's surface under `mainSelector`: rows, field, actions, operation, geometry and tokens. */
@@ -62,7 +66,7 @@ function measureTagging(mainSelector) {
             text: [...row.firstElementChild.children].map(node => [name(node), text(node), node.localName === 'label' ? node.htmlFor : null]),
             control: control(row), flexWrap: getComputedStyle(row).flexWrap,
             controlBelow: row.lastElementChild.getBoundingClientRect().top >= row.firstElementChild.getBoundingClientRect().bottom - 0.5 })),
-        field: { tree: [...field.children].map(name), label: [text(field.querySelector('label')), field.querySelector('label').htmlFor],
+        field: field && { tree: [...field.children].map(name), label: [text(field.querySelector('label')), field.querySelector('label').htmlFor],
             textarea: { id: field.querySelector('textarea').id, value: field.querySelector('textarea').value,
                 ...css(field.querySelector('textarea'), 'fontSize', 'minHeight', 'backgroundColor', 'color', 'borderTopColor') },
             ...css(field, 'display', 'rowGap', 'fontSize', 'marginTop', 'marginBottom') },
@@ -70,6 +74,31 @@ function measureTagging(mainSelector) {
             ...css(actions, 'display', 'flexWrap', 'columnGap', 'justifyContent'),
             primary: css(actions.querySelector('.ca-primary'), 'backgroundColor', 'color', 'fontSize', 'paddingTop', 'paddingLeft'),
             plain: css(actions.querySelector('button:not(.ca-primary)'), 'backgroundColor', 'color', 'fontSize', 'borderTopColor') },
+        // D202 (#431): the Skipped tags block (the concept has none).
+        skipped: (block => block && { tree: [...block.children].map(name), key: block.dataset.key,
+            text: [...block.firstElementChild.children].map(node => [node.localName, text(node), node.localName === 'label' ? node.htmlFor : null]),
+            add: [...block.querySelector('.skip-add').children].map(node => [name(node), node.id, node.getAttribute('placeholder'), text(node)]),
+            preview: [text(block.querySelector('.skip-preview')), block.querySelector('.skip-preview').getAttribute('role')],
+            ...css(block, 'paddingTop', 'paddingBottom', 'borderTopWidth', 'borderTopColor'),
+            label: css(block.querySelector('label'), 'fontSize', 'fontWeight', 'color'),
+            description: css(block.querySelector('.setting-block-text p'), 'fontSize', 'color', 'marginTop'),
+            input: css(block.querySelector('input'), 'fontSize', 'backgroundColor', 'color', 'borderTopColor') })(
+            surface.querySelector(':scope > .setting-block[data-setting="tag-skipped"]')),
+        // D203 (#431): Saved instructions (the concept has a template field instead).
+        instructions: (block => block && { tree: [...block.children].map(name), key: block.dataset.key,
+            text: [...block.firstElementChild.children].map(node => [node.localName, text(node)]),
+            list: [...block.querySelectorAll('[role="option"]')].map(option => [text(option.firstElementChild),
+                [...option.querySelectorAll('.badges > .chip')].map(chip => [text(chip), chip.className]), option.getAttribute('aria-selected')]),
+            listRole: block.querySelector('.instruction-list').getAttribute('role'),
+            actions: [...block.querySelectorAll('.instruction-actions > button')].map(item => [text(item), item.className, item.disabled]),
+            editor: [...block.querySelectorAll('.instruction-editor .field')].map(item => [text(item.querySelector('label > span')),
+                item.querySelector('input, textarea').value, item.querySelector('input, textarea').readOnly]),
+            note: text(block.querySelector('#instruction-note')),
+            layout: getComputedStyle(block.querySelector('.instructions-layout')).gridTemplateColumns.split(' ').length,
+            ...css(block, 'paddingTop', 'paddingBottom', 'borderTopWidth', 'borderTopColor'),
+            label: css(block.querySelector('label'), 'fontSize', 'fontWeight', 'color'),
+            textarea: css(block.querySelector('textarea'), 'fontSize', 'backgroundColor', 'borderTopColor') })(
+            surface.querySelector(':scope > .setting-block[data-setting="tag-instructions"]')),
         operations: [...surface.querySelectorAll(':scope > .operation')].map(row => ({ tree: [...row.children].map(name),
             title: text(row.querySelector('h3')), description: text(row.querySelector('p')),
             actions: [...row.querySelectorAll('.row-actions > button')].map(item => [text(item), item.className]) })),
@@ -103,13 +132,21 @@ function measureTagging(mainSelector) {
  * The concept's Auto-tagging with the recorded deviations applied, for the fixture (all engines on disk, none loaded).
  * `phone` is a viewport at the concept's 700px breakpoint or below.
  */
-function mapTaggingConcept(reference, { template, phone }) {
+function mapTaggingConcept(reference, { builtin, saved, phone }) {
     const [model, existing, general, character] = reference.rows;
     const [preview] = reference.actions.buttons;
+    // D203: Built-in first, then the saved entries, in each default select.
+    const names = ['Built-in', ...saved.map(entry => entry.name)];
+    const defaultRow = (engine, long) => ({ ...existing,
+        text: [['label', `Default for ${long}`, `instruction-default-${engine}`], ['p', DEFAULT_DESCRIPTION, null]],
+        control: { ...existing.control, id: `instruction-default-${engine}`, options: names.map(label => [label, false]),
+            selected: names[1] } });
     return {
         ...reference,
-        // D133 adds a row after the thresholds; D134 adds the operation after the actions.
-        tree: [...reference.tree.slice(0, 6), 'div.setting-row', ...reference.tree.slice(6), 'div.operation'],
+        // D133 adds a row after the thresholds, D202 the Skipped tags block after it; D203 replaces the template field
+        // with Saved instructions, the two default rows and their note; D134 adds the operation after the actions.
+        tree: [...reference.tree.slice(0, 6), 'div.setting-row', 'div.setting-block', 'div.setting-block', 'div.setting-row',
+            'div.setting-row', 'p.instruction-reset.small', reference.tree[7], 'div.operation'],
         rows: [
             // D132 (OQ5, OQ6): the four real engines with their download size, and the chosen one's live status.
             { ...model, text: [model.text[0], ['p', 'Downloaded. Not loaded.', null]],
@@ -120,16 +157,49 @@ function mapTaggingConcept(reference, { template, phone }) {
             // D133: the persisted suggestion count, on the concept's number row.
             { ...general, text: [['label', 'Suggestions per image', 'tag-suggestions'], ['p', SUGGESTIONS, null]],
                 control: { ...general.control, id: 'tag-suggestions', value: '10' } },
+            // D203: the default of each language-model engine (the fixture's saved entry is both), on the concept's
+            // select row.
+            defaultRow('gguf', 'GGUF JoyCaption'), defaultRow('hf', 'HuggingFace JoyCaption'),
         ],
-        // The saved template (the server's default until one is saved) replaces the concept's sample text.
-        field: { ...reference.field, textarea: { ...reference.field.textarea, value: template } },
+        // D203: Saved instructions in the concept's setting-row tokens (as D202), Built-in selected and read-only.
+        instructions: { tree: ['div.setting-block-text', 'div.instructions-layout'], key: 'autotag_instructions',
+            text: [['label', 'Saved instructions'], ['p', `${INSTRUCTIONS_DESCRIPTION} ${saved.length} of 20 saved · Built\u2011in is not counted.`]],
+            list: [['Built-in', [['Read-only', 'chip']], 'true'],
+                ...saved.map((entry, index) => [entry.name, index === 0
+                    ? [['Default for GGUF', 'chip blue'], ['Default for HuggingFace', 'chip blue']] : [], 'false'])],
+            listRole: 'listbox',
+            actions: [['+ New', '', false], ['Duplicate', '', false], ['Delete', 'danger', true]],
+            editor: [['Name', 'Built-in', true], ['Text', builtin, true]],
+            note: 'Built-in instructions can’t be changed. Duplicate them to make your own.',
+            layout: phone ? 1 : 2,
+            paddingTop: reference.row.paddingTop, paddingBottom: reference.row.paddingBottom,
+            borderTopWidth: reference.row.borderTopWidth, borderTopColor: reference.row.borderTopColor,
+            label: reference.label,
+            textarea: { fontSize: reference.field.textarea.fontSize, backgroundColor: reference.field.textarea.backgroundColor,
+                borderTopColor: reference.field.textarea.borderTopColor } },
+        // D202 (#431): the Skipped tags block in the concept's setting-row tokens: its label and description as a row's,
+        // the row's padding and rule above, the concept's field input; an empty list says so.
+        skipped: { tree: ['div.setting-block-text', 'div.skip-add', 'p.skip-problem.small', 'div.skip-chips.tags', 'p.skip-preview.small'],
+            key: 'autotag_skipped_tags',
+            text: [['label', 'Skipped tags', 'tag-skipped-input'], ['p', SKIPPED_DESCRIPTION, null]],
+            add: [['input', 'tag-skipped-input', 'Add a word or words', ''], ['button', 'tag-skipped-add', null, 'Add']],
+            preview: ['No tags are skipped.', 'status'],
+            paddingTop: reference.row.paddingTop, paddingBottom: reference.row.paddingBottom,
+            borderTopWidth: reference.row.borderTopWidth, borderTopColor: reference.row.borderTopColor,
+            label: reference.label,
+            description: { fontSize: reference.description.fontSize, color: reference.description.color,
+                marginTop: reference.description.marginTop },
+            input: { fontSize: '12px', backgroundColor: reference.field.textarea.backgroundColor, color: reference.field.textarea.color,
+                borderTopColor: reference.field.textarea.borderTopColor } },
+        // D203: no template field.
+        field: null,
         // D132: Download (for an engine already on disk, "Download again") and Unload replace the two simulated jobs.
         actions: { ...reference.actions, buttons: [preview, ['Download again', ''], ['Unload', '']] },
         // D134: the prompt-tag batch, reviewed first.
         operations: [{ tree: ['div', 'div.row-actions'], title: 'Tag output images', description: BATCH, actions: [['Review', '']] }],
         // D132 (#398): every select shows its whole chosen option at every width (at 390 the concept's 120px cap cuts
         // them; production lets each grow past it).
-        selectsFit: reference.selectsFit.map(() => true),
+        selectsFit: [...reference.selectsFit, true, true].map(() => true),
     };
 }
 
@@ -153,7 +223,9 @@ async function productionTagging(page, theme) {
 async function savedTemplate(request, page) {
     const response = await request.get('/prompt_manager/settings');
     await expect(response).toBeOK();
-    return { template: (await response.json()).settings.autotag_template, phone: page.viewportSize().width <= 700 };
+    const { settings } = await response.json();
+    return { builtin: settings.autotag_builtin_instructions, saved: settings.autotag_instructions,
+        phone: page.viewportSize().width <= 700 };
 }
 
 for (const theme of THEMES) for (const [width, height] of SIZES) {
@@ -177,14 +249,15 @@ for (const theme of THEMES) for (const width of [390, 320]) {
         await page.locator('#workspace-main #tag-existing').selectOption('replace_after_review');
         await page.locator('#workspace-main section.surface').screenshot({ path: testInfo.outputPath(`production-tagging-selects-${theme}-${width}.png`) });
         const selects = page.locator('#workspace-main section.surface > .setting-row > select');
-        await expect(selects).toHaveCount(2);
-        for (let index = 0; index < 2; index += 1) {
+        // D203 adds the two per-engine default selects.
+        await expect(selects).toHaveCount(4);
+        for (let index = 0; index < 4; index += 1) {
             const select = selects.nth(index);
             const values = await select.evaluate(node => [...node.options].map(option => option.value));
             for (const value of values) {
                 await select.selectOption(value);
                 const measured = await page.evaluate(measureTagging, '#workspace-main');
-                expect(measured.selectsFit, `${await select.getAttribute('id')}=${value}`).toEqual([true, true]);
+                expect(measured.selectsFit, `${await select.getAttribute('id')}=${value}`).toEqual([true, true, true, true]);
                 expect(measured.pageScroll, value).toBe(false);
             }
         }
@@ -198,12 +271,16 @@ test('auto-tagging comparison detects mutations', async ({ page, request }) => {
     const expected = mapTaggingConcept(concept, saved);
     const production = await productionTagging(page, 'dark');
     expect(diffInventory(expected, production)).toEqual([]);
-    // Unmapped, the section differs only where D132, D133 and D134 are recorded (and the saved template's text).
-    expect(diffInventory(concept, production).map(item => item.path.split('.').slice(0, 3).join('.'))
+    // Unmapped, the section differs only where D132, D133, D134, D202 and D203 are recorded (and the saved template's text).
+    // (The concept has no Skipped tags block, so every path under it is one D202 difference.)
+    expect(diffInventory(concept, production).map(item => (/^(skipped|instructions|field)\b/.test(item.path) ? item.path.split('.')[0]
+        : item.path.split('.').slice(0, 3).join('.')))
         .filter((path, index, all) => all.indexOf(path) === index).sort()).toEqual([
-        'actions.buttons.1', 'actions.buttons.2', 'field.textarea.value', 'operations.0.actions', 'operations.0.description',
-        'operations.0.title', 'operations.0.tree', 'operations.length', 'rows.0.control', 'rows.0.text', 'rows.4.control', 'rows.4.controlBelow',
-        'rows.4.flexWrap', 'rows.4.text', 'rows.4.tree', 'rows.length', 'tree.6', 'tree.7', 'tree.8', 'tree.9', 'tree.length'].sort());
+        'actions.buttons.1', 'actions.buttons.2', 'field', 'instructions', 'operations.0.actions', 'operations.0.description',
+        'operations.0.title', 'operations.0.tree', 'operations.length', 'rows.0.control', 'rows.0.text',
+        ...[4, 5, 6].flatMap(row => ['control', 'controlBelow', 'flexWrap', 'text', 'tree'].map(key => `rows.${row}.${key}`)),
+        'rows.length', 'selectsFit.2', 'selectsFit.3', 'selectsFit.length', 'skipped',
+        ...Array.from({ length: 8 }, (_, index) => `tree.${index + 6}`), 'tree.length'].sort());
     const measure = () => page.evaluate(measureTagging, '#workspace-main');
     const paths = async () => diffInventory(expected, await measure()).map(item => item.path);
     // A removed row.
@@ -254,8 +331,8 @@ test('auto-tagging at 390 wraps only the engine row', async ({ page, request })
     const concept = await conceptTagging(page, 'dark');
     const production = await productionTagging(page, 'dark');
     expect(diffInventory(mapTaggingConcept(concept, await savedTemplate(request, page)), production)).toEqual([]);
-    expect(production.rows.map(row => row.flexWrap)).toEqual(['wrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap']);
-    expect(production.selectsFit).toEqual([true, true]);
+    expect(production.rows.map(row => row.flexWrap)).toEqual(['wrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap', 'nowrap']);
+    expect(production.selectsFit).toEqual([true, true, true, true]);
 });
 
 /** Runs in the page: the open review dialog: its title, body and the concept's tokens. */

tests/browser/tagging-canonical-comparison.mjs

@@ -92,6 +92,8 @@ export function cardActionsInventory(card) {
     };
 }
 
+// #431: the fixture's saved "Describe the image" entry, the default of both engines (workspace_tagging_fixture.py).
+export const FIXTURE_INSTRUCTIONS_ID='d35c71be0a1e';
 // D84 (plan D61): the legacy engines' values, labels and sizes, GGUF JoyCaption in the concept's Ollama slot.
 const MODEL_LABELS=Object.freeze({'wd14-swinv2':['wd14-swinv2','WD14 SwinV2 · ~400 MB'],'wd14-vit':['wd14-vit','WD14 ViT · ~400 MB'],
     ollama:['gguf','GGUF JoyCaption (Recommended) · ~4.5 GB'],huggingface:['hf','HuggingFace JoyCaption · ~16 GB']});
@@ -106,17 +108,24 @@ const CONCEPT_LABELS=Object.freeze({'WD14 SwinV2 · fast classifier':'WD14 SwinV
  *   (`chip`: a concept `.chip` inventory, the heading's size chip) around the row's own text (12px) in the checked
  *   row's colours (accent border, `--soft-blue`);
  * - D84 (plan D61): the legacy engine labels and values, and the server's default instructions (`instructions`);
+ * - D204 (#431): a "Saved instructions" select (`picker`: its value and options) before the instructions, on the
+ *   concept's select field tokens;
  * - D91 (plan D68): a Suggestions count field after the model's own fields, on the concept's number field tokens
  *   (`numberField`: the concept's General confidence field) with the configured count (`limit`);
  * - D29: the prototype's "Sample suggestions from …" status reads "Suggestions from …".
  * The opened state is compared unmapped: both show the concept's on-screen "Generate suggestions with the selected
  * model before approving." (its renderTagModelOptions, a1062–1076, replaces the markup's sentence at once).
  */
-export function mapConceptTagging(reference,{instructions,limit=10,chip,numberField}) {
+export function mapConceptTagging(reference,{instructions,limit=10,chip,numberField,
+    picker={value:FIXTURE_INSTRUCTIONS_ID,options:[['builtin','Built-in'],[FIXTURE_INSTRUCTIONS_ID,`${instructions} · default`]]}}) {
     const [select,...own]=reference.modelPanel.fields;
+    // D204 (#431): a "Saved instructions" select on the concept's select field, before the instructions.
+    const pickField={...select,label:'Saved instructions',control:{...select.control,id:'image-tag-instructions-pick',
+        value:picker.value,options:picker.options}};
     const suggestionsField={...numberField,label:'Suggestions',control:{...numberField.control,id:'image-suggestion-limit',
         value:String(limit),min:'1',max:'100',step:'1'}};
-    const mappedOwn=own.map(field=>field.control.id==='image-tag-instructions'?{...field,control:{...field.control,value:instructions}}:field);
+    const mappedOwn=own.flatMap(field=>field.control.id==='image-tag-instructions'
+        ?[pickField,{...field,control:{...field.control,value:instructions}}]:[field]);
     const rows=reference.suggestions.rows.map(row=>({...row,
         control:row.control?.kind==='checkbox'&&row.control.checked?{kind:'remove',label:`Remove ${row.name}`}:row.control,
         borderTopLeftRadius:chip.borderTopLeftRadius}));

tests/browser/workspace-layout-tags-system.spec.mjs

@@ -156,8 +156,9 @@ test('at 390px the window fits the screen, actions stay reachable and the page s
     expect(frame.bottom-frame.top).toBeLessThan(844);
     expect(frame.bottom-frame.top).toBeGreaterThanOrEqual(280);
     expect(await page.evaluate(()=>document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
-    // The last row's actions can be scrolled to inside the window and fit its width.
-    const last=rows(page).last().getByRole('button',{name:'Rename / merge',exact:true});
+    // The first page's last row's actions can be scrolled to inside the window and fit its width.
+    // Pinned to row 100: reaching it loads the next page (D183), and last() would then follow row 200.
+    const last=rows(page).nth(99).getByRole('button',{name:'Rename / merge',exact:true});
     await last.scrollIntoViewIfNeeded();await expect(last).toBeInViewport();
     const [button]=await boxes(last);const [after]=await boxes(tagWindow(page));
     expect(button.right).toBeLessThanOrEqual(after.right);

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

@@ -112,13 +112,14 @@ test('model options are the four real engines with size and the description show
     await expect(status(page)).toHaveText('Unsaved changes.');
     // The other rows keep the concept's copy and the saved values (D133 adds Suggestions per image).
     expect(await surface(page).locator(':scope > .setting-row label').allTextContents()).toEqual(['Tagging model', 'Existing tags',
-        'General-tag confidence', 'Character-tag confidence', 'Suggestions per image']);
+        'General-tag confidence', 'Character-tag confidence', 'Suggestions per image', 'Default for GGUF JoyCaption',
+        'Default for HuggingFace JoyCaption']);
     await expect(page.locator('#tag-existing')).toHaveValue('skip');
     await expect(page.locator('#threshold-general')).toHaveValue('0.35');
     await expect(page.locator('#threshold-character')).toHaveValue('0.85');
     await expect(page.locator('#tag-suggestions')).toHaveValue('10');
-    const settings = await serverJson(request, SETTINGS_URL);
-    await expect(page.locator('#tag-template')).toHaveValue(settings.settings.autotag_template);
+    // D203 (#431): Saved instructions replace the template field.
+    await expect(page.locator('#tag-template')).toHaveCount(0);
     // Unload is offered only while a model is loaded (none is).
     await expect(actionOf(page, 'Unload')).toBeDisabled();
 });
@@ -418,3 +419,156 @@ test('a model that is not downloaded cannot be reviewed for a batch; the button
     await expect(dialog(page)).toHaveCount(0);
     expect(page.modelCalls.filter(call => call.includes('/batch/preview'))).toEqual([]);
 });
+
+// D202 (#431): Skipped tags: add (button and Enter), the preview over the library's tags and the WD14 label list, the
+// per-chip counts, remove, Save preferences and a reload; a list the server refuses highlights the block.
+const SKIPPED_PREVIEW = '/prompt_manager/autotag/skipped-tags/preview';
+const skippedBlock = page => surface(page).locator(':scope > .setting-block[data-setting="tag-skipped"]');
+const skippedInput = page => page.locator('#tag-skipped-input');
+const skippedChips = page => skippedBlock(page).locator('.skip-chips .chip.tag-suggestion');
+const skippedPreview = page => skippedBlock(page).locator('.skip-preview');
+
+test('skipped tags add, preview, remove, save and reload (D202)', async ({ page, request }) => {
+    await openTagging(page);
+    await expect(skippedBlock(page).locator('label')).toHaveText('Skipped tags');
+    await expect(skippedBlock(page)).toHaveAttribute('data-key', 'autotag_skipped_tags');
+    await expect(skippedPreview(page)).toHaveText('No tags are skipped.');
+    await expect(skippedPreview(page)).toHaveAttribute('role', 'status');
+    // The label list on disk (blurry, blurry_background, signature, …) and the library tags (warm_light, …).
+    let answer = page.waitForResponse(item => item.url().endsWith(SKIPPED_PREVIEW));
+    await skippedInput(page).fill('blurry');
+    await skippedInput(page).press('Enter');
+    expect((await answer).status()).toBe(200);
+    await expect(skippedInput(page)).toHaveValue('');
+    await expect(skippedPreview(page)).toHaveText('Hides 2 tags from suggestions: blurry, blurry_background. '
+        + 'Tags already on images are not changed.');
+    answer = page.waitForResponse(item => item.url().endsWith(SKIPPED_PREVIEW));
+    await skippedInput(page).fill('light');
+    await page.getByRole('button', { name: 'Add', exact: true }).click();
+    await answer;
+    await expect(skippedPreview(page)).toHaveText('Hides 3 tags from suggestions: warm_light, blurry, blurry_background. '
+        + 'Tags already on images are not changed.');
+    await expect(skippedChips(page)).toHaveText(['blurry2×', 'light1×']);
+    await expect(skippedChips(page).first()).toHaveAttribute('title', 'Hides 2 tags');
+    // An entry that hides nothing is muted; a duplicate is not added and the line under the input says so.
+    answer = page.waitForResponse(item => item.url().endsWith(SKIPPED_PREVIEW));
+    await skippedInput(page).fill('zebra');
+    await skippedInput(page).press('Enter');
+    await answer;
+    await expect(skippedChips(page).last()).toHaveClass(/\bnone\b/);
+    await expect(skippedChips(page).last()).toHaveAttribute('title', 'Hides no known tag');
+    await skippedInput(page).fill('Blurry');
+    await skippedInput(page).press('Enter');
+    await expect(page.locator('#tag-skipped-problem')).toHaveText('Already in the list.');
+    await expect(skippedInput(page)).toHaveAttribute('aria-invalid', 'true');
+    await skippedInput(page).fill('a, b');
+    await skippedInput(page).press('Enter');
+    await expect(page.locator('#tag-skipped-problem')).toHaveText('No commas or line breaks.');
+    // Remove zebra, then save.
+    await skippedChips(page).last().getByRole('button', { name: 'Remove zebra', exact: true }).click();
+    await expect(skippedChips(page)).toHaveCount(2);
+    await expect(status(page)).toHaveText('Unsaved changes.');
+    await save(page).click();
+    await expect(status(page)).toHaveText('Saved to the server configuration.');
+    expect((await serverJson(request, SETTINGS_URL)).settings.autotag_skipped_tags).toEqual(['blurry', 'light']);
+    await openTagging(page);
+    await expect(skippedChips(page)).toHaveText(['blurry2×', 'light1×']);
+    // Removing a chip and adding it back is no change.
+    await skippedChips(page).last().getByRole('button', { name: 'Remove light', exact: true }).click();
+    await expect(status(page)).toHaveText('Unsaved changes.');
+    await skippedInput(page).fill('light');
+    await skippedInput(page).press('Enter');
+    await expect(status(page)).toHaveText('No unsaved changes.');
+});
+
+test('skipped tags preview checks library tags only without a label list, and a refused save highlights it', async ({ page, request }) => {
+    await expect(await request.post('/__test__/tagging/defaults', { data: { general: 0.35, character: 0.85, limit: 10,
+        labels: false } })).toBeOK();
+    await openTagging(page);
+    const answer = page.waitForResponse(item => item.url().endsWith(SKIPPED_PREVIEW));
+    await skippedInput(page).fill('blurry');
+    await skippedInput(page).press('Enter');
+    await answer;
+    await expect(skippedPreview(page)).toHaveText('Hides 0 tags from suggestions. Checked against library tags only; no WD14 '
+        + 'label list is downloaded. Tags already on images are not changed.');
+    // The server is the authority: a list it refuses keeps the draft, says why and highlights the block.
+    await page.route(`**${SETTINGS_URL}`, route => (route.request().method() === 'POST'
+        ? route.fulfill({ status: 400, contentType: 'application/json',
+            body: JSON.stringify({ success: false, error: 'Skipped tags: entry 1 is empty.' }) })
+        : route.fallback()));
+    await save(page).click();
+    await expect(status(page)).toHaveText('Skipped tags: entry 1 is empty.');
+    await expect(skippedBlock(page)).toHaveAttribute('aria-invalid', 'true');
+    await page.unrouteAll({ behavior: 'ignoreErrors' });
+});
+
+// D203 (#431): Saved instructions: Built-in read-only, New, edit, per-engine defaults, Delete resets a default, Save
+// preferences and a reload; the server pairs the two keys. D205: the batch review names the engine's default.
+const instructionOption = (page, name) => page.locator('#instruction-list [role="option"]').filter({ has: page.locator(`span:text-is("${name}")`) });
+
+test('saved instructions: new, edit, per-engine default, delete, save and reload (D203)', async ({ page, request }) => {
+    await openTagging(page);
+    const settings = (await serverJson(request, SETTINGS_URL)).settings;
+    await expect(page.locator('#instructions-count')).toHaveText('1 of 20 saved · Built\u2011in is not counted.');
+    await expect(page.locator('#instruction-list [role="option"] > span:first-child')).toHaveText(['Built-in', 'Describe the image']);
+    await expect(page.locator('#instruction-name')).toHaveValue('Built-in');
+    await expect(page.locator('#instruction-text')).toHaveValue(settings.autotag_builtin_instructions);
+    await expect(page.locator('#instruction-text')).toHaveAttribute('readonly', '');
+    await expect(page.locator('#instruction-delete')).toBeDisabled();
+    await expect(page.locator('#instruction-default-gguf')).toHaveValue(settings.autotag_instructions[0].id);
+    // + New, then name and text it, and make it HuggingFace's default.
+    await page.locator('#instruction-new').click();
+    await expect(page.locator('#instruction-name')).toHaveValue('New instructions');
+    await expect(page.locator('#instruction-note')).toHaveText('The text must not be empty.');
+    await page.locator('#instruction-name').fill('Photo realism');
+    await page.locator('#instruction-text').fill('Tag camera angle and lighting.');
+    await expect(page.locator('#instruction-text').locator('xpath=..').locator('label .muted')).toHaveText('30 of 4,000 characters');
+    await page.locator('#instruction-default-hf').selectOption({ label: 'Photo realism' });
+    await expect(instructionOption(page, 'Photo realism').locator('.chip')).toHaveText(['Default for HuggingFace']);
+    await expect(status(page)).toHaveText('Unsaved changes.');
+    await save(page).click();
+    await expect(status(page)).toHaveText('Saved to the server configuration.');
+    let saved = (await serverJson(request, SETTINGS_URL)).settings;
+    expect(saved.autotag_instructions.map(entry => [entry.name, entry.text])).toEqual([['Describe the image', 'Describe the image'],
+        ['Photo realism', 'Tag camera angle and lighting.']]);
+    expect(saved.autotag_default_instructions.hf).toBe(saved.autotag_instructions[1].id);
+    // A reload shows the saved list; deleting GGUF's default resets it to Built-in and says so.
+    await openTagging(page);
+    await instructionOption(page, 'Describe the image').click();
+    await page.locator('#instruction-delete').click();
+    await expect(page.locator('#instruction-reset')).toHaveText('GGUF now uses Built-in.');
+    await expect(page.locator('#instruction-default-gguf')).toHaveValue('builtin');
+    await save(page).click();
+    await expect(status(page)).toHaveText('Saved to the server configuration.');
+    saved = (await serverJson(request, SETTINGS_URL)).settings;
+    expect(saved.autotag_instructions.map(entry => entry.name)).toEqual(['Photo realism']);
+    expect(saved.autotag_default_instructions.gguf).toBe('builtin');
+    expect(saved.autotag_template).toBe(saved.autotag_builtin_instructions);
+});
+
+test('a refused instructions save names the entry and highlights the block (D203)', async ({ page }) => {
+    await openTagging(page);
+    await page.locator('#instruction-duplicate').click();
+    await page.locator('#instruction-name').fill('describe the IMAGE');
+    await expect(page.locator('#instruction-note')).toHaveText('The name “describe the IMAGE” is already used.');
+    await save(page).click();
+    await expect(status(page)).toHaveText('Saved instructions: entry 2 name “describe the IMAGE” is already used.');
+    await expect(surface(page).locator('.setting-block[data-setting="tag-instructions"]')).toHaveAttribute('aria-invalid', 'true');
+});
+
+test('the batch review names the language model\'s default instructions (D205)', async ({ page }) => {
+    await openTagging(page);
+    await page.locator('#tag-model').selectOption('gguf');
+    await page.locator('#tag-existing').selectOption('merge');
+    const answer = page.waitForResponse(item => item.url().endsWith(PREVIEW_URL));
+    await reviewButton(page).click();
+    await answer;
+    await expect(dialog(page).locator('#modal-title')).toHaveText('Review tag output images');
+    const grid = await gridOf(page);
+    expect(grid.slice(-3)).toEqual([['Instructions', 'Describe the image'], ['Settings', 'Up to 10 tags per image'],
+        grid.at(-1)]);
+    // The batch sends the default's text.
+    const start = page.waitForRequest(item => item.url().endsWith('/prompt_manager/jobs/autotag'));
+    await dialog(page).getByRole('button', { name: 'Start tagging', exact: true }).click();
+    expect((await start).postDataJSON().options).toEqual({ instructions: 'Describe the image' });
+});

tests/browser/workspace-system.spec.mjs

@@ -8,6 +8,8 @@ import { readCoverageTable, parseControl, CONTROL_EXEMPTIONS } from '../../tools
 const workspace = '/prompt_manager/workspace';
 const OVERVIEW_URL = '/prompt_manager/system/overview';
 const THUMBNAILS_URL = '/prompt_manager/images/thumbnails/status';
+// The sidebar's Images count (state.mjs NAV_COUNT_SOURCES): the Images page's own total.
+const IMAGES_COUNT_URL = '/prompt_manager/images/output?mode=workspace&limit=1';
 const number = value => value.toLocaleString('en-US');
 
 test.beforeEach(async ({ page, request, browserName }) => {
@@ -55,6 +57,7 @@ test('overview shows real counts and Not checked', async ({ page, request }) =>
     page.on('request', item => { if (!['GET', 'HEAD', 'OPTIONS'].includes(item.method())) writes.push(item.url()); });
     const overview = await serverJson(request, OVERVIEW_URL);
     const thumbnails = await serverJson(request, THUMBNAILS_URL);
+    const images = (await serverJson(request, IMAGES_COUNT_URL)).total;
     // The concept fixture: six positives, their saved negatives and 24 linked images, all with thumbnails.
     expect([overview.library.positive_prompts, overview.images.indexed, thumbnails.pending]).toEqual([6, 24, 0]);
     // I2: the Overview never walks the sources for thumbnails; the row reads the status route itself.
@@ -66,7 +69,8 @@ test('overview shows real counts and Not checked', async ({ page, request }) =>
         [item.querySelector('strong').textContent, item.querySelector('span').textContent]))).toEqual([
         [number(overview.library.positive_prompts), 'Positive prompts'],
         [number(overview.library.negative_variants), 'Negative variants'],
-        [number(overview.images.indexed), 'Images'],
+        // #555: the Images page's own count, the same number as its sidebar badge.
+        [number(images), 'Images'],
         ['Not checked', 'Database integrity'],
     ]);
     expect(await rowsOf(layout, 'Library health')).toEqual([
@@ -79,11 +83,31 @@ test('overview shows real counts and Not checked', async ({ page, request }) =>
     expect(await rowsOf(layout, 'Workspace preferences')).toEqual([
         ['One display configuration', 'Grid and density settings are shared across views.', 'Appearance'],
         ['2 output sources', 'Monitoring and enrichment share one source list.', 'Manage sources'],
-        ['Statistics', 'Runs by category, with library totals.', 'Explore'],
+        ['Statistics', 'Runs by category, with database record counts.', 'Explore'],
     ]);
     expect(writes).toEqual([]);
 });
 
+test('#555: the Images metric is the sidebar Images count, not the indexed image rows', async ({ page, request }) => {
+    const overview = await serverJson(request, OVERVIEW_URL);
+    // The Images page lists files no row links (the demo library: 122 files, 110 rows); the listing says so.
+    const listed = overview.images.indexed + 12;
+    await page.route(`**${IMAGES_COUNT_URL}`, async route => {
+        const response = await route.fetch();
+        await route.fulfill({ response, json: { ...(await response.json()), total: listed } });
+    });
+    const layout = await openOverview(page);
+    const imagesMetric = layout.locator('.summary-metrics > .metric').filter({ has: page.locator('span', { hasText: /^Images$/ }) });
+    await expect(imagesMetric.locator('strong')).toHaveText(number(listed));
+    await expect(page.locator('#primary-nav a[data-route="images"] .nav-count')).toHaveText(number(listed));
+    // A failed count reads as a dash, never the row count.
+    await page.unroute(`**${IMAGES_COUNT_URL}`);
+    await page.route(`**${IMAGES_COUNT_URL}`, route => route.fulfill({ status: 503, json: { success: false, error: 'Unavailable' } }));
+    await page.goto(`${workspace}#/system/appearance`);
+    await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Overview', exact: true }).click();
+    await expect(imagesMetric.locator('strong')).toHaveText('–');
+});
+
 // D129 (#249 S6b): where the library lives. The hook makes the fixture's database read as a node-folder library; its
 // Move library is a stand-in that touches no file (workspace_system_fixture.py).
 const banner = page => page.locator('#library-banner');
@@ -364,7 +388,7 @@ test('View backups / Appearance / Manage sources switch sections', async ({ page
     }
 });
 
-test('statistics dialog lists runs by category and library totals', async ({ page, request }) => {
+test('statistics dialog lists runs by category and database record counts', async ({ page, request }) => {
     const statistics = await serverJson(request, '/prompt_manager/system/statistics');
     expect(statistics.by_category.length).toBeGreaterThan(1);
     const layout = await openOverview(page);
@@ -373,13 +397,14 @@ test('statistics dialog lists runs by category and library totals', async ({ pag
     const dialog = page.locator('dialog#modal[open]');
     await expect(dialog.locator('#modal-title')).toHaveText('Usage statistics');
     const tables = dialog.locator('#modal-body > table');
-    await expect(tables.locator('caption')).toHaveText(['Runs by category', 'Library totals']);
+    await expect(tables.locator('caption')).toHaveText(['Runs by category', 'Database records']);
     // D153 (#447): no rating column and no rated-images total.
     await expect(tables.first().locator('thead th')).toHaveText(['Category', 'Runs']);
     const cells = table => table.locator('tbody tr').evaluateAll(rows => rows.map(row => [...row.cells].map(cell => cell.textContent)));
     expect(await cells(tables.first())).toEqual(statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs)]));
-    expect(await cells(tables.nth(1))).toEqual([['Prompts', number(statistics.totals.total_prompts)],
-        ['Tags', number(statistics.totals.total_tags)], ['Images', number(statistics.totals.total_images)]]);
+    // #555: raw rows of the legacy /stats, labelled as rows so they never read as the Library or Images page counts.
+    expect(await cells(tables.nth(1))).toEqual([['Prompt records', number(statistics.totals.total_prompts)],
+        ['Tags on prompts', number(statistics.totals.total_tags)], ['Image records', number(statistics.totals.total_images)]]);
     await page.keyboard.press('Escape');
     await expect(explore).toBeFocused();
     // A statistics read that fails says so; the Overview stays.

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

@@ -341,3 +341,21 @@ test('a running scan makes the start report busy', async ({ page, request }) =>
         await request.post(`/__test__/jobs/${scan.job.id}/finish`, { data: { state: 'finished' } });
     }
 });
+
+// D204 (#431): Auto-tag selected has the same picker; the job sends the text the dialog shows.
+test('Auto-tag selected picks saved instructions and sends the text shown (D204)', async ({ page }) => {
+    await select(page, FIRST);
+    await barButton(page, 'Auto-tag selected').click();
+    await expect(title(page)).toHaveText('Auto-tag selected images');
+    const body = modal(page).locator('#modal-body');
+    await body.getByRole('combobox', { name: 'Tagging model', exact: true }).selectOption('gguf');
+    const pick = body.getByRole('combobox', { name: 'Saved instructions', exact: true });
+    await expect(pick).toHaveAttribute('id', 'bulk-tag-instructions-pick');
+    await expect(pick.locator('option')).toHaveText(['Built-in', 'Describe the image · default']);
+    const text = body.getByRole('textbox', { name: 'Tagging instructions', exact: true });
+    await text.fill('Bulk one-off.');
+    await expect(pick.locator('option:checked')).toHaveText('Edited for this run');
+    const started = jobStart(page);
+    await actionButtons(page).filter({ hasText: 'Start auto-tagging' }).click();
+    expect((await started).postDataJSON().options.instructions).toBe('Bulk one-off.');
+});

tests/browser/workspace-tagging.spec.mjs

@@ -4,7 +4,7 @@
 import { startCoverage, saveCoverage } from '../../tools/vendor/browser-coverage.mjs';
 import { test, expect } from './fixtures.mjs';
 import { saveImageTags } from './concept-inventory.mjs';
-import { taggingInventory } from './tagging-canonical-comparison.mjs';
+import { FIXTURE_INSTRUCTIONS_ID, taggingInventory } from './tagging-canonical-comparison.mjs';
 
 const images = '/prompt_manager/workspace#/images';
 const MODULE = '/prompt_manager/js/workspace/image-tagging.mjs';
@@ -849,3 +849,61 @@ test('a failed listing re-read after a save says so and keeps the cards (M2)', a
     await expect(page.locator('#gallery-continuation [aria-disabled="true"]')).toHaveCount(0);
     await page.unroute(failing);
 });
+
+// #431: the saved Skipped tags hide matching suggestions before the limit (WD14 fills it from lower scores), and the
+// chip hint says how many were not suggested.
+test('suggestions omit skipped tags and say how many were hidden', async ({ page, request }) => {
+    await expect(await request.post('/__test__/tagging/defaults', { data: { general: 0.35, character: 0.85, limit: 4,
+        skipped: ['desert', 'rock'] } })).toBeOK();
+    await openTag(page);
+    const answer = await (await generated(page)).json();
+    expect(answer.skipped).toBe(2);
+    await expect(chips(page).locator(':scope > span:first-child')).toHaveText(['sandstone', 'arch', 'sky', 'dune']);
+    await expect(dialog(page).locator('#tag-suggestions > p.small')).toHaveText(`${CHIP_HINT} 2 skipped tags were not suggested.`);
+});
+
+// D204 (#431): the Saved instructions select above Tagging instructions: the engine default, a pick, a one-off edit
+// ("Edited for this run" and the muted note), an engine switch resets, WD14 hides both; Generate sends the text shown.
+test('the saved instructions picker fills, edits one-off and resets per engine (D204)', async ({ page, request }) => {
+    const settings = await (await request.get('/prompt_manager/settings')).json();
+    const builtin = settings.settings.autotag_builtin_instructions;
+    await openTag(page);
+    const options = dialog(page).locator('#image-tag-model-options');
+    const pick = options.getByRole('combobox', { name: 'Saved instructions', exact: true });
+    const text = options.getByRole('textbox', { name: 'Tagging instructions', exact: true });
+    const note = options.locator('.instructions-edited');
+    await expect(pick).toHaveCount(0);
+    await model(page).selectOption('gguf');
+    await expect(pick.locator('option')).toHaveText(['Built-in', 'Describe the image · default']);
+    await expect(pick).toHaveAttribute('id', 'image-tag-instructions-pick');
+    await expect(text).toHaveValue('Describe the image');
+    await expect(note).toBeHidden();
+    // A keyboard pick (the select focused) keeps focus on the select the fields are re-rendered with.
+    await pick.focus();
+    await pick.selectOption('builtin');
+    await expect(text).toHaveValue(builtin);
+    await expect(pick).toBeFocused();
+    await text.fill('Only the sky.');
+    await expect(text).toHaveAttribute('aria-describedby', 'image-tag-instructions-pick-note');
+    await expect(pick.locator('option:checked')).toHaveText('Edited for this run');
+    await expect(pick.locator('option[value="edited"]')).toBeDisabled();
+    await expect(note).toHaveText('Edits apply to this run only. Manage saved instructions in System › Auto-tagging.');
+    await expect(text).toBeFocused();
+    // Generate sends the edited text; the saved entries are unchanged.
+    const sent = page.waitForRequest(item => item.url().endsWith('/image-annotations/suggest'));
+    await generate(page).click();
+    expect((await sent).postDataJSON().options.instructions).toBe('Only the sky.');
+    // Choosing an entry replaces the edit; switching engines starts from the new engine's default.
+    await pick.selectOption('builtin');
+    await expect(text).toHaveValue(builtin);
+    await expect(note).toBeHidden();
+    await text.fill('Edited again.');
+    await model(page).selectOption('hf');
+    await expect(text).toHaveValue('Describe the image');
+    await expect(pick).toHaveValue(FIXTURE_INSTRUCTIONS_ID);
+    await model(page).selectOption('wd14-vit');
+    await expect(pick).toHaveCount(0);
+    await expect(text).toHaveCount(0);
+    expect((await (await request.get('/prompt_manager/settings')).json()).settings.autotag_instructions)
+        .toEqual(settings.settings.autotag_instructions);
+});

tests/browser/workspace-vocabulary.spec.mjs

@@ -145,9 +145,10 @@ test('long vocabularies append and Load more is keyboard reachable',async({page,
     await expect(loadMore(page)).toHaveCount(0);
     await expect(rows(page).nth(200).getByRole('button',{name:'Browse',exact:true})).toBeFocused();
     await expect(rows(page).locator('td:nth-child(1)')).toHaveText(manifest.tags);
-    // Reload with the window at its top: Firefox restores a scrolled window, whose end then appends a page before the check.
-    await main(page).locator('.two-col .table-wrap').evaluate(node=>new Promise(resolve=>{node.scrollTop=0;requestAnimationFrame(()=>requestAnimationFrame(resolve));}));
-    await page.reload();
+    // Open the screen as a new history entry, not a reload: Firefox restores a reloaded page's scrolled tag window, and
+    // its end then appends a page before the check (#567). Scrolling the window to its top first does not always stick.
+    await page.goto('about:blank');
+    await page.goto(route);
     await expect(rows(page)).toHaveCount(100);
     // D183: the end of the list arrives inside the tag window.
     const scroll=top=>main(page).locator('.two-col .table-wrap').evaluate((node,y)=>new Promise(resolve=>{node.scrollTop=y ?? node.scrollHeight;requestAnimationFrame(()=>requestAnimationFrame(resolve));}),top);

tests/browser/workspace_tagging_fixture.py

@@ -226,6 +226,7 @@ def register_tagging_commands(
         return download["result"]
 
     _set_defaults(model, DEFAULTS)  # the server starts on the standard ones
+    _write_labels(model, True)
 
     @routes.post("/__test__/tagging/reset")
     async def reset(request: web.Request) -> web.Response:
@@ -244,6 +245,7 @@ def register_tagging_commands(
         model.loaded = None
         restore_download()
         _set_defaults(model, DEFAULTS)
+        await api._run_in_executor(_write_labels, model, True)
         # A test that ends with the dialog open leaves its capture behind; drop
         # every capture so the next test starts below the store's limits.
         await api._run_in_executor(api.close_annotation_captures)
@@ -353,13 +355,22 @@ def register_tagging_commands(
 
         ``{"general": g, "character": c, "limit": n}``: the WD14 thresholds
         (in [0, 1]) and the persisted suggestion count (1..100), so a test can
-        tell the server's values from the dialog's built-in ones. Reset
-        restores the standard 0.35 / 0.85 / 10.
+        tell the server's values from the dialog's built-in ones. Optional
+        ``skipped`` sets the saved Skipped tags (#431) and ``labels`` (true or
+        false) writes or removes the fake WD14 SwinV2 label list the Skipped
+        tags preview reads. Reset restores the standard 0.35 / 0.85 / 10, no
+        skipped tags and the label list.
         """
         data = await request.json() if request.can_read_body else None
         if request.query or not _valid_defaults(data):
             raise web.HTTPBadRequest()
         _set_defaults(model, (data["general"], data["character"], data["limit"]))
+        if "skipped" in data:
+            from py.config import AutotagConfig
+
+            AutotagConfig.SKIPPED_TAGS = tuple(data["skipped"])
+        if "labels" in data:
+            await api._run_in_executor(_write_labels, model, data["labels"])
         return web.json_response({"success": True})
 
     @routes.get("/__test__/tagging/captures")
@@ -380,10 +391,15 @@ DOWNLOAD_HOLD_LIMIT_S = 60
 DEFAULTS = (0.35, 0.85, 10)
 
 
+# The saved "Describe the image" entry's id (#431).
+FIXTURE_INSTRUCTIONS_ID = "d35c71be0a1e"
+
+
 def _set_defaults(model, values) -> None:
     """Set the saved tagging defaults (``AutotagConfig``, #328); a reset also
-    puts back the saved model, batch policy and template (the fake model's
-    short instructions, which the concept comparisons show)."""
+    puts back the saved model, batch policy, skipped tags and instructions
+    (the fake model's short instructions, which the concept comparisons
+    show)."""
     from py.config import AutotagConfig
 
     general, character, limit = values
@@ -393,7 +409,48 @@ def _set_defaults(model, values) -> None:
     if values == DEFAULTS:
         AutotagConfig.MODEL_TYPE = "wd14-swinv2"
         AutotagConfig.EXISTING = "skip"
-        AutotagConfig.TEMPLATE = model.default_prompt
+        # #431: Built-in is always the shipped text, so the fake model's short
+        # instructions are a saved entry, the default of both engines (the
+        # concept comparisons show it).
+        AutotagConfig.INSTRUCTIONS = (
+            {
+                "id": FIXTURE_INSTRUCTIONS_ID,
+                "name": model.default_prompt,
+                "text": model.default_prompt,
+            },
+        )
+        AutotagConfig.DEFAULT_INSTRUCTIONS = {
+            "gguf": FIXTURE_INSTRUCTIONS_ID,
+            "hf": FIXTURE_INSTRUCTIONS_ID,
+        }
+        AutotagConfig._LEGACY_TEMPLATE = None
+        AutotagConfig.SKIPPED_TAGS = ()
+
+
+# The fake WD14 SwinV2 label list (general 0, character 4, rating 9): the
+# names the Skipped tags preview checks beside the library's tags (#431).
+FAKE_LABELS = (
+    ("blurry", "0"),
+    ("blurry_background", "0"),
+    ("signature", "0"),
+    ("watermark", "0"),
+    ("t-shirt", "0"),
+    ("half-closed_eyes", "0"),
+    ("saber_(fate)", "4"),
+    ("general", "9"),
+)
+
+
+def _write_labels(model, present: bool) -> None:
+    """Write (or remove) the fake label list under the fake models folder."""
+    path = Path(model.models_dir) / "WD14-SwinV2" / "selected_tags.csv"
+    if not present:
+        path.unlink(missing_ok=True)
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["tag_id,name,category,count"]
+    lines += [f"{i},{name},{cat},1" for i, (name, cat) in enumerate(FAKE_LABELS)]
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
 
 
 def _valid_defaults(data: object) -> bool:
@@ -402,9 +459,20 @@ def _valid_defaults(data: object) -> bool:
         and not isinstance(value, bool)
         and 0 <= value <= 1
     )
+    optional = {"skipped", "labels"}
+    if isinstance(data, dict) and "skipped" in data:
+        try:
+            from py.tagging_defaults import validate_skipped_tags
+
+            validate_skipped_tags(data["skipped"])
+        except ValueError:
+            return False
+    if isinstance(data, dict) and not isinstance(data.get("labels", True), bool):
+        return False
     return (
         isinstance(data, dict)
-        and set(data) == {"general", "character", "limit"}
+        and {"general", "character", "limit"} <= set(data)
+        and set(data) <= {"general", "character", "limit"} | optional
         and unit(data["general"])
         and unit(data["character"])
         and type(data["limit"]) is int

tests/fixtures/legacy_contract_snapshot.json

@@ -105,6 +105,7 @@
     "POST /prompt_manager/autotag/batch/preview",
     "POST /prompt_manager/autotag/download/{model_type}",
     "POST /prompt_manager/autotag/single",
+    "POST /prompt_manager/autotag/skipped-tags/preview",
     "POST /prompt_manager/autotag/start",
     "POST /prompt_manager/autotag/unload",
     "POST /prompt_manager/bulk/category",
@@ -184,10 +185,14 @@
     "monitor.scheduled",
     "revision",
     "settings",
+    "settings.autotag_builtin_instructions",
     "settings.autotag_character_threshold",
+    "settings.autotag_default_instructions",
     "settings.autotag_existing",
     "settings.autotag_general_threshold",
+    "settings.autotag_instructions",
     "settings.autotag_model_type",
+    "settings.autotag_skipped_tags",
     "settings.autotag_suggestion_limit",
     "settings.autotag_template",
     "settings.cpu_count",

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

@@ -53,8 +53,12 @@ function observed(overrides = {}, capture = {}) {
         ...overrides,
     };
 }
+// #431: the saved instructions; the fixture's entry is the default of both engines.
+const SAVED_ENTRY = { id: '0123456789ab', name: 'Saved', text: DEFAULT_PROMPT };
 const models = (overrides = {}) => ({
-    success: true, models: { 'wd14-swinv2': { downloaded: true } }, default_prompt: DEFAULT_PROMPT,
+    success: true, models: { 'wd14-swinv2': { downloaded: true } },
+    instructions: [{ id: 'builtin', name: 'Built-in', text: 'Built-in text.' }, SAVED_ENTRY],
+    default_instructions: { gguf: SAVED_ENTRY.id, hf: SAVED_ENTRY.id },
     wd14_general_threshold: 0.35, wd14_character_threshold: 0.85, suggestion_limit: 10, ...overrides,
 });
 const SANDSTONE = [
@@ -244,10 +248,13 @@ test('dialog starts on the saved model unless a preset or the user chose one', a
 });
 
 test('an unreadable or malformed models read falls back to the documented defaults', async () => {
-    for (const route of [() => fail(500, null), () => response(200, models({ default_prompt: 4, suggestion_limit: 0, wd14_general_threshold: 2, wd14_character_threshold: 'x' }))]) {
+    for (const route of [() => fail(500, null), () => response(200, models({ instructions: 4, suggestion_limit: 0, wd14_general_threshold: 2, wd14_character_threshold: 'x' }))]) {
         const { c } = await opened({ [`GET ${MODELS}`]: route });
         assert.equal(c.state.phase, 'ready');
-        assert.deepEqual({ ...c.state.options }, { general_threshold: 0.35, character_threshold: 0.85, instructions: '', suggestion_limit: 10 });
+        // #431: the client's Built-in copy (D204's read failure).
+        const { BUILTIN_INSTRUCTIONS } = await load();
+        assert.deepEqual({ ...c.state.options }, { general_threshold: 0.35, character_threshold: 0.85, instructions: BUILTIN_INSTRUCTIONS,
+            suggestion_limit: 10 });
     }
 });
 
@@ -936,3 +943,99 @@ test('#515: text typed before Retry after a failed first observation follows the
     assert.equal(c.state.manual, 'Minimal, warm_light, dunes');
     assert.equal(c.state.statusText, '');
 });
+
+test('the chip hint says how many skipped tags were not suggested (#431)', async () => {
+    const { skippedNote } = await load();
+    assert.equal(skippedNote(0), '');
+    assert.equal(skippedNote(undefined), '');
+    assert.equal(skippedNote(1), ' 1 skipped tag was not suggested.');
+    assert.equal(skippedNote(2), ' 2 skipped tags were not suggested.');
+    for (const [skipped, hint] of [[2, 'Remove anything you do not want to add. 2 skipped tags were not suggested.'],
+        [0, 'Remove anything you do not want to add.'], ['3', 'Remove anything you do not want to add.']]) {
+        const { c } = await opened({ [`POST ${SUGGEST}`]: () => response(200, { ...suggested(), skipped }) });
+        await c.generate();
+        assert.equal(c.state.chipHint, hint, String(skipped));
+    }
+});
+
+// D204 (#431): the Saved instructions picker of both dialogs.
+const PHOTO_ENTRY = { id: '0123456789ac', name: 'Photo', text: 'Photo tags.' };
+const picker = (overrides = {}) => ({ [`GET ${MODELS}`]: () => response(200, models({ model_type: 'gguf',
+    instructions: [{ id: 'builtin', name: 'Built-in', text: 'Built-in text.' }, SAVED_ENTRY, PHOTO_ENTRY],
+    default_instructions: { gguf: SAVED_ENTRY.id, hf: PHOTO_ENTRY.id }, ...overrides })) });
+
+test('the picker starts at the engine default; a pick replaces the text and an edit is one-off (D204)', async () => {
+    const { c } = await opened(picker());
+    assert.deepEqual([c.state.instructionId, c.state.options.instructions, c.state.instructionsEdited], [SAVED_ENTRY.id, DEFAULT_PROMPT, false]);
+    const revision = c.state.optionsRevision;
+    c.pickInstructions(PHOTO_ENTRY.id);
+    assert.deepEqual([c.state.instructionId, c.state.options.instructions, c.state.instructionsEdited], [PHOTO_ENTRY.id, 'Photo tags.', false]);
+    assert.equal(c.state.optionsRevision, revision + 1, 'a pick re-renders the textarea');
+    c.setOption('instructions', 'Photo tags, please.');
+    assert.equal(c.state.instructionsEdited, true);
+    assert.equal(c.state.optionsRevision, revision + 1, 'typing never re-renders');
+    // Choosing an entry again replaces the edit without asking; an unknown id changes nothing.
+    c.pickInstructions(PHOTO_ENTRY.id);
+    assert.deepEqual([c.state.options.instructions, c.state.instructionsEdited], ['Photo tags.', false]);
+    c.pickInstructions('nope');
+    assert.equal(c.state.instructionId, PHOTO_ENTRY.id);
+    // Switching engines resets to the new engine's default and drops a one-off edit; WD14 is never "edited".
+    c.setOption('instructions', 'edited');
+    c.setModel('hf');
+    assert.deepEqual([c.state.instructionId, c.state.options.instructions, c.state.instructionsEdited], [PHOTO_ENTRY.id, 'Photo tags.', false]);
+    c.setModel('wd14-vit');
+    assert.equal(c.state.instructionsEdited, false);
+    c.setModel('gguf');
+    assert.deepEqual([c.state.instructionId, c.state.options.instructions], [SAVED_ENTRY.id, DEFAULT_PROMPT]);
+    c.dispose();
+});
+
+test('a preset shows the entry with its text, else "Edited for this run" (D204)', async () => {
+    const { c } = await opened(picker(), { preset: { model: 'hf', options: { instructions: DEFAULT_PROMPT } } });
+    assert.deepEqual([c.state.instructionId, c.state.instructionsEdited], [SAVED_ENTRY.id, false]);
+    const { c: other } = await opened(picker(), { preset: { model: 'hf', options: { instructions: 'Something else' } } });
+    assert.deepEqual([other.state.instructionId, other.state.options.instructions, other.state.instructionsEdited],
+        [PHOTO_ENTRY.id, 'Something else', true]);
+    for (const controller of [c, other]) controller.dispose();
+});
+
+test('a models read without instructions offers Built-in only with the client copy (D204)', async () => {
+    const { BUILTIN_INSTRUCTIONS, readChoices } = await load();
+    assert.equal(BUILTIN_INSTRUCTIONS.startsWith('Generate only comma-separated Danbooru tags'), true);
+    for (const value of [null, {}, { instructions: [] }, { instructions: [{ id: 'x', name: 'X', text: 'y' }] }]) {
+        assert.deepEqual(readChoices(value).entries.map(entry => entry.id), ['builtin'], JSON.stringify(value));
+    }
+    // A default naming no entry is Built-in.
+    assert.deepEqual({ ...readChoices({ instructions: [{ id: 'builtin', name: 'Built-in', text: 't' }], default_instructions: { gguf: 'gone' } }).defaults },
+        { gguf: 'builtin', hf: 'builtin' });
+    const { c } = await opened(picker({ instructions: 'broken' }));
+    assert.deepEqual([c.state.instructionId, c.state.options.instructions], ['builtin', BUILTIN_INSTRUCTIONS]);
+    c.dispose();
+});
+
+test('the bulk options pick and reset like the Tag image dialog (D204)', async () => {
+    const { createTaggingOptionsController } = await load();
+    const options = createTaggingOptionsController({ api: harness(defaultRoutes(picker())).api });
+    await options.open();
+    assert.deepEqual([options.state.model, options.state.instructionId, options.state.options.instructions], ['gguf', SAVED_ENTRY.id, DEFAULT_PROMPT]);
+    options.pickInstructions(PHOTO_ENTRY.id);
+    assert.equal(options.request().options.instructions, 'Photo tags.');
+    options.setOption('instructions', 'One-off.');
+    assert.equal(options.state.instructionsEdited, true);
+    assert.equal(options.request().options.instructions, 'One-off.');
+    options.setModel('hf');
+    assert.deepEqual([options.state.instructionId, options.state.instructionsEdited], [PHOTO_ENTRY.id, false]);
+    options.pickInstructions('nope');
+    options.dispose();
+    options.pickInstructions(SAVED_ENTRY.id);
+    assert.equal(options.state.instructionId, PHOTO_ENTRY.id);
+});
+
+test('the client Built-in copy equals the server DEFAULT_TAG_TEMPLATE (#431)', async () => {
+    const { BUILTIN_INSTRUCTIONS } = await load();
+    const source = require('node:fs').readFileSync(require('node:path').join(__dirname, '../../py/tagging_defaults.py'), 'utf8');
+    const block = source.slice(source.indexOf('DEFAULT_TAG_TEMPLATE = ('), source.indexOf('\n)\n', source.indexOf('DEFAULT_TAG_TEMPLATE = (')));
+    const text = [...block.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map(([, part]) => JSON.parse(`"${part}"`)).join('');
+    assert.ok(text.length > 100);
+    assert.equal(BUILTIN_INSTRUCTIONS, text);
+});

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

@@ -180,7 +180,9 @@ test('the bulk options start from the server defaults and wait for them before S
     assert.equal(options.state.canStart, false);
     assert.equal(options.state.canGenerate, false);
     const opening = options.open();
-    answer({ wd14_general_threshold: 0.5, wd14_character_threshold: 0.9, default_prompt: 'Say it', suggestion_limit: 7,
+    answer({ wd14_general_threshold: 0.5, wd14_character_threshold: 0.9, suggestion_limit: 7,
+        instructions: [{ id: 'builtin', name: 'Built-in', text: 'Built-in text.' }, { id: '0123456789ab', name: 'Say', text: 'Say it' }],
+        default_instructions: { gguf: '0123456789ab', hf: 'builtin' },
         models: { 'wd14-swinv2': { downloaded: true }, 'wd14-vit': { downloaded: false }, gguf: { downloaded: true } } });
     await opening;
     assert.equal(options.state.canStart, true);

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

@@ -0,0 +1,257 @@
+// System › Auto-tagging "Saved instructions" (#431, D203): Built-in read-only, New, Duplicate, Delete (a deleted default
+// resets to Built-in), the caps, the editor drafts and the per-engine default selects.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const instructionsModule = import('../../web/js/workspace/system-instructions.mjs');
+const stateModule = import('../../web/js/workspace/system-state.mjs');
+const coreModule = import('../../web/js/shared/toolkit/core.js');
+
+/** A minimal DOM: elements with children, attributes, listeners (aborted by their signal) and focus. */
+function fakeDOM() {
+    const previous = global.document;
+    class Element {
+        constructor(tag) {
+            this.tagName = tag.toUpperCase();
+            this.children = [];
+            this.attributes = {};
+            this.listeners = [];
+            this.dataset = {};
+            this.className = '';
+            this.id = '';
+            this.value = '';
+            this.title = '';
+            this.disabled = false;
+            this._text = '';
+        }
+        get localName() { return this.tagName.toLowerCase(); }
+        get textContent() { return this._text + this.children.map(child => (typeof child === 'string' ? child : child.textContent)).join(''); }
+        set textContent(text) { this.children = []; this._text = String(text); }
+        append(...nodes) { for (const node of nodes) { if (typeof node !== 'string') node.parentNode = this; this.children.push(node); } }
+        replaceChildren(...nodes) { this.children = []; this._text = ''; this.append(...nodes); }
+        querySelectorAll(selector) {
+            assert.equal(selector, 'button');
+            const found = [];
+            const walk = node => { for (const child of node.children) if (typeof child !== 'string') { if (child.tagName === 'BUTTON') found.push(child); walk(child); } };
+            walk(this);
+            return found;
+        }
+        focus() { global.document.activeElement = this; }
+        setAttribute(name, value) { this.attributes[name] = String(value); }
+        getAttribute(name) { return Object.hasOwn(this.attributes, name) ? this.attributes[name] : null; }
+        removeAttribute(name) { delete this.attributes[name]; }
+        addEventListener(type, callback, options = {}) {
+            if (options.signal?.aborted) return;
+            const entry = { type, callback };
+            this.listeners.push(entry);
+            options.signal?.addEventListener('abort', () => { this.listeners = this.listeners.filter(item => item !== entry); });
+        }
+        dispatch(type, event = {}) {
+            return Promise.all(this.listeners.filter(item => item.type === type).map(({ callback }) => callback({ type, target: this, ...event })));
+        }
+    }
+    global.document = { createElement: tag => new Element(tag), activeElement: null };
+    const walk = (node, found = []) => { found.push(node); node.children.forEach(child => typeof child !== 'string' && walk(child, found)); return found; };
+    return { find: (root, predicate) => walk(root).find(predicate), restore() { global.document = previous; } };
+}
+
+
+const PHOTO = { id: '0123456789ab', name: 'Custom template', text: 'Photo tags.' };
+const ANIME = { id: '0123456789ac', name: 'Anime', text: 'Anime tags.' };
+const HOST = { autotag_builtin_instructions: 'Built-in text.', autotag_instructions: [PHOTO, ANIME],
+    autotag_default_instructions: { gguf: PHOTO.id, hf: PHOTO.id } };
+
+async function mounted({ host = HOST } = {}) {
+    const { savedInstructionsBlock } = await instructionsModule;
+    const { createSystemDrafts } = await stateModule;
+    const { createScope } = await coreModule;
+    const dom = fakeDOM();
+    const drafts = createSystemDrafts({
+        readBrowser: () => ({}), readRuntime: () => ({}), readHost: async () => ({ values: host, revision: 'sha256:one' }),
+        writeBrowser: async () => ({}), writeHost: async () => ({ success: true, persisted: true }), writeRuntime: async () => ({}),
+    });
+    const scope = createScope();
+    let counter = 0;
+    const random = bytes => bytes.map(() => (counter += 1));
+    const block = savedInstructionsBlock({ scope, drafts, random });
+    const root = global.document.createElement('div');
+    root.append(...block.nodes);
+    scope.cleanup(drafts.subscribe(block.repaint));
+    block.repaint();
+    await drafts.reloadHost();
+    const byId = id => dom.find(root, node => node.id === id);
+    const options = () => byId('instruction-list').children.map(option => [option.children[0].textContent,
+        option.children[1]?.children.map(badge => badge.textContent) ?? [], option.getAttribute('aria-selected')]);
+    const click = id => byId(id).dispatch('click');
+    // A click on an option reaches the list's one listener (as it bubbles in a browser).
+    const pick = name => byId('instruction-list').dispatch('click', { target: byId('instruction-list').children
+        .find(option => option.children[0].textContent === name).children[0] });
+    return { dom, drafts, scope, block, byId, options, click, pick, root };
+}
+
+test('helpers: Built-in first, defaults, free names, ids and the server sentences', async () => {
+    const { allEntries, defaultEntry, freeName, newId, listProblem, entryNote } = await instructionsModule;
+    assert.deepEqual(allEntries(HOST).map(entry => entry.name), ['Built-in', 'Custom template', 'Anime']);
+    assert.equal(allEntries(HOST)[0].text, 'Built-in text.');
+    assert.equal(defaultEntry(HOST, 'hf').text, 'Photo tags.');
+    assert.equal(defaultEntry({ ...HOST, autotag_default_instructions: { gguf: 'gone', hf: 'builtin' } }, 'gguf').name, 'Built-in');
+    assert.equal(freeName('New instructions', allEntries(HOST)), 'New instructions');
+    assert.equal(freeName('anime', allEntries(HOST)), 'anime (2)');
+    assert.equal(freeName('Anime', [...allEntries(HOST), { name: 'Anime (2)' }]), 'Anime (3)');
+    let calls = 0;
+    const id = newId([{ id: '000000000000' }], bytes => { calls += 1; return bytes.fill(calls === 1 ? 0 : 171); });
+    assert.equal(id, 'abababababab');
+    assert.match(newId([]), /^[0-9a-f]{12}$/);
+    const list = entries => listProblem({ autotag_instructions: entries });
+    assert.equal(list([PHOTO]), null);
+    assert.equal(list([{ ...PHOTO, name: ' ' }]), 'Saved instructions: entry 1 needs a name.');
+    assert.equal(list([PHOTO, { ...ANIME, name: 'x'.repeat(61) }]), 'Saved instructions: entry 2 name must be at most 60 characters.');
+    assert.equal(list([{ ...PHOTO, name: 'a\nb' }]), 'Saved instructions: entry 1 name must not contain a line break.');
+    assert.equal(list([{ ...PHOTO, name: 'built-in' }]), 'Saved instructions: the name “Built-in” is reserved.');
+    assert.equal(list([PHOTO, { ...ANIME, name: ' custom TEMPLATE ' }]), 'Saved instructions: entry 2 name “custom TEMPLATE” is already used.');
+    assert.equal(list([{ ...PHOTO, text: ' ' }]), 'Saved instructions: entry 1 text must be non-empty text.');
+    assert.equal(list([{ ...PHOTO, text: 'x'.repeat(4001) }]), 'Saved instructions: entry 1 text must be at most 4000 characters.');
+    const long = { ...PHOTO, text: 'x'.repeat(4001) };
+    assert.equal(entryNote(long, [long]), 'The text must be at most 4,000 characters.');
+});
+
+test('the list shows Built-in read-only first, the saved entries and their default chips', async () => {
+    const view = await mounted();
+    try {
+        assert.deepEqual(view.options(), [['Built-in', ['Read-only'], 'true'],
+            ['Custom template', ['Default for GGUF', 'Default for HuggingFace'], 'false'], ['Anime', [], 'false']]);
+        assert.equal(view.byId('instructions-count').textContent, '2 of 20 saved · Built‑in is not counted.');
+        assert.equal(view.byId('instruction-name').value, 'Built-in');
+        assert.equal(view.byId('instruction-name').readOnly, true);
+        assert.equal(view.byId('instruction-text').value, 'Built-in text.');
+        assert.equal(view.byId('instruction-text').readOnly, true);
+        assert.equal(view.byId('instruction-note').textContent, 'Built-in instructions can’t be changed. Duplicate them to make your own.');
+        assert.equal(view.byId('instruction-delete').disabled, true);
+        assert.equal(view.byId('instruction-list').getAttribute('role'), 'listbox');
+        assert.equal(view.block.nodes[0].dataset.key, 'autotag_instructions');
+        assert.deepEqual(view.byId('instruction-default-gguf').children.map(option => option.textContent), ['Built-in', 'Custom template', 'Anime']);
+        assert.equal(view.byId('instruction-default-gguf').value, PHOTO.id);
+        assert.equal(view.byId('instruction-default-hf').dataset.key, 'autotag_default_instructions');
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('editing a saved entry drafts the list; its counts and note follow', async () => {
+    const view = await mounted();
+    try {
+        await view.pick('Anime');
+        assert.equal(view.byId('instruction-name').readOnly, false);
+        assert.equal(view.byId('instruction-delete').disabled, false);
+        view.byId('instruction-name').value = 'Anime tags';
+        await view.byId('instruction-name').dispatch('input');
+        view.byId('instruction-text').value = 'Tags, anime.';
+        await view.byId('instruction-text').dispatch('input');
+        assert.deepEqual(view.drafts.get('host', 'autotag_instructions'), [PHOTO, { ...ANIME, name: 'Anime tags', text: 'Tags, anime.' }]);
+        assert.equal(view.byId('instruction-name').parentNode.children[0].children[1].textContent, '10 of 60');
+        assert.equal(view.byId('instruction-text').parentNode.children[0].children[1].textContent, '12 of 4,000 characters');
+        view.byId('instruction-name').value = 'custom template';
+        await view.byId('instruction-name').dispatch('input');
+        assert.equal(view.byId('instruction-note').textContent, 'The name “custom template” is already used.');
+        // Built-in is never edited.
+        await view.pick('Built-in');
+        view.byId('instruction-text').value = 'changed';
+        await view.byId('instruction-text').dispatch('input');
+        assert.equal(view.drafts.get('host', 'autotag_instructions')[0], PHOTO);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('New and Duplicate append an entry with a fresh id and a free name; the caps disable them', async () => {
+    const view = await mounted();
+    try {
+        await view.click('instruction-new');
+        const added = view.drafts.get('host', 'autotag_instructions').at(-1);
+        assert.match(added.id, /^[0-9a-f]{12}$/);
+        assert.deepEqual([added.name, added.text], ['New instructions', '']);
+        assert.equal(view.options().at(-1)[2], 'true');
+        assert.equal(view.byId('instruction-note').textContent, 'The text must not be empty.');
+        await view.pick('Built-in');
+        await view.click('instruction-duplicate');
+        assert.deepEqual(view.drafts.get('host', 'autotag_instructions').at(-1).name, 'Built-in copy');
+        assert.equal(view.drafts.get('host', 'autotag_instructions').at(-1).text, 'Built-in text.');
+        const full = await mounted({ host: { ...HOST, autotag_instructions: Array.from({ length: 20 },
+            (_, i) => ({ id: i.toString(16).padStart(12, '0'), name: `n${i}`, text: 't' })) } });
+        try {
+            assert.equal(full.byId('instruction-new').disabled, true);
+            assert.equal(full.byId('instruction-duplicate').disabled, true);
+            assert.equal(full.byId('instruction-cap').hidden, false);
+            await full.click('instruction-new');
+            assert.equal(full.drafts.get('host', 'autotag_instructions').length, 20);
+        } finally { full.scope.dispose(); }
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('deleting a default resets that engine to Built-in and says so; a select change clears the note', async () => {
+    const view = await mounted();
+    try {
+        await view.pick('Custom template');
+        await view.click('instruction-delete');
+        assert.deepEqual(view.drafts.get('host', 'autotag_instructions'), [ANIME]);
+        assert.deepEqual(view.drafts.get('host', 'autotag_default_instructions'), { gguf: 'builtin', hf: 'builtin' });
+        assert.equal(view.byId('instruction-reset').textContent, 'GGUF and HuggingFace now use Built-in.');
+        assert.equal(view.options()[1][2], 'true', 'the next entry is selected');
+        view.byId('instruction-default-hf').value = ANIME.id;
+        await view.byId('instruction-default-hf').dispatch('change');
+        assert.deepEqual(view.drafts.get('host', 'autotag_default_instructions'), { gguf: 'builtin', hf: ANIME.id });
+        assert.equal(view.byId('instruction-reset').textContent, '');
+        await view.click('instruction-delete');
+        assert.equal(view.byId('instruction-reset').textContent, 'HuggingFace now uses Built-in.');
+        assert.deepEqual(view.options().map(([name]) => name), ['Built-in']);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('arrow keys move the selection; before the read everything is disabled', async () => {
+    const view = await mounted();
+    try {
+        const list = view.byId('instruction-list');
+        await list.dispatch('keydown', { key: 'ArrowDown' });
+        assert.equal(view.byId('instruction-name').value, 'Custom template');
+        await list.dispatch('keydown', { key: 'End' });
+        assert.equal(view.byId('instruction-name').value, 'Anime');
+        await list.dispatch('keydown', { key: 'ArrowDown' });
+        assert.equal(view.byId('instruction-name').value, 'Anime');
+        await list.dispatch('keydown', { key: 'Home' });
+        assert.equal(view.byId('instruction-name').value, 'Built-in');
+        await list.dispatch('keydown', { key: 'a' });
+        assert.equal(list.getAttribute('aria-activedescendant'), 'instruction-option-builtin');
+    } finally { view.scope.dispose(); view.dom.restore(); }
+    const unread = await mounted({ host: {} });
+    try {
+        assert.equal(unread.byId('instruction-new').disabled, true);
+        assert.equal(unread.byId('instruction-default-gguf').disabled, true);
+    } finally { unread.scope.dispose(); unread.dom.restore(); }
+});
+
+test('the reset note goes once the defaults are saved; a long name is cut to fit its copy suffix', async () => {
+    const view = await mounted();
+    try {
+        await view.pick('Custom template');
+        await view.click('instruction-delete');
+        assert.equal(view.byId('instruction-reset').textContent, 'GGUF and HuggingFace now use Built-in.');
+        await view.drafts.save();
+        assert.equal(view.byId('instruction-reset').textContent, '');
+        await view.pick('Anime');
+        view.byId('instruction-name').value = 'x'.repeat(60);
+        await view.byId('instruction-name').dispatch('input');
+        await view.click('instruction-duplicate');
+        const copy = view.drafts.get('host', 'autotag_instructions').at(-1).name;
+        assert.equal(copy, `${'x'.repeat(55)} copy`);
+        await view.click('instruction-duplicate');
+        assert.equal([...view.drafts.get('host', 'autotag_instructions').at(-1).name].length <= 60, true);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('option clicks are one listener on the list, not one per repaint', async () => {
+    const view = await mounted();
+    try {
+        const list = view.byId('instruction-list');
+        const before = list.listeners.length;
+        for (let i = 0; i < 5; i += 1) await view.pick('Anime');
+        assert.equal(list.listeners.length, before);
+        assert.equal(view.byId('instruction-list').children.every(option => option.listeners.length === 0), true);
+        assert.equal(view.byId('instruction-name').value, 'Anime');
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});

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

@@ -16,12 +16,22 @@ const OVERVIEW = Object.freeze({
 
 test('metrics are the server counts and Not checked before any health check', async () => {
     const { metricValues } = await overviewModule;
-    assert.deepEqual(metricValues(OVERVIEW), [
+    assert.deepEqual(metricValues(OVERVIEW, 24), [
         [(1234).toLocaleString(), 'Positive prompts'], ['7', 'Negative variants'], ['24', 'Images'],
         ['Not checked', 'Database integrity'],
     ]);
 });
 
+test('#555: the Images metric is the Images page count (the sidebar badge), not the indexed rows', async () => {
+    const { metricValues } = await overviewModule;
+    // The demo library: 110 indexed rows, 122 files on the Images page (unlinked ones included).
+    const overview = { ...OVERVIEW, images: { indexed: 110, rated: 0 } };
+    assert.deepEqual(metricValues(overview, 122)[2], [(122).toLocaleString(), 'Images']);
+    // Not read yet (undefined) or failed (null): a dash, as on the workspace Overview, never the row count.
+    assert.deepEqual(metricValues(overview, undefined)[2], ['–', 'Images']);
+    assert.deepEqual(metricValues(overview, null)[2], ['–', 'Images']);
+});
+
 test('metric 4 is the last health result', async () => {
     const { integrityText } = await overviewModule;
     assert.equal(integrityText(null), 'Not checked');
@@ -150,7 +160,7 @@ test('statistics rows are the real runs, then the library totals, without rating
         rated_images: 20,
     };
     assert.deepEqual(categoryRows(statistics), [['Landscapes', (1200).toLocaleString()], ['Uncategorized', '3']]);
-    assert.deepEqual(totalsRows(statistics), [['Prompts', '12'], ['Tags', '15'], ['Images', '24']]);
+    assert.deepEqual(totalsRows(statistics), [['Prompt records', '12'], ['Tags on prompts', '15'], ['Image records', '24']]);
 });
 
 /** A fake api answering each `get`/`post` from a queue per URL, recording the calls. */

tests/js/workspace-system-skipped-tags.test.js

@@ -0,0 +1,247 @@
+// System › Auto-tagging "Skipped tags" (#431, D202): the add input, the chips, the client checks and the preview line.
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const skippedModule = import('../../web/js/workspace/system-skipped-tags.mjs');
+const stateModule = import('../../web/js/workspace/system-state.mjs');
+const coreModule = import('../../web/js/shared/toolkit/core.js');
+
+/** A minimal DOM: elements with children, attributes, listeners (aborted by their signal) and focus. */
+function fakeDOM() {
+    const previous = global.document;
+    class Element {
+        constructor(tag) {
+            this.tagName = tag.toUpperCase();
+            this.children = [];
+            this.attributes = {};
+            this.listeners = [];
+            this.dataset = {};
+            this.className = '';
+            this.id = '';
+            this.value = '';
+            this.title = '';
+            this.disabled = false;
+            this._text = '';
+        }
+        get localName() { return this.tagName.toLowerCase(); }
+        get textContent() { return this._text + this.children.map(child => (typeof child === 'string' ? child : child.textContent)).join(''); }
+        set textContent(text) { this.children = []; this._text = String(text); }
+        append(...nodes) { for (const node of nodes) { if (typeof node !== 'string') node.parentNode = this; this.children.push(node); } }
+        replaceChildren(...nodes) { this.children = []; this._text = ''; this.append(...nodes); }
+        querySelectorAll(selector) {
+            assert.equal(selector, 'button');
+            const found = [];
+            const walk = node => { for (const child of node.children) if (typeof child !== 'string') { if (child.tagName === 'BUTTON') found.push(child); walk(child); } };
+            walk(this);
+            return found;
+        }
+        focus() { global.document.activeElement = this; }
+        setAttribute(name, value) { this.attributes[name] = String(value); }
+        getAttribute(name) { return Object.hasOwn(this.attributes, name) ? this.attributes[name] : null; }
+        removeAttribute(name) { delete this.attributes[name]; }
+        addEventListener(type, callback, options = {}) {
+            if (options.signal?.aborted) return;
+            const entry = { type, callback };
+            this.listeners.push(entry);
+            options.signal?.addEventListener('abort', () => { this.listeners = this.listeners.filter(item => item !== entry); });
+        }
+        dispatch(type, event = {}) {
+            return Promise.all(this.listeners.filter(item => item.type === type).map(({ callback }) => callback({ type, target: this, ...event })));
+        }
+    }
+    global.document = { createElement: tag => new Element(tag), activeElement: null };
+    const walk = (node, found = []) => { found.push(node); node.children.forEach(child => typeof child !== 'string' && walk(child, found)); return found; };
+    return { find: (root, predicate) => walk(root).find(predicate), restore() { global.document = previous; } };
+}
+
+const tick = () => new Promise(resolve => setTimeout(resolve, 5));
+
+async function mounted({ saved = ['blurry'], answer, host = true } = {}) {
+    const { skippedTagsBlock } = await skippedModule;
+    const { createSystemDrafts } = await stateModule;
+    const { createScope } = await coreModule;
+    const dom = fakeDOM();
+    const drafts = createSystemDrafts({
+        readBrowser: () => ({}), readRuntime: () => ({}),
+        readHost: async () => ({ values: host ? { autotag_skipped_tags: saved } : {}, revision: 'sha256:one' }),
+        writeBrowser: async () => ({}), writeHost: async () => ({ success: true, persisted: true }), writeRuntime: async () => ({}),
+    });
+    const scope = createScope();
+    const posts = [];
+    const api = {
+        post: (url, body, options) => {
+            posts.push({ url, body, signal: options.signal });
+            if (answer) return answer(body, options);
+            return Promise.resolve({ success: true, count: body.entries.length, sample: body.entries, sample_limit: 12,
+                per_entry: body.entries.map((entry, index) => ({ entry, count: index })), sources: { library: 3, wd14: ['WD14 SwinV2'] } });
+        },
+    };
+    const block = skippedTagsBlock({ api, scope, drafts, delay: 1 });
+    scope.cleanup(drafts.subscribe(block.repaint));
+    block.repaint();
+    await drafts.reloadHost();
+    const byId = id => dom.find(block.node, node => node.id === id);
+    const chips = () => dom.find(block.node, node => node.className === 'tags skip-chips');
+    const preview = () => dom.find(block.node, node => node.className === 'small skip-preview');
+    const add = async text => { byId('tag-skipped-input').value = text; await byId('tag-skipped-add').dispatch('click'); };
+    return { dom, drafts, scope, block, byId, chips, preview, posts, add };
+}
+
+test('words split like the server: NFC, lower case, space, _ and - only', async () => {
+    const { entryWords } = await skippedModule;
+    assert.deepEqual(entryWords('Half-closed_eyes'), ['half', 'closed', 'eyes']);
+    assert.deepEqual(entryWords('saber_(fate)'), ['saber', '(fate)']);
+    assert.deepEqual(entryWords(' _ - '), []);
+    assert.deepEqual(entryWords('CAFÉ'), ['café']);
+});
+
+test('the client checks say why an entry is not added', async () => {
+    const { entryProblem, SKIPPED_COPY } = await skippedModule;
+    assert.equal(entryProblem('  sky ', ['blurry']), '');
+    assert.equal(entryProblem('   ', []), SKIPPED_COPY.empty);
+    assert.equal(entryProblem('_--', []), 'Enter a word.');
+    assert.equal(entryProblem('a, b', []), 'No commas or line breaks.');
+    assert.equal(entryProblem('a\nb', []), 'No commas or line breaks.');
+    assert.equal(entryProblem('x'.repeat(51), []), 'At most 50 characters.');
+    assert.equal(entryProblem('🏜'.repeat(50), []), '');
+    assert.equal(entryProblem('Blurry-Background', ['blurry background']), 'Already in the list.');
+    assert.equal(entryProblem('sky', Array.from({ length: 200 }, (_, i) => `w${i}`)), 'The list is full (200).');
+});
+
+test('the preview line states the count, the sample and the sources', async () => {
+    const { previewText, chipCount } = await skippedModule;
+    assert.deepEqual(previewText({ count: 15, sample: ['blurry', 'signature'], sources: { wd14: ['WD14 SwinV2'] } }), {
+        lead: 'Hides 15 tags from suggestions', rest: ': blurry, signature and 13 more. Tags already on images are not changed.' });
+    assert.deepEqual(previewText({ count: 1, sample: ['blurry'], sources: { wd14: [] } }), {
+        lead: 'Hides 1 tag from suggestions',
+        rest: ': blurry. Checked against library tags only; no WD14 label list is downloaded. Tags already on images are not changed.' });
+    assert.deepEqual(previewText({ count: 0, sample: [], sources: { wd14: ['WD14 ViT'] } }), {
+        lead: 'Hides 0 tags from suggestions', rest: '. Tags already on images are not changed.' });
+    assert.deepEqual(previewText(null).lead, 'Hides 0 tags from suggestions');
+    assert.deepEqual(chipCount(3), { title: 'Hides 3 tags', text: '3' });
+    assert.deepEqual(chipCount(1), { title: 'Hides 1 tag', text: '1' });
+    assert.deepEqual(chipCount(0), { title: 'Hides no known tag', text: 'none' });
+    assert.equal(chipCount(undefined), null);
+});
+
+test('the block shows the saved list, previews it and carries its setting keys', async () => {
+    const view = await mounted({ saved: ['blurry', 'signature'] });
+    try {
+        assert.equal(view.block.node.dataset.setting, 'tag-skipped');
+        assert.equal(view.block.node.dataset.key, 'autotag_skipped_tags');
+        assert.equal(view.preview().textContent, 'Checking…');
+        await tick();
+        assert.deepEqual(view.posts.map(post => [post.url, post.body]),
+            [['/prompt_manager/autotag/skipped-tags/preview', { entries: ['blurry', 'signature'] }]]);
+        assert.equal(view.preview().textContent, 'Hides 2 tags from suggestions: blurry, signature. Tags already on images are not changed.');
+        const chips = view.chips().children;
+        assert.deepEqual(chips.map(chip => [chip.className, chip.title, chip.textContent]), [
+            ['chip tag-suggestion none', 'Hides no known tag', 'blurrynone×'],
+            ['chip tag-suggestion', 'Hides 1 tag', 'signature1×']]);
+        assert.equal(chips[1].children[2].getAttribute('aria-label'), 'Remove signature');
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('add and remove draft the list; a list set back is clean; Enter adds', async () => {
+    const view = await mounted();
+    try {
+        await view.add('  closed eyes ');
+        assert.deepEqual(view.drafts.get('host', 'autotag_skipped_tags'), ['blurry', 'closed eyes']);
+        assert.equal(view.byId('tag-skipped-input').value, '');
+        assert.equal(view.drafts.dirty(), true);
+        view.byId('tag-skipped-input').value = 'sky';
+        let prevented = false;
+        await view.byId('tag-skipped-input').dispatch('keydown', { key: 'Enter', preventDefault: () => { prevented = true; } });
+        assert.equal(prevented, true);
+        await view.byId('tag-skipped-input').dispatch('keydown', { key: 'a' });
+        assert.deepEqual(view.drafts.get('host', 'autotag_skipped_tags'), ['blurry', 'closed eyes', 'sky']);
+        // Remove the two added chips: the list equals the saved one and nothing is unsaved (sameDraft).
+        const removeButton = index => view.chips().children[index].children.at(-1);
+        removeButton(2).focus();
+        await removeButton(2).dispatch('click');
+        assert.equal(global.document.activeElement, removeButton(1), 'focus moves to the neighbour');
+        await removeButton(1).dispatch('click');
+        assert.deepEqual(view.drafts.get('host', 'autotag_skipped_tags'), ['blurry']);
+        assert.equal(view.drafts.dirty(), false);
+        await tick();
+        // Only the last list of a quick series is asked for.
+        assert.deepEqual(view.posts.map(post => post.body.entries), [['blurry']]);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('a refused entry is not added and the line under the input says why', async () => {
+    const view = await mounted();
+    try {
+        const problem = () => view.byId('tag-skipped-problem').textContent;
+        await view.add('Blurry');
+        assert.equal(problem(), 'Already in the list.');
+        assert.equal(view.byId('tag-skipped-input').getAttribute('aria-invalid'), 'true');
+        assert.equal(view.byId('tag-skipped-input').value, 'Blurry');
+        await view.byId('tag-skipped-input').dispatch('input');
+        assert.equal(problem(), '');
+        assert.equal(view.byId('tag-skipped-input').getAttribute('aria-invalid'), null);
+        await view.add('a,b');
+        assert.equal(problem(), 'No commas or line breaks.');
+        await view.add(' ');
+        assert.equal(problem(), 'Enter a word.');
+        assert.deepEqual(view.drafts.get('host', 'autotag_skipped_tags'), ['blurry']);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('a full list disables Add and says so', async () => {
+    const view = await mounted({ saved: Array.from({ length: 200 }, (_, i) => `w${i}`) });
+    try {
+        assert.equal(view.byId('tag-skipped-add').disabled, true);
+        assert.equal(view.byId('tag-skipped-problem').textContent, 'The list is full (200).');
+        await view.chips().children[0].children.at(-1).dispatch('click');
+        assert.equal(view.byId('tag-skipped-add').disabled, false);
+        assert.equal(view.byId('tag-skipped-problem').textContent, '');
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('an empty list says no tags are skipped without a request', async () => {
+    const view = await mounted({ saved: [] });
+    try {
+        await tick();
+        assert.equal(view.preview().textContent, 'No tags are skipped.');
+        assert.deepEqual(view.posts, []);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('a failed preview says so; a newer list aborts the older request', async () => {
+    let calls = 0;
+    const view = await mounted({ answer: (body, options) => {
+        calls += 1;
+        if (calls === 1) return new Promise((_resolve, reject) => options.signal.addEventListener('abort', () => reject(new Error('aborted'))));
+        return Promise.reject(Object.assign(new Error('busy'), { code: 'busy' }));
+    } });
+    try {
+        await tick();
+        assert.equal(view.posts.length, 1);
+        await view.add('sky');
+        assert.equal(view.posts[0].signal.aborted, true);
+        await tick();
+        assert.equal(view.preview().textContent, 'The preview could not be read.');
+        // The list stays editable.
+        assert.equal(view.byId('tag-skipped-input').disabled, false);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('before the settings are read the controls are disabled', async () => {
+    const view = await mounted({ host: false });
+    try {
+        assert.equal(view.byId('tag-skipped-input').disabled, true);
+        assert.equal(view.byId('tag-skipped-add').disabled, true);
+        await view.add('sky');
+        assert.equal(view.drafts.get('host', 'autotag_skipped_tags'), undefined);
+    } finally { view.scope.dispose(); view.dom.restore(); }
+});
+
+test('leaving the section aborts a request in flight and the pending timer', async () => {
+    const view = await mounted({ answer: (_body, options) => new Promise((_r, reject) => options.signal.addEventListener('abort', () => reject(new Error('x')))) });
+    await tick();
+    assert.equal(view.posts.length, 1);
+    view.scope.dispose();
+    assert.equal(view.posts[0].signal.aborted, true);
+    view.dom.restore();
+});

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

@@ -402,11 +402,12 @@ test('a partial host save keeps what saved, adopts its revision and fails only t
     assert.equal(drafts.statusText(), 'missing can\'t be used: not found. Remove it or reconnect it, then save.');
     // The next save carries the revision the saved part produced: no false "changed elsewhere".
     domains.outcome.host = null;
-    drafts.set('host', 'gallery_root_paths', ['a']);
+    // (#431: a list equal to the saved one is no change, so a different one is drafted.)
+    drafts.set('host', 'gallery_root_paths', ['a', 'b']);
     const second = await drafts.save();
     assert.equal(second.host, 'saved');
     assert.equal(domains.calls.at(-1)[2].expected_revision, 'sha256:lora');
-    assert.deepEqual(domains.calls.at(-1)[1], { gallery_root_paths: ['a'] });
+    assert.deepEqual(domains.calls.at(-1)[1], { gallery_root_paths: ['a', 'b'] });
     // Without a server reason, the status says some were saved and the highlighted ones were not.
     domains.outcome.host = () => { throw Object.assign(new Error('boom'), { partial: { saved: ['x'], revision: 'sha256:three' } }); };
     drafts.set('host', 'x', 1);
@@ -429,3 +430,39 @@ test('runtime adapter maps config.level to runtime_level and back', async () =>
     assert.deepEqual(runtimeBody({ runtime_level: 'WARNING' }), { level: 'WARNING' });
     assert.deepEqual(runtimeBody({ runtime_level: 'CRITICAL', console_logging: true }), { level: 'CRITICAL', console_logging: true });
 });
+
+test('sameDraft compares arrays and plain objects by value, keys in any order (#431)', async () => {
+    const { sameDraft } = await source;
+    assert.equal(sameDraft(1, 1), true);
+    assert.equal(sameDraft(Number.NaN, Number.NaN), true);
+    assert.equal(sameDraft(0, -0), false);
+    assert.equal(sameDraft(['a', 'b'], ['a', 'b']), true);
+    assert.equal(sameDraft(['a', 'b'], ['b', 'a']), false);
+    assert.equal(sameDraft([], []), true);
+    assert.equal(sameDraft([], {}), false);
+    assert.equal(sameDraft({ gguf: 'x', hf: 'y' }, { hf: 'y', gguf: 'x' }), true);
+    assert.equal(sameDraft([{ id: 'a', name: 'n' }], [{ name: 'n', id: 'a' }]), true);
+    assert.equal(sameDraft({ a: 1 }, { a: 2 }), false);
+    assert.equal(sameDraft('a', ['a']), false);
+    assert.equal(sameDraft(null, {}), false);
+    assert.equal(sameDraft(new Date(0), new Date(0)), false);
+});
+
+test('a list draft set back to the saved list is clean, and a save cleans it (#431)', async () => {
+    const domains = adapters({ host: { autotag_skipped_tags: ['blurry'] } });
+    const drafts = await loaded(domains);
+    drafts.set('host', 'autotag_skipped_tags', ['blurry', 'signature']);
+    assert.equal(drafts.dirty('host'), true);
+    // Removing the added chip builds a new array equal to the saved one.
+    drafts.set('host', 'autotag_skipped_tags', ['blurry']);
+    assert.equal(drafts.dirty('host'), false);
+    drafts.set('host', 'autotag_skipped_tags', ['signature']);
+    await drafts.save();
+    assert.equal(drafts.dirty('host'), false);
+    assert.deepEqual(drafts.saved('host').autotag_skipped_tags, ['signature']);
+    // A reload whose list equals the draft's (a new array) keeps nothing dirty.
+    drafts.set('host', 'autotag_skipped_tags', ['sky']);
+    domains.readHost = async () => ({ values: { autotag_skipped_tags: ['sky'] }, revision: 'sha256:three' });
+    await drafts.load('host');
+    assert.equal(drafts.dirty('host'), false);
+});

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

@@ -42,6 +42,8 @@ function fakeDOM() {
                 this.children.push(node);
             }
         }
+        replaceChildren(...nodes) { this.children = []; this._text = ''; this.append(...nodes); }
+        focus() { global.document.activeElement = this; }
         remove() { if (this.parentNode) this.parentNode.children = this.parentNode.children.filter(child => child !== this); this.parentNode = null; }
         setAttribute(name, value) { this.attributes[name] = String(value); }
         getAttribute(name) { return Object.hasOwn(this.attributes, name) ? this.attributes[name] : null; }
@@ -65,7 +67,9 @@ function fakeDOM() {
 }
 
 const HOST = { autotag_model_type: 'wd14-swinv2', autotag_existing: 'skip', autotag_general_threshold: 0.35,
-    autotag_character_threshold: 0.85, autotag_suggestion_limit: 10, autotag_template: 'Describe the image as tags.' };
+    autotag_character_threshold: 0.85, autotag_suggestion_limit: 10, autotag_builtin_instructions: 'Built-in tags.',
+    autotag_instructions: [{ id: '0123456789ab', name: 'Describe', text: 'Describe the image as tags.' }],
+    autotag_default_instructions: { gguf: '0123456789ab', hf: 'builtin' } };
 const entry = (label, size, extra = {}) => ({ name: label, label, size_label: size, downloaded: true, loaded: false, ...extra });
 const MODELS = {
     success: true,
@@ -124,7 +128,8 @@ test('the section keeps the concept surface, rows, labels and actions in order',
     for (const option of ['Skip already tagged', 'Merge with existing', 'Replace after review']) assert.ok(body.includes(option) && SOURCE.includes(`'${option}'`));
     assert.ok(body.includes('<h2>Auto-tagging</h2>') && SOURCE.includes("'h2', 'Auto-tagging'"));
     assert.ok(body.includes('One tagging configuration for images and prompt-library actions. Every result can be reviewed before applying.'));
-    assert.ok(body.includes('LLM tag template') && SOURCE.includes("'LLM tag template'"));
+    // D203 (#431): Saved instructions replace the concept's template field.
+    assert.ok(body.includes('LLM tag template') && !SOURCE.includes("'LLM tag template'"));
     assert.ok(body.includes('"Preview tagging review", "tag-review", "", "ca-primary"'));
     // Prototype copy is never shipped.
     for (const sample of ['Simulate download', 'Simulate unload', 'Ollama']) assert.ok(!SOURCE.includes(sample), sample);
@@ -167,27 +172,25 @@ test('controls draft their host keys; numbers as numbers, other text as typed',
     const { SETTING_KEYS, coerceNumber, draftValue } = await tagging;
     assert.deepEqual(SETTING_KEYS, { 'tag-model': 'autotag_model_type', 'tag-existing': 'autotag_existing',
         'threshold-general': 'autotag_general_threshold', 'threshold-character': 'autotag_character_threshold',
-        'tag-suggestions': 'autotag_suggestion_limit', 'tag-template': 'autotag_template' });
+        'tag-suggestions': 'autotag_suggestion_limit' });
     assert.deepEqual(['0.4', ' 1.5 ', '15', '', 'abc', '1e-1'].map(coerceNumber), [0.4, 1.5, 15, '', 'abc', 0.1]);
     assert.equal(draftValue('autotag_suggestion_limit', '15'), 15);
-    assert.equal(draftValue('autotag_template', ' 12 '), ' 12 ');
+    assert.equal(draftValue('autotag_existing', ' 12 '), ' 12 ');
     assert.equal(draftValue('autotag_existing', undefined), '');
     const { dom, drafts, scope, byId } = await mounted();
     try {
         assert.equal(byId('tag-model').value, 'wd14-swinv2');
         assert.equal(byId('threshold-general').value, '0.35');
-        assert.equal(byId('tag-template').value, HOST.autotag_template);
         assert.deepEqual([byId('threshold-general').min, byId('threshold-general').max, byId('threshold-general').step], ['0', '1', '0.05']);
         assert.deepEqual([byId('tag-suggestions').min, byId('tag-suggestions').max], ['1', '100']);
         byId('tag-existing').value = 'merge'; await byId('tag-existing').dispatch('change');
         byId('threshold-general').value = '0.4'; await byId('threshold-general').dispatch('change');
         byId('tag-suggestions').value = '15'; await byId('tag-suggestions').dispatch('change');
-        byId('tag-template').value = 'Tags only.'; await byId('tag-template').dispatch('input');
         assert.deepEqual(drafts.changes('host'), { autotag_existing: 'merge', autotag_general_threshold: 0.4,
-            autotag_suggestion_limit: 15, autotag_template: 'Tags only.' });
+            autotag_suggestion_limit: 15 });
         // Every control names its stored key, so a refused save highlights it (D92).
         for (const id of Object.keys(SETTING_KEYS)) assert.equal(byId(id).dataset.key, SETTING_KEYS[id]);
-        assert.equal(byId('tag-template').dataset.setting, 'tag-template');
+        assert.equal(byId('tag-template'), undefined);
     } finally { scope.dispose(); assert.equal(dom.listenerCount(), 0); dom.restore(); }
 });
 
@@ -201,7 +204,8 @@ test('opening the section reads the model status once; the select waits for it',
         assert.deepEqual(byId('tag-model').options.map(option => option.textContent),
             ['WD14 SwinV2 · ~400 MB', 'WD14 ViT · ~400 MB', 'GGUF JoyCaption · ~4.5 GB', 'HuggingFace JoyCaption · ~16 GB']);
         assert.deepEqual(surface.children.map(node => node.className),
-            ['', '', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'field', 'row-actions', 'operation']);
+            ['', '', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'setting-row', 'setting-block', 'setting-block', 'setting-row',
+            'setting-row', 'small instruction-reset', 'row-actions', 'operation']);
     } finally { scope.dispose(); dom.restore(); }
     const failed = await mounted({ modelsFail: true });
     try {
@@ -302,7 +306,9 @@ test('Preview tagging review opens the Tag image dialog with the section’s val
     assert.deepEqual(taggingPreset(HOST), { model: 'wd14-swinv2', options: { general_threshold: 0.35, character_threshold: 0.85,
         suggestion_limit: 10 } });
     assert.deepEqual(taggingPreset({ ...HOST, autotag_model_type: 'gguf' }), { model: 'gguf',
-        options: { instructions: HOST.autotag_template, suggestion_limit: 10 } });
+        options: { instructions: 'Describe the image as tags.', suggestion_limit: 10 } });
+    // D205 (#431): each language-model engine reads its own drafted default; Built-in's text comes from the server.
+    assert.deepEqual(taggingPreset({ ...HOST, autotag_model_type: 'hf' }).options.instructions, 'Built-in tags.');
     assert.equal(draftProblem(HOST), null);
     assert.deepEqual(draftProblem({ ...HOST, autotag_general_threshold: 1.5 }),
         { key: 'autotag_general_threshold', message: 'General-tag confidence must be between 0 and 1.' });
@@ -319,15 +325,17 @@ test('Preview tagging review opens the Tag image dialog with the section’s val
     assert.equal(taggingPreset({ ...HOST, autotag_general_threshold: 0.1 + 0.2 }).options.general_threshold, 0.3);
     assert.equal(draftProblem({ ...HOST, autotag_suggestion_limit: 2.5 }).key, 'autotag_suggestion_limit');
     assert.equal(draftProblem({ ...HOST, autotag_suggestion_limit: 0 }, { limit: false }), null);
-    assert.deepEqual(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '  ' }),
-        { key: 'autotag_template', message: 'LLM tag template must be non-empty text.' });
-    assert.deepEqual(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: 'x'.repeat(4001) }),
-        { key: 'autotag_template', message: 'LLM tag template must be at most 4000 characters.' });
+    // #431: a saved entry the server would refuse holds back a language-model run, with the server's sentence.
+    const entries = list => ({ ...HOST, autotag_model_type: 'hf', autotag_instructions: list });
+    assert.deepEqual(draftProblem(entries([{ id: '0123456789ab', name: 'A', text: '  ' }])),
+        { key: 'autotag_instructions', message: 'Saved instructions: entry 1 text must be non-empty text.' });
+    assert.deepEqual(draftProblem(entries([{ id: '0123456789ab', name: 'A', text: 'x'.repeat(4001) }])),
+        { key: 'autotag_instructions', message: 'Saved instructions: entry 1 text must be at most 4000 characters.' });
     // Characters are code points, as Python's len counts them: 4000 emoji (8000 UTF-16 units) are allowed.
-    assert.equal(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '🏜'.repeat(4000) }), null);
-    assert.equal(draftProblem({ ...HOST, autotag_model_type: 'hf', autotag_template: '🏜'.repeat(4001) }).key, 'autotag_template');
-    // A WD14 run never reads the template, nor a language model the thresholds.
-    assert.equal(draftProblem({ ...HOST, autotag_template: '' }), null);
+    assert.equal(draftProblem(entries([{ id: '0123456789ab', name: 'A', text: '🏜'.repeat(4000) }])), null);
+    assert.equal(draftProblem(entries([{ id: '0123456789ab', name: 'A', text: '🏜'.repeat(4001) }])).key, 'autotag_instructions');
+    // A WD14 run never reads the instructions, nor a language model the thresholds.
+    assert.equal(draftProblem({ ...HOST, autotag_instructions: [{ id: '0123456789ab', name: '', text: '' }] }), null);
     assert.equal(draftProblem({ ...HOST, autotag_model_type: 'gguf', autotag_general_threshold: 7 }), null);
 
     const none = await mounted({ image: null });
@@ -372,9 +380,12 @@ test('the batch review grid, body and Cancel-only reasons (D134, #379, CUJ 4–5
         ['Settings', 'General 0.35 · Character 0.85 · up to 10 tags per image'], ['Backup', 'Create and verify before changes']]);
     const llm = { ...HOST, autotag_model_type: 'gguf' };
     assert.deepEqual(batchGrid({ ...PLAN, model: { type: 'gguf' }, backup: { policy: 'off' }, estimate_seconds: null,
-        estimate_device: null, suggestion_limit: 4 }, llm).slice(-3),
+        estimate_device: null, suggestion_limit: 4 }, llm).slice(-4),
     [['Time', 'Language-model engines take longer per image. Activity shows the time left once tagging starts.'],
-        ['Settings', 'Template of 27 characters · up to 4 tags per image'], ['Backup', 'No safety backup (the policy is off)']]);
+        ['Instructions', 'Describe'], ['Settings', 'Up to 4 tags per image'], ['Backup', 'No safety backup (the policy is off)']]);
+    // D205 (#431): HF shows its own default by name.
+    assert.deepEqual(batchGrid({ ...PLAN, model: { type: 'hf' } }, { ...llm, autotag_model_type: 'hf' }).find(([term]) => term === 'Instructions'),
+        ['Instructions', 'Built-in']);
     assert.equal(batchGrid({}, HOST)[2][1], '0');
     assert.equal(batchGrid({}, HOST)[6][1], 'General 0.35 · Character 0.85');
     assert.equal(existingLabel('odd'), 'odd');
@@ -382,7 +393,7 @@ test('the batch review grid, body and Cancel-only reasons (D134, #379, CUJ 4–5
         options: { general_threshold: 0.35, character_threshold: 0.85 } });
     // #369: a threshold a hair off the grid is sent snapped to it.
     assert.equal(batchBody({ ...HOST, autotag_character_threshold: 0.1 + 0.2 }).options.character_threshold, 0.3);
-    assert.deepEqual(batchBody(llm), { model_type: 'gguf', existing: 'skip', options: { instructions: HOST.autotag_template } });
+    assert.deepEqual(batchBody(llm), { model_type: 'gguf', existing: 'skip', options: { instructions: 'Describe the image as tags.' } });
     assert.equal(batchCloseNote(PLAN), null);
     assert.equal(batchCloseNote({ ...PLAN, review_required: true }), REPLACE_NOTE);
     assert.equal(REPLACE_NOTE, 'Replacing tags needs a review of each image. Use Preview tagging review, or choose Skip or Merge for a batch run.');

tests/test_api_annotation_suggest.py

@@ -73,6 +73,7 @@ class FakeTagger:
         self.calls = []
         self.read_paths = []
         self.read_bytes = []
+        self.skips = []
         self.download_model = MagicMock(side_effect=AssertionError("downloaded"))
         self.load_error = None
         self.block = None  # (entered, proceed) events
@@ -115,8 +116,10 @@ class FakeTagger:
         prompt=None,
         general_threshold=None,
         character_threshold=None,
+        skip=None,
     ):
         self.read_paths.append(image_path)
+        self.skips.append(skip)
         with open(image_path, "rb") as handle:
             self.read_bytes.append(handle.read())
         self.calls.append(
@@ -132,9 +135,11 @@ class FakeTagger:
             entered, proceed = self.block
             entered.set()
             proceed.wait(WAIT)
+        # As the engine does (#431): a skipped tag uses up no slot.
+        kept = [pair for pair in SCORED if skip is None or not skip.matches(pair[0])]
         if self.loaded.startswith("wd14"):
-            return list(SCORED[:limit])
-        return [(name, None) for name, _ in SCORED[:limit]]
+            return list(kept[:limit])
+        return [(name, None) for name, _ in kept[:limit]]
 
 
 class SuggestTestCase(AnnotationAPITestCase):

tests/test_api_annotations.py

@@ -1144,8 +1144,10 @@ class TestEnvelopes(AnnotationAPITestCase):
         self.assertEqual(
             sorted(await self.json_of(resp)),
             [
+                "default_instructions",  # #431 adds the saved instructions
                 "default_prompt",
                 "existing",  # #328 adds the saved batch policy and model
+                "instructions",
                 "loaded_model_type",
                 "model_loaded",
                 "model_type",

tests/test_api_autotag.py

@@ -129,8 +129,10 @@ class FakeAutotagService:
         prompt=None,
         general_threshold=None,
         character_threshold=None,
+        skip=None,
     ):
-        """The suggestion entry point (#379): the fixed tags, at most ``limit``."""
+        """The suggestion entry point (#379): the fixed tags, at most ``limit``,
+        without the ones ``skip`` hides (#431)."""
         self.suggest_calls += 1
         tags = self.generate_tags(
             image_path,
@@ -138,6 +140,7 @@ class FakeAutotagService:
             general_threshold=general_threshold,
             character_threshold=character_threshold,
         )
+        tags = [name for name in tags if skip is None or not skip.matches(name)]
         return [(name, None) for name in tags[:limit]]
 
 
@@ -1533,7 +1536,8 @@ class TestSavedTaggingDefaults(AutotagAPITestCase):
             "EXISTING",
             "GENERAL_THRESHOLD",
             "CHARACTER_THRESHOLD",
-            "TEMPLATE",
+            "INSTRUCTIONS",
+            "DEFAULT_INSTRUCTIONS",
             "SUGGESTION_LIMIT",
         ):
             self.addCleanup(setattr, AutotagConfig, attr, getattr(AutotagConfig, attr))
@@ -1554,7 +1558,11 @@ class TestSavedTaggingDefaults(AutotagAPITestCase):
         self.config.EXISTING = "replace_after_review"
         self.config.GENERAL_THRESHOLD = 0.4
         self.config.CHARACTER_THRESHOLD = 0.7
-        self.config.TEMPLATE = "Saved template"
+        # #431: the saved engine's default instructions.
+        self.config.INSTRUCTIONS = (
+            {"id": "0123456789ab", "name": "Saved", "text": "Saved template"},
+        )
+        self.config.DEFAULT_INSTRUCTIONS = {"gguf": "0123456789ab", "hf": "builtin"}
         self.config.SUGGESTION_LIMIT = 15
         data = await (await self.client.get("/prompt_manager/autotag/models")).json()
         self.assertEqual(
@@ -1578,6 +1586,27 @@ class TestSavedTaggingDefaults(AutotagAPITestCase):
                 "suggestion_limit": 15,
             },
         )
+        # Built-in first with every text, and each engine's default.
+        self.assertEqual(
+            data["instructions"],
+            [
+                {"id": "builtin", "name": "Built-in", "text": DEFAULT_TAG_TEMPLATE},
+                {"id": "0123456789ab", "name": "Saved", "text": "Saved template"},
+            ],
+        )
+        self.assertEqual(
+            data["default_instructions"], {"gguf": "0123456789ab", "hf": "builtin"}
+        )
+        # HF reads its own default; a WD14 engine reads GGUF's.
+        for model_type, prompt in (
+            ("hf", DEFAULT_TAG_TEMPLATE),
+            ("wd14-vit", "Saved template"),
+        ):
+            self.config.MODEL_TYPE = model_type
+            data = await (
+                await self.client.get("/prompt_manager/autotag/models")
+            ).json()
+            self.assertEqual(data["default_prompt"], prompt, model_type)
 
     async def test_single_without_thresholds_uses_saved_ones(self):
         image = self._make_image(self.output_dir)

tests/test_api_lora.py

@@ -840,6 +840,23 @@ class TestLoraScanRoute(LoraAPITestCase):
             ("error", error["message"], 0),
         )
 
+    async def test_unexpected_scan_error_is_generic_in_the_stream(self):
+        self._enable()
+        secret = str(self.tmp_root / "x.db")
+        err = RuntimeError(f"could not open {secret}")
+        with patch.object(self.api.db, "replace_category_prompts", side_effect=err):
+            with self.assertLogs("prompt_manager.api", level="ERROR") as logs:
+                resp = await self.client.request("POST", "/prompt_manager/lora/scan")
+                body = await resp.text()  # the stream ends inside the patch
+        self.assertNotIn("x.db", body)
+        error = self._sse_events(body)[-1]
+        self.assertEqual(
+            (error["type"], error["status"], error["progress"]),
+            ("error", error["message"], 0),
+        )
+        self.assertIn("server log", error["message"])
+        self.assertIn(secret, "\n".join(logs.output))
+
     @staticmethod
     def _sse_events(text):
         return [

tests/test_autotag_batch.py

@@ -54,6 +54,8 @@ class PerImageTagger(HookedTagger):
         names = self.by_bytes.get(self.read_bytes[-1])
         if names is None:
             return result
+        skip = kwargs.get("skip")  # as the engine does (#431)
+        names = [name for name in names if skip is None or not skip.matches(name)]
         return [(name, 0.9) for name in names][: kwargs["limit"]]
 
 

tests/test_autotag_legacy.py

@@ -158,7 +158,30 @@ class TestLegacyBatch(LegacyTestCase):
         self.image("b.png", (2, 2, 2))
         await self.relist()
         await self.legacy("model_type=gguf&prompt=%20")
-        self.assertEqual(self.tagger.calls[-1]["prompt"], AutotagConfig.TEMPLATE)
+        self.assertEqual(
+            self.tagger.calls[-1]["prompt"],
+            AutotagConfig.default_instructions_text("gguf"),
+        )
+        # #431: a blank prompt falls back to the request engine's own default.
+        saved = (AutotagConfig.INSTRUCTIONS, AutotagConfig.DEFAULT_INSTRUCTIONS)
+        self.addCleanup(
+            lambda: (
+                setattr(AutotagConfig, "INSTRUCTIONS", saved[0]),
+                setattr(AutotagConfig, "DEFAULT_INSTRUCTIONS", saved[1]),
+            )
+        )
+        AutotagConfig.INSTRUCTIONS = (
+            {"id": "0123456789ab", "name": "Photo", "text": "Photo tags."},
+        )
+        AutotagConfig.DEFAULT_INSTRUCTIONS = {"gguf": "builtin", "hf": "0123456789ab"}
+        for model_type, expected in (
+            ("hf", "Photo tags."),
+            ("gguf", AutotagConfig.default_instructions_text("gguf")),
+        ):
+            self.image(f"{model_type}.png", (3, 3, len(model_type)))
+            await self.relist()
+            await self.legacy(f"model_type={model_type}&prompt=%20&skip_tagged=false")
+            self.assertEqual(self.tagger.calls[-1]["prompt"], expected, model_type)
         self.assertEqual(self.tagger.custom_prompt, "legacy prompt")
 
     async def test_a_missing_backend_package_is_one_error_frame(self):

tests/test_config.py

@@ -442,8 +442,11 @@ class TestAutotagConfig(unittest.TestCase):
                 "EXISTING",
                 "GENERAL_THRESHOLD",
                 "CHARACTER_THRESHOLD",
-                "TEMPLATE",
                 "SUGGESTION_LIMIT",
+                "SKIPPED_TAGS",
+                "INSTRUCTIONS",
+                "DEFAULT_INSTRUCTIONS",
+                "_LEGACY_TEMPLATE",
             )
         }
 
@@ -487,16 +490,14 @@ class TestAutotagConfig(unittest.TestCase):
                     "general_threshold": 0.35,
                     "character_threshold": 0.85,
                     "suggestion_limit": 10,
+                    "skipped_tags": [],
+                    "instructions": [],
+                    "default_instructions": {"gguf": "builtin", "hf": "builtin"},
                 }
             },
         )
-        # The built-in template is not written; a saved one is.
-        self.config_class.TEMPLATE = "Saved."
-        self.assertEqual(
-            PromptManagerConfig.get_config()["autotag"]["defaults"]["template"],
-            "Saved.",
-        )
-        self.config_class.TEMPLATE = config_module.DEFAULT_TAG_TEMPLATE
+        # #431: the old template key is written only as the GGUF default's
+        # mirror (test_saved_instructions covers it).
         with tempfile.TemporaryDirectory() as tmpdir:
             path = os.path.join(tmpdir, "config.json")
             PromptManagerConfig.update_config(
@@ -524,16 +525,16 @@ class TestAutotagConfig(unittest.TestCase):
             "existing": "merge",
             "general_threshold": 0.4,
             "character_threshold": 0.7,
-            "template": "Tags only.",
             "suggestion_limit": 15,
+            "skipped_tags": ("blurry", "closed eyes"),
         }
         fallback = {
             "model_type": "wd14-swinv2",
             "existing": "skip",
             "general_threshold": 0.35,
             "character_threshold": 0.85,
-            "template": config_module.DEFAULT_TAG_TEMPLATE,
             "suggestion_limit": 10,
+            "skipped_tags": (),
         }
         bad_values = {
             "model_type": ["wd14-convnext", 3, None],
@@ -544,6 +545,8 @@ class TestAutotagConfig(unittest.TestCase):
             # 4000 characters are at most 16,000 UTF-8 bytes, so the 16 KiB
             # byte cap can only be met past the character cap.
             "template": ["", "   ", "x" * 4001, "\U0001f600" * 4097, "\ud800", 7],
+            # #431: the whole list falls back; entries are never dropped one by one.
+            "skipped_tags": ["blurry", ["a,b"], ["sky", "Sky"], [""], ["x"] * 201],
         }
         for key, values in bad_values.items():
             for value in values:
@@ -552,7 +555,7 @@ class TestAutotagConfig(unittest.TestCase):
                     with tempfile.TemporaryDirectory() as tmpdir:
                         path = os.path.join(tmpdir, "config.json")
                         with open(path, "w") as f:
-                            json.dump({"autotag": {"defaults": saved}}, f)
+                            json.dump({"autotag": {"defaults": saved}}, f, default=list)
                         with self.assertLogs(
                             "prompt_manager.config", level="WARNING"
                         ) as logs:
@@ -563,7 +566,32 @@ class TestAutotagConfig(unittest.TestCase):
                         k: getattr(self.config_class, attr)
                         for k, (attr, _v, _d) in self.config_class._KEYS.items()
                     }
-                    self.assertEqual(loaded, dict(good, **{key: fallback[key]}))
+                    # The old template is no attribute any more (#431): a bad
+                    # one is only warned about and imports nothing.
+                    expected = (
+                        dict(good, **{key: fallback[key]}) if key in fallback else good
+                    )
+                    self.assertEqual(loaded, expected)
+
+    def test_skipped_tags_load_trimmed_and_warn_once_when_damaged(self):
+        """#431: the list is kept as typed (trimmed); a damaged list is
+        replaced by no skipped tags with one warning naming the reason."""
+        PromptManagerConfig.update_config(
+            {"autotag": {"defaults": {"skipped_tags": [" blurry ", "(fate)"]}}}
+        )
+        self.assertEqual(self.config_class.SKIPPED_TAGS, ("blurry", "(fate)"))
+        with self.assertLogs("prompt_manager.config", level="WARNING") as logs:
+            PromptManagerConfig.update_config(
+                {"autotag": {"defaults": {"skipped_tags": ["sky", "a,b"]}}}
+            )
+        self.assertEqual(self.config_class.SKIPPED_TAGS, ())
+        self.assertEqual(
+            [record.getMessage() for record in logs.records],
+            [
+                "autotag.defaults.skipped_tags entry 2 must not contain a comma"
+                " or a line break; using no skipped tags"
+            ],
+        )
 
     def test_tagging_validators_moved_with_their_messages(self):
         validate_threshold = config_module.validate_threshold

tests/test_file_prompt.py

@@ -564,6 +564,66 @@ class TestUndecidedGraph(unittest.TestCase):
         self.assertEqual(decision.review, "untraced")
 
 
+def _search_list(text="fox", side="positive"):
+    """f22: a PromptSearchList batch (no PromptManager node) feeds CLIPTextEncode."""
+    graph = parity.build("f22")["prompt"]
+    graph["10"]["inputs"]["text"] = text
+    if side == "negative":
+        # The search feeds the negative; the positive is typed text.
+        graph["6"]["inputs"]["text"] = parity.POS
+        graph["7"]["inputs"]["text"] = ["10", 0]
+    return graph
+
+
+class TestSearchTextIsNeverAPrompt(unittest.TestCase):
+    """#548: the PromptSearchList query is a search, never the prompt."""
+
+    def test_the_search_text_is_never_linked_or_stored(self):
+        for policy in Policy:
+            with self.subTest(policy=policy):
+                decision = _decide(
+                    _graph(_search_list()), policy=policy, lookup=_Lookup()
+                )
+                self.assertEqual(decision.kind, "never")
+                self.assertIsNone(decision.text)
+                self.assertEqual(decision.unlinked_status, "unresolved")
+                self.assertTrue(decision.try_recorded_run)
+
+    def test_a_search_text_from_a_primitive_is_never_linked(self):
+        graph = _search_list()
+        graph["10"]["inputs"]["text"] = ["30", 0]
+        graph["30"] = {"class_type": "PrimitiveString", "inputs": {"value": "fox"}}
+        for policy in Policy:
+            with self.subTest(policy=policy):
+                decision = _decide(_graph(graph), policy=policy, lookup=_Lookup())
+                self.assertEqual(decision.kind, "never")
+                self.assertIsNone(decision.text)
+
+    def test_an_empty_search_text_is_unchanged(self):
+        """Regression guard (passes on the base): nothing to exclude."""
+        for policy in Policy:
+            with self.subTest(policy=policy):
+                decision = _decide(
+                    _graph(_search_list("")), policy=policy, lookup=_Lookup()
+                )
+                self.assertEqual((decision.kind, decision.text), ("never", None))
+
+    def test_without_a_sampler_any_search_list_query_is_excluded(self):
+        graph = _search_list()
+        del graph["3"]
+        self.assertTrue(file_prompt._search_text(graph, " fox "))
+        self.assertFalse(file_prompt._search_text(graph, "a fox"))
+        self.assertFalse(file_prompt._search_text(None, "fox"))
+
+    def test_a_search_on_the_negative_keeps_the_typed_positive(self):
+        """Regression guard (passes on the base): only the positive's source
+        is excluded, so the legacy answer from typed text still links."""
+        graph = _search_list(side="negative")
+        decision = _decide(_graph(graph), lookup=_Lookup())
+        self.assertEqual((decision.kind, decision.text), ("positive", parity.POS))
+        self.assertEqual(decision.source, "legacy-parser")
+
+
 class TestStepsWithoutAnUndecidedGraph(unittest.TestCase):
     def test_step_9_ambiguous_parameters_only(self):
         meta = {

tests/test_image_monitor_singleton.py

@@ -392,7 +392,10 @@ class TestStartStop(unittest.TestCase):
             self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs,
         ):
             self.assertFalse(self.monitor.stop_monitoring(timeout=5.0))
-        self.assertEqual(fake.calls[-1], ("join", 0.0))
+        # The stop runs on its own thread and gets 0 s too: it may not have
+        # returned yet, and then nothing is joined at all.
+        joins = [call for call in fake.calls if call[0] == "join"]
+        self.assertTrue(all(call == ("join", 0.0) for call in joins), fake.calls)
         self.assertIn(
             "watchdog observer still running after 0.0 s", "\n".join(logs.output)
         )
@@ -401,6 +404,80 @@ class TestStartStop(unittest.TestCase):
     def test_stop_monitoring_without_an_observer_returns_true(self):
         self.assertTrue(self.monitor.stop_monitoring())
 
+    def test_threads_the_observer_starts_are_daemons(self):
+        # watchdog 7 on Windows starts a plain threading.Thread per watch in
+        # observer.start(); a non-daemon one holds the interpreter's exit
+        # before any atexit callback runs (#561).
+        fake = ReaderObserver()
+        self.addCleanup(fake.release.set)
+        self._start_with(fake)
+        self.assertIsNotNone(fake.reader)
+        self.assertTrue(fake.reader.daemon)
+        self.assertFalse(threading.current_thread().daemon)
+
+    def test_an_observer_that_fails_to_start_on_its_thread_is_reported(self):
+        fake = FakeObserver()
+        fake.start = MagicMock(side_effect=OSError("handle refused"))
+        with self.assertLogs("prompt_manager.image_monitor", "ERROR") as logs:
+            with patch.object(im_mod, "Observer", return_value=fake):
+                self.monitor.start_monitoring([self.tmp.name])
+        self.assertIn("handle refused", "\n".join(logs.output))
+        self.assertFalse(self.monitor.is_monitoring)
+
+    def test_an_observer_stop_that_never_returns_is_bounded(self):
+        # watchdog's observer.stop() joins its emitters (and, in 7.x on
+        # Windows, their reader threads) without a limit (#561).
+        fake = StuckStopObserver()
+        self.addCleanup(fake.release.set)
+        self._start_with(fake)
+        with self.assertLogs("prompt_manager.image_monitor", "WARNING") as logs:
+            self.assertFalse(self.monitor.stop_monitoring(timeout=0.05))
+        self.assertIn("watchdog observer still running", "\n".join(logs.output))
+        self.assertTrue(fake.entered.wait(30))
+        self.assertFalse(self.monitor.is_monitoring)
+        # A second stop waits for the stop already running; it never calls
+        # observer.stop() a second time.
+        fake.release.set()
+        self.assertTrue(self.monitor.stop_monitoring())
+        self.assertEqual(fake.stop_calls, 1)
+        self.assertFalse(self.monitor._unfinished)
+
+
+class ReaderObserver(FakeObserver):
+    """A FakeObserver whose start() starts a plain thread, as watchdog 7's
+    Windows emitter does for its ReadDirectoryChangesW reader."""
+
+    def __init__(self):
+        super().__init__()
+        self.release = threading.Event()
+        self.reader = None
+
+    def start(self):
+        self.reader = threading.Thread(target=self.release.wait)
+        self.reader.start()
+        super().start()
+
+    def stop(self):
+        self.release.set()
+        self.reader.join(30)
+        super().stop()
+
+
+class StuckStopObserver(FakeObserver):
+    """A FakeObserver whose stop() does not return until ``release``."""
+
+    def __init__(self):
+        super().__init__()
+        self.entered = threading.Event()
+        self.release = threading.Event()
+        self.stop_calls = 0
+
+    def stop(self):
+        self.stop_calls += 1
+        self.entered.set()
+        self.release.wait(30)
+        super().stop()
+
 
 class FakeEvent:
     def __init__(self, path, is_directory=False):

tests/test_init_package.py

@@ -390,7 +390,16 @@ class TestConsoleBanner(unittest.TestCase):
 
         stream.flush()
         banner = stream.buffer.getvalue().decode("cp1252")
-        self.assertIn("Loaded:", banner)
+        lines = [
+            line
+            for line in banner.splitlines()
+            if "PromptManager" in line or "loaded" in line
+        ]
+        self.assertEqual(len(lines), 1, banner)
+        self.assertRegex(
+            lines[0], r"\[ComfyUI-PromptManager\] Version:.* \S+ - \d+ tools loaded$"
+        )
+        self.assertNotIn("Loaded:", banner)
 
 
 class PriorFileHandler(logging.FileHandler):
@@ -553,7 +562,7 @@ class TestPackageLoggerIsolation(unittest.TestCase):
         original_print = print
 
         def fail_banner(*args, **kwargs):
-            if any("Total:" in str(arg) for arg in args):
+            if any("tools loaded" in str(arg) for arg in args):
                 captured["package"] = sys.modules[name]
                 captured["handlers"] = [
                     h
@@ -587,13 +596,16 @@ PACKAGE_THREAD_NAMES = ("PromptManagerPromptCleanup", "PromptManagerImageWorker"
 
 def package_threads():
     """Live threads this design owns: the tracker, the image worker, and the
-    watchdog observer and emitters (which have no name of their own)."""
+    watchdog observer and emitters (which have no name of their own).
+    watchdog 7's InotifyFD, one daemon reader per process that no observer
+    stop ends, is not the package's."""
     from watchdog.utils import BaseThread
 
     return {
         thread
         for thread in threading.enumerate()
-        if thread.name in PACKAGE_THREAD_NAMES or isinstance(thread, BaseThread)
+        if thread.name in PACKAGE_THREAD_NAMES
+        or (isinstance(thread, BaseThread) and type(thread).__name__ != "InotifyFD")
     }
 
 

tests/test_legacy_parity_gate.py

@@ -108,6 +108,15 @@ LEGACY_WRONG = {
         "a cozy library with tall shelves",
         "legacy shows branch 1; the file name names branch 4's saver",
     ),
+    # #548, the one shape where nothing is read on purpose: legacy shows a
+    # PromptSearchList's search text ("fox") as the positive, but that is the
+    # library query, not the prompt the batch ran. The scan and the monitor
+    # never store or link it either (utils.file_prompt._search_text).
+    ("inspection_parity", "f22"): (
+        None,
+        "legacy shows the PromptSearchList search text; each item is decided "
+        "at run time, so no positive is read (#548)",
+    ),
 }
 
 
@@ -149,6 +158,24 @@ class LegacyParityGateTest(unittest.TestCase):
                 self.assertEqual(text, expected)
                 self.assertNotEqual(text, legacy)
 
+    def test_the_search_list_query_is_never_stored_either(self):
+        """#548: the scan and the monitor depart from legacy for f22 too."""
+        from utils.file_prompt import Policy, decide_file_prompt
+
+        graph, workflow = corpora()["inspection_parity"]["f22"]
+        self.assertEqual(legacy_positive(graph, workflow), "fox")
+        for policy in Policy:
+            with self.subTest(policy=policy):
+                decision = decide_file_prompt(
+                    {"prompt": graph, "workflow": workflow},
+                    file_name="f22.png",
+                    file_size=None,
+                    in_output=True,
+                    lookup=lambda: None,
+                    policy=policy,
+                )
+                self.assertEqual((decision.kind, decision.text), ("never", None))
+
     def test_no_graph_leaves_the_legacy_agreement(self):
         recorded = json.loads(AGREEMENT_PATH.read_text(encoding="utf-8"))
         current = {name: agreeing(graphs) for name, graphs in corpora().items()}

tests/test_package_exit.py

@@ -31,22 +31,65 @@ CHILD = textwrap.dedent("""
     import threading
 
     root, tmp = sys.argv[1], sys.argv[2]
+    stuck = sys.argv[3:] == ["stuck-observer"]
     sys.path.insert(0, root)
     state = {}
 
+    # watchdog 7's Windows observer at its worst (#561): start() starts a
+    # plain reader thread, and stop() waits for it, which never ends.
+    class StuckObserver:
+
+        def __init__(self, *args, **kwargs):
+            self._never = threading.Event()
+            self._reader = None
+
+        def schedule(self, *args, **kwargs):
+            pass
+
+        def start(self):
+            self._reader = threading.Thread(
+                target=self._never.wait, name="StuckReader"
+            )
+            self._reader.start()
+
+        def stop(self):
+            self._reader.join()
+
+        def join(self, timeout=None):
+            self._reader.join(timeout)
+
+        def is_alive(self):
+            return self._reader.is_alive()
+
+    if stuck:
+        import watchdog.observers
+
+        watchdog.observers.Observer = StuckObserver
+
     def report():
         from watchdog.utils import BaseThread
 
         package = state.get("package")
         result = getattr(package, "_background_work_result", None)
         # The image worker, the tracker, and watchdog's observer and emitters.
+        # watchdog 7's InotifyFD is one daemon reader per process that no
+        # observer stop ends, by design; it is not the package's.
         alive = sorted(
             t.name
             for t in threading.enumerate()
             if t.name in ("PromptManagerImageWorker", "PromptManagerPromptCleanup")
-            or isinstance(t, BaseThread)
+            or (isinstance(t, BaseThread) and type(t).__name__ != "InotifyFD")
+        )
+        # Threads that would hold the exit before any atexit callback (#561).
+        holding = sorted(
+            t.name
+            for t in threading.enumerate()
+            if not t.daemon and t is not threading.main_thread()
+        )
+        print(
+            "PM_EXIT_REPORT "
+            + json.dumps({"result": result, "alive": alive, "holding": holding})
         )
-        print("PM_EXIT_REPORT " + json.dumps({"result": result, "alive": alive}))
         sys.stdout.flush()
 
     # First registered, so it runs last: after the package's teardown and
@@ -64,6 +107,10 @@ CHILD = textwrap.dedent("""
             fake_server_module(queue_task_done=True),
         )
     state["package"] = package
+    if stuck:
+        # The stop gives up after this long instead of the full 5 s.
+        monitor_module = sys.modules[package.__name__ + ".utils.image_monitor"]
+        monitor_module.OBSERVER_JOIN_SECONDS = 0.5
     monitor = package._global_image_monitor
     handler = monitor.handler if monitor is not None else None
     if handler is None:
@@ -78,47 +125,52 @@ CHILD = textwrap.dedent("""
     """)
 
 
+def run_child(testcase, *args):
+    """Run CHILD with ``args``; returns (completed, report, detail)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        os.makedirs(os.path.join(tmp, "output"))
+        script = os.path.join(tmp, "child.py")
+        with open(script, "w", encoding="utf-8") as handle:
+            handle.write(CHILD)
+        env = dict(os.environ)
+        env.pop("PROMPT_MANAGER_CONFIG_PATH", None)
+        # The child's library and log file live in its own folder, never
+        # in the checkout's logs/ (which this runner may hold open) or a
+        # data folder the caller set.
+        env["PROMPT_MANAGER_DATA_DIR"] = tmp
+        env["PYTHONIOENCODING"] = "utf-8"
+        try:
+            completed = subprocess.run(
+                [sys.executable, script, ROOT, tmp, *args],
+                cwd=ROOT,
+                env=env,
+                capture_output=True,
+                timeout=CHILD_CEILING_SECONDS,
+                encoding="utf-8",
+                errors="replace",
+            )
+        except subprocess.TimeoutExpired as hung:
+            testcase.fail(
+                f"the child did not exit within {CHILD_CEILING_SECONDS} s\n"
+                f"stdout:\n{hung.stdout}\nstderr:\n{hung.stderr}"
+            )
+        # Leaving the block removes the folder: on Windows that fails
+        # if the child left a handle open, which it cannot once it exited,
+        # so the check here is that the child exited at all.
+    detail = f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
+    testcase.assertEqual(completed.returncode, 0, detail)
+    reports = [
+        line[len(REPORT_PREFIX) :]
+        for line in completed.stdout.splitlines()
+        if line.startswith(REPORT_PREFIX)
+    ]
+    testcase.assertEqual(len(reports), 1, detail)
+    return completed, json.loads(reports[0]), detail
+
+
 class TestPackageExit(unittest.TestCase):
     def test_teardown_runs_at_a_normal_exit_with_the_worker_alive(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            os.makedirs(os.path.join(tmp, "output"))
-            script = os.path.join(tmp, "child.py")
-            with open(script, "w", encoding="utf-8") as handle:
-                handle.write(CHILD)
-            env = dict(os.environ)
-            env.pop("PROMPT_MANAGER_CONFIG_PATH", None)
-            # The child's library and log file live in its own folder, never
-            # in the checkout's logs/ (which this runner may hold open) or a
-            # data folder the caller set.
-            env["PROMPT_MANAGER_DATA_DIR"] = tmp
-            env["PYTHONIOENCODING"] = "utf-8"
-            try:
-                completed = subprocess.run(
-                    [sys.executable, script, ROOT, tmp],
-                    cwd=ROOT,
-                    env=env,
-                    capture_output=True,
-                    timeout=CHILD_CEILING_SECONDS,
-                    encoding="utf-8",
-                    errors="replace",
-                )
-            except subprocess.TimeoutExpired as hung:
-                self.fail(
-                    f"the child did not exit within {CHILD_CEILING_SECONDS} s\n"
-                    f"stdout:\n{hung.stdout}\nstderr:\n{hung.stderr}"
-                )
-            # Leaving the block removes the folder: on Windows that fails
-            # if the child left a handle open, which it cannot once it exited,
-            # so the check here is that the child exited at all.
-        detail = f"stdout:\n{completed.stdout}\nstderr:\n{completed.stderr}"
-        self.assertEqual(completed.returncode, 0, detail)
-        reports = [
-            line[len(REPORT_PREFIX) :]
-            for line in completed.stdout.splitlines()
-            if line.startswith(REPORT_PREFIX)
-        ]
-        self.assertEqual(len(reports), 1, detail)
-        report = json.loads(reports[0])
+        completed, report, detail = run_child(self)
         # "thumbnails" is True here because no preview worker started; its
         # close result is tested in test_thumbnail_auto and test_init_package.
         self.assertEqual(
@@ -127,6 +179,7 @@ class TestPackageExit(unittest.TestCase):
             detail,
         )
         self.assertEqual(report["alive"], [], detail)
+        self.assertEqual(report["holding"], [], detail)
         # The teardown's own warnings. Import-time warnings (the API's
         # output-folder search finds no ComfyUI here) are not about exit.
         for text in (
@@ -137,6 +190,16 @@ class TestPackageExit(unittest.TestCase):
         ):
             self.assertNotIn(text, completed.stderr, detail)
 
-
-if __name__ == "__main__":
-    unittest.main()
+    def test_an_observer_that_never_stops_does_not_hold_the_exit(self):
+        # Before #561 the reader thread kept the interpreter waiting before
+        # any atexit callback ran, so the teardown never started.
+        completed, report, detail = run_child(self, "stuck-observer")
+        self.assertEqual(
+            report["result"],
+            {"monitor": False, "thumbnails": True, "tracker": True},
+            detail,
+        )
+        # The stuck reader is still alive, but as a daemon it holds nothing.
+        self.assertEqual(report["holding"], [], detail)
+        self.assertIn("watchdog observer still running", completed.stderr, detail)
+        self.assertIn("Background work not stopped in time", completed.stderr, detail)

tests/test_pair_scan.py

@@ -90,6 +90,18 @@ class TestPairScan(AdminAPITestCase):
         self.assertEqual(self.api.db.list_prompt_pairs()["total"], 0)
         self.assertEqual(self._texts(), [])
 
+    def test_a_prompt_search_list_query_is_never_stored_as_a_prompt(self):
+        # #548: the search text was stored and every batch image linked to it.
+        g = sampled_graph()
+        g["10"] = {
+            "class_type": "PromptSearchList",
+            "inputs": {"text": "fox", "category": "", "tags": "", "limit": 50},
+        }
+        g["1"]["inputs"]["text"] = ["10", 0]
+        self.assertEqual(self._scanned("search.png", g), "unresolved")
+        self.assertEqual(self._texts(), [])
+        self.assertEqual(self.api.db.list_prompt_pairs()["total"], 0)
+
     def test_numeric_widgets_are_never_stored_as_a_prompt(self):
         # The pre-redesign scan stored "2048" from a resolution widget here.
         g = {

tests/test_saved_instructions.py

@@ -0,0 +1,379 @@
+"""Saved instructions with a default per language-model engine (#431, PR 2).
+
+The entry and default validation, the in-memory migration of the old single
+``autotag.defaults.template`` at load (first upgrade and re-upgrade), the
+load fallbacks, and ``AutotagConfig.default_instructions_text``.
+"""
+
+import hashlib
+import json
+import os
+import sys
+import tempfile
+import unittest
+from unittest.mock import MagicMock
+
+# config.py imports ComfyUI's server module; stand it in (as test_config does).
+_mock_server = MagicMock()
+_mock_server.PromptServer.instance.routes = MagicMock()
+sys.modules.setdefault("server", _mock_server)
+
+from py.config import AutotagConfig, PromptManagerConfig  # noqa: E402
+from py.tagging_defaults import (  # noqa: E402
+    BUILTIN_INSTRUCTIONS_ID,
+    DEFAULT_TAG_TEMPLATE,
+    MAX_SAVED_INSTRUCTIONS,
+    validate_default_instructions,
+    validate_instructions,
+)
+
+ATTRS = ("MODEL_TYPE", "INSTRUCTIONS", "DEFAULT_INSTRUCTIONS", "_LEGACY_TEMPLATE")
+
+
+def entry(id_, name, text="Tags only."):
+    return {"id": id_, "name": name, "text": text}
+
+
+def sha12(text):
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]
+
+
+class TestValidation(unittest.TestCase):
+    def test_entries_are_kept_with_trimmed_names(self):
+        self.assertEqual(
+            validate_instructions([entry("0123456789ab", "  Photo ", "Tags.")]),
+            [entry("0123456789ab", "Photo", "Tags.")],
+        )
+        self.assertEqual(validate_instructions([]), [])
+
+    def test_every_refusal_sentence(self):
+        ok = entry("0123456789ab", "One")
+        cases = (
+            ("x", "Saved instructions must be a list."),
+            (
+                [
+                    entry(f"{i:012x}", f"n{i}")
+                    for i in range(MAX_SAVED_INSTRUCTIONS + 1)
+                ],
+                "Saved instructions: at most 20 entries besides Built-in.",
+            ),
+            ([ok, "x"], "Saved instructions: entry 2 has an invalid id."),
+            (
+                [entry("ABCDEF012345", "A")],
+                "Saved instructions: entry 1 has an invalid id.",
+            ),
+            ([entry("builtin", "A")], "Saved instructions: entry 1 has an invalid id."),
+            (
+                [{"id": "0123456789ab", "name": "A"}],
+                "Saved instructions: entry 1 has an invalid id.",
+            ),
+            (
+                [ok, entry("0123456789ab", "Two")],
+                "Saved instructions: entry 2 repeats the id of entry 1.",
+            ),
+            (
+                [entry("0123456789ab", "  ")],
+                "Saved instructions: entry 1 needs a name.",
+            ),
+            (
+                [entry("0123456789ab", "x" * 61)],
+                "Saved instructions: entry 1 name must be at most 60 characters.",
+            ),
+            (
+                [entry("0123456789ab", "a\nb")],
+                "Saved instructions: entry 1 name must not contain a line break.",
+            ),
+            (
+                [ok, entry("0123456789ac", "one")],
+                "Saved instructions: entry 2 name “one” is already used.",
+            ),
+            (
+                [entry("0123456789ab", "BUILT-IN")],
+                "Saved instructions: the name “Built-in” is reserved.",
+            ),
+            (
+                [entry("0123456789ab", "A", "  ")],
+                "Saved instructions: entry 1 text must be non-empty text.",
+            ),
+            (
+                [entry("0123456789ab", "A", "x" * 4001)],
+                "Saved instructions: entry 1 text must be at most 4000 characters.",
+            ),
+        )
+        for value, message in cases:
+            with self.subTest(message=message):
+                with self.assertRaises(ValueError) as caught:
+                    validate_instructions(value)
+                self.assertEqual(str(caught.exception), message)
+
+    def test_defaults_name_built_in_or_a_saved_entry(self):
+        saved = [entry("0123456789ab", "One")]
+        self.assertEqual(
+            validate_default_instructions(
+                {"gguf": "builtin", "hf": "0123456789ab"}, saved
+            ),
+            {"gguf": "builtin", "hf": "0123456789ab"},
+        )
+        for value, message in (
+            (
+                {"gguf": "ffffffffffff", "hf": "builtin"},
+                "Default for GGUF JoyCaption must be one of the saved instructions.",
+            ),
+            (
+                {"gguf": "builtin", "hf": "nope"},
+                "Default for HuggingFace JoyCaption must be one of the saved "
+                "instructions.",
+            ),
+            (
+                {"gguf": "builtin"},
+                "Default instructions must name GGUF and HuggingFace.",
+            ),
+            (
+                {"gguf": [], "hf": "builtin"},
+                "Default for GGUF JoyCaption must be one of the saved instructions.",
+            ),
+            ("builtin", "Default instructions must name GGUF and HuggingFace."),
+        ):
+            with self.subTest(value=value):
+                with self.assertRaises(ValueError) as caught:
+                    validate_default_instructions(value, saved)
+                self.assertEqual(str(caught.exception), message)
+
+
+class ConfigTestCase(unittest.TestCase):
+    def setUp(self):
+        saved = {attr: getattr(AutotagConfig, attr) for attr in ATTRS}
+        self.addCleanup(
+            lambda: [setattr(AutotagConfig, a, v) for a, v in saved.items()]
+        )
+        AutotagConfig.update_config({"defaults": {}})
+
+    def load(self, defaults, warnings=0):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = os.path.join(tmpdir, "config.json")
+            with open(path, "w", encoding="utf-8") as handle:
+                json.dump({"autotag": {"defaults": defaults}}, handle)
+            before = os.stat(path).st_mtime_ns, open(path, "rb").read()
+            if warnings:
+                with self.assertLogs("prompt_manager.config", level="WARNING") as logs:
+                    PromptManagerConfig.load_from_file(path)
+                self.assertEqual(len(logs.records), warnings, logs.output)
+                self.logs = [record.getMessage() for record in logs.records]
+            else:
+                PromptManagerConfig.load_from_file(path)
+            # Nothing is written at load.
+            self.assertEqual(
+                (os.stat(path).st_mtime_ns, open(path, "rb").read()), before
+            )
+
+    def state(self):
+        return [dict(e) for e in AutotagConfig.INSTRUCTIONS], dict(
+            AutotagConfig.DEFAULT_INSTRUCTIONS
+        )
+
+
+class TestLoad(ConfigTestCase):
+    def test_a_new_install_has_built_in_only_for_both_engines(self):
+        self.load({})
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+        self.assertEqual(
+            AutotagConfig.default_instructions_text("gguf"), DEFAULT_TAG_TEMPLATE
+        )
+        self.assertEqual(
+            AutotagConfig.all_instructions()[0],
+            {
+                "id": BUILTIN_INSTRUCTIONS_ID,
+                "name": "Built-in",
+                "text": DEFAULT_TAG_TEMPLATE,
+            },
+        )
+
+    def test_saved_entries_and_per_engine_defaults_load(self):
+        saved = [
+            entry("0123456789ab", "Photo", "Photo tags."),
+            entry("0123456789ac", "Anime", "Anime tags."),
+        ]
+        self.load(
+            {
+                "instructions": saved,
+                "default_instructions": {"gguf": "0123456789ac", "hf": "0123456789ab"},
+            }
+        )
+        self.assertEqual(
+            self.state(), (saved, {"gguf": "0123456789ac", "hf": "0123456789ab"})
+        )
+        self.assertEqual(AutotagConfig.default_instructions_text("gguf"), "Anime tags.")
+        self.assertEqual(AutotagConfig.default_instructions_text("hf"), "Photo tags.")
+        with self.assertRaises(ValueError):
+            AutotagConfig.default_instructions_text("wd14-vit")
+
+    def test_a_dangling_default_falls_back_to_built_in_with_a_warning(self):
+        saved = [entry("0123456789ab", "Photo")]
+        self.load(
+            {
+                "instructions": saved,
+                "default_instructions": {"gguf": "ffffffffffff", "hf": "0123456789ab"},
+            },
+            warnings=1,
+        )
+        self.assertEqual(
+            self.state(), (saved, {"gguf": "builtin", "hf": "0123456789ab"})
+        )
+        self.assertEqual(
+            self.logs,
+            [
+                "autotag.defaults.default_instructions.gguf names no saved "
+                "instructions; using Built-in"
+            ],
+        )
+
+    def test_a_damaged_list_falls_back_to_built_in_only_and_the_defaults_follow(self):
+        self.load(
+            {
+                "instructions": [
+                    entry("0123456789ab", "A"),
+                    entry("0123456789ab", "B"),
+                ],
+                "default_instructions": {"gguf": "0123456789ab", "hf": "builtin"},
+            },
+            warnings=1,  # one warning; the defaults follow the list silently
+        )
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+        self.assertEqual(
+            self.logs[0],
+            "autotag.defaults.instructions entry 2 repeats the id of entry 1; "
+            "using Built-in only",
+        )
+
+    def test_damaged_defaults_fall_back_with_a_warning(self):
+        self.load({"default_instructions": "builtin"}, warnings=1)
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+
+
+class TestMigration(ConfigTestCase):
+    CUSTOM = "My own tags, please."
+
+    def test_first_upgrade_makes_custom_template_the_default_for_both(self):
+        self.load({"template": self.CUSTOM})
+        self.assertEqual(
+            self.state(),
+            (
+                [entry(sha12(self.CUSTOM), "Custom template", self.CUSTOM)],
+                {"gguf": sha12(self.CUSTOM), "hf": sha12(self.CUSTOM)},
+            ),
+        )
+        # Deterministic: a second load gives the same ids.
+        first = self.state()
+        self.load({"template": self.CUSTOM})
+        self.assertEqual(self.state(), first)
+
+    def test_a_template_equal_to_built_in_creates_no_entry(self):
+        self.load({"template": DEFAULT_TAG_TEMPLATE})
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+
+    def test_an_invalid_template_is_ignored_with_todays_warning(self):
+        self.load({"template": "   "}, warnings=1)
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+        self.assertIn("autotag.defaults.template", self.logs[0])
+
+    def test_a_stored_default_is_never_overwritten_by_the_first_upgrade(self):
+        self.load(
+            {
+                "template": self.CUSTOM,
+                "default_instructions": {"gguf": "builtin", "hf": "builtin"},
+            },
+            warnings=0,
+        )
+        self.assertEqual(
+            self.state(),
+            (
+                [entry(sha12(self.CUSTOM), "Custom template", self.CUSTOM)],
+                {"gguf": "builtin", "hf": "builtin"},
+            ),
+        )
+
+    def test_the_mirror_of_a_saved_default_imports_nothing(self):
+        saved = [entry(sha12(self.CUSTOM), "Custom template", self.CUSTOM)]
+        both = {"gguf": sha12(self.CUSTOM), "hf": "builtin"}
+        self.load(
+            {
+                "template": self.CUSTOM,
+                "instructions": saved,
+                "default_instructions": both,
+            }
+        )
+        self.assertEqual(self.state(), (saved, both))
+
+    def test_re_upgrade_imports_an_edit_made_on_an_older_build(self):
+        saved = [entry(sha12(self.CUSTOM), "Custom template", "Edited since.")]
+        both = {"gguf": sha12(self.CUSTOM), "hf": "builtin"}
+        with self.assertLogs("prompt_manager.config", level="INFO") as logs:
+            self.load(
+                {
+                    "template": self.CUSTOM,
+                    "instructions": saved,
+                    "default_instructions": both,
+                }
+            )
+        instructions, defaults = self.state()
+        # The text's own hash is taken by the edited entry: the next free one.
+        imported = hashlib.sha256((self.CUSTOM + "\n2").encode()).hexdigest()[:12]
+        self.assertEqual(
+            instructions, saved + [entry(imported, "Custom template (2)", self.CUSTOM)]
+        )
+        self.assertEqual(defaults, both)
+        self.assertIn(
+            "Imported the tagging template edited on an older version as "
+            "'Custom template (2)'",
+            "\n".join(logs.output),
+        )
+
+    def test_re_upgrade_into_a_full_list_imports_nothing_and_warns(self):
+        saved = [entry(f"{i:012x}", f"n{i}") for i in range(MAX_SAVED_INSTRUCTIONS)]
+        self.load({"template": self.CUSTOM, "instructions": saved}, warnings=1)
+        self.assertEqual(self.state()[0], saved)
+        self.assertIn("full", self.logs[0])
+
+
+class TestGetConfig(ConfigTestCase):
+    def test_get_config_writes_the_lists_and_the_gguf_mirror(self):
+        AutotagConfig.INSTRUCTIONS = (entry("0123456789ab", "Photo", "Photo tags."),)
+        AutotagConfig.DEFAULT_INSTRUCTIONS = {"gguf": "0123456789ab", "hf": "builtin"}
+        defaults = AutotagConfig.get_config()["defaults"]
+        self.assertEqual(
+            defaults["instructions"], [entry("0123456789ab", "Photo", "Photo tags.")]
+        )
+        self.assertEqual(
+            defaults["default_instructions"], {"gguf": "0123456789ab", "hf": "builtin"}
+        )
+        self.assertEqual(defaults["template"], "Photo tags.")
+        AutotagConfig.DEFAULT_INSTRUCTIONS = {"gguf": "builtin", "hf": "0123456789ab"}
+        self.assertNotIn("template", AutotagConfig.get_config()["defaults"])
+
+
+class TestDamagedValues(ConfigTestCase):
+    def test_a_non_text_default_falls_back_with_a_warning(self):
+        self.load({"default_instructions": {"gguf": [], "hf": "builtin"}}, warnings=1)
+        self.assertEqual(self.state(), ([], {"gguf": "builtin", "hf": "builtin"}))
+
+    def test_a_damaged_list_warns_once_and_migrates_the_template_afresh(self):
+        custom = "My own tags, please."
+        self.load(
+            {
+                "template": custom,
+                "instructions": "broken",
+                "default_instructions": {"gguf": "0123456789ab", "hf": "builtin"},
+            },
+            warnings=1,
+        )
+        self.assertEqual(
+            self.state(),
+            (
+                [entry(sha12(custom), "Custom template", custom)],
+                {"gguf": sha12(custom), "hf": sha12(custom)},
+            ),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_saved_instructions_routes.py

@@ -0,0 +1,224 @@
+"""Saved instructions through POST /settings and the legacy fallbacks (#431).
+
+Server-side pairing (a save carrying either key writes both, the missing one
+from the running, migrated configuration), the downgrade mirror in the old
+``template`` key, the refusals, GET /settings, and the legacy single route's
+blank-prompt fallback per request engine. The "restart" is a reload of the
+isolated config.json (``PROMPT_MANAGER_CONFIG_PATH`` in the temp tree).
+"""
+
+import hashlib
+
+try:
+    from test_settings_sources import SourcesTestCase
+    from test_autotag_legacy import LegacyTestCase
+except ImportError:
+    from tests.test_settings_sources import SourcesTestCase
+    from tests.test_autotag_legacy import LegacyTestCase
+
+from py.config import AutotagConfig, PromptManagerConfig
+from py.tagging_defaults import DEFAULT_TAG_TEMPLATE
+
+ATTRS = ("MODEL_TYPE", "INSTRUCTIONS", "DEFAULT_INSTRUCTIONS", "_LEGACY_TEMPLATE")
+SETTINGS = "/prompt_manager/settings"
+CUSTOM = "My own tags, please."
+CUSTOM_ID = hashlib.sha256(CUSTOM.encode()).hexdigest()[:12]
+
+
+def entry(id_, name, text):
+    return {"id": id_, "name": name, "text": text}
+
+
+class InstructionsTestCase(SourcesTestCase):
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+        saved = {attr: getattr(AutotagConfig, attr) for attr in ATTRS}
+        self.addCleanup(
+            lambda: [setattr(AutotagConfig, a, v) for a, v in saved.items()]
+        )
+
+    def restart(self):
+        PromptManagerConfig.load_from_file(self.config_path)
+
+    async def save(self, payload, revision=True):
+        if revision:
+            payload = {"expected_revision": (await self._get())["revision"], **payload}
+        return await self._post(SETTINGS, payload)
+
+    def disk(self):
+        return self._read_config()["autotag"]["defaults"]
+
+
+class TestMigrationPersists(InstructionsTestCase):
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+        self._write_config(
+            {"custom": {"keep": True}, "autotag": {"defaults": {"template": CUSTOM}}}
+        )
+        self.restart()
+
+    async def test_get_shows_the_migrated_entry_and_writes_nothing(self):
+        before = self._config_bytes()
+        settings = (await self._get())["settings"]
+        self.assertEqual(
+            settings["autotag_instructions"],
+            [entry(CUSTOM_ID, "Custom template", CUSTOM)],
+        )
+        self.assertEqual(
+            settings["autotag_default_instructions"],
+            {"gguf": CUSTOM_ID, "hf": CUSTOM_ID},
+        )
+        self.assertEqual(settings["autotag_template"], CUSTOM)
+        self.assertEqual(settings["autotag_builtin_instructions"], DEFAULT_TAG_TEMPLATE)
+        self.assertEqual(self._config_bytes(), before)
+
+    async def test_a_save_of_only_the_hf_default_writes_the_migrated_list_too(self):
+        status, data = await self.save(
+            {"autotag_default_instructions": {"gguf": CUSTOM_ID, "hf": "builtin"}}
+        )
+        self.assertEqual(status, 200, data)
+        disk = self.disk()
+        self.assertEqual(
+            disk["instructions"], [entry(CUSTOM_ID, "Custom template", CUSTOM)]
+        )
+        self.assertEqual(
+            disk["default_instructions"], {"gguf": CUSTOM_ID, "hf": "builtin"}
+        )
+        self.assertEqual(disk["template"], CUSTOM)
+        self.assertEqual(self._read_config()["custom"], {"keep": True})
+        self.restart()
+        self.assertEqual(
+            (list(AutotagConfig.INSTRUCTIONS), AutotagConfig.DEFAULT_INSTRUCTIONS),
+            (
+                [entry(CUSTOM_ID, "Custom template", CUSTOM)],
+                {"gguf": CUSTOM_ID, "hf": "builtin"},
+            ),
+        )
+
+    async def test_gguf_built_in_deletes_the_mirror_and_keeps_custom_template(self):
+        status, data = await self.save(
+            {"autotag_default_instructions": {"gguf": "builtin", "hf": CUSTOM_ID}}
+        )
+        self.assertEqual(status, 200, data)
+        self.assertNotIn("template", self.disk())
+        self.restart()
+        self.assertEqual(
+            list(AutotagConfig.INSTRUCTIONS),
+            [entry(CUSTOM_ID, "Custom template", CUSTOM)],
+        )
+        self.assertEqual(
+            AutotagConfig.DEFAULT_INSTRUCTIONS, {"gguf": "builtin", "hf": CUSTOM_ID}
+        )
+        self.assertEqual(
+            AutotagConfig.default_instructions_text("gguf"), DEFAULT_TAG_TEMPLATE
+        )
+
+    async def test_a_save_of_only_the_list_keeps_the_defaults_that_still_exist(self):
+        photo = entry("0123456789ab", "Photo", "Photo tags.")
+        status, data = await self.save(
+            {
+                "autotag_instructions": [
+                    entry(CUSTOM_ID, "Custom template", CUSTOM),
+                    photo,
+                ]
+            }
+        )
+        self.assertEqual(status, 200, data)
+        self.assertEqual(
+            self.disk()["default_instructions"], {"gguf": CUSTOM_ID, "hf": CUSTOM_ID}
+        )
+        self.assertEqual(AutotagConfig.INSTRUCTIONS[1], photo)
+        # A list that drops a default without moving it is refused, nothing written.
+        before = self._config_bytes()
+        status, data = await self.save({"autotag_instructions": [photo]})
+        self.assertEqual(status, 400, data)
+        self.assertEqual(
+            data["error"],
+            "Default for GGUF JoyCaption must be one of the saved instructions.",
+        )
+        self.assertEqual(self._config_bytes(), before)
+
+
+class TestRefusals(InstructionsTestCase):
+    async def test_the_old_template_key_is_refused(self):
+        before = self._config_bytes()
+        status, data = await self.save({"autotag_template": "Tags only."})
+        self.assertEqual(
+            (status, data["error"]),
+            (
+                400,
+                "LLM tag template was replaced by Saved instructions. Reload the page.",
+            ),
+        )
+        self.assertEqual(self._config_bytes(), before)
+
+    async def test_instruction_keys_without_a_revision_are_refused(self):
+        for payload in (
+            {"autotag_instructions": []},
+            {"autotag_default_instructions": {"gguf": "builtin", "hf": "builtin"}},
+        ):
+            with self.subTest(payload=payload):
+                status, data = await self.save(payload, revision=False)
+                self.assertEqual(
+                    (status, data["error"]), (400, "Reload the page and try again.")
+                )
+
+    async def test_entry_refusals_name_the_entry(self):
+        status, data = await self.save(
+            {
+                "autotag_instructions": [
+                    entry("0123456789ab", "Photo", "Photo tags."),
+                    entry("0123456789ac", "photo", "x"),
+                ]
+            }
+        )
+        self.assertEqual(
+            (status, data["error"]),
+            (400, "Saved instructions: entry 2 name “photo” is already used."),
+        )
+
+    async def test_a_new_entry_can_become_a_default_in_one_save(self):
+        photo = entry("0123456789ab", "Photo", "Photo tags.")
+        status, data = await self.save(
+            {
+                "autotag_instructions": [photo],
+                "autotag_default_instructions": {
+                    "gguf": "0123456789ab",
+                    "hf": "builtin",
+                },
+            }
+        )
+        self.assertEqual(status, 200, data)
+        self.assertEqual(self.disk()["template"], "Photo tags.")
+        settings = (await self._get())["settings"]
+        self.assertEqual(settings["autotag_template"], "Photo tags.")
+        self.assertEqual(AutotagConfig.default_instructions_text("gguf"), "Photo tags.")
+        self.assertEqual(AutotagConfig._LEGACY_TEMPLATE, "Photo tags.")
+
+
+class TestLegacySingleFallback(LegacyTestCase):
+    async def test_a_blank_prompt_uses_the_request_engines_default(self):
+        saved = {attr: getattr(AutotagConfig, attr) for attr in ATTRS}
+        self.addCleanup(
+            lambda: [setattr(AutotagConfig, a, v) for a, v in saved.items()]
+        )
+        AutotagConfig.INSTRUCTIONS = (entry("0123456789ab", "Photo", "Photo tags."),)
+        AutotagConfig.DEFAULT_INSTRUCTIONS = {"gguf": "builtin", "hf": "0123456789ab"}
+        prompt = self.prompt("a prompt")
+        image = self.link(prompt, self.image("a.png", (1, 2, 3), sees=["bird"]))
+        for model_type, expected in (
+            ("hf", "Photo tags."),
+            ("gguf", DEFAULT_TAG_TEMPLATE),
+        ):
+            with self.subTest(model_type=model_type):
+                status, data = await self.single(
+                    {"image_id": image, "model_type": model_type, "prompt": " "}
+                )
+                self.assertEqual(status, 200, data)
+                self.assertEqual(self.tagger.calls[-1]["prompt"], expected)
+
+
+if __name__ == "__main__":
+    import unittest
+
+    unittest.main()

tests/test_settings_sources.py

@@ -1023,15 +1023,17 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
         "EXISTING",
         "GENERAL_THRESHOLD",
         "CHARACTER_THRESHOLD",
-        "TEMPLATE",
         "SUGGESTION_LIMIT",
+        "SKIPPED_TAGS",
+        "INSTRUCTIONS",
+        "DEFAULT_INSTRUCTIONS",
+        "_LEGACY_TEMPLATE",
     )
     SAVED = {
         "autotag_model_type": "gguf",
         "autotag_existing": "merge",
         "autotag_general_threshold": 0.4,
         "autotag_character_threshold": 0.8,
-        "autotag_template": "Tags only.",
         "autotag_suggestion_limit": 15,
     }
 
@@ -1067,8 +1069,11 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
                 "EXISTING": "merge",
                 "GENERAL_THRESHOLD": 0.4,
                 "CHARACTER_THRESHOLD": 0.8,
-                "TEMPLATE": "Tags only.",
                 "SUGGESTION_LIMIT": 15,
+                "SKIPPED_TAGS": (),
+                "INSTRUCTIONS": (),
+                "DEFAULT_INSTRUCTIONS": {"gguf": "builtin", "hf": "builtin"},
+                "_LEGACY_TEMPLATE": None,
             },
         )
         settings = (await self._get())["settings"]
@@ -1139,11 +1144,11 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
                 "replace",
                 "Existing tags must be skip, merge or replace_after_review.",
             ),
-            ("autotag_template", " ", "LLM tag template must be non-empty text."),
+            # #431: the old template is refused whatever it holds.
             (
                 "autotag_template",
-                "x" * 4001,
-                "LLM tag template must be at most 4000 characters.",
+                "Tags only.",
+                "LLM tag template was replaced by Saved instructions. Reload the page.",
             ),
             (
                 "autotag_suggestion_limit",
@@ -1166,3 +1171,64 @@ class TestAutotagDefaultsSettings(SourcesTestCase):
                 self.assertEqual(status, 400, data)
                 self.assertEqual(data["error"], message)
                 self.assertEqual((self._config_bytes(), self._runtime()), before)
+
+    async def test_skipped_tags_save_trimmed_and_read_back(self):
+        """#431: the list is saved as typed (trimmed), published at once and
+        read back by GET /settings."""
+        self._write_config({"custom": {"keep": True}})
+        settings = (await self._get())["settings"]
+        self.assertEqual(settings["autotag_skipped_tags"], [])
+        revision = (await self._get())["revision"]
+        status, data = await self._post(
+            "/prompt_manager/settings",
+            {
+                "expected_revision": revision,
+                "autotag_skipped_tags": [" blurry ", "closed eyes", "(fate)"],
+            },
+        )
+        self.assertEqual(status, 200, data)
+        saved = self._read_config()
+        self.assertEqual(
+            saved["autotag"]["defaults"],
+            {"skipped_tags": ["blurry", "closed eyes", "(fate)"]},
+        )
+        self.assertEqual(saved["custom"], {"keep": True})
+        self.assertEqual(self.autotag.SKIPPED_TAGS, ("blurry", "closed eyes", "(fate)"))
+        settings = (await self._get())["settings"]
+        self.assertEqual(
+            settings["autotag_skipped_tags"], ["blurry", "closed eyes", "(fate)"]
+        )
+
+    async def test_bad_skipped_tags_are_refused_with_their_sentence(self):
+        self._write_config({"custom": {"keep": True}})
+        revision = (await self._get())["revision"]
+        before = (self._config_bytes(), self._runtime())
+        for value, message in (
+            (["sky", "  "], "Skipped tags: entry 2 is empty."),
+            (["x" * 51], "Skipped tags: entry 1 must be at most 50 characters."),
+            (
+                ["a, b"],
+                "Skipped tags: entry 1 must not contain a comma or a line break.",
+            ),
+            (["blurry", "Blurry"], "Skipped tags: entry 2 repeats entry 1."),
+            ([f"w{i}" for i in range(201)], "Skipped tags: at most 200 entries."),
+        ):
+            with self.subTest(value=value[:3]):
+                status, data = await self._post(
+                    "/prompt_manager/settings",
+                    {"expected_revision": revision, "autotag_skipped_tags": value},
+                )
+                self.assertEqual(status, 400, data)
+                self.assertEqual(data["error"], message)
+                self.assertEqual((self._config_bytes(), self._runtime()), before)
+
+    async def test_skipped_tags_without_a_revision_are_refused(self):
+        """A list saved without expected_revision could merge a stale copy."""
+        self._write_config({"custom": {"keep": True}})
+        before = (self._config_bytes(), self._runtime())
+        status, data = await self._post(
+            "/prompt_manager/settings", {"autotag_skipped_tags": ["blurry"]}
+        )
+        self.assertEqual(status, 400, data)
+        self.assertEqual(data["error"], "Reload the page and try again.")
+        self.assertEqual((self._config_bytes(), self._runtime()), before)

tests/test_skipped_tags.py

@@ -0,0 +1,281 @@
+"""Skipped tags (#431): the words whose suggested tags are never offered.
+
+The normalizer, the entry validation, the whole-word matcher, the WD14 label
+reader and the filter in ``AutoTagService.generate_tag_suggestions``. No model
+is loaded: ``_scored_tags`` is replaced by a fixed list.
+"""
+
+import csv
+import os
+import tempfile
+import unicodedata
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from py.tagging_defaults import (
+    MAX_SKIPPED_TAG_CHARS,
+    MAX_SKIPPED_TAGS,
+    SkipMatcher,
+    tag_words,
+    validate_skipped_tags,
+    wd14_label_names,
+)
+
+# The design's matching table: (entry, tag, hidden).
+MATCHING = (
+    ("blurry", "blurry", True),
+    ("blurry", "blurry_background", True),
+    ("blurry", "very_blurry", True),
+    ("blurry", "slightly_blurry_background", True),
+    ("blurry", "unblurry", False),
+    ("blur", "blurry", False),
+    ("blurry background", "blurry_background", True),
+    ("blurry background", "Blurry-Background", True),
+    ("background blurry", "blurry_background", False),
+    ("shirt", "t-shirt", True),
+    ("shirt", "shirt_lift", True),
+    ("closed eyes", "half-closed_eyes", True),
+    ("girl", "1girl", False),
+    ("girl", "2girls", False),
+    ("girls", "multiple_girls", True),
+    ("fate", "saber_(fate)", False),
+    ("(fate)", "saber_(fate)", True),
+    ("saber", "saber_(fate)", True),
+    (":d", ":d", True),
+    ("café", unicodedata.normalize("NFD", "café"), True),
+)
+
+
+class TestWords(unittest.TestCase):
+    def test_words_split_only_on_space_underscore_and_hyphen(self):
+        self.assertEqual(tag_words("Half-closed_eyes"), ("half", "closed", "eyes"))
+        self.assertEqual(tag_words("saber_(fate)"), ("saber", "(fate)"))
+        self.assertEqual(tag_words("  a__b--c  d "), ("a", "b", "c", "d"))
+        self.assertEqual(tag_words("_-- _"), ())
+        self.assertEqual(tag_words(":d"), (":d",))
+
+    def test_words_are_nfc_and_case_folded(self):
+        self.assertEqual(
+            tag_words("CAFÉ"), tag_words(unicodedata.normalize("NFD", "café"))
+        )
+        self.assertEqual(tag_words("Straße"), ("strasse",))
+
+
+class TestMatcher(unittest.TestCase):
+    def test_every_row_of_the_matching_table(self):
+        for entry, tag, hidden in MATCHING:
+            with self.subTest(entry=entry, tag=tag):
+                self.assertIs(SkipMatcher([entry]).matches(tag), hidden)
+
+    def test_a_tag_without_words_never_matches(self):
+        matcher = SkipMatcher(["blurry"])
+        for tag in ("", "_", "- _"):
+            with self.subTest(tag=tag):
+                self.assertFalse(matcher.matches(tag))
+
+    def test_an_empty_matcher_hides_nothing_and_is_false(self):
+        self.assertFalse(SkipMatcher())
+        self.assertFalse(SkipMatcher([]).matches("blurry"))
+        self.assertTrue(SkipMatcher(["blurry"]))
+
+    def test_entries_of_different_lengths_are_all_checked(self):
+        matcher = SkipMatcher(["sky", "closed eyes", "very long entry here"])
+        self.assertTrue(matcher.matches("blue_sky"))
+        self.assertTrue(matcher.matches("half-closed_eyes"))
+        self.assertTrue(matcher.matches("a_very_long_entry_here_b"))
+        self.assertFalse(matcher.matches("very_long_entry"))
+
+    def test_counting_view_records_the_distinct_names_it_hid(self):
+        counting = SkipMatcher(["blurry"]).counting()
+        self.assertTrue(counting.matches("blurry"))
+        self.assertTrue(counting.matches("Blurry"))
+        self.assertTrue(counting.matches("blurry_background"))
+        self.assertFalse(counting.matches("sky"))
+        self.assertEqual(counting.hidden, {"blurry", "blurry_background"})
+
+
+class TestValidation(unittest.TestCase):
+    def test_entries_are_trimmed_and_kept_as_typed(self):
+        self.assertEqual(
+            validate_skipped_tags(["  Blurry ", "closed eyes", "(fate)"]),
+            ["Blurry", "closed eyes", "(fate)"],
+        )
+        self.assertEqual(validate_skipped_tags([]), [])
+
+    def test_caps_count_code_points_after_trimming(self):
+        self.assertEqual(
+            validate_skipped_tags([" " + "🏜" * MAX_SKIPPED_TAG_CHARS + " "]),
+            ["🏜" * MAX_SKIPPED_TAG_CHARS],
+        )
+        entries = [f"word{index}" for index in range(MAX_SKIPPED_TAGS)]
+        self.assertEqual(validate_skipped_tags(entries), entries)
+
+    def test_every_refusal_sentence(self):
+        cases = (
+            ("blurry", "Skipped tags must be a list of words."),
+            (
+                [f"w{index}" for index in range(MAX_SKIPPED_TAGS + 1)],
+                "Skipped tags: at most 200 entries.",
+            ),
+            (["ok", 3], "Skipped tags: entry 2 must be text."),
+            (["ok", "   "], "Skipped tags: entry 2 is empty."),
+            (["_ --"], "Skipped tags: entry 1 is empty."),
+            (["x" * 51], "Skipped tags: entry 1 must be at most 50 characters."),
+            (
+                ["a, b"],
+                "Skipped tags: entry 1 must not contain a comma or a line break.",
+            ),
+            (
+                ["a\nb"],
+                "Skipped tags: entry 1 must not contain a comma or a line break.",
+            ),
+            (
+                ["a\x7fb"],
+                "Skipped tags: entry 1 must not contain a comma or a line break.",
+            ),
+            (
+                ["blurry", "sky", "Blurry"],
+                "Skipped tags: entry 3 repeats entry 1.",
+            ),
+            (
+                ["blurry background", "blurry-Background"],
+                "Skipped tags: entry 2 repeats entry 1.",
+            ),
+        )
+        for value, message in cases:
+            with self.subTest(value=value):
+                with self.assertRaises(ValueError) as caught:
+                    validate_skipped_tags(value)
+                self.assertEqual(str(caught.exception), message)
+
+
+class TestWd14Labels(unittest.TestCase):
+    def setUp(self):
+        directory = tempfile.TemporaryDirectory()
+        self.addCleanup(directory.cleanup)
+        self.path = Path(directory.name) / "selected_tags.csv"
+
+    def write(self, rows):
+        lines = ["tag_id,name,category,count"]
+        lines += [f"{i},{name},{category},1" for i, (name, category) in enumerate(rows)]
+        self.path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    def test_only_general_and_character_names_are_read(self):
+        self.write(
+            [
+                ("blurry", "0"),
+                ("general", "9"),
+                ("saber_(fate)", "4"),
+                ("artist", "1"),
+                ("café", "0"),
+            ]
+        )
+        self.assertEqual(
+            wd14_label_names(self.path), ("blurry", "saber_(fate)", "café")
+        )
+
+    def test_the_list_is_read_again_only_when_the_file_changes(self):
+        self.write([("blurry", "0")])
+        with patch(
+            "py.tagging_defaults.read_wd14_label_rows",
+            wraps=__import__(
+                "py.tagging_defaults", fromlist=["x"]
+            ).read_wd14_label_rows,
+        ) as reader:
+            self.assertEqual(wd14_label_names(self.path), ("blurry",))
+            self.assertEqual(wd14_label_names(self.path), ("blurry",))
+            self.assertEqual(reader.call_count, 1)
+            self.write([("blurry", "0"), ("sky", "0")])
+            os.utime(self.path, ns=(1, 2))
+            self.assertEqual(wd14_label_names(self.path), ("blurry", "sky"))
+            self.assertEqual(reader.call_count, 2)
+
+    def test_a_damaged_list_is_a_value_error_for_the_caller_to_skip(self):
+        # A field over the csv module's size limit raises csv.Error.
+        big = "x" * (csv.field_size_limit() + 1)
+        self.path.write_text(
+            f"tag_id,name,category,count\n1,{big},0,1\n", encoding="utf-8"
+        )
+        with self.assertRaises(ValueError):
+            wd14_label_names(self.path)
+
+    def test_a_missing_list_raises_for_the_caller_to_skip(self):
+        with self.assertRaises(OSError):
+            wd14_label_names(self.path)
+
+
+class FilterService:
+    """``AutoTagService`` with a fixed model output instead of a model."""
+
+    def __init__(self, scored):
+        from py.autotag import AutoTagService
+
+        self.service = AutoTagService.__new__(AutoTagService)
+        self.service._scored_tags = lambda *args, **kwargs: list(scored)
+
+    def suggest(self, limit, skip=None):
+        return self.service.generate_tag_suggestions(
+            "image.png", limit=limit, skip=skip
+        )
+
+
+class TestFilter(unittest.TestCase):
+    def test_skipped_tags_do_not_use_up_slots(self):
+        """WD14: the next-best tags above the thresholds fill the limit."""
+        scored = [
+            ("blurry", 0.99),
+            ("sky", 0.9),
+            ("blurry_background", 0.8),
+            ("cloud", 0.7),
+            ("sun", 0.6),
+            ("sea", 0.5),
+        ]
+        service = FilterService(scored)
+        self.assertEqual(
+            service.suggest(3, SkipMatcher(["blurry"])),
+            [("sky", 0.9), ("cloud", 0.7), ("sun", 0.6)],
+        )
+        self.assertEqual(service.suggest(3), scored[:3])
+
+    def test_a_language_model_may_return_fewer_than_the_limit(self):
+        service = FilterService([("blurry", None), ("sky", None), ("signature", None)])
+        self.assertEqual(
+            service.suggest(10, SkipMatcher(["blurry", "signature"])), [("sky", None)]
+        )
+
+    def test_order_is_invalid_name_then_skip_then_dedupe_then_limit(self):
+        hidden = []
+
+        class Recording:
+            def matches(self, name):
+                hidden.append(name)
+                return name.startswith("skip")
+
+        service = FilterService(
+            [
+                ("bad,name", None),
+                ("  Sky ", None),
+                ("skip_me", None),
+                ("sky", None),
+                ("cloud", None),
+                ("sun", None),
+            ]
+        )
+        self.assertEqual(
+            service.suggest(2, Recording()), [("Sky", None), ("cloud", None)]
+        )
+        # The refused name never reaches the matcher; trimmed names do; the
+        # duplicate is checked after the skip; nothing after the limit.
+        self.assertEqual(hidden, ["Sky", "skip_me", "sky", "cloud"])
+
+    def test_the_counting_view_reports_hidden_names(self):
+        counting = SkipMatcher(["blurry"]).counting()
+        FilterService([("blurry", 0.9), ("sky", 0.8), ("Blurry", 0.7)]).suggest(
+            5, counting
+        )
+        self.assertEqual(counting.hidden, {"blurry"})
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_skipped_tags_routes.py

@@ -0,0 +1,280 @@
+"""Skipped tags on every suggestion path, and their preview (#431).
+
+Tag image (``/image-annotations/suggest``), Auto-tag selected (the
+``image-tags`` job), the System batch (the ``autotag`` job), the legacy
+``/autotag/start`` and ``/autotag/single`` all hide a suggested tag whose
+words contain a skipped entry; a job runs with the list it started with.
+``POST /autotag/skipped-tags/preview`` counts what a list would hide among
+the library's tags and the downloaded WD14 label lists, writing nothing.
+"""
+
+import tempfile
+from pathlib import Path
+
+try:
+    from test_autotag_legacy import LegacyTestCase
+except ImportError:
+    from tests.test_autotag_legacy import LegacyTestCase
+
+from py.config import AutotagConfig
+
+PREVIEW = "/prompt_manager/autotag/skipped-tags/preview"
+
+
+class SkippedTestCase(LegacyTestCase):
+    async def get_application(self):
+        app = await super().get_application()
+        self.addCleanup(
+            setattr, AutotagConfig, "SKIPPED_TAGS", AutotagConfig.SKIPPED_TAGS
+        )
+        AutotagConfig.SKIPPED_TAGS = ()
+        return app
+
+    def job_lines(self, job):
+        return [line.split(" ", 1)[1] for line in job.log]
+
+
+class TestEveryPathHidesSkippedTags(SkippedTestCase):
+    async def test_tag_image_suggestions_omit_skipped_tags_and_count_them(self):
+        AutotagConfig.SKIPPED_TAGS = ("sandstone", "tag 001")
+        observed = await self.observed()
+
+        body = await self.suggest_ok(self.suggest_body(observed))
+
+        names = [row["name"] for row in body["suggestions"]]
+        self.assertNotIn("sandstone", names)
+        self.assertNotIn("tag_001", names)
+        # Skipped tags use up no slot: the next ones fill the limit.
+        self.assertEqual(len(names), 10)
+        self.assertEqual(names[:3], ["desert", "tag_000", "tag_002"])
+        self.assertEqual(body["skipped"], 2)
+
+    async def test_tag_image_without_skipped_tags_reports_zero(self):
+        observed = await self.observed()
+        body = await self.suggest_ok(self.suggest_body(observed))
+        self.assertEqual(body["suggestions"][0]["name"], "sandstone")
+        self.assertEqual(body["skipped"], 0)
+
+    async def test_auto_tag_selected_runs_with_the_list_of_its_start(self):
+        self.png("a.png")
+        self.png("b.png", color=(1, 2, 3))
+        AutotagConfig.SKIPPED_TAGS = ("desert",)
+
+        def save_mid_run(_path):
+            # A save while the job runs does not change that job.
+            AutotagConfig.SKIPPED_TAGS = ("sandstone",)
+
+        self.tagger.on_generate = save_mid_run
+        options = {
+            "general_threshold": 0.35,
+            "character_threshold": 0.85,
+            "suggestion_limit": 2,
+        }
+
+        job = await self.run_job(self.auto_body(["a.png", "b.png"], options=options))
+
+        self.assertEqual(job.state, "finished")
+        self.assertEqual(self.stored("a.png")["tags"], ["sandstone", "tag_000"])
+        self.assertEqual(self.stored("b.png")["tags"], ["sandstone", "tag_000"])
+        self.assertIn("Skipped tags: 1 entry", self.job_lines(job))
+
+    async def test_the_system_batch_hides_skipped_tags_and_logs_the_list(self):
+        self.image("a.png", (1, 2, 3), sees=["bird", "blurry_background", "sky"])
+        AutotagConfig.SKIPPED_TAGS = ("blurry", "watermark")
+
+        job = await self.run_batch(existing="merge")
+
+        self.assertEqual(self.stored("a.png")["tags"], ["bird", "sky"])
+        self.assertIn("Skipped tags: 2 entries", self.job_lines(job))
+
+        AutotagConfig.SKIPPED_TAGS = ()
+        self.image("b.png", (4, 5, 6), sees=["blurry"])
+        await self.relist()
+        job = await self.run_batch(existing="merge")
+        self.assertEqual(self.stored("b.png")["tags"], ["blurry"])
+        self.assertIn("Skipped tags: none", self.job_lines(job))
+
+    async def test_the_legacy_batch_hides_skipped_tags(self):
+        self.image("a.png", (1, 2, 3), sees=["bird", "signature"])
+        AutotagConfig.SKIPPED_TAGS = ("signature",)
+
+        response, frames = await self.legacy()
+
+        self.assertEqual(response.status, 200)
+        self.assertEqual(frames[-1]["type"], "complete", frames[-1])
+        self.assertEqual(self.stored("a.png")["tags"], ["bird"])
+
+    async def test_the_legacy_single_review_hides_skipped_tags(self):
+        prompt = self.prompt("a prompt")
+        image = self.link(
+            prompt, self.image("a.png", (1, 2, 3), sees=["bird", "t-shirt"])
+        )
+        AutotagConfig.SKIPPED_TAGS = ("shirt",)
+
+        status, data = await self.single({"image_id": image, "model_type": "wd14-vit"})
+
+        self.assertEqual(status, 200, data)
+        self.assertEqual(data["tags"], ["bird"])
+
+    async def test_hand_typed_and_stored_tags_are_never_filtered(self):
+        path = self.image("a.png", (1, 2, 3), sees=["bird"])
+        self.saved_set("a.png", path.read_bytes(), ["blurry_hand_tag"])
+        AutotagConfig.SKIPPED_TAGS = ("blurry",)
+
+        await self.run_batch(existing="merge")
+        job = await self.run_job(self.add_body(["a.png"], ["blurry"]))
+
+        self.assertEqual(job.state, "finished")
+        self.assertEqual(
+            self.stored("a.png")["tags"], ["blurry_hand_tag", "bird", "blurry"]
+        )
+
+
+def write_labels(directory, subdir, rows):
+    path = Path(directory) / subdir / "selected_tags.csv"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["tag_id,name,category,count"]
+    lines += [f"{i},{name},{category},1" for i, (name, category) in enumerate(rows)]
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+class TestPreview(SkippedTestCase):
+    async def asyncSetUp(self):
+        await super().asyncSetUp()
+        models = tempfile.TemporaryDirectory()
+        self.addCleanup(models.cleanup)
+        self.models_dir = Path(models.name)
+        self.tagger.models_dir = self.models_dir
+        for name in ("Blurry", "portrait", "my_signature_style"):
+            self.prompt(f"prompt with {name}", tags=[name])
+
+    async def preview(self, entries):
+        response = await self.client.post(PREVIEW, json={"entries": entries})
+        return response.status, await self.json_of(response)
+
+    async def test_library_tags_only_when_no_label_list_is_downloaded(self):
+        status, data = await self.preview(["blurry", "signature", "watermark"])
+
+        self.assertEqual(status, 200, data)
+        self.assertEqual(
+            data,
+            {
+                "success": True,
+                "count": 2,
+                "sample": ["Blurry", "my_signature_style"],
+                "sample_limit": 12,
+                "per_entry": [
+                    {"entry": "blurry", "count": 1},
+                    {"entry": "signature", "count": 1},
+                    {"entry": "watermark", "count": 0},
+                ],
+                "sources": {"library": 3, "wd14": []},
+            },
+        )
+
+    async def test_both_label_lists_join_the_library_tags(self):
+        write_labels(
+            self.models_dir,
+            "WD14-SwinV2",
+            [
+                ("blurry", "0"),
+                ("blurry_background", "0"),
+                ("watermark", "0"),
+                ("general", "9"),
+                ("saber_(fate)", "4"),
+            ],
+        )
+        write_labels(
+            self.models_dir,
+            "WD14-ViT",
+            [
+                ("blurry_foreground", "0"),
+                ("watermark", "0"),
+                ("fate_(series)", "3"),
+            ],
+        )
+
+        status, data = await self.preview(["blurry", "watermark", "(fate)", "general"])
+
+        self.assertEqual(status, 200, data)
+        # Library spellings first (case-folded duplicates are one tag), then the
+        # label lists' names, each part sorted case-folded; rating and copyright
+        # rows are never suggested, so never counted.
+        self.assertEqual(
+            data["sample"],
+            [
+                "Blurry",
+                "blurry_background",
+                "blurry_foreground",
+                "saber_(fate)",
+                "watermark",
+            ],
+        )
+        self.assertEqual(data["count"], 5)
+        self.assertEqual(
+            data["per_entry"],
+            [
+                {"entry": "blurry", "count": 3},
+                {"entry": "watermark", "count": 1},
+                {"entry": "(fate)", "count": 1},
+                {"entry": "general", "count": 0},
+            ],
+        )
+        self.assertEqual(
+            data["sources"], {"library": 3, "wd14": ["WD14 SwinV2", "WD14 ViT"]}
+        )
+
+    async def test_the_sample_holds_at_most_twelve(self):
+        write_labels(
+            self.models_dir,
+            "WD14-SwinV2",
+            [(f"sky_{index:02d}", "0") for index in range(20)],
+        )
+        status, data = await self.preview(["sky"])
+        self.assertEqual(status, 200, data)
+        self.assertEqual(data["count"], 20)
+        self.assertEqual(data["sample"], [f"sky_{index:02d}" for index in range(12)])
+
+    async def test_a_bad_list_is_refused_with_the_save_sentence(self):
+        for body, message in (
+            ({"entries": ["sky", "Sky"]}, "Skipped tags: entry 2 repeats entry 1."),
+            (
+                {"entries": ["a,b"]},
+                "Skipped tags: entry 1 must not contain a comma or a line break.",
+            ),
+            ({"entries": "sky"}, "Skipped tags must be a list of words."),
+        ):
+            with self.subTest(body=body):
+                response = await self.client.post(PREVIEW, json=body)
+                self.assertEqual(response.status, 400)
+                self.assertEqual((await response.json())["error"], message)
+        response = await self.client.post(PREVIEW, json={"entries": [], "x": 1})
+        self.assertEqual(response.status, 400)
+
+    async def test_preview_loads_no_model_opens_no_image_and_writes_nothing(self):
+        write_labels(self.models_dir, "WD14-SwinV2", [("blurry", "0")])
+        self.image("a.png", (1, 2, 3))
+        before = self.prompt_rows()
+
+        status, data = await self.preview(["blurry"])
+
+        self.assertEqual(status, 200, data)
+        self.assertEqual(self.tagger.load_calls, [])
+        self.assertEqual(self.tagger.read_paths, [])
+        self.assertEqual(self.prompt_rows(), before)
+        self.assertEqual(self.api._jobs.list(), [])
+
+    async def test_preview_is_busy_while_an_exclusive_job_runs(self):
+        async with self.api._jobs.hold(
+            "restore", "Restore library", admission="exclusive"
+        ):
+            status, data = await self.preview(["blurry"])
+        self.assertEqual(status, 409, data)
+        self.assertEqual(data["code"], "busy")
+        self.assertEqual(data["running"]["title"], "Restore library")
+
+
+if __name__ == "__main__":
+    import unittest
+
+    unittest.main()

tests/trash_route_audit.py

@@ -164,6 +164,7 @@ ROUTE_AUDIT = {
         "PATCH /prompt_manager/saved-views/{view_id}",
         "PATCH /prompt_manager/vocabulary/tags/{tag_id}",
         "POST /prompt_manager/autotag/download/{model_type}",
+        "POST /prompt_manager/autotag/skipped-tags/preview",
         "POST /prompt_manager/autotag/unload",
         "POST /prompt_manager/bulk/category",
         "POST /prompt_manager/bulk/delete",

tests/vendor/ci-workflow.test.mjs

@@ -129,11 +129,11 @@ test('Firefox/WebKit page workflows run only outside pull requests; coverage run
     }
 });
 
-test('coverage runs as three shards that each upload their raw coverage', () => {
+test('coverage runs as four shards that each upload their raw coverage', () => {
     const coverage = allJobs.get('frontend-coverage');
-    assert.deepEqual(matrixList(coverage, 'shard'), ['1', '2', '3']);
-    assert.match(coverage, /^ {4}name: frontend coverage \(shard \$\{\{ matrix\.shard \}\}\/3\)$/m);
-    assert.match(coverage, /npm run --prefix tools\/vendor test:coverage:shard -- \$\{\{ matrix\.shard \}\}\/3/);
+    assert.deepEqual(matrixList(coverage, 'shard'), ['1', '2', '3', '4']);
+    assert.match(coverage, /^ {4}name: frontend coverage \(shard \$\{\{ matrix\.shard \}\}\/4\)$/m);
+    assert.match(coverage, /npm run --prefix tools\/vendor test:coverage:shard -- \$\{\{ matrix\.shard \}\}\/4/);
     const upload = steps(coverage).find(step => /name: coverage-raw-\$\{\{ matrix\.shard \}\}/.test(step));
     assert.ok(upload, 'each shard uploads coverage-raw-N');
     assert.match(upload, /^ {10}path: coverage\/js\/raw\/?$/m);
@@ -331,7 +331,7 @@ const testJobs = () => jobs(readWorkflow('test.yml'));
 
 test('the Python matrix is Linux 3.12 on a pull request and Linux 3.12-3.14 on every other event', () => {
     const body = testJobs().get('test');
-    assert.deepEqual(matrixList(body, 'os'), ['ubuntu-latest'], 'Windows and macOS never gate a merge');
+    assert.deepEqual(matrixList(body, 'os'), ['ubuntu-latest'], 'Windows never gates a merge');
     const match = /^ {8}python-version: \$\{\{ github\.event_name == 'pull_request' && fromJSON\('(\[[^\]]*\])'\) \|\| fromJSON\('(\[[^\]]*\])'\) \}\}$/m.exec(body);
     assert.ok(match, 'python-version is chosen by event');
     assert.deepEqual({ pr: JSON.parse(match[1]), other: JSON.parse(match[2]) }, { pr: ['3.12'], other: ['3.12', '3.13', '3.14'] });
@@ -339,34 +339,21 @@ test('the Python matrix is Linux 3.12 on a pull request and Linux 3.12-3.14 on e
     assert.match(body, /^ {4}name: py\$\{\{ matrix\.python-version \}\} on \$\{\{ matrix\.os \}\}$/m);
 });
 
-test('Windows and macOS run 3.12-3.14 on main, nightly and on demand, never on a PR or in the queue', () => {
+test('Windows runs 3.12-3.14 on main, nightly and on demand, never on a PR or in the queue', () => {
     const text = readWorkflow('portability.yml');
     const triggers = text.slice(text.indexOf('\non:'), text.indexOf('\nconcurrency:'));
     for (const event of ['push', 'schedule', 'workflow_dispatch']) assert.match(triggers, new RegExp(`^ {2}${event}:`, 'm'));
     for (const event of ['pull_request', 'merge_group']) assert.doesNotMatch(triggers, new RegExp(`^ {2}${event}`, 'm'));
     assert.match(triggers, /^ {4}branches: \[main\]$/m, 'push runs only for main');
     const body = jobs(text).get('test');
-    assert.deepEqual(matrixList(body, 'os'), ['windows-latest', 'macos-latest']);
+    assert.deepEqual(matrixList(body, 'os'), ['windows-latest'], 'macOS is not tested in CI (#571)');
+    assert.doesNotMatch(text, /macos-/, 'no macOS runner is used');
     assert.deepEqual(matrixList(body, 'python-version'), ['"3.12"', '"3.13"', '"3.14"']);
     assert.match(body, /^ {6}fail-fast: false$/m);
     assert.match(body, /^ {8}run: python -m tests\.run_suite -v$/m);
     assert.doesNotMatch(text, /cancel-in-progress: true|cancel-in-progress: \$/, 'no portability run is cancelled');
 });
 
-// #499: the native trash proof runs on both macOS CPUs, apart from the suite so a red suite never skips it.
-test('portability runs the native trash proof on arm64 and Intel macOS', () => {
-    const body = jobs(readWorkflow('portability.yml')).get('native-trash');
-    assert.ok(body, 'portability.yml has a native-trash job');
-    assert.deepEqual(matrixList(body, 'os'), ['macos-latest', 'macos-15-intel']);
-    assert.match(body, /^ {6}fail-fast: false$/m);
-    assert.doesNotMatch(body, /^ {4}needs:/m, 'it does not wait for the suite job');
-    assert.match(body, /^ {10}PM_NATIVE_TRASH: macos$/m);
-    assert.match(body, /^ {8}run: python -m unittest tests\.test_trash_macos_native tests\.test_trash_macos -v$/m);
-    const jobMinutes = Number(/^ {4}timeout-minutes: (\d+)$/m.exec(body)[1]);
-    const stepMinutes = Number(/^ {8}timeout-minutes: (\d+)$/m.exec(body)?.[1]);
-    assert.ok(stepMinutes > 0 && jobMinutes - stepMinutes >= 2, 'the proof step stops before the job limit');
-});
-
 // #493: the portability limit follows the rule in its comment: ceil(1.5 x the slowest of three
 // green main runs) + 3 minutes, never under 5, with those runs and times written above jobs:.
 // The times are whole-job wall times. That the runs were green and on main is the author's word.
@@ -427,5 +414,5 @@ test('every required check reports on a pull request and the gates carry the ful
     ].sort());
     assert.equal(contexts.filter(context => /^py/.test(context)).length, 1,
         'a dropped matrix leg never reports on a pull request, so it cannot be required');
-    assert.ok(!contexts.some(context => /windows|macos/.test(context)), 'Windows and macOS never gate a merge');
+    assert.ok(!contexts.some(context => /windows|macos/.test(context)), 'Windows never gates a merge');
 });

tools/vendor/frontend-coverage-baseline.json

@@ -629,6 +629,18 @@
     "functions": 95,
     "statements": 98
   },
+  "workspace/system-instructions.mjs": {
+    "lines": 80,
+    "branches": 80,
+    "functions": 80,
+    "statements": 80
+  },
+  "workspace/system-skipped-tags.mjs": {
+    "lines": 80,
+    "branches": 80,
+    "functions": 80,
+    "statements": 80
+  },
   "workspace/system-state.mjs": {
     "lines": 98,
     "branches": 94,

utils/file_prompt.py

@@ -230,6 +230,9 @@ def _undecided_graph(found: _File) -> Decision:
     if switched is not None:
         # The legacy answer is a switched-off node's own text (#90)
         return Decision(switched, canonical=found.canonical)
+    if text is not None and _search_text(found.canonical["prompt"], text):
+        # The query of a Search List batch is a search, never a prompt (#548)
+        return _never(found, _unlinked(found), try_recorded_run=True)
     if text is not None and _joined_text(found.canonical["prompt"], text):
         # The legacy parser joins prepend + text + append: the text a
         # PromptManager node stores cannot be told from it (#343).
@@ -311,6 +314,8 @@ _NOT_TEXT_INPUTS = frozenset(
     }
 )
 _MAX_SWITCH_VISITS = 5000
+# The batch node whose ``text`` input is a library search query (#548).
+SEARCH_LIST_TYPE = "PromptSearchList"
 
 
 def _negative_name(key: Any) -> bool:
@@ -328,10 +333,28 @@ def _switched_off_upstream(graph: Any) -> Optional[str]:
     """
     if not isinstance(graph, dict):
         return None
-    roots = _positive_roots(graph)
-    if not roots:
+    upstream = _positive_upstream(graph)
+    if upstream is None:
         ids = _prompt_manager_ids(graph)
         return _switch_kind(save_setting(graph, node_id) for node_id in ids)
+    found = [
+        node_id
+        for node_id in upstream
+        if graph[node_id].get("class_type") in PROMPT_MANAGER_TYPES
+    ]
+    return _switch_kind(save_setting(graph, node_id) for node_id in found)
+
+
+def _positive_upstream(graph: dict) -> Optional[set]:
+    """The ids of the nodes upstream of a sampler's positive, or None when
+    the graph has no recognisable sampler.
+
+    Follows every input except negative and non-text ones (#90's walk follows
+    only prompt-like names).
+    """
+    roots = _positive_roots(graph)
+    if not roots:
+        return None
     seen, found = set(), set()
     stack = [str(link[0]) for link in roots]
     while stack and len(seen) < _MAX_SWITCH_VISITS:
@@ -342,8 +365,7 @@ def _switched_off_upstream(graph: Any) -> Optional[str]:
         node = graph.get(node_id)
         if not isinstance(node, dict):
             continue
-        if node.get("class_type") in PROMPT_MANAGER_TYPES:
-            found.add(node_id)
+        found.add(node_id)
         inputs = node.get("inputs")
         for key, value in (inputs.items() if isinstance(inputs, dict) else ()):
             if key in _NOT_TEXT_INPUTS or _negative_name(key):
@@ -351,7 +373,28 @@ def _switched_off_upstream(graph: Any) -> Optional[str]:
             if isinstance(value, (list, tuple)) and len(value) == 2:
                 if isinstance(value[0], (str, int)) and isinstance(value[1], int):
                     stack.append(str(value[0]))
-    return _switch_kind(save_setting(graph, node_id) for node_id in found)
+    return found
+
+
+def _search_text(graph: Any, text: str) -> bool:
+    """Whether ``text`` is the search query of a PromptSearchList node that
+    feeds a positive (any such node when no sampler is recognised).
+
+    The legacy parser traces a positive wired from a Search List to the
+    node's ``text`` input, which is the database search, never the prompt
+    the batch ran (#548). Each item is counted by the node at run time.
+    """
+    if not isinstance(graph, dict):
+        return False
+    upstream = _positive_upstream(graph)
+    ids = graph if upstream is None else upstream
+    wanted = text.strip()
+    return any(
+        isinstance(graph[node_id], dict)
+        and graph[node_id].get("class_type") == SEARCH_LIST_TYPE
+        and resolve_text(graph, node_id) == wanted
+        for node_id in ids
+    )
 
 
 def _off_text(graph: Any, text: str) -> Optional[str]:

utils/image_monitor.py

@@ -96,6 +96,65 @@ WORKER_JOIN_SECONDS = 5.0
 OBSERVER_JOIN_SECONDS = 5.0
 
 
+def _start_daemon_observer(observer) -> None:
+    """``observer.start()`` on a short-lived daemon thread (#561).
+
+    A thread is a daemon when the thread that creates it is one. watchdog
+    7 on Windows starts a plain ``threading.Thread`` per watch inside
+    ``start()``; created from ComfyUI's main thread it is not a daemon, and
+    the interpreter waits for every such thread before it runs any
+    ``atexit`` callback, so the teardown that would stop it never runs.
+    Started from here, every thread the observer creates is a daemon.
+    Waits for the start without a limit (start-up, not exit); re-raises
+    what ``start()`` raised.
+    """
+    raised: List[BaseException] = []
+
+    def start() -> None:
+        try:
+            observer.start()
+        except BaseException as e:  # re-raised on the caller's thread
+            raised.append(e)
+
+    starter = threading.Thread(
+        target=start, name="PromptManagerObserverStart", daemon=True
+    )
+    starter.start()
+    starter.join()
+    if raised:
+        raise raised[0]
+
+
+class _ObserverStop:
+    """One ``observer.stop()`` running on a daemon thread (#561).
+
+    watchdog's ``stop()`` joins its emitters (and, in 7.x on Windows, their
+    reader threads) without a limit. Run here, a stop that never returns
+    holds neither the caller past its deadline nor the interpreter's exit.
+    """
+
+    def __init__(self, observer) -> None:
+        self.error: Optional[Exception] = None
+        self._thread = threading.Thread(
+            target=self._run,
+            args=(observer,),
+            name="PromptManagerObserverStop",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def _run(self, observer) -> None:
+        try:
+            observer.stop()
+        except Exception as e:  # reported by the stop that waits for it
+            self.error = e
+
+    def wait(self, timeout: float) -> bool:
+        """True once ``stop()`` has returned or raised."""
+        self._thread.join(timeout)
+        return not self._thread.is_alive()
+
+
 class ImageGenerationHandler(FileSystemEventHandler):
     """Filesystem event handler for detecting new image generation.
 
@@ -1170,6 +1229,9 @@ class ImageMonitor:
         # (observer, handler) pairs a stop left running: the next stop waits
         # for them again instead of reporting True.
         self._unfinished: List[Tuple[Any, Any]] = []
+        # Observer stops still running on their thread, by observer: a later
+        # stop waits for the same call instead of starting another (#561).
+        self._observer_stops: Dict[Any, _ObserverStop] = {}
         self.logger = get_logger("prompt_manager.image_monitor")
         self.review_recorder: Optional[Callable[[str], str]] = None
         self.thumbnail_queue: Optional[Callable[[str], str]] = None
@@ -1273,7 +1335,7 @@ class ImageMonitor:
             self.logger.warning("No directory could be watched")
             return
         try:
-            observer.start()
+            _start_daemon_observer(observer)
         except Exception as e:
             self.logger.error(f"Image monitoring could not start: {e}")
             return
@@ -1303,12 +1365,12 @@ class ImageMonitor:
 
         Closes the handler first (its worker is joined and its dispatch
         returns at once), then stops the watchdog observer and joins it. The
-        worker and the observer share the one deadline: the observer's join
-        gets what the worker left, possibly 0 s.
-        watchdog's ``observer.stop()`` joins its emitters without a limit;
-        it counts against the deadline but is not bounded here. A part an
-        earlier call left running is waited for again. Safe to call when
-        monitoring never started and more than once.
+        worker and the observer share the one deadline: the observer's stop
+        and join get what the worker left, possibly 0 s. watchdog's
+        ``observer.stop()`` joins its emitters without a limit, so it runs on
+        a daemon thread and is waited for only until the deadline (#561). A
+        part an earlier call left running is waited for again. Safe to call
+        when monitoring never started and more than once.
 
         Returns:
             True when every worker and observer it stopped has ended.
@@ -1349,13 +1411,27 @@ class ImageMonitor:
             return False
 
     def _stop_observer(self, observer, timeout: float) -> bool:
-        """``observer.stop()`` (safe to repeat), then a join of ``timeout``
-        seconds; a join that times out is logged with the time it got."""
+        """``observer.stop()`` on its own daemon thread, then a join, both
+        within ``timeout`` seconds; a stop or join still running then is
+        logged with the time it got. A stop still running from an earlier
+        call is waited for, never started again."""
         if observer is None:
             return True
+        deadline = time.monotonic() + timeout
+        stop = self._observer_stops.get(observer)
+        if stop is None:
+            stop = self._observer_stops[observer] = _ObserverStop(observer)
+        if not stop.wait(timeout):
+            self.logger.warning(
+                f"watchdog observer still running after {timeout:.1f} s"
+            )
+            return False
+        del self._observer_stops[observer]
+        if stop.error is not None:
+            self.logger.warning(f"Error while stopping image monitoring: {stop.error}")
+            return False
         try:
-            observer.stop()
-            observer.join(timeout)
+            observer.join(max(0.0, deadline - time.monotonic()))
         except Exception as e:
             self.logger.warning(f"Error while stopping image monitoring: {e}")
             return False

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

@@ -31,6 +31,26 @@ const SOURCES = new Set(['images', 'library', 'review', 'tags', 'bulk']);
 const OPTION_KEYS = new Set(['general_threshold', 'character_threshold', 'instructions', 'suggestion_limit']);
 const DEFAULTS = Object.freeze({general_threshold: 0.35, character_threshold: 0.85, instructions: '', suggestion_limit: 10});
 const MAX_SUGGESTIONS = 100;
+/**
+ * #431: Built-in's text (`DEFAULT_TAG_TEMPLATE` in py/tagging_defaults.py, pinned equal by
+ * tests/test_saved_instructions.py), for when `/autotag/models` cannot be read.
+ */
+export const BUILTIN_INSTRUCTIONS = 'Generate only comma-separated Danbooru tags (lowercase_underscores, no spaces).\n'
+    + 'Include: subject_count (1girl/1boy/etc), gender, ethnicity (asian, caucasian, etc), age_approx (teen, young_woman), '
+    + 'body_attributes, face_features, hairstyle, appearance, clothing, accessories, pose, expression, action, camera_angle, '
+    + 'camera_shot, scene_composition (wide_shot, long_shot, dutch_angle), environment, background_elements, lighting, mood.\n'
+    + 'Prioritize visual accuracy.\n'
+    + 'No sentences, no commentary, no captions. Only tags. Keep length short but descriptive.';
+export const BUILTIN_ID = 'builtin';
+/** The saved instructions when the server cannot say (D204): Built-in only, the default of both engines. */
+const FALLBACK_CHOICES = Object.freeze({
+    entries: Object.freeze([Object.freeze({id: BUILTIN_ID, name: 'Built-in', text: BUILTIN_INSTRUCTIONS})]),
+    defaults: Object.freeze({gguf: BUILTIN_ID, hf: BUILTIN_ID}),
+});
+/** The value and label of the select's extra option while the text differs from the chosen entry (D204). */
+export const EDITED_VALUE = 'edited';
+export const EDITED_LABEL = 'Edited for this run';
+export const EDITED_NOTE = 'Edits apply to this run only. Manage saved instructions in System › Auto-tagging.';
 const MAX_INSTRUCTION_CHARS = 4000;
 const EDITABLE = new Set(['ready', 'generate-error', 'write-error', 'conflict']);
 // Answers after which only a fresh observation can save (the capture or epoch is gone); Retry observes again (D116).
@@ -182,27 +202,54 @@ function validateReceipt(value) {
     return value;
 }
 
+/** #431: the saved instructions of `/autotag/models` (Built-in first) and each engine's default, else Built-in only. */
+export function readChoices(value) {
+    const entries = Array.isArray(value?.instructions) ? value.instructions.filter(entry => object(entry)
+        && typeof entry.id === 'string' && typeof entry.name === 'string' && typeof entry.text === 'string') : [];
+    if (entries[0]?.id !== BUILTIN_ID) return FALLBACK_CHOICES;
+    const ids = new Set(entries.map(entry => entry.id));
+    const defaults = Object.fromEntries(['gguf', 'hf'].map(engine => {
+        const id = value?.default_instructions?.[engine];
+        return [engine, ids.has(id) ? id : BUILTIN_ID];
+    }));
+    return Object.freeze({entries: Object.freeze(entries.map(entry => Object.freeze({...entry}))), defaults: Object.freeze(defaults)});
+}
+
+/** The language-model engine whose default a model reads (GGUF for a WD14 model, which takes none). */
+const engineOf = model => (model === 'hf' ? 'hf' : 'gguf');
+/** The default entry of `model`'s engine. */
+export const engineDefault = (choices, model) => choices.entries.find(entry => entry.id === choices.defaults[engineOf(model)])
+    ?? choices.entries[0];
+/** The entry to show for `text` (a preset): the one with that text, else the engine's default. */
+const entryFor = (choices, model, text) => choices.entries.find(entry => entry.text === text) ?? engineDefault(choices, model);
+/** What the instruction fields hold for `model` with its engine's default (#431). */
+const instructionsFor = (choices, model) => {
+    const entry = engineDefault(choices, model);
+    return {instructionId: entry.id, text: entry.text};
+};
+
 /**
  * Thresholds, instructions and suggestion count from the server, else the documented defaults, the models'
- * download status (`models`, null when unknown) and the saved tagging model (`model`, null when unknown; #328).
+ * download status (`models`, null when unknown), the saved tagging model (`model`, null when unknown; #328) and the
+ * saved instructions (`choices`, #431).
  */
 async function readDefaults(api, signal) {
     try {
         const value = await api.get(MODELS_URL, {signal, cache: 'no-store'});
-        if (!object(value)) return {defaults: DEFAULTS, models: null, model: null};
+        if (!object(value)) return {defaults: DEFAULTS, models: null, model: null, choices: FALLBACK_CHOICES};
         return {
+            choices: readChoices(value),
             model: typeof value.model_type === 'string' && modelOf(value.model_type) ? value.model_type : null,
             defaults: {
                 general_threshold: unit(value.wd14_general_threshold) ? value.wd14_general_threshold : DEFAULTS.general_threshold,
                 character_threshold: unit(value.wd14_character_threshold) ? value.wd14_character_threshold : DEFAULTS.character_threshold,
-                instructions: typeof value.default_prompt === 'string' ? value.default_prompt : DEFAULTS.instructions,
                 suggestion_limit: limit(value.suggestion_limit) ? value.suggestion_limit : DEFAULTS.suggestion_limit,
             },
             models: object(value.models) ? value.models : null,
         };
     } catch {
         // The defaults keep the dialog usable; Generate reports a real failure itself.
-        return {defaults: DEFAULTS, models: null, model: null};
+        return {defaults: DEFAULTS, models: null, model: null, choices: FALLBACK_CHOICES};
     }
 }
 
@@ -257,11 +304,27 @@ function initialState(source, preset) {
         image: null, savedTags: [], tagRevision: 0, currentTags: null, manual: '',
         model: preset?.model ?? MODEL_OPTIONS[0].id, options: {...DEFAULTS, ...preset?.options}, generated: false, suggestions: [],
         suggestionsText: COPY.modelChanged, statusText: '', generateSupported: false, generateReason: null, toast: null,
+        skippedCount: 0,
+        // #431 (D204): the saved instructions, each engine's default and the entry the select shows.
+        instructionChoices: FALLBACK_CHOICES, instructionId: BUILTIN_ID,
         // Bumped whenever the controller itself rewrites the option fields or the manual draft, never while typing.
         optionsRevision: 0, draftRevision: 0,
     };
 }
 
+/** #431: how many suggestions the saved Skipped tags hid, after the chip hint ('' when none). */
+export function skippedNote(count) {
+    if (!Number.isSafeInteger(count) || count <= 0) return '';
+    return count === 1 ? ' 1 skipped tag was not suggested.' : ` ${count.toLocaleString('en-US')} skipped tags were not suggested.`;
+}
+
+/** D204: whether a language model's instructions differ from the chosen saved entry's text (a one-off edit). */
+export function instructionsEdited(state) {
+    if (modelOf(state.model)?.classifier !== false) return false;
+    const entry = state.instructionChoices?.entries.find(item => item.id === state.instructionId);
+    return !entry || entry.text !== state.options.instructions;
+}
+
 /** Derived labels and permissions; never stored independently of the fields they follow. */
 function derive(state) {
     const editable = EDITABLE.has(state.phase);
@@ -269,7 +332,8 @@ function derive(state) {
         ...state,
         primaryLabel: state.generated ? 'Approve selected tags' : 'Save manual tags',
         countText: state.generated ? `${state.suggestions.length} ${noun(state.suggestions.length, 'suggestion')}` : 'Not generated',
-        chipHint: state.suggestions.length ? COPY.chipHint : '',
+        chipHint: state.suggestions.length ? COPY.chipHint + skippedNote(state.skippedCount) : '',
+        instructionsEdited: instructionsEdited(state),
         canSave: editable,
         canGenerate: editable && state.generateSupported,
         canRetry: RETRYABLE.has(state.phase),
@@ -387,6 +451,10 @@ export function createImageTaggingController({api, target, source = 'images', on
         if (closed || serial !== openSerial) return;
         // The saved model (System › Auto-tagging) unless a preset or the user already chose one (#328).
         const savedModel = !chosen && !modelPicked && read.model ? {model: read.model} : {};
+        // #431: the instructions start from the model's engine default; a preset's text wins (D204).
+        const model = savedModel.model ?? state.model;
+        const presetText = chosen?.options.instructions;
+        const entry = presetText === undefined ? engineDefault(read.choices, model) : entryFor(read.choices, model, presetText);
         observedOnce = true;
         const {width, height, media_type: mediaType, preview_url: previewUrl, generate} = value.capture;
         // The draft is read now, so text typed while observing is kept (#515). A kept draft stays as typed unless
@@ -403,7 +471,8 @@ export function createImageTaggingController({api, target, source = 'images', on
             savedTags: value.tags.slice(), tagRevision: value.tag_revision,
             manual: draft === null ? value.tags.join(', ') : changed || unseen ? mergeCurrent(value.tags, draft) : draft,
             draftRevision: state.draftRevision + 1,
-            ...savedModel, options: {...defaults, ...chosen?.options}, optionsRevision: state.optionsRevision + 1,
+            ...savedModel, options: {...defaults, instructions: entry.text, ...chosen?.options}, optionsRevision: state.optionsRevision + 1,
+            instructionChoices: read.choices, instructionId: entry.id,
             generateSupported: generate.supported, generateReason: generate.reason,
             statusText: changed ? `${COPY.changedElsewhere} ${savedNow(value.tags)}${reason ? ` ${reason}` : ''}` : reason,
         });
@@ -421,15 +490,26 @@ export function createImageTaggingController({api, target, source = 'images', on
         if (id === state.model) return;
         stopGenerating();
         const phase = state.phase === 'generating' || state.phase === 'generate-error' ? 'ready' : state.phase;
+        const {instructionId, text} = instructionsFor(state.instructionChoices, id);
         set({
             phase, model: id, generated: false, suggestions: [], suggestionsText: COPY.modelChanged, statusText: reasonText(),
             optionsRevision: state.optionsRevision + 1,
-            // Like the mock, a model change re-renders its fields with the defaults; the count is kept (D91).
+            // Like the mock, a model change re-renders its fields with the defaults; the count is kept (D91). The
+            // instructions start from the new engine's default, dropping a one-off edit (D204).
             options: {...state.options, general_threshold: defaults.general_threshold,
-                character_threshold: defaults.character_threshold, instructions: defaults.instructions},
+                character_threshold: defaults.character_threshold, instructions: text},
+            instructionId,
         });
     }
 
+    /** D204: choose a saved entry; its text replaces the instructions (and a one-off edit). */
+    function pickInstructions(id) {
+        if (closed) return;
+        const entry = state.instructionChoices.entries.find(item => item.id === id);
+        if (!entry) return;
+        set({instructionId: id, options: {...state.options, instructions: entry.text}, optionsRevision: state.optionsRevision + 1});
+    }
+
     function setOption(key, value) {
         requireValue(OPTION_KEYS.has(key), 'Unknown tagging option');
         set({options: {...state.options, [key]: value}});
@@ -445,13 +525,14 @@ export function createImageTaggingController({api, target, source = 'images', on
         const options = requestOptions(model, state.options);
         const stale = () => closed || serial !== generateSerial;
         set({phase: 'generating', statusText: COPY.generating});
-        let rows;
+        let rows, skippedCount;
         try {
             const value = await api.post(SUGGEST_URL, {
                 target: {...imageTarget}, capture_token: capture.token, expected_epoch: epoch, model_type: model, options,
             }, {signal: controller.signal});
             if (stale()) return false;
             rows = validateSuggestions(value, options.suggestion_limit);
+            skippedCount = Number.isSafeInteger(value.skipped) && value.skipped > 0 ? value.skipped : 0;
         } catch (error) {
             if (stale()) return false;
             const phase = isApiError(error) && REOPEN[error.code];
@@ -460,7 +541,7 @@ export function createImageTaggingController({api, target, source = 'images', on
         }
         generateAbort = null;
         set({
-            phase: 'ready', generated: true, suggestions: rows, suggestionsText: rows.length ? '' : COPY.empty,
+            phase: 'ready', generated: true, suggestions: rows, suggestionsText: rows.length ? '' : COPY.empty, skippedCount,
             statusText: `Suggestions from ${modelOf(model).label}. Approve tags to save.`,
         });
         return true;
@@ -585,7 +666,7 @@ export function createImageTaggingController({api, target, source = 'images', on
     return {
         get state() {return state;},
         get target() {return imageTarget;},
-        subscribe, open, setManual, setModel, setOption, generate, remove, save, retry, retarget, cancel, dispose,
+        subscribe, open, setManual, setModel, setOption, pickInstructions, generate, remove, save, retry, retarget, cancel, dispose,
     };
 }
 
@@ -604,8 +685,9 @@ export function createTaggingOptionsController({api} = {}) {
     let abort = null;
     let modelPicked = false;
     const deriveOptions = value => ({...value, canGenerate: false, unavailable: modelUnavailable(models, value.model),
-        canStart: value.phase === 'ready' && !modelUnavailable(models, value.model)});
-    let state = freeze(deriveOptions({phase: 'loading', model: MODEL_OPTIONS[0].id, options: {...DEFAULTS}, optionsRevision: 0}));
+        canStart: value.phase === 'ready' && !modelUnavailable(models, value.model), instructionsEdited: instructionsEdited(value)});
+    let state = freeze(deriveOptions({phase: 'loading', model: MODEL_OPTIONS[0].id, options: {...DEFAULTS}, optionsRevision: 0,
+        instructionChoices: FALLBACK_CHOICES, instructionId: BUILTIN_ID}));
 
     function set(patch) {
         if (closed) return;
@@ -620,17 +702,28 @@ export function createTaggingOptionsController({api} = {}) {
         ({defaults, models} = read);
         // The saved model (System › Auto-tagging) unless the user already chose one (#328).
         const savedModel = !modelPicked && read.model ? {model: read.model} : {};
-        set({phase: 'ready', ...savedModel, options: {...defaults}, optionsRevision: state.optionsRevision + 1});
+        const {instructionId, text} = instructionsFor(read.choices, savedModel.model ?? state.model);
+        set({phase: 'ready', ...savedModel, options: {...defaults, instructions: text}, optionsRevision: state.optionsRevision + 1,
+            instructionChoices: read.choices, instructionId});
     }
     function setModel(id) {
         requireValue(modelOf(id), 'Unknown tagging model');
         if (closed) return;
         modelPicked = true;
         if (id === state.model) return;
-        // As in the Tag image dialog: the model's fields start from the defaults again; the count is kept (D91).
-        set({model: id, optionsRevision: state.optionsRevision + 1,
+        // As in the Tag image dialog: the model's fields start from the defaults again; the count is kept (D91), and
+        // the instructions from the new engine's default (D204).
+        const {instructionId, text} = instructionsFor(state.instructionChoices, id);
+        set({model: id, optionsRevision: state.optionsRevision + 1, instructionId,
             options: {...state.options, general_threshold: defaults.general_threshold,
-                character_threshold: defaults.character_threshold, instructions: defaults.instructions}});
+                character_threshold: defaults.character_threshold, instructions: text}});
+    }
+    /** D204: choose a saved entry; its text replaces the instructions. */
+    function pickInstructions(id) {
+        if (closed) return;
+        const entry = state.instructionChoices.entries.find(item => item.id === id);
+        if (!entry) return;
+        set({instructionId: id, options: {...state.options, instructions: entry.text}, optionsRevision: state.optionsRevision + 1});
     }
     function setOption(key, value) {
         requireValue(OPTION_KEYS.has(key), 'Unknown tagging option');
@@ -653,6 +746,6 @@ export function createTaggingOptionsController({api} = {}) {
     }
     return {
         get state() {return state;},
-        subscribe, open, setModel, setOption, request, dispose,
+        subscribe, open, setModel, setOption, pickInstructions, request, dispose,
     };
 }

web/js/workspace/image-tagging.mjs

@@ -17,7 +17,8 @@
  * flight at close keeps its capture until it settles, and its outcome is still toasted and announced.
  */
 import { createButton, createScope } from '../shared/toolkit/core.js';
-import { createImageTaggingController, MODEL_OPTIONS, optionError } from './image-tagging-state.mjs';
+import { createImageTaggingController, EDITED_LABEL, EDITED_NOTE, EDITED_VALUE, MODEL_OPTIONS, engineDefault, optionError }
+    from './image-tagging-state.mjs';
 import { closeWorkspaceDialog, field, openContentDialog } from './workspace-dialogs.mjs';
 import { createWorkspaceIcon } from './icons.mjs';
 import { showWorkspaceToast } from './toast.mjs';
@@ -107,9 +108,13 @@ function numberInput(value, {min, max, step}) {
  * It follows `controller` until `scope` is disposed (reused by the bulk Auto-tag dialog, D85, without Generate:
  * `generate: false`). Returns the `element`, `validate()` (the fields' native validity, then what the controller would
  * refuse; true when valid, else the first invalid field reports) and `requestGenerate()`, Generate's own path (field
- * validity first), for a Retry after a failed Generate.
+ * validity first), for a Retry after a failed Generate. D204 (#431): for a language model, a "Saved instructions" select
+ * (`pickId`) sits above "Tagging instructions": it starts at the engine's default ("<name> · default"), a pick replaces
+ * the text, and while the text differs from the picked entry it shows "Edited for this run" (not choosable) with a
+ * muted note under the textarea.
  */
-export function renderModelPanel({scope, controller, heading = 'Auto-tag this image', generate: withGenerate = true}) {
+export function renderModelPanel({scope, controller, heading = 'Auto-tag this image', generate: withGenerate = true,
+    pickId = 'image-tag-instructions-pick'}) {
     const panel = el('div', undefined, 'tag-model-panel');
     const select = el('select');
     for (const option of MODEL_OPTIONS) {
@@ -125,9 +130,35 @@ export function renderModelPanel({scope, controller, heading = 'Auto-tag this im
     if (withGenerate) panel.append(generate);
     const inputs = new Map();
     let shownModel = null, shownOptions = null;
+    // D204: the Saved instructions select and the one-off note, while a language model is chosen.
+    let pick = null, editedNote = null, shownEdited = null;
+
+    /** The select's options: every entry (the engine default marked), plus "Edited for this run" while edited. */
+    function fillPick(state) {
+        shownEdited = state.instructionsEdited;
+        const fallback = engineDefault(state.instructionChoices, state.model).id;
+        pick.replaceChildren(...state.instructionChoices.entries.map(entry => {
+            const option = el('option', entry.id === fallback ? `${entry.name} · default` : entry.name);
+            option.value = entry.id;
+            return option;
+        }));
+        if (state.instructionsEdited) {
+            const option = el('option', EDITED_LABEL);
+            option.value = EDITED_VALUE;
+            option.disabled = true;
+            pick.append(option);
+        }
+        pick.value = state.instructionsEdited ? EDITED_VALUE : state.instructionId;
+        editedNote.hidden = !state.instructionsEdited;
+        // The note describes the textarea while it shows.
+        const area = inputs.get('instructions');
+        if (state.instructionsEdited) area?.setAttribute('aria-describedby', editedNote.id);
+        else area?.removeAttribute('aria-describedby');
+    }
 
     function renderOptions(state) {
         inputs.clear();
+        pick = editedNote = null;
         const classifier = MODEL_OPTIONS.find(option => option.id === state.model).classifier;
         const rows = [];
         if (classifier) {
@@ -139,10 +170,17 @@ export function renderModelPanel({scope, controller, heading = 'Auto-tag this im
             }
             rows.push(pair);
         } else {
+            pick = el('select');
+            pick.addEventListener('change', () => { if (pick.value !== EDITED_VALUE) controller.pickInstructions(pick.value); });
+            rows.push(field('Saved instructions', pick, pickId));
             const area = el('textarea');
             area.value = state.options.instructions;
             inputs.set('instructions', area);
             rows.push(field('Tagging instructions', area, OPTION_IDS.instructions));
+            editedNote = el('p', EDITED_NOTE, 'small instructions-edited');
+            editedNote.id = `${pickId}-note`;
+            rows.push(editedNote);
+            fillPick(state);
         }
         // D91: the number of suggestions, for every model.
         const count = numberInput(state.options.suggestion_limit, {min: '1', max: '100', step: '1'});
@@ -162,7 +200,13 @@ export function renderModelPanel({scope, controller, heading = 'Auto-tag this im
             shownModel = state.model;
             shownOptions = state.optionsRevision;
             select.value = state.model;
+            // A pick re-renders the fields; keyboard focus stays on the select it was made with.
+            const picking = pick !== null && document.activeElement === pick;
             renderOptions(state);
+            if (picking) pick?.focus();
+        } else if (pick && state.instructionsEdited !== shownEdited) {
+            // Typing never re-renders the fields (I1): only the select and the note follow an edit.
+            fillPick(state);
         }
         setDisabled(generate, !state.canGenerate);
     }

web/js/workspace/images-tagging-bulk.mjs

@@ -167,7 +167,8 @@ export function openAutoTag({api, scope, store, images, trigger, onTagged = () =
     const options = createTaggingOptionsController({api});
     // D85: the Tag image dialog's model panel without Generate; its Suggestions field is the job's count (D91).
     const {element: panel, validate} = renderModelPanel({scope: local, controller: options,
-        heading: `Auto-tag ${countOf(filter ? count : listed.length, 'image')}`, generate: false}); // D118
+        heading: `Auto-tag ${countOf(filter ? count : listed.length, 'image')}`, generate: false, // D118
+        pickId: 'bulk-tag-instructions-pick'}); // D204
     let choice = APPLY_CHOICES[0];
     const actions = el('div', undefined, 'dialog-actions');
     const cancel = createButton('Cancel');

web/js/workspace/index.mjs

@@ -176,6 +176,12 @@ function mountWorkspace() {
     function notifyCounts() { for (const listener of countListeners) listener(); }
     /** Re-read the given counts unless a read is already in flight. */
     function freshenCounts(ids) { refreshCounts(ids.filter(id => !countRequests.has(id))); }
+    /** #555: the counts as System › Overview reads them, so its Images metric and the Images badge cannot differ. */
+    const sharedCounts = Object.freeze({
+        get: id => knownCounts.get(id),
+        subscribe(listener) { countListeners.add(listener); return () => countListeners.delete(listener); },
+        freshen: freshenCounts,
+    });
     /** A count a page has just read itself: it replaces the badge, and an older read in flight no longer lands. */
     function setCount(id, count) {
         countRequests.get(id)?.abort();
@@ -488,7 +494,7 @@ function mountWorkspace() {
         if (route.id === 'system') {
             // The concept's System (app.js renderSystem): its heading description, section nav and Save row.
             description.textContent = route.description;
-            system = mountSystem(main, api, view, { section: route.section, activity });
+            system = mountSystem(main, api, view, { section: route.section, activity, counts: sharedCounts });
             return;
         }
         if (route.id === 'inspect') {

web/js/workspace/system-instructions.mjs

@@ -0,0 +1,351 @@
+/**
+ * System › Auto-tagging "Saved instructions" (#431, D203): named language-model instructions and the default of each
+ * language-model engine. It replaces the concept's "LLM tag template" textarea.
+ *
+ * A `.setting-block` (`data-setting="tag-instructions"`, `data-key="autotag_instructions"`): the label, the
+ * description with the count ("N of 20 saved · Built\u2011in is not counted."), a `role="listbox"` list (Built-in first,
+ * "Read-only", then the saved entries, each with its "Default for GGUF" / "Default for HuggingFace" chips), "+ New",
+ * "Duplicate" and "Delete", and the editor beside the list (under it below 700 px): "Name" (60 characters, live count)
+ * and "Text" ("N of 4,000 characters"), both read-only for Built-in with its note. Then two `.setting-row` selects,
+ * "Default for GGUF JoyCaption" and "Default for HuggingFace JoyCaption" (`data-key="autotag_default_instructions"`),
+ * and the note a deleted default leaves ("GGUF now uses Built-in."). Host drafts: `autotag_instructions` (the saved
+ * entries, never Built-in) and `autotag_default_instructions`; the server pairs them on save. Built-in's text is the
+ * read-only `autotag_builtin_instructions` of GET /settings. Ids are 12 lowercase hex characters made here.
+ */
+import { createButton } from '../shared/toolkit/core.js';
+import { settingRow } from './system-controls.mjs';
+
+export const INSTRUCTIONS_KEY = 'autotag_instructions';
+export const DEFAULTS_KEY = 'autotag_default_instructions';
+export const BUILTIN_TEXT_KEY = 'autotag_builtin_instructions';
+export const BUILTIN_ID = 'builtin';
+export const BUILTIN_NAME = 'Built-in';
+export const MAX_SAVED = 20;
+export const MAX_NAME_CHARS = 60;
+export const MAX_TEXT_CHARS = 4000;
+export const ENGINES = Object.freeze([['gguf', 'GGUF', 'GGUF JoyCaption'], ['hf', 'HuggingFace', 'HuggingFace JoyCaption']]);
+
+export const INSTRUCTIONS_COPY = Object.freeze({
+    label: 'Saved instructions',
+    description: 'Instructions for the language-model engines. Built-in can’t be changed; duplicate it to make your own.',
+    count: saved => `${saved} of ${MAX_SAVED} saved · Built\u2011in is not counted.`,
+    readOnly: 'Read-only',
+    defaultFor: short => `Default for ${short}`,
+    newLabel: '+ New',
+    duplicate: 'Duplicate',
+    delete: 'Delete',
+    cap: `At most ${MAX_SAVED} saved instructions.`,
+    name: 'Name',
+    text: 'Text',
+    nameCount: length => `${length} of ${MAX_NAME_CHARS}`,
+    textCount: length => `${length.toLocaleString('en-US')} of ${MAX_TEXT_CHARS.toLocaleString('en-US')} characters`,
+    builtinNote: 'Built-in instructions can’t be changed. Duplicate them to make your own.',
+    newName: 'New instructions',
+    copyName: name => `${name} copy`,
+    defaultRow: long => `Default for ${long}`,
+    defaultDescription: 'The Tag image dialog and batches start from this.',
+    reset: shorts => `${shorts.join(' and ')} now ${shorts.length > 1 ? 'use' : 'uses'} Built-in.`,
+});
+
+/** Characters as Python's `len` counts them (code points). */
+const characters = text => [...String(text ?? '')].length;
+const fold = text => String(text ?? '').trim().toLowerCase();
+
+/** The saved entries of the drafts (`[]` when unread or damaged). */
+export const savedEntries = values => (Array.isArray(values?.[INSTRUCTIONS_KEY]) ? values[INSTRUCTIONS_KEY] : []);
+
+/** Built-in (its text from GET /settings) and then the saved entries. */
+export function allEntries(values) {
+    const text = typeof values?.[BUILTIN_TEXT_KEY] === 'string' ? values[BUILTIN_TEXT_KEY] : '';
+    return [{ id: BUILTIN_ID, name: BUILTIN_NAME, text }, ...savedEntries(values)];
+}
+
+/** The drafted default entry of `engine` (`gguf` or `hf`); Built-in when the id names nothing. */
+export function defaultEntry(values, engine) {
+    const entries = allEntries(values);
+    const id = values?.[DEFAULTS_KEY]?.[engine];
+    return entries.find(entry => entry.id === id) ?? entries[0];
+}
+
+/** `base`, else `base (2)`, `base (3)`… whichever no entry uses (case-insensitive). */
+export function freeName(base, entries) {
+    const taken = new Set(entries.map(entry => fold(entry.name)));
+    if (!taken.has(fold(base))) return base;
+    for (let n = 2; ; n += 1) if (!taken.has(fold(`${base} (${n})`))) return `${base} (${n})`;
+}
+
+/** "<name> copy" (then "(2)"…), the name cut so the whole stays within the 60-character limit. */
+export function copyName(name, entries) {
+    for (let room = MAX_NAME_CHARS - ' copy'.length; room > 0; room -= 1) {
+        const base = [...String(name ?? '').trim()].slice(0, room).join('').trimEnd();
+        const candidate = freeName(INSTRUCTIONS_COPY.copyName(base), entries);
+        if (characters(candidate) <= MAX_NAME_CHARS) return candidate;
+    }
+    return freeName(INSTRUCTIONS_COPY.copyName(BUILTIN_NAME), entries);
+}
+
+/** A new entry id: 12 lowercase hex characters from `random` (crypto.getRandomValues), never one already used. */
+export function newId(entries, random = bytes => globalThis.crypto.getRandomValues(bytes)) {
+    const used = new Set(entries.map(entry => entry.id));
+    for (;;) {
+        const id = [...random(new Uint8Array(6))].map(byte => byte.toString(16).padStart(2, '0')).join('');
+        if (!used.has(id)) return id;
+    }
+}
+
+/** The editor's note for a saved entry's name and text (the mock's short sentences), or ''. */
+export function entryNote(entry, entries) {
+    const name = String(entry.name ?? '').trim();
+    if (!name) return 'Needs a name.';
+    if (characters(name) > MAX_NAME_CHARS) return `The name must be at most ${MAX_NAME_CHARS} characters.`;
+    if (/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(name)) return 'The name must not contain a line break.';
+    if (fold(name) === fold(BUILTIN_NAME)) return 'The name “Built-in” is reserved.';
+    if (entries.some(other => other !== entry && other.id !== BUILTIN_ID && fold(other.name) === fold(name))) {
+        return `The name “${name}” is already used.`;
+    }
+    if (!String(entry.text ?? '').trim()) return 'The text must not be empty.';
+    if (characters(entry.text) > MAX_TEXT_CHARS) return `The text must be at most ${MAX_TEXT_CHARS.toLocaleString('en-US')} characters.`;
+    return '';
+}
+
+/**
+ * The server's sentence for the first saved entry it would refuse (Built-in is not counted), else null. The Save row
+ * shows the server's own refusal; this one holds back Preview tagging review and the batch Review.
+ */
+export function listProblem(values) {
+    const entries = savedEntries(values);
+    for (const [index, entry] of entries.entries()) {
+        // As the server checks them: a repeated name is the later entry's problem.
+        const note = entryNote(entry, entries.slice(0, index + 1));
+        if (!note) continue;
+        const n = index + 1;
+        if (note.startsWith('Needs')) return `Saved instructions: entry ${n} needs a name.`;
+        if (note.includes('reserved')) return 'Saved instructions: the name “Built-in” is reserved.';
+        if (note.includes('already used')) return `Saved instructions: entry ${n} name “${String(entry.name).trim()}” is already used.`;
+        if (note.includes('line break')) return `Saved instructions: entry ${n} name must not contain a line break.`;
+        if (note.startsWith('The name')) return `Saved instructions: entry ${n} name must be at most ${MAX_NAME_CHARS} characters.`;
+        if (note.includes('empty')) return `Saved instructions: entry ${n} text must be non-empty text.`;
+        return `Saved instructions: entry ${n} text must be at most ${MAX_TEXT_CHARS} characters.`;
+    }
+    return null;
+}
+
+function el(tag, text, className) {
+    const node = document.createElement(tag);
+    if (text !== undefined) node.textContent = text;
+    if (className) node.className = className;
+    return node;
+}
+
+/** A `.field` with a label row (text and a muted count) and its control. */
+function field(id, label, control) {
+    const wrap = el('div', undefined, 'field');
+    const caption = el('label');
+    caption.htmlFor = id;
+    const count = el('span', '', 'small muted');
+    caption.append(el('span', label), count);
+    control.id = id;
+    wrap.append(caption, control);
+    return { wrap, count };
+}
+
+/**
+ * Build the block and the two default rows; `drafts` is the System draft store. Returns `{nodes, repaint}`: System
+ * appends `nodes` in order and calls `repaint` whenever the drafts change.
+ */
+export function savedInstructionsBlock({ scope, drafts, random }) {
+    const block = el('div', undefined, 'setting-block');
+    block.dataset.setting = 'tag-instructions';
+    block.dataset.key = INSTRUCTIONS_KEY;
+    const text = el('div', undefined, 'setting-block-text');
+    const label = el('label', INSTRUCTIONS_COPY.label);
+    label.id = 'instructions-label';
+    const description = el('p', `${INSTRUCTIONS_COPY.description} `);
+    const count = el('span', '');
+    count.id = 'instructions-count';
+    description.append(count);
+    text.append(label, description);
+
+    const layout = el('div', undefined, 'instructions-layout');
+    const side = el('div', undefined, 'instructions-side');
+    const list = el('div', undefined, 'instruction-list');
+    list.id = 'instruction-list';
+    list.setAttribute('role', 'listbox');
+    list.setAttribute('aria-labelledby', 'instructions-label');
+    list.tabIndex = 0;
+    const actions = el('div', undefined, 'row-actions instruction-actions');
+    const create = createButton(INSTRUCTIONS_COPY.newLabel);
+    create.id = 'instruction-new';
+    const duplicate = createButton(INSTRUCTIONS_COPY.duplicate);
+    duplicate.id = 'instruction-duplicate';
+    const remove = createButton(INSTRUCTIONS_COPY.delete, 'danger');
+    remove.id = 'instruction-delete';
+    actions.append(create, duplicate, remove);
+    const cap = el('p', INSTRUCTIONS_COPY.cap, 'small');
+    cap.id = 'instruction-cap';
+    cap.hidden = true;
+    side.append(list, actions, cap);
+
+    const editor = el('div', undefined, 'instruction-editor');
+    const nameInput = el('input');
+    nameInput.autocomplete = 'off';
+    const name = field('instruction-name', INSTRUCTIONS_COPY.name, nameInput);
+    const textArea = el('textarea');
+    textArea.rows = 7;
+    const body = field('instruction-text', INSTRUCTIONS_COPY.text, textArea);
+    const note = el('p', '', 'small');
+    note.id = 'instruction-note';
+    note.setAttribute('role', 'status');
+    editor.append(name.wrap, body.wrap, note);
+    layout.append(side, editor);
+    block.append(text, layout);
+
+    const selects = ENGINES.map(([engine, , long]) => {
+        const row = settingRow({ id: `instruction-default-${engine}`, label: INSTRUCTIONS_COPY.defaultRow(long),
+            description: INSTRUCTIONS_COPY.defaultDescription, control: { type: 'select', options: [[BUILTIN_ID, BUILTIN_NAME]] } });
+        const select = row.children[1];
+        select.dataset.key = DEFAULTS_KEY;
+        return { engine, select, row };
+    });
+    const reset = el('p', '', 'small instruction-reset');
+    reset.id = 'instruction-reset';
+    reset.setAttribute('role', 'status');
+
+    let selectedId = BUILTIN_ID;
+    const values = () => ({ [INSTRUCTIONS_KEY]: drafts.get('host', INSTRUCTIONS_KEY),
+        [DEFAULTS_KEY]: drafts.get('host', DEFAULTS_KEY), [BUILTIN_TEXT_KEY]: drafts.get('host', BUILTIN_TEXT_KEY) });
+    const ready = () => Array.isArray(drafts.get('host', INSTRUCTIONS_KEY)) && drafts.get('host', DEFAULTS_KEY) !== undefined;
+    const defaults = () => ({ ...(drafts.get('host', DEFAULTS_KEY) ?? {}) });
+    const setEntries = next => drafts.set('host', INSTRUCTIONS_KEY, next);
+    const selected = () => allEntries(values()).find(entry => entry.id === selectedId) ?? allEntries(values())[0];
+
+    /** Replace the selected saved entry's `key` with `value` (a new list of new objects). */
+    function edit(key, value) {
+        if (selectedId === BUILTIN_ID) return;
+        setEntries(savedEntries(values()).map(entry => (entry.id === selectedId ? { ...entry, [key]: value } : entry)));
+    }
+
+    function add(entry) {
+        const entries = savedEntries(values());
+        if (!ready() || entries.length >= MAX_SAVED) return;
+        selectedId = entry.id;
+        reset.textContent = '';
+        setEntries([...entries, entry]);
+    }
+
+    function deleteSelected() {
+        const entries = savedEntries(values());
+        const index = entries.findIndex(entry => entry.id === selectedId);
+        if (index < 0) return;
+        const gone = entries[index];
+        const next = defaults();
+        const shorts = [];
+        for (const [engine, short] of ENGINES) {
+            if (next[engine] === gone.id) { next[engine] = BUILTIN_ID; shorts.push(short); }
+        }
+        const left = entries.filter(entry => entry.id !== gone.id);
+        selectedId = (left[index] ?? left[index - 1])?.id ?? BUILTIN_ID;
+        reset.textContent = shorts.length ? INSTRUCTIONS_COPY.reset(shorts) : '';
+        if (shorts.length) drafts.set('host', DEFAULTS_KEY, next);
+        setEntries(left);
+    }
+
+    function select(id) {
+        selectedId = id;
+        repaint();
+    }
+
+    function renderList(entries, chosen) {
+        list.replaceChildren(...entries.map(entry => {
+            const option = el('div');
+            option.id = `instruction-option-${entry.id}`;
+            option.dataset.id = entry.id;
+            option.setAttribute('role', 'option');
+            option.setAttribute('aria-selected', String(entry.id === selectedId));
+            option.append(el('span', entry.name));
+            const badges = el('span', undefined, 'badges');
+            if (entry.id === BUILTIN_ID) badges.append(el('span', INSTRUCTIONS_COPY.readOnly, 'chip'));
+            for (const [engine, short] of ENGINES) {
+                if (chosen[engine] === entry.id) badges.append(el('span', INSTRUCTIONS_COPY.defaultFor(short), 'chip blue'));
+            }
+            if (badges.children.length) option.append(badges);
+            return option;
+        }));
+        list.setAttribute('aria-activedescendant', `instruction-option-${selectedId}`);
+    }
+
+    function repaint() {
+        // The note a deleted default left goes once the defaults are saved (or set back).
+        if (!Object.hasOwn(drafts.changes('host'), DEFAULTS_KEY)) reset.textContent = '';
+        const loaded = ready();
+        for (const control of [create, duplicate, remove, nameInput, textArea, ...selects.map(item => item.select)]) {
+            control.disabled = !loaded;
+        }
+        if (!loaded) return;
+        const current = values();
+        const entries = allEntries(current);
+        if (!entries.some(entry => entry.id === selectedId)) selectedId = BUILTIN_ID;
+        const chosen = defaults();
+        const saved = savedEntries(current);
+        renderList(entries, chosen);
+        const entry = selected();
+        const builtin = entry.id === BUILTIN_ID;
+        // A focused field keeps what the user is typing.
+        if (document.activeElement !== nameInput) nameInput.value = entry.name;
+        if (document.activeElement !== textArea) textArea.value = entry.text;
+        nameInput.readOnly = textArea.readOnly = builtin;
+        name.count.textContent = builtin ? '' : INSTRUCTIONS_COPY.nameCount(characters(entry.name));
+        body.count.textContent = INSTRUCTIONS_COPY.textCount(characters(entry.text));
+        const problem = builtin ? '' : entryNote(entry, entries);
+        note.textContent = builtin ? INSTRUCTIONS_COPY.builtinNote : problem;
+        note.className = problem ? 'small skip-problem' : 'small';
+        const full = saved.length >= MAX_SAVED;
+        create.disabled = duplicate.disabled = full;
+        remove.disabled = builtin;
+        cap.hidden = !full;
+        count.textContent = INSTRUCTIONS_COPY.count(saved.length);
+        for (const { engine, select: menu } of selects) {
+            menu.replaceChildren(...entries.map(item => {
+                const option = el('option', item.name);
+                option.value = item.id;
+                return option;
+            }));
+            menu.value = chosen[engine] ?? BUILTIN_ID;
+        }
+    }
+
+    scope.listen(create, 'click', () => {
+        const entries = allEntries(values());
+        add({ id: newId(entries, random), name: freeName(INSTRUCTIONS_COPY.newName, entries), text: '' });
+        textArea.focus?.();
+    });
+    scope.listen(duplicate, 'click', () => {
+        const entries = allEntries(values());
+        const source = selected();
+        add({ id: newId(entries, random), name: copyName(source.name, entries), text: source.text });
+    });
+    scope.listen(remove, 'click', deleteSelected);
+    // One listener for every option, however often the list is rebuilt.
+    scope.listen(list, 'click', event => {
+        let node = event.target;
+        while (node && node !== list && node.getAttribute?.('role') !== 'option') node = node.parentNode;
+        if (node && node !== list) select(node.dataset.id);
+    });
+    scope.listen(nameInput, 'input', () => edit('name', nameInput.value));
+    scope.listen(textArea, 'input', () => edit('text', textArea.value));
+    scope.listen(list, 'keydown', event => {
+        const ids = allEntries(values()).map(entry => entry.id);
+        const at = ids.indexOf(selectedId);
+        const next = { ArrowDown: at + 1, ArrowUp: at - 1, Home: 0, End: ids.length - 1 }[event.key];
+        if (next === undefined) return;
+        event.preventDefault?.();
+        select(ids[Math.max(0, Math.min(ids.length - 1, next))]);
+    });
+    for (const { engine, select: menu } of selects) {
+        scope.listen(menu, 'change', () => {
+            reset.textContent = '';
+            drafts.set('host', DEFAULTS_KEY, { ...defaults(), [engine]: menu.value });
+        });
+    }
+    return { nodes: [block, ...selects.map(item => item.row), reset], repaint };
+}

web/js/workspace/system-overview.mjs

@@ -11,8 +11,10 @@
  *   D99: its Review thumbnails opens the same "Thumbnail maintenance" dialog as Sources (thumbnail-review.mjs).
  *   #317: it reads "N missing · M outdated · K failed"; while previews are outdated (another format than the
  *   configured one) a second button, "Convert outdated", opens that dialog on its Convert outdated scope (D131).
- * - D96: the Statistics dialog lists the real runs per category, then "Library totals" (D153: no rating column or
- *   rated-images total).
+ * - #555: metric 3, "Images", is the shell's Images count (the Images page's total, its sidebar badge), not the
+ *   overview's indexed rows, which leave out files no row links: a dash until it is read or when its read failed.
+ * - D96: the Statistics dialog lists the real runs per category, then "Database records" (D153: no rating column or
+ *   rated-images total; #555: the legacy row counts, labelled as records).
  * - D95: the "Health report" lists every check the server ran, Missing files per image source, with a chip per real
  *   result and when it was checked. The check runs from Maintenance's notice ("Run health checks", D123) as a
  *   read job of the registry, tracked in the Activity store (its event stream); the report opens when it ends.
@@ -61,12 +63,20 @@ export function integrityText(health) {
     return health.status === 'passed' ? 'Passed' : 'Incomplete';
 }
 
-/** The concept's four metrics `[value, label]`, in its order. */
-export function metricValues(overview) {
+/** #555: the Images metric's value from the shell's Images count; a dash while unread (undefined) or failed (null). */
+export function imagesText(images) {
+    return Number.isSafeInteger(images) && images >= 0 ? number(images) : '–';
+}
+
+/**
+ * The concept's four metrics `[value, label]`, in its order. `images` is the shell's Images count (#555): the concept's
+ * `images.length`, the same number as the Images sidebar badge.
+ */
+export function metricValues(overview, images) {
     return [
         [number(overview.library.positive_prompts), 'Positive prompts'],
         [number(overview.library.negative_variants), 'Negative variants'],
-        [number(overview.images.indexed), 'Images'],
+        [imagesText(images), 'Images'],
         [integrityText(overview.health), 'Database integrity'],
     ];
 }
@@ -174,10 +184,15 @@ export function categoryRows(statistics) {
     return statistics.by_category.map(row => [row.category ?? 'Uncategorized', number(row.runs)]);
 }
 
-/** D96: the added "Library totals" rows `[label, count]` (the legacy statistics; D153 drops the rated images). */
+/**
+ * D96: the added "Database records" rows `[label, count]` (the legacy statistics; D153 drops the rated images). #555:
+ * they count raw rows (every prompt row, tags on a prompt, every image row), so they say so and never read as the
+ * Library or Images page counts.
+ */
 export function totalsRows(statistics) {
     const { totals } = statistics;
-    return [['Prompts', totals.total_prompts], ['Tags', totals.total_tags], ['Images', totals.total_images]]
+    return [['Prompt records', totals.total_prompts], ['Tags on prompts', totals.total_tags],
+        ['Image records', totals.total_images]]
         .map(([label, value]) => [label, number(value)]);
 }
 
@@ -208,11 +223,11 @@ function table(caption, head, rows, empty) {
     return node;
 }
 
-/** The Statistics dialog: "Runs by category" (the concept's table), then "Library totals" (D96). */
+/** The Statistics dialog: "Runs by category" (the concept's table), then "Database records" (D96, #555). */
 export function statisticsNodes(statistics) {
     return [
         table('Runs by category', ['Category', 'Runs'], categoryRows(statistics), 'No prompts in the library yet.'),
-        table('Library totals', ['Total', 'Count'], totalsRows(statistics), ''),
+        table('Database records', ['Total', 'Count'], totalsRows(statistics), ''),
     ];
 }
 
@@ -332,9 +347,9 @@ export function healthNotice({ api, activity, scope, navigate = navigateTo, noti
     return notice;
 }
 
-function metricsNode(overview) {
+function metricsNode(overview, images) {
     const metrics = el('div', undefined, 'summary-metrics');
-    for (const [value, label] of metricValues(overview)) {
+    for (const [value, label] of metricValues(overview, images)) {
         const metric = el('div', undefined, 'metric');
         metric.append(el('strong', value), el('span', label));
         metrics.append(metric);
@@ -349,7 +364,7 @@ function surface(heading, rows) {
 }
 
 /** The Overview's nodes, and its thumbnail row (painted by its own read). */
-function overviewNodes(overview, { api, activity, notify, scope, navigate, openStatistics, openThumbnails }) {
+function overviewNodes(overview, { api, activity, notify, scope, navigate, openStatistics, openThumbnails, images }) {
     const go = section => () => navigate(`#/system/${section}`);
     const review = operationRow({ scope, title: ambiguousTitle(overview.needs_review),
         description: Number.isSafeInteger(overview.needs_review?.pending)
@@ -374,26 +389,36 @@ function overviewNodes(overview, { api, activity, notify, scope, navigate, openS
         operationRow({ scope, title: 'One display configuration', description: 'Grid and density settings are shared across views.',
             label: 'Appearance', onClick: go('appearance') }),
         operationRow({ scope, title: sourcesTitle, description: sourcesDescription, label: 'Manage sources', onClick: go('sources') }),
-        operationRow({ scope, title: 'Statistics', description: 'Runs by category, with library totals.', label: 'Explore',
+        operationRow({ scope, title: 'Statistics', description: 'Runs by category, with database record counts.', label: 'Explore',
             onClick: openStatistics }),
     ]);
     const columns = el('div', undefined, 'two-col');
     columns.append(health, preferences);
-    return { nodes: [metricsNode(overview), columns], thumbnails, backup: backupRow };
+    const metrics = metricsNode(overview, images);
+    return { nodes: [metrics, columns], thumbnails, backup: backupRow, metrics };
 }
 
 /**
  * The Overview section's mount (`mountSystem`'s `sections.overview`): returns its loading line, which the server's
  * answer replaces in place (the concept's metrics and columns sit directly in `.settings-layout`). A read that a newer
  * one superseded, or one answering after the section left, paints nothing.
+ *
+ * `counts` is the shell's sidebar counts (`{get(id), subscribe(listener), freshen(ids)}`, index.mjs): the Images metric
+ * shows its `images` count and follows it, and a visit re-reads it as the workspace Overview does (#555).
  */
-export function mountOverview(container, { api, activity, scope, navigate = navigateTo, notify = showWorkspaceToast,
-    latestOnly = window.ApiClient.latestOnly, STALE = window.ApiClient.STALE }) {
+export function mountOverview(container, { api, activity, scope, counts = null, navigate = navigateTo,
+    notify = showWorkspaceToast, latestOnly = window.ApiClient.latestOnly, STALE = window.ApiClient.STALE }) {
     const overviewRead = latestOnly({ lifetime: scope.signal });
     const statisticsRead = latestOnly({ lifetime: scope.signal });
     const thumbnailsRead = latestOnly({ lifetime: scope.signal });
     const backupRead = latestOnly({ lifetime: scope.signal });
     let shown = [];
+    // #555: the Images metric's value node, repainted whenever the shell's Images count changes.
+    let imagesValue = null;
+    const imagesCount = () => counts?.get('images');
+    const paintImages = () => {
+        if (imagesValue) imagesValue.textContent = imagesText(imagesCount());
+    };
     // The backup status (undefined while read, null when it failed), painted into its row once both are there (S9).
     let backupStatus;
     let backupRow = null;
@@ -439,8 +464,10 @@ export function mountOverview(container, { api, activity, scope, navigate = navi
         try {
             const overview = await overviewRead(signal => api.get(OVERVIEW_URL, { signal, cache: 'no-store' }));
             if (overview === STALE || scope.signal.aborted) return;
-            const { nodes, thumbnails, backup } = overviewNodes(overview, { api, activity, notify, scope, navigate, openStatistics,
+            const { nodes, thumbnails, backup, metrics } = overviewNodes(overview, { api, activity, notify, scope, navigate,
+                openStatistics, images: imagesCount(),
                 openThumbnails: trigger => openThumbnailReview({ api, store: activity, scope, trigger, navigate }) });
+            imagesValue = metrics.children[2].querySelector('strong');
             thumbnailRow = thumbnails;
             backupRow = backup;
             sources = overview.sources;
@@ -488,6 +515,10 @@ export function mountOverview(container, { api, activity, scope, navigate = navi
     const first = swap(loading());
     // D129: a finished Move library changes where the library lives.
     scope.cleanup(onMoveEnded(activity, load));
+    if (counts) {
+        scope.cleanup(counts.subscribe(paintImages));
+        counts.freshen(['images']);
+    }
     load();
     loadThumbnails();
     loadBackup();

web/js/workspace/system-skipped-tags.mjs

@@ -0,0 +1,246 @@
+/**
+ * System › Auto-tagging "Skipped tags" (#431, D202): words whose suggested tags are never offered, on every suggestion
+ * path (the server filters; hand-typed and stored tags are never touched).
+ *
+ * A `.setting-block` after "Suggestions per image": the label and description, an "Add a word or words" input
+ * (`#tag-skipped-input`) with Add (Enter adds too), the entries as removable chips in the Tag image dialog's D83 chip
+ * markup, and a preview line (`role="status"`) that says how many known tags the list hides
+ * (`POST /prompt_manager/autotag/skipped-tags/preview`: the library's tags plus the downloaded WD14 label lists). The
+ * block carries `data-setting="tag-skipped"` and `data-key="autotag_skipped_tags"`, so a refused save highlights it.
+ * The list is the host draft `autotag_skipped_tags` (an array), saved by the one Save row. The client checks repeat the
+ * server's rules (the server is the authority): an empty, too long, comma or duplicate entry is not added and the line
+ * under the input says why; the list holds at most 200 entries.
+ */
+import { createButton } from '../shared/toolkit/core.js';
+
+export const SKIPPED_KEY = 'autotag_skipped_tags';
+export const PREVIEW_URL = '/prompt_manager/autotag/skipped-tags/preview';
+export const MAX_ENTRIES = 200;
+export const MAX_ENTRY_CHARS = 50;
+export const PREVIEW_DELAY_MS = 300;
+export const SAMPLE_LIMIT = 12;
+
+export const SKIPPED_COPY = Object.freeze({
+    label: 'Skipped tags',
+    description: 'Suggested tags that contain one of these words are hidden. Words are separated by spaces, _ or -; '
+        + 'other characters such as ( ) belong to the word.',
+    placeholder: 'Add a word or words',
+    add: 'Add',
+    chips: 'Skipped tags',
+    empty: 'Enter a word.',
+    comma: 'No commas or line breaks.',
+    long: `At most ${MAX_ENTRY_CHARS} characters.`,
+    duplicate: 'Already in the list.',
+    full: `The list is full (${MAX_ENTRIES}).`,
+    none: 'No tags are skipped.',
+    checking: 'Checking…',
+    failed: 'The preview could not be read.',
+    unchanged: 'Tags already on images are not changed.',
+    libraryOnly: 'Checked against library tags only; no WD14 label list is downloaded.',
+    hidesNothing: 'Hides no known tag',
+});
+
+const plural = (count, word) => `${count.toLocaleString('en-US')} ${word}${count === 1 ? '' : 's'}`;
+
+/** The words of an entry or a tag as the server splits them: NFC, lower case, split on space, `_` and `-`. */
+export const entryWords = text => String(text ?? '').normalize('NFC').toLowerCase().split(/[ _-]+/).filter(Boolean);
+const entryKey = text => entryWords(text).join(' ');
+
+/** Why `raw` cannot be added to `entries` (the line under the input), or '' when it can. */
+export function entryProblem(raw, entries) {
+    const entry = String(raw ?? '').trim();
+    if (!entryWords(entry).length) return SKIPPED_COPY.empty;
+    // Commas and control characters (a pasted line break), as the server refuses them.
+    if (/[,\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(entry)) return SKIPPED_COPY.comma;
+    if ([...entry].length > MAX_ENTRY_CHARS) return SKIPPED_COPY.long;
+    const key = entryKey(entry);
+    if (entries.some(item => entryKey(item) === key)) return SKIPPED_COPY.duplicate;
+    if (entries.length >= MAX_ENTRIES) return SKIPPED_COPY.full;
+    return '';
+}
+
+/** A chip's title and count text for an entry the last preview counted (`count` undefined: not counted yet). */
+export function chipCount(count) {
+    if (!Number.isSafeInteger(count)) return null;
+    return count ? { title: `Hides ${plural(count, 'tag')}`, text: count.toLocaleString('en-US') }
+        : { title: SKIPPED_COPY.hidesNothing, text: 'none' };
+}
+
+/**
+ * The preview line for a preview answer (`{count, sample, sources}`): the bold lead "Hides N tags from suggestions",
+ * then the sample (": a, b and K more. ") and the closing sentences. Returns `{lead, rest}`.
+ */
+export function previewText(result) {
+    const count = Number.isSafeInteger(result?.count) && result.count > 0 ? result.count : 0;
+    const sample = Array.isArray(result?.sample) ? result.sample.filter(name => typeof name === 'string') : [];
+    const more = count - sample.length;
+    const listed = count && sample.length ? `: ${sample.join(', ')}${more > 0 ? ` and ${more.toLocaleString('en-US')} more` : ''}. ` : '. ';
+    const labels = Array.isArray(result?.sources?.wd14) && result.sources.wd14.length > 0;
+    return {
+        lead: `Hides ${plural(count, 'tag')} from suggestions`,
+        rest: `${listed}${labels ? '' : `${SKIPPED_COPY.libraryOnly} `}${SKIPPED_COPY.unchanged}`,
+    };
+}
+
+function el(tag, text, className) {
+    const node = document.createElement(tag);
+    if (text !== undefined) node.textContent = text;
+    if (className) node.className = className;
+    return node;
+}
+
+/**
+ * Build the block; `drafts` is the System draft store, `api` the workspace client. Returns `{node, repaint}`: System
+ * calls `repaint` whenever the drafts change (the chips follow the drafted list, and a changed list is previewed
+ * `PREVIEW_DELAY_MS` after the last change, one request at a time: a newer list aborts the older request).
+ */
+export function skippedTagsBlock({ api, scope, drafts, delay = PREVIEW_DELAY_MS }) {
+    const block = el('div', undefined, 'setting-block');
+    block.dataset.setting = 'tag-skipped';
+    block.dataset.key = SKIPPED_KEY;
+    const text = el('div', undefined, 'setting-block-text');
+    const label = el('label', SKIPPED_COPY.label);
+    label.htmlFor = 'tag-skipped-input';
+    text.append(label, el('p', SKIPPED_COPY.description));
+    const addRow = el('div', undefined, 'skip-add');
+    const input = el('input');
+    input.id = 'tag-skipped-input';
+    input.autocomplete = 'off';
+    input.placeholder = SKIPPED_COPY.placeholder;
+    input.setAttribute('aria-describedby', 'tag-skipped-problem');
+    const add = createButton(SKIPPED_COPY.add);
+    add.id = 'tag-skipped-add';
+    addRow.append(input, add);
+    const problem = el('p', '', 'small skip-problem');
+    problem.id = 'tag-skipped-problem';
+    problem.setAttribute('role', 'alert');
+    const chips = el('div', undefined, 'tags skip-chips');
+    chips.setAttribute('role', 'group');
+    chips.setAttribute('aria-label', SKIPPED_COPY.chips);
+    const preview = el('p', '', 'small skip-preview');
+    preview.setAttribute('role', 'status');
+    preview.setAttribute('aria-live', 'polite');
+    block.append(text, addRow, problem, chips, preview);
+
+    const entries = () => {
+        const value = drafts.get('host', SKIPPED_KEY);
+        return Array.isArray(value) ? value : null;
+    };
+    let counts = new Map();
+    let shown = null; // the list the chips show (JSON)
+    let pending = null; // the list the preview line is (or is being) made for (JSON)
+    let timer = null;
+    let request = null;
+    scope.cleanup(() => { clearTimeout(timer); request?.abort(); });
+
+    const say = message => {
+        problem.textContent = message;
+        if (message) input.setAttribute('aria-invalid', 'true');
+        else input.removeAttribute('aria-invalid');
+    };
+    const setList = next => drafts.set('host', SKIPPED_KEY, next);
+
+    function addEntry() {
+        const list = entries();
+        if (!list) return;
+        const message = entryProblem(input.value, list);
+        say(message);
+        if (message) return;
+        const entry = input.value.trim();
+        input.value = '';
+        setList([...list, entry]);
+    }
+
+    function removeEntry(index) {
+        const list = entries();
+        if (!list) return;
+        const buttons = [...chips.querySelectorAll?.('button') ?? []];
+        const focused = buttons.indexOf(document.activeElement);
+        setList(list.filter((_entry, at) => at !== index));
+        // The removed chip's focus moves to its neighbour's ×, else to the input.
+        if (focused >= 0) {
+            const left = [...chips.querySelectorAll?.('button') ?? []];
+            (left[Math.min(focused, left.length - 1)] ?? input).focus?.();
+        }
+    }
+
+    function renderChips(list) {
+        chips.replaceChildren(...list.map((entry, index) => {
+            const count = chipCount(counts.get(entry));
+            const chip = el('span', undefined, `chip tag-suggestion${count?.text === 'none' ? ' none' : ''}`);
+            if (count) chip.title = count.title;
+            chip.append(el('span', entry));
+            if (count) chip.append(el('span', count.text, 'tag-confidence'));
+            const remove = createButton('×');
+            remove.setAttribute('aria-label', `Remove ${entry}`);
+            scope.listen(remove, 'click', () => removeEntry(index));
+            chip.append(remove);
+            return chip;
+        }));
+    }
+
+    function showPreview(result) {
+        const { lead, rest } = previewText(result);
+        preview.replaceChildren(el('b', lead), rest);
+    }
+
+    async function runPreview(list) {
+        request?.abort();
+        const controller = new AbortController();
+        request = controller;
+        try {
+            const result = await api.post(PREVIEW_URL, { entries: list }, { signal: controller.signal });
+            if (controller.signal.aborted || scope.signal.aborted) return;
+            counts = new Map((Array.isArray(result?.per_entry) ? result.per_entry : [])
+                .filter(row => typeof row?.entry === 'string').map(row => [row.entry, row.count]));
+            showPreview(result);
+            renderChips(entries() ?? list);
+        } catch {
+            if (controller.signal.aborted || scope.signal.aborted) return;
+            preview.textContent = SKIPPED_COPY.failed;
+        } finally {
+            if (request === controller) request = null;
+        }
+    }
+
+    function schedule(list) {
+        clearTimeout(timer);
+        request?.abort();
+        request = null;
+        if (!list.length) {
+            counts = new Map();
+            preview.textContent = SKIPPED_COPY.none;
+            return;
+        }
+        preview.textContent = SKIPPED_COPY.checking;
+        timer = setTimeout(() => runPreview(list), delay);
+    }
+
+    function repaint() {
+        const list = entries();
+        input.disabled = add.disabled = list === null;
+        if (list === null) return;
+        const full = list.length >= MAX_ENTRIES;
+        add.disabled = full;
+        if (full && !problem.textContent) say(SKIPPED_COPY.full);
+        if (!full && problem.textContent === SKIPPED_COPY.full) say('');
+        const key = JSON.stringify(list);
+        if (key !== shown) {
+            shown = key;
+            renderChips(list);
+        }
+        if (key !== pending) {
+            pending = key;
+            schedule(list);
+        }
+    }
+
+    scope.listen(add, 'click', addEntry);
+    scope.listen(input, 'keydown', event => {
+        if (event.key !== 'Enter') return;
+        event.preventDefault?.();
+        addEntry();
+    });
+    scope.listen(input, 'input', () => { if (problem.textContent !== SKIPPED_COPY.full) say(''); });
+    return { node: block, repaint };
+}

web/js/workspace/system-state.mjs

@@ -76,6 +76,22 @@ export function statusText(outcome) {
     return saved.join(' ') || SETTINGS_STATUS.clean;
 }
 
+const plain = value => value !== null && typeof value === 'object'
+    && (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype);
+/** JSON with every object's keys sorted, so key order never makes two values differ. */
+const canonical = value => JSON.stringify(value, (key, item) => (item && typeof item === 'object' && !Array.isArray(item)
+    ? Object.fromEntries(Object.keys(item).sort().map(name => [name, item[name]])) : item));
+
+/**
+ * #431: whether a draft equals a saved value: `Object.is`, or both are arrays or plain objects with the same JSON (keys
+ * sorted). A list setting (Skipped tags) whose added entry was removed again is clean, not a new array that differs.
+ */
+export function sameDraft(a, b) {
+    if (Object.is(a, b)) return true;
+    if (!plain(a) || !plain(b) || Array.isArray(a) !== Array.isArray(b)) return false;
+    return canonical(a) === canonical(b);
+}
+
 function requireDomain(domain) {
     if (!DRAFT_DOMAINS.includes(domain)) throw new TypeError(`Unknown settings domain: ${domain}`);
 }
@@ -112,7 +128,7 @@ export function createSystemDrafts(adapters) {
             values = await (domain === 'browser' ? adapters.readBrowser() : adapters.readRuntime());
         }
         baseline[domain] = { ...(values ?? {}) };
-        for (const [key, value] of drafts[domain]) if (Object.is(baseline[domain][key], value)) drafts[domain].delete(key);
+        for (const [key, value] of drafts[domain]) if (sameDraft(baseline[domain][key], value)) drafts[domain].delete(key);
         notify();
         return { ...baseline[domain] };
     }
@@ -124,7 +140,7 @@ export function createSystemDrafts(adapters) {
 
     function set(domain, key, value) {
         requireDomain(domain);
-        if (Object.is(baseline[domain][key], value)) drafts[domain].delete(key);
+        if (sameDraft(baseline[domain][key], value)) drafts[domain].delete(key);
         else drafts[domain].set(key, value);
         failedKeys[domain].delete(key);
         outcome = null;
@@ -153,7 +169,7 @@ export function createSystemDrafts(adapters) {
     function commit(domain, written) {
         for (const [key, value] of written) {
             baseline[domain][key] = value;
-            if (drafts[domain].has(key) && Object.is(drafts[domain].get(key), value)) drafts[domain].delete(key);
+            if (drafts[domain].has(key) && sameDraft(drafts[domain].get(key), value)) drafts[domain].delete(key);
         }
     }
 

web/js/workspace/system-tagging.mjs

@@ -9,7 +9,9 @@
  * - "Existing tags", "General-tag confidence", "Character-tag confidence": the concept's labels and descriptions
  *   verbatim (they state the shipped defaults); host keys `autotag_existing`, `autotag_general_threshold`,
  *   `autotag_character_threshold`. D133 adds "Suggestions per image" (`autotag_suggestion_limit`, 1–100) after them.
- * - The `.field` "LLM tag template" (`#tag-template`, `autotag_template`).
+ * - D202 (#431): the "Skipped tags" block after it (system-skipped-tags.mjs, host key `autotag_skipped_tags`).
+ * - D203 (#431): "Saved instructions" and the two per-engine default rows (system-instructions.mjs, host keys
+ *   `autotag_instructions` and `autotag_default_instructions`) replace the concept's "LLM tag template" field.
  * - `.row-actions`: "Preview tagging review" (`ca-primary`) opens the Tag image dialog for the image selected in Images
  *   with the section's current model and values, aria-disabled without one (the D115 sentence) or with an invalid
  *   value (the toast names it). D132: the concept's two simulated job buttons are "Download" (or
@@ -35,6 +37,9 @@ import { selectedImage } from './images.mjs';
 import { NO_SELECTION } from './vocabulary.mjs';
 import { showWorkspaceToast } from './toast.mjs';
 import { navigateTo } from './state.mjs';
+import { skippedTagsBlock } from './system-skipped-tags.mjs';
+import { BUILTIN_TEXT_KEY, DEFAULTS_KEY, INSTRUCTIONS_KEY, defaultEntry, listProblem, savedInstructionsBlock }
+    from './system-instructions.mjs';
 
 export const MODELS_URL = '/prompt_manager/autotag/models';
 export const UNLOAD_URL = '/prompt_manager/autotag/unload';
@@ -68,10 +73,10 @@ export const SETTING_KEYS = Object.freeze({
     'threshold-general': 'autotag_general_threshold',
     'threshold-character': 'autotag_character_threshold',
     'tag-suggestions': 'autotag_suggestion_limit',
-    'tag-template': 'autotag_template',
 });
+/** #431: the values the instruction readers take besides the rows' (D203, D205). */
+const INSTRUCTION_VALUES = Object.freeze([INSTRUCTIONS_KEY, DEFAULTS_KEY, BUILTIN_TEXT_KEY]);
 const NUMERIC = new Set(['autotag_general_threshold', 'autotag_character_threshold', 'autotag_suggestion_limit']);
-const MAX_TEMPLATE_CHARS = 4000;
 
 export const STATUS_COPY = Object.freeze({
     loading: 'Loading model status…',
@@ -91,9 +96,6 @@ export const SETTING_PROBLEMS = Object.freeze({
     autotag_general_threshold_step: 'General-tag confidence must be a multiple of 0.05.',
     autotag_character_threshold_step: 'Character-tag confidence must be a multiple of 0.05.',
     autotag_suggestion_limit: 'Suggestions per image must be a whole number from 1 to 100.',
-    // The server's two template sentences (`validate_template`), blank first.
-    autotag_template: 'LLM tag template must be non-empty text.',
-    autotag_template_length: `LLM tag template must be at most ${MAX_TEMPLATE_CHARS} characters.`,
 });
 /** Characters as Python's `len` counts them (code points), not UTF-16 units. */
 export const characters = text => [...String(text ?? '')].length;
@@ -191,20 +193,23 @@ const onStep = value => Math.abs(value * 20 - Math.round(value * 20)) <= 1e-12;
 // A threshold on the grid, handed on exactly as the server stores it (anything else is left for draftProblem to refuse).
 const snapped = value => (unit(value) && onStep(value) ? Math.round(value * 20) / 20 : value);
 
+/** #431 (D205): the drafted default instructions of the drafted language-model engine. */
+export const engineInstructions = values => defaultEntry(values, values.autotag_model_type === 'hf' ? 'hf' : 'gguf');
+
 /**
  * The first setting the chosen model would use that the section cannot send, as `{key, message}`, else null: WD14
- * reads both thresholds (0 to 1 in steps of 0.05, #369), the language models the template; Generate also reads the
- * suggestion count (`limit`).
+ * reads both thresholds (0 to 1 in steps of 0.05, #369), the language models the saved instructions (#431: the server's
+ * sentence for the first entry it would refuse); Generate also reads the suggestion count (`limit`).
  */
 export function draftProblem(values, { limit = true } = {}) {
     const model = values.autotag_model_type;
-    const keys = CLASSIFIERS.has(model) ? ['autotag_general_threshold', 'autotag_character_threshold'] : ['autotag_template'];
+    const keys = CLASSIFIERS.has(model) ? ['autotag_general_threshold', 'autotag_character_threshold'] : [INSTRUCTIONS_KEY];
     if (limit) keys.push('autotag_suggestion_limit');
     for (const key of keys) {
         const value = values[key];
-        if (key === 'autotag_template') {
-            if (typeof value !== 'string' || value.trim() === '') return { key, message: SETTING_PROBLEMS.autotag_template };
-            if (characters(value) > MAX_TEMPLATE_CHARS) return { key, message: SETTING_PROBLEMS.autotag_template_length };
+        if (key === INSTRUCTIONS_KEY) {
+            const message = listProblem(values);
+            if (message) return { key, message };
             continue;
         }
         const valid = key === 'autotag_suggestion_limit' ? Number.isInteger(value) && value >= 1 && value <= 100 : unit(value);
@@ -220,7 +225,7 @@ export function taggingPreset(values) {
     const options = CLASSIFIERS.has(model)
         ? { general_threshold: snapped(values.autotag_general_threshold),
             character_threshold: snapped(values.autotag_character_threshold) }
-        : { instructions: values.autotag_template };
+        : { instructions: engineInstructions(values).text };
     return { model, options: { ...options, suggestion_limit: values.autotag_suggestion_limit } };
 }
 
@@ -230,7 +235,7 @@ export function batchBody(values) {
     const options = CLASSIFIERS.has(model)
         ? { general_threshold: snapped(values.autotag_general_threshold),
             character_threshold: snapped(values.autotag_character_threshold) }
-        : { instructions: values.autotag_template };
+        : { instructions: engineInstructions(values).text };
     return { model_type: model, existing: values.autotag_existing, options };
 }
 
@@ -285,14 +290,20 @@ export function timeText(plan) {
     return durationText(Math.ceil(seconds / 60)) + (plan.estimate_device === 'gpu' ? TIME_ON_GPU : TIME_ON_CPU);
 }
 
-/** D134: the review's rows from the server's preview and the drafts it was made with (image counts, #379). */
+/**
+ * D134: the review's rows from the server's preview and the drafts it was made with (image counts, #379). D205 (#431):
+ * a language-model engine shows its default instructions by name in an "Instructions" row, and Settings reads "Up to L
+ * tags per image".
+ */
 export function batchGrid(plan, values) {
     const id = plan.model?.type ?? values.autotag_model_type;
-    let settings = CLASSIFIERS.has(id)
-        ? `General ${values.autotag_general_threshold} · Character ${values.autotag_character_threshold}`
-        : `Template of ${number(characters(values.autotag_template))} characters`;
+    const classifier = CLASSIFIERS.has(id);
     // The saved count the run uses (the preview's), not an unsaved draft.
-    if (Number.isSafeInteger(plan.suggestion_limit)) settings += ` · up to ${number(plan.suggestion_limit)} tags per image`;
+    const limit = Number.isSafeInteger(plan.suggestion_limit) ? `up to ${number(plan.suggestion_limit)} tags per image` : '';
+    const settings = classifier
+        ? `General ${values.autotag_general_threshold} · Character ${values.autotag_character_threshold}${limit ? ` · ${limit}` : ''}`
+        : limit.charAt(0).toUpperCase() + limit.slice(1);
+    const instructions = classifier ? [] : [['Instructions', defaultEntry(values, id === 'hf' ? 'hf' : 'gguf').name]];
     return [
         ['Model', `${modelLabel(id, plan.model)} · ${modelSize(id, plan.model)}`],
         ['Existing tags', existingLabel(plan.existing ?? values.autotag_existing)],
@@ -300,6 +311,7 @@ export function batchGrid(plan, values) {
         ['Already auto-tagged', number(plan.already_tagged)],
         ['Images to tag', `about ${number(plan.to_tag)}`],
         ['Time', timeText(plan)],
+        ...instructions,
         ['Settings', settings],
         ['Backup', backupText(plan.backup)],
     ];
@@ -410,17 +422,13 @@ export function mountTagging(container, { api, activity, scope, drafts, notify =
     // D133: the persisted suggestion count, which the concept does not show.
     add(settingRow({ id: 'tag-suggestions', label: 'Suggestions per image', description: SUGGESTIONS_DESCRIPTION,
         control: { type: 'number', min: 1, max: 100, step: 1 } }), 'tag-suggestions');
+    // D202 (#431): the words whose suggested tags are hidden on every suggestion path.
+    const skipped = skippedTagsBlock({ api, scope, drafts });
+    surface.append(skipped.node);
 
-    const field = el('div', undefined, 'field');
-    const templateLabel = el('label', 'LLM tag template');
-    templateLabel.htmlFor = 'tag-template';
-    const template = el('textarea');
-    template.id = 'tag-template';
-    template.dataset.setting = 'tag-template';
-    template.dataset.key = SETTING_KEYS['tag-template'];
-    field.append(templateLabel, template);
-    surface.append(field);
-    controls.push({ id: 'tag-template', key: SETTING_KEYS['tag-template'], input: template, text: null });
+    // D203 (#431): the saved instructions and each language-model engine's default replace the template field.
+    const instructions = savedInstructionsBlock({ scope, drafts });
+    surface.append(...instructions.nodes);
 
     for (const { key, input } of controls) {
         // Text controls draft while typing (the Save row follows at once); selects and numbers on change.
@@ -449,11 +457,14 @@ export function mountTagging(container, { api, activity, scope, drafts, notify =
     // The "could not be read" line under each row, while the server settings could not be read.
     const notes = new Map();
     const image = selected();
-    const current = () => Object.fromEntries(Object.values(SETTING_KEYS).map(key => [key, drafts.get('host', key)]));
+    const current = () => Object.fromEntries([...Object.values(SETTING_KEYS), ...INSTRUCTION_VALUES]
+        .map(key => [key, drafts.get('host', key)]));
     const chosen = () => drafts.get('host', 'autotag_model_type');
     const known = () => MODEL_IDS.includes(chosen());
 
     const repaint = () => {
+        skipped.repaint();
+        instructions.repaint();
         const values = current();
         const unread = values.autotag_model_type === undefined;
         const failed = drafts.hostState?.() === 'failed' && unread;

web/js/workspace/system.mjs

@@ -135,7 +135,7 @@ export const DELIVERED_SECTIONS = Object.freeze({
 /**
  * Mount System under the heading `renderHeading` wrote in `main`. Returns `{show(section)}`, which shows another
  * section in place. `scope` is the page's view scope; `sections` maps a section id to a delivered section's mount
- * (`(container, {api, activity, scope, drafts}) => nodes`) for every section. `activity` is the page's Activity store, which follows the jobs a section starts.
+ * (`(container, {api, activity, scope, drafts, counts}) => nodes`; `counts` is the shell's sidebar counts, #555) for every section. `activity` is the page's Activity store, which follows the jobs a section starts.
  *
  * The host values are read on mount (and by the store again after a conflict), so a save carries the current revision;
  * until a read returned one, a host save fails without a request (system-state.mjs). The browser values are read on
@@ -159,7 +159,8 @@ function legacyPagesLine() {
     return line;
 }
 
-export function mountSystem(main, api, scope, { section, activity, sections = DELIVERED_SECTIONS, navigate = navigateTo }) {
+export function mountSystem(main, api, scope, { section, activity, counts = null, sections = DELIVERED_SECTIONS,
+    navigate = navigateTo }) {
     const store = systemDrafts(api);
     jobs = activity;
     store.reloadHost();
@@ -208,7 +209,7 @@ export function mountSystem(main, api, scope, { section, activity, sections = DE
         for (const button of nav.children) button.setAttribute('aria-pressed', String(button.dataset.value === next));
         while (layout.firstChild !== saveRow) layout.firstChild.remove();
         // Every section is delivered (S12), and the router only names known sections (state.mjs).
-        const nodes = sections[next](layout, { api, activity, scope: sectionScope, drafts: store });
+        const nodes = sections[next](layout, { api, activity, scope: sectionScope, drafts: store, counts });
         layout.prepend(...nodes);
         if (next === 'overview') main.append(legacyPages);
         else legacyPages.remove();

web/js/workspace/workspace.css

@@ -443,12 +443,12 @@ pre.prompt-text { font: inherit; font-size: 12px; line-height: 1.75; margin-bloc
    suggestions are removable chips, each the concept's `.chip` corner (4px; the later `.tag-suggestion` row rule would
    give 5px) around the row's 12px text in its checked suggestion row's tokens (`.tag-suggestion:has(input:checked)`,
    s1655): a name, the confidence and a × button. */
-#tag-suggestions .chip.tag-suggestion { display: inline-flex; gap: 6px; padding: 2px 2px 2px 8px; margin-bottom: 0; cursor: default; color: inherit; border-color: var(--ca-accent); background: var(--soft-blue); border-radius: 4px; /* D83 */ }
-#tag-suggestions .chip.tag-suggestion .tag-confidence { margin-inline-start: 0; /* D83 */ }
-.ca-tools #tag-suggestions .chip.tag-suggestion > button { min-block-size: 24px; min-inline-size: 24px; padding: 0 6px; /* D83 */ }
+#tag-suggestions .chip.tag-suggestion, .skip-chips .chip.tag-suggestion { display: inline-flex; gap: 6px; padding: 2px 2px 2px 8px; margin-bottom: 0; cursor: default; color: inherit; border-color: var(--ca-accent); background: var(--soft-blue); border-radius: 4px; /* D83 */ }
+#tag-suggestions .chip.tag-suggestion .tag-confidence, .skip-chips .chip.tag-suggestion .tag-confidence { margin-inline-start: 0; /* D83 */ }
+.ca-tools #tag-suggestions .chip.tag-suggestion > button, .ca-tools .skip-chips .chip.tag-suggestion > button { min-block-size: 24px; min-inline-size: 24px; padding: 0 6px; /* D83 */ }
 @media (pointer: coarse) {
     /* D83: the chip's × keeps the concept's 40px coarse target. */
-    .ca-tools #tag-suggestions .chip.tag-suggestion > button { min-block-size: 40px; min-inline-size: 40px; }
+    .ca-tools #tag-suggestions .chip.tag-suggestion > button, .ca-tools .skip-chips .chip.tag-suggestion > button { min-block-size: 40px; min-inline-size: 40px; }
 }
 
 /* Needs review (#249 PR F): the concept's Metadata review page (app.js a749–760) in its own classes. */
@@ -492,15 +492,58 @@ pre.prompt-text { font: inherit; font-size: 12px; line-height: 1.75; margin-bloc
 @media (max-width: 700px) {
   #workspace-main .setting-row :is(#send-destination, #renderer) { max-width: 160px !important; /* D106 */ }
 }
+/* D202 (#431): System › Auto-tagging "Skipped tags", a setting whose control (an add input, the chips and the preview
+   line) is wider than a `.setting-row` column: the row's label and description tokens over the full width, the chips
+   in the Tag image dialog's D83 chip markup (an entry that hides no known tag is muted). */
+.setting-block { padding: 17px 0; border-top: 1px solid var(--line); /* D202 */ }
+.setting-block-text label { font-size: 12px; font-weight: 500; display: block; /* D202 */ }
+.setting-block-text p { font-size: 11px; color: var(--ca-muted); margin-top: 4px; max-width: 640px; /* D202 */ }
+.setting-block[aria-invalid="true"] { box-shadow: inset 3px 0 0 var(--red); padding-inline-start: 12px; /* D202 */ }
+.skip-add { display: flex; gap: 8px; margin-top: 12px; max-width: 460px; /* D202 */ }
+.skip-add input { flex: 1; min-width: 0; font-size: 12px; /* D202 */ }
+.skip-problem { color: var(--red); margin-top: 6px; /* D202 */ }
+.skip-problem:empty, .skip-chips:empty { display: none; /* D202 */ }
+.skip-chips .chip.tag-suggestion.none { border-color: var(--line); background: var(--ca-field); color: var(--ca-muted); /* D202 */ }
+.skip-preview { margin-top: 12px; max-width: 760px; /* D202 */ }
+.skip-preview b { font-weight: 500; color: var(--ca-text); /* D202 */ }
+@media (max-width: 700px) {
+    .skip-add { max-width: none; /* D202 */ }
+}
+
+/* D203 (#431): "Saved instructions": the list (Built-in first, its chips) beside the Name/Text editor, stacked under
+   it below 700px, and the note a deleted default leaves under the two default rows. */
+.instructions-layout { display: grid; grid-template-columns: minmax(200px, 260px) minmax(0, 1fr); gap: 18px; margin-top: 12px; /* D203 */ }
+.instruction-list { border: 1px solid var(--line); border-radius: 6px; background: var(--ca-field); max-height: 300px; overflow: auto; /* D203 */ }
+.instruction-list [role="option"] { display: flex; flex-direction: column; gap: 4px; padding: 9px 12px; cursor: pointer; border-bottom: 1px solid var(--line); font-size: 12px; /* D203 */ }
+.instruction-list [role="option"]:last-child { border-bottom: 0; /* D203 */ }
+.instruction-list [role="option"][aria-selected="true"] { background: var(--soft-blue); box-shadow: inset 3px 0 0 var(--ca-accent); /* D203 */ }
+.instruction-list .badges { display: flex; flex-wrap: wrap; gap: 4px; /* D203 */ }
+.instruction-actions { margin-top: 10px; flex-wrap: wrap; /* D203 */ }
+.instruction-editor .field:first-child { margin-top: 0; /* D203 */ }
+.instruction-editor input[readonly], .instruction-editor textarea[readonly] { color: var(--ca-muted); /* D203 */ }
+.instruction-editor label { display: flex; justify-content: space-between; gap: 8px; /* D203 */ }
+.instruction-reset { color: var(--warning); margin: 0 0 14px; /* D203 */ }
+.instruction-reset:empty { display: none; /* D203 */ }
+@media (max-width: 700px) {
+    .instructions-layout { grid-template-columns: 1fr; /* D203 */ }
+}
+
+/* D204 (#431): the one-off edit's note under "Tagging instructions" in the Tag image and Auto-tag selected dialogs. */
+.tag-model-panel .instructions-edited { margin: -6px 0 12px; /* D204 */ }
+.tag-model-panel .instructions-edited[hidden] { display: none; /* D204 */ }
+
 /* D132: at phone width the concept's 120px cap cuts every engine label ("WD14 SwinV2 · ~400 MB"); the Tagging model
    select alone keeps its natural width there (its widest engine label) and, with no room beside the row text, wraps
    under it. Existing tags (#398) never shrinks for its row text and, past the cap, keeps its natural width beside the
    text ("Replace after review"), bounded by its row like the engine select. */
 .setting-row #tag-existing { flex-shrink: 0; /* D132 */ }
+/* D203: the default-instructions selects show their chosen name whole, as Existing tags does (#398). */
+.setting-row #instruction-default-gguf, .setting-row #instruction-default-hf { flex-shrink: 0; /* D203 */ }
 @media (max-width: 700px) {
   #workspace-main .setting-row:has(> #tag-model) { flex-wrap: wrap; /* D132 */ }
   #workspace-main .setting-row #tag-model { flex-shrink: 0; max-width: 100% !important; /* D132 */ }
   #workspace-main .setting-row #tag-existing { max-width: 100% !important; /* D132 */ }
+  #workspace-main .setting-row #instruction-default-gguf, #workspace-main .setting-row #instruction-default-hf { max-width: 100% !important; /* D203 */ }
 }
 
 /* D109: System › Diagnostics & logs' added Lines field sits in the concept's toolbar like its Level select, and a value