Merge pull request 'v26.05.27.0: PostCard redesign + IR-style tag suffix + drop meta/rating + extension v1.0.4 CSP fix' (#28) from dev into main

The two prefix-parsing tests were pinned to `artist:Eric`, but `artist`
was removed from KNOWN_KINDS in commit 4cad07a (provenance is a separate
axis from tags). The parser now keeps `artist:` literal, so the assertion
`body["name"] == "Eric"` failed.

Repointed to `character:Saber` (still in KNOWN_KINDS). Also updated the
stale `artist:` docstring example in parse_kind_prefix to `fandom:`.

Caught by [[reference-grep-pinned-tests-in-plans]] — should have grep'd
tests/ for `artist:` when shrinking KNOWN_KINDS. Banking the miss.

.forgejo/workflows/build.yml

@@ -2,7 +2,17 @@ name: Build images
 
 on:
   push:
-    branches: [dev, main]
+    # `:dev` builds dropped 2026-05-26 — operator tests from `:latest` after
+    # merge-to-main, not from the dev branch image. Saves one full docker
+    # build per dev push.
+    branches: [main]
+    # Tag-push triggers an immutable per-version image build (e.g.
+    # `:v26.05.26.5`) — gives a real rollback story alongside the floating
+    # `:main` / `:latest`. Layer reuse keeps the registry-storage cost
+    # negligible per tag. Doesn't overlap with the push-to-main build (that
+    # one publishes `:main` + `:latest`; the tag-push build publishes only
+    # `:<tag>`).
+    tags: ['v*']
 
 # Requires repo secret RELEASE_TOKEN — a Forgejo PAT with scopes:
 #   - write:package, read:package  (for docker push to git.fabledsword.com)
@@ -158,8 +168,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Download signed XPI from Forgejo release asset (main only)
-        if: github.ref == 'refs/heads/main'
+      - name: Download signed XPI from Forgejo release asset (main + tags)
+        # Fires on main-push AND on tag-push. Tag-push builds re-package the
+        # same source code as the preceding main-push build but with an
+        # immutable version tag — they need the XPI too, otherwise the
+        # versioned image ships without the signed extension.
+        if: github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/')
         env:
           TOKEN: ${{ secrets.RELEASE_TOKEN }}
         run: |
@@ -200,7 +214,20 @@ jobs:
       - name: Determine tag
         id: tag
         run: |
-          if [ "${GITHUB_REF##*/}" = "main" ]; then
+          # Three trigger shapes:
+          #   refs/tags/v…   → tag-push: publish ONLY the immutable version
+          #                    tag (e.g. :v26.05.26.5). Don't touch :latest;
+          #                    that already got published by the main-push
+          #                    build for the merge commit.
+          #   refs/heads/main → push to main (incl. PR merge commits):
+          #                    publish :main + :latest (floating).
+          #   anything else  → safety net; shouldn't fire given the `on:`
+          #                    config above (dev was dropped). Tag :dev to
+          #                    surface the unexpected run in the registry.
+          if [ "${GITHUB_REF#refs/tags/}" != "${GITHUB_REF}" ]; then
+            TAG_NAME="${GITHUB_REF#refs/tags/}"
+            echo "tags=git.fabledsword.com/bvandeusen/fabledcurator:${TAG_NAME}" >> "$GITHUB_OUTPUT"
+          elif [ "${GITHUB_REF##*/}" = "main" ]; then
             echo "tags=git.fabledsword.com/bvandeusen/fabledcurator:main,git.fabledsword.com/bvandeusen/fabledcurator:latest" >> "$GITHUB_OUTPUT"
           else
             echo "tags=git.fabledsword.com/bvandeusen/fabledcurator:dev" >> "$GITHUB_OUTPUT"
@@ -231,7 +258,13 @@ jobs:
       - name: Determine tag
         id: tag
         run: |
-          if [ "${GITHUB_REF##*/}" = "main" ]; then
+          # Mirrors build-web's three-shape logic (tag-push / main-push /
+          # safety-net dev). The -ml image follows the same release cadence
+          # as the web image.
+          if [ "${GITHUB_REF#refs/tags/}" != "${GITHUB_REF}" ]; then
+            TAG_NAME="${GITHUB_REF#refs/tags/}"
+            echo "tags=git.fabledsword.com/bvandeusen/fabledcurator-ml:${TAG_NAME}" >> "$GITHUB_OUTPUT"
+          elif [ "${GITHUB_REF##*/}" = "main" ]; then
             echo "tags=git.fabledsword.com/bvandeusen/fabledcurator-ml:main,git.fabledsword.com/bvandeusen/fabledcurator-ml:latest" >> "$GITHUB_OUTPUT"
           else
             echo "tags=git.fabledsword.com/bvandeusen/fabledcurator-ml:dev" >> "$GITHUB_OUTPUT"

.forgejo/workflows/ci.yml

@@ -8,8 +8,10 @@ name: CI
 on:
   push:
     branches: [dev, main]
-  pull_request:
-    branches: [main]
+  # pull_request trigger intentionally absent — with branches: [dev, main]
+  # above, every PR commit already fires CI via the push event on dev. Adding
+  # pull_request would duplicate runs on dev→main PRs. FC has no fork PRs
+  # (single-operator Forgejo repo) so push coverage is complete.
 
 jobs:
   backend-lint-and-test:
@@ -24,13 +26,17 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Cache pip wheels
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: pip-${{ runner.os }}-py314-${{ hashFiles('requirements.txt') }}
-          restore-keys: |
-            pip-${{ runner.os }}-py314-
+      # Cache step removed 2026-05-26: act_runner's cache backend has been
+      # broken on this homelab runner since 2026-05-15 (first as request-
+      # timeout warnings, then as hard "Cannot find module .../dist/restore/
+      # index.js" failures that tank the whole job). The cache step targeted
+      # ~/.cache/pip but the install below uses `uv pip install` primarily,
+      # whose own cache lives at ~/.cache/uv — so the cache step's real
+      # benefit was marginal even when working. Cost of removal: ~30s of
+      # wheel downloads per job. Future re-enable: mount ~/.cache/uv as a
+      # docker volume at the runner level (skips actions/cache entirely),
+      # or fix the runner-side cache backend (clear /var/run/act/actions/*,
+      # pin act_runner version, etc.).
 
       - name: Install Python deps
         # ruff is pre-installed in the ci-python image (see CI-Runner/CI-python/
@@ -124,13 +130,6 @@ jobs:
           --health-retries 10
     steps:
       - uses: actions/checkout@v4
-      - name: Cache pip wheels
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: pip-${{ runner.os }}-py314-${{ hashFiles('requirements.txt') }}
-          restore-keys: |
-            pip-${{ runner.os }}-py314-
       - name: API integration shard (resolve service IPs, migrate, test)
         run: |
           set -eux
@@ -189,13 +188,6 @@ jobs:
           --health-retries 10
     steps:
       - uses: actions/checkout@v4
-      - name: Cache pip wheels
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: pip-${{ runner.os }}-py314-${{ hashFiles('requirements.txt') }}
-          restore-keys: |
-            pip-${{ runner.os }}-py314-
       - name: Importer integration shard (resolve service IPs, migrate, test)
         run: |
           set -eux
@@ -254,13 +246,6 @@ jobs:
           --health-retries 10
     steps:
       - uses: actions/checkout@v4
-      - name: Cache pip wheels
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: pip-${{ runner.os }}-py314-${{ hashFiles('requirements.txt') }}
-          restore-keys: |
-            pip-${{ runner.os }}-py314-
       - name: Core integration shard (everything not api / importer / migration / phash / sidecar / scan / archive / backfill)
         run: |
           set -eux

alembic/versions/0021_image_provenance_unique.py

@@ -0,0 +1,54 @@
+"""provenance-race: dedupe + UNIQUE(image_record_id, post_id) on image_provenance
+
+Revision ID: 0021
+Revises: 0020
+Create Date: 2026-05-26
+
+Closes the race in Importer._apply_sidecar's existence-check + INSERT pattern.
+Two workers writing for the same (image, post) pair both saw no existing row
+and both inserted, leaving duplicates that then broke .scalar_one_or_none()
+on every subsequent deep-scan rederive against those images
+(MultipleResultsFound). Most plausibly seeded when the 5-min recovery sweep
+re-enqueued a still-running long-import task and the second worker collided
+with the first inside _apply_sidecar.
+
+Migration steps:
+  1. DELETE all but min(id) per (image_record_id, post_id) pair. Operator's
+     DB had 2 affected pairs at write-time; harmless no-op if zero.
+  2. Add UNIQUE constraint so the importer's new savepoint+IntegrityError
+     recovery path can trip on collision and re-select, mirroring
+     uq_source_artist_platform_url and uq_post_source_external_id.
+"""
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "0021"
+down_revision: Union[str, None] = "0020"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.execute(
+        """
+        DELETE FROM image_provenance ip1
+        USING image_provenance ip2
+        WHERE ip1.image_record_id = ip2.image_record_id
+          AND ip1.post_id = ip2.post_id
+          AND ip1.id > ip2.id
+        """
+    )
+    op.create_unique_constraint(
+        "uq_image_provenance_image_post",
+        "image_provenance",
+        ["image_record_id", "post_id"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(
+        "uq_image_provenance_image_post",
+        "image_provenance",
+        type_="unique",
+    )

alembic/versions/0022_source_per_artist_platform.py

@@ -0,0 +1,223 @@
+"""source-collapse: one Source per (artist, platform) — consolidate junk per-post Sources
+
+Revision ID: 0022
+Revises: 0021
+Create Date: 2026-05-26
+
+Closes the operator-flagged 2026-05-26 issue where the filesystem importer
+called _find_or_create_source(url=sd.post_url), creating one Source row per
+imported post URL. Operator's Atole artist had 406 Source rows where there
+should have been 1 (the /cw/Atole subscription Source).
+
+Source represents a subscription feed (one per artist+platform — the
+gallery-dl URL polled by the FC-3 downloader). Posts hang off it. The
+filesystem importer was misusing Source as a per-post key.
+
+Migration steps per (artist_id, platform) group with >1 Source:
+  1. Pick canonical — prefer a URL NOT matching '/posts/<id>$' (real
+     campaign URL like /cw/Atole); else min(id).
+  2. PRE-merge any Posts under non-canonical sources whose
+     external_post_id ALREADY exists under the canonical source. (Same
+     gallery-dl post imported via two different sidecar paths can plant
+     two Post rows with identical external_post_id under different
+     Sources for the same artist.) Repoint ImageProvenance +
+     ImageRecord.primary_post_id to the canonical-side Post, dedupe
+     ImageProvenance against alembic 0021's uq, then delete the
+     non-canonical-side Post. This MUST happen before step 3 — Postgres
+     fires uq_post_source_external_id row-by-row during the bulk UPDATE
+     and the merge-after-reparent ordering 500s on first collision
+     (operator-hit during v26.05.26.1 deploy, 2026-05-26).
+  3. Reparent remaining Posts onto canonical (no collisions possible now).
+  4. Reparent ImageProvenance.source_id off the non-canonical sources.
+  5. Delete the orphan Source rows.
+  6. If the canonical Source's URL still looks like a per-post URL (no
+     campaign URL existed among candidates), rewrite it to
+     'sidecar:<platform>:<artist_slug>' so the artist detail page shows
+     something readable.
+"""
+from typing import Sequence, Union
+
+from alembic import op
+from sqlalchemy import text
+
+revision: str = "0022"
+down_revision: Union[str, None] = "0021"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_POST_URL_RE = r"/posts/[^/]+$"
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    # Find (artist_id, platform) groups with > 1 Source row.
+    groups = conn.execute(text("""
+        SELECT artist_id, platform
+        FROM source
+        GROUP BY artist_id, platform
+        HAVING COUNT(*) > 1
+    """)).fetchall()
+
+    for artist_id, platform in groups:
+        rows = conn.execute(
+            text("""
+                SELECT id, url FROM source
+                WHERE artist_id = :a AND platform = :p
+                ORDER BY id ASC
+            """),
+            {"a": artist_id, "p": platform},
+        ).fetchall()
+
+        # Canonical: first row whose URL doesn't look like a per-post URL;
+        # else min(id).
+        canonical_id = None
+        for sid, url in rows:
+            if not _matches_post_url(url):
+                canonical_id = sid
+                break
+        if canonical_id is None:
+            canonical_id = rows[0][0]
+
+        other_ids = [sid for sid, _ in rows if sid != canonical_id]
+        if not other_ids:
+            continue
+
+        # STEP 2: PRE-merge ALL Posts with duplicate external_post_id
+        # across the entire (canonical + others) group, BEFORE the bulk
+        # reparent. Two cases must both be handled:
+        #   (A) canonical has Post X with epid=N; an "other" source has
+        #       Post Y with epid=N → after bulk UPDATE, (canonical, N)
+        #       collides with itself.
+        #   (B) two different "other" sources each have a Post with
+        #       epid=N; canonical has none → after bulk UPDATE, both
+        #       are repointed to (canonical, N) and the second collides.
+        # The earlier version of this migration only handled (A); the
+        # operator's deploy 2026-05-26 tripped (B) at line 139.
+        # Fix: group ALL Posts in the (artist, platform) by epid; for
+        # any group with count>1, pick the keep (prefer one already
+        # under canonical; else lowest id) and merge the rest into it.
+        all_posts = conn.execute(
+            text("""
+                SELECT external_post_id, id, source_id
+                FROM post
+                WHERE source_id = :canonical OR source_id = ANY(:others)
+                ORDER BY external_post_id, id
+            """),
+            {"canonical": canonical_id, "others": other_ids},
+        ).fetchall()
+        by_epid: dict = {}
+        for epid, post_id, src_id in all_posts:
+            by_epid.setdefault(epid, []).append((post_id, src_id))
+        for _epid, posts in by_epid.items():
+            if len(posts) <= 1:
+                continue
+            # Prefer a Post already under canonical as the keep.
+            canonical_posts = [p for p in posts if p[1] == canonical_id]
+            if canonical_posts:
+                keep_id = canonical_posts[0][0]
+            else:
+                keep_id = posts[0][0]  # already sorted by id ASC
+            drop_ids = [p[0] for p in posts if p[0] != keep_id]
+            for drop_id in drop_ids:
+                # Pre-delete image_provenance rows under drop_ whose
+                # image_record_id ALREADY has a provenance under keep —
+                # the UPDATE below would otherwise repoint them and
+                # trip uq_image_provenance_image_post (alembic 0021)
+                # row-by-row before any after-the-fact dedupe could
+                # run. Operator's v26.05.26.3 deploy 2026-05-26 tripped
+                # this at line 123.
+                conn.execute(
+                    text("""
+                        DELETE FROM image_provenance
+                        WHERE post_id = :drop_
+                          AND image_record_id IN (
+                              SELECT image_record_id FROM image_provenance
+                              WHERE post_id = :keep
+                          )
+                    """),
+                    {"keep": keep_id, "drop_": drop_id},
+                )
+                # Now safe to repoint the survivors.
+                conn.execute(
+                    text("""
+                        UPDATE image_provenance SET post_id = :keep
+                        WHERE post_id = :drop_
+                    """),
+                    {"keep": keep_id, "drop_": drop_id},
+                )
+                conn.execute(
+                    text("""
+                        UPDATE image_record SET primary_post_id = :keep
+                        WHERE primary_post_id = :drop_
+                    """),
+                    {"keep": keep_id, "drop_": drop_id},
+                )
+                conn.execute(
+                    text("DELETE FROM post WHERE id = :drop_"),
+                    {"drop_": drop_id},
+                )
+
+        # STEP 3: Bulk reparent the remaining Posts off the other
+        # Sources. After step 2, no collisions on
+        # (canonical, external_post_id) are possible.
+        conn.execute(
+            text("""
+                UPDATE post SET source_id = :canonical
+                WHERE source_id = ANY(:others)
+            """),
+            {"canonical": canonical_id, "others": other_ids},
+        )
+
+        # STEP 4: Reparent ImageProvenance.source_id (denormalized FK).
+        # No UNIQUE on source_id; safe bulk update.
+        conn.execute(
+            text("""
+                UPDATE image_provenance SET source_id = :canonical
+                WHERE source_id = ANY(:others)
+            """),
+            {"canonical": canonical_id, "others": other_ids},
+        )
+
+        # STEP 5: Drop the orphan Sources.
+        conn.execute(
+            text("DELETE FROM source WHERE id = ANY(:others)"),
+            {"others": other_ids},
+        )
+
+        # If the canonical's URL still looks per-post (no campaign URL
+        # existed among the candidates), rewrite to a synthetic anchor so
+        # the artist detail page renders something readable.
+        canonical_url = conn.execute(
+            text("SELECT url FROM source WHERE id = :id"),
+            {"id": canonical_id},
+        ).scalar_one()
+        if _matches_post_url(canonical_url):
+            slug = conn.execute(
+                text("SELECT slug FROM artist WHERE id = :id"),
+                {"id": artist_id},
+            ).scalar_one()
+            conn.execute(
+                text("""
+                    UPDATE source
+                    SET url = :new_url, enabled = false
+                    WHERE id = :id
+                """),
+                {
+                    "id": canonical_id,
+                    "new_url": f"sidecar:{platform}:{slug}",
+                },
+            )
+
+
+def downgrade() -> None:
+    # Lossy migration — orphan Sources deleted, Posts reparented, Posts
+    # merged. No safe downgrade. If you need to roll back the schema
+    # invariant, fork from 0021 and re-run filesystem imports.
+    pass
+
+
+def _matches_post_url(url: str) -> bool:
+    """True if url ends with /posts/<token> (gallery-dl-style per-post URL)."""
+    import re
+    return bool(re.search(_POST_URL_RE, url or ""))

alembic/versions/0023_drop_meta_rating_tag_kinds.py

@@ -0,0 +1,99 @@
+"""drop meta + rating tag kinds — operator-retired 2026-05-26
+
+Revision ID: 0023
+Revises: 0022
+Create Date: 2026-05-26
+
+Operator decided meta + rating aren't valid tag kinds for FC. Per-row
+behavior: DELETE existing rows (operator chose "clean break" over
+"convert to general"). All cascading FKs (image_tag, tag_alias,
+tag_allowlist, tag_reference_embedding, tag_suggestion_rejection,
+series_page) use ondelete="CASCADE" so a single DELETE on tag cleans
+the related rows in one go.
+
+After the data cleanup, recreate the tag_kind ENUM without 'meta' /
+'rating' (Postgres has no `ALTER TYPE ... DROP VALUE`; standard
+rename-create-cast-drop dance). The server default 'general' is
+dropped before the type swap and restored after.
+"""
+from typing import Sequence, Union
+
+from alembic import op
+
+revision: str = "0023"
+down_revision: Union[str, None] = "0022"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # 1. Delete tags of the retired kinds. CASCADE handles related tables.
+    op.execute("DELETE FROM tag WHERE kind IN ('meta', 'rating')")
+
+    # 2. Drop the CHECK constraint that references the enum's literal
+    #    values. Postgres can't resolve `kind = 'character'` across the
+    #    type swap below — the literal would bind to the new tag_kind
+    #    but the column is on tag_kind_old, producing
+    #    "operator does not exist: tag_kind = tag_kind_old".
+    #    (Operator-hit during the v26.05.26.5 deploy attempt; ck was
+    #    originally added by alembic 0002.) Recreated post-swap.
+    op.drop_constraint(
+        "ck_tag_fandom_requires_character", "tag", type_="check"
+    )
+
+    # 3. Drop the server default — ALTER COLUMN TYPE can't carry it
+    #    across the type swap below.
+    op.execute("ALTER TABLE tag ALTER COLUMN kind DROP DEFAULT")
+
+    # 4. Recreate the tag_kind enum without meta/rating.
+    op.execute("ALTER TYPE tag_kind RENAME TO tag_kind_old")
+    op.execute(
+        "CREATE TYPE tag_kind AS ENUM ("
+        "'artist', 'character', 'fandom', 'general', "
+        "'series', 'archive', 'post'"
+        ")"
+    )
+    op.execute(
+        "ALTER TABLE tag "
+        "ALTER COLUMN kind TYPE tag_kind "
+        "USING kind::text::tag_kind"
+    )
+    op.execute("DROP TYPE tag_kind_old")
+
+    # 5. Restore the server default.
+    op.execute("ALTER TABLE tag ALTER COLUMN kind SET DEFAULT 'general'")
+
+    # 6. Restore the CHECK constraint (now bound to the new tag_kind).
+    op.create_check_constraint(
+        "ck_tag_fandom_requires_character",
+        "tag",
+        "(fandom_id IS NULL) OR (kind = 'character')",
+    )
+
+
+def downgrade() -> None:
+    # Add the values back to the enum so old code can boot. The deleted
+    # tag rows are gone permanently — no safe restore.
+    op.drop_constraint(
+        "ck_tag_fandom_requires_character", "tag", type_="check"
+    )
+    op.execute("ALTER TABLE tag ALTER COLUMN kind DROP DEFAULT")
+    op.execute("ALTER TYPE tag_kind RENAME TO tag_kind_old")
+    op.execute(
+        "CREATE TYPE tag_kind AS ENUM ("
+        "'artist', 'character', 'fandom', 'general', "
+        "'series', 'archive', 'post', 'meta', 'rating'"
+        ")"
+    )
+    op.execute(
+        "ALTER TABLE tag "
+        "ALTER COLUMN kind TYPE tag_kind "
+        "USING kind::text::tag_kind"
+    )
+    op.execute("DROP TYPE tag_kind_old")
+    op.execute("ALTER TABLE tag ALTER COLUMN kind SET DEFAULT 'general'")
+    op.create_check_constraint(
+        "ck_tag_fandom_requires_character",
+        "tag",
+        "(fandom_id IS NULL) OR (kind = 'character')",
+    )

backend/app/__init__.py

@@ -3,13 +3,23 @@
 import logging
 from pathlib import Path
 
-from quart import Quart
+from quart import Quart, request
 
 from .api import all_blueprints
 from .config import get_config
 from .frontend import frontend_bp
 from .services.credential_crypto import CredentialCrypto
 
+# Browser-extension origins. The FabledCurator extension fetches from
+# moz-extension://<uuid>/ on Firefox and chrome-extension://<uuid>/ on
+# Chromium-based browsers. Operator-flagged 2026-05-26: extension's
+# 'Test connection' returned `NetworkError` because the X-Extension-Key
+# header on /api/credentials triggers a CORS preflight that our routes
+# don't handle. Whitelisting only these two schemes (not opening CORS
+# up generally) lets the extension talk to a plain-HTTP self-hosted FC
+# without weakening the no-CORS posture for normal browser usage.
+_EXTENSION_ORIGIN_SCHEMES = ("moz-extension://", "chrome-extension://")
+
 _CREDENTIAL_KEY_PATH = Path("/images/secrets/credential_key.b64")
 
 
@@ -35,6 +45,33 @@ def create_app() -> Quart:
     # Registered last so /api/* routes win over the SPA catch-all.
     app.register_blueprint(frontend_bp)
 
+    @app.before_request
+    async def _extension_cors_preflight():
+        # Short-circuit OPTIONS preflight from the browser extension with a
+        # 204 + CORS headers (the after_request hook below adds them).
+        # Without this, OPTIONS lands on routes that only declared POST/GET
+        # methods and 405s before the after_request gets a chance.
+        if request.method != "OPTIONS":
+            return None
+        origin = request.headers.get("Origin", "")
+        if any(origin.startswith(s) for s in _EXTENSION_ORIGIN_SCHEMES):
+            return "", 204
+        return None
+
+    @app.after_request
+    async def _extension_cors_headers(response):
+        origin = request.headers.get("Origin", "")
+        if any(origin.startswith(s) for s in _EXTENSION_ORIGIN_SCHEMES):
+            response.headers["Access-Control-Allow-Origin"] = origin
+            response.headers["Access-Control-Allow-Methods"] = (
+                "GET, POST, PATCH, DELETE, OPTIONS"
+            )
+            response.headers["Access-Control-Allow-Headers"] = (
+                "Content-Type, X-Extension-Key"
+            )
+            response.headers["Access-Control-Max-Age"] = "86400"
+        return response
+
     @app.after_serving
     async def _dispose_db_engine() -> None:
         from .extensions import dispose_engine

backend/app/api/__init__.py

@@ -38,6 +38,7 @@ def all_blueprints() -> list[Blueprint]:
     from .system_activity import system_activity_bp
     from .system_backup import system_backup_bp
     from .tags import tags_bp
+    from .thumbnails import thumbnails_bp
     return [
         api_bp,
         attachments_bp,
@@ -58,6 +59,7 @@ def all_blueprints() -> list[Blueprint]:
         allowlist_bp,
         aliases_bp,
         ml_admin_bp,
+        thumbnails_bp,
         sources_bp,
         platforms_bp,
         posts_bp,

backend/app/api/import_admin.py

@@ -103,17 +103,22 @@ async def list_tasks():
 
 @import_admin_bp.route("/retry-failed", methods=["POST"])
 async def retry_failed():
+    # Fold SELECT into UPDATE…WHERE…RETURNING — the prior SELECT-then-
+    # UPDATE-WHERE-id-IN pattern blew past psycopg's 65535-parameter
+    # ceiling once failed_ids exceeded ~65k rows.
     async with get_session() as session:
-        failed_ids = (
-            await session.execute(select(ImportTask.id).where(ImportTask.status == "failed"))
-        ).scalars().all()
+        result = await session.execute(
+            update(ImportTask)
+            .where(ImportTask.status == "failed")
+            .values(
+                status="queued", error=None,
+                started_at=None, finished_at=None,
+            )
+            .returning(ImportTask.id)
+        )
+        failed_ids = [row[0] for row in result.all()]
         if not failed_ids:
             return jsonify({"retried": 0})
-        await session.execute(
-            update(ImportTask)
-            .where(ImportTask.id.in_(failed_ids))
-            .values(status="queued", error=None, started_at=None, finished_at=None)
-        )
         await session.commit()
 
     from ..tasks.import_file import import_media_file
@@ -138,28 +143,26 @@ async def clear_stuck():
     autoretry-looped for 2 days after a corrupt-data PIL OSError.
     """
     async with get_session() as session:
-        stuck_ids = (
-            await session.execute(
-                select(ImportTask.id).where(
-                    ImportTask.status.in_(["pending", "queued", "processing"])
-                )
+        # Fold SELECT into UPDATE…WHERE — see /retry-failed for the
+        # 65535-parameter ceiling rationale. rowcount is enough here
+        # because we don't need the ids afterward (no .delay()).
+        clear_result = await session.execute(
+            update(ImportTask)
+            .where(
+                ImportTask.status.in_(["pending", "queued", "processing"])
             )
-        ).scalars().all()
-        if stuck_ids:
-            await session.execute(
-                update(ImportTask)
-                .where(ImportTask.id.in_(stuck_ids))
-                .values(
-                    status="failed",
-                    finished_at=datetime.now(UTC),
-                    error=(
-                        "manually cleared via /api/import/clear-stuck "
-                        "— stuck in non-terminal state; retry once "
-                        "underlying cause (corrupt file, missing model, "
-                        "etc.) is resolved"
-                    ),
-                )
+            .values(
+                status="failed",
+                finished_at=datetime.now(UTC),
+                error=(
+                    "manually cleared via /api/import/clear-stuck "
+                    "— stuck in non-terminal state; retry once "
+                    "underlying cause (corrupt file, missing model, "
+                    "etc.) is resolved"
+                ),
             )
+        )
+        tasks_failed = clear_result.rowcount or 0
 
         # Finalize any 'running' ImportBatch that no longer has any
         # active children. The "Scanning..." banner is driven by
@@ -195,7 +198,7 @@ async def clear_stuck():
         await session.commit()
 
     return jsonify({
-        "tasks_failed": len(stuck_ids),
+        "tasks_failed": tasks_failed,
         "batches_finalized": finalized_batches,
     })
 

backend/app/api/tags.py

@@ -15,6 +15,7 @@ from ..services.tag_service import (
     TagService,
     TagValidationError,
 )
+from ..utils.tag_prefix import parse_kind_prefix
 
 tags_bp = Blueprint("tags", __name__, url_prefix="/api")
 
@@ -105,13 +106,39 @@ async def directory():
 
 @tags_bp.route("/tags", methods=["POST"])
 async def create_tag():
+    """Create a tag. Two input shapes accepted:
+      1. Explicit: {name, kind, fandom_id?} — caller already split, kind wins.
+      2. IR-suffix: {name} where name = "kind:Name" (e.g. "artist:Eric").
+         The server runs parse_kind_prefix(name) to derive kind; the colon
+         and prefix are stripped from the stored tag name. If no recognized
+         prefix is present, the kind defaults to `general`.
+    Explicit kind ALWAYS wins (backward-compat for existing callers).
+    """
     body = await request.get_json()
-    if not body or "name" not in body or "kind" not in body:
-        return jsonify({"error": "name and kind required"}), 400
+    if not body or "name" not in body:
+        return jsonify({"error": "name required"}), 400
     name = body["name"]
-    kind = _coerce_kind(body["kind"])
-    if kind is None:
-        return jsonify({"error": f"invalid kind {body['kind']!r}"}), 400
+    explicit_kind_raw = body.get("kind")
+
+    if explicit_kind_raw is not None:
+        # Caller provided kind — honor it; don't re-parse.
+        kind = _coerce_kind(explicit_kind_raw)
+        if kind is None:
+            return jsonify({"error": f"invalid kind {explicit_kind_raw!r}"}), 400
+    else:
+        # IR-style: parse "kind:Name" from the raw name.
+        parsed_kind, parsed_name = parse_kind_prefix(name)
+        if parsed_kind is not None:
+            name = parsed_name
+            kind = _coerce_kind(parsed_kind)
+            # parse_kind_prefix only returns kinds from KNOWN_KINDS which
+            # are all valid TagKind members, so _coerce_kind can't return
+            # None here — but defensive.
+            if kind is None:
+                return jsonify({"error": f"invalid kind {parsed_kind!r}"}), 400
+        else:
+            kind = TagKind.general
+
     fandom_id = body.get("fandom_id")
 
     async with get_session() as session:

backend/app/api/thumbnails.py

@@ -0,0 +1,13 @@
+"""Thumbnail admin API: backfill trigger."""
+
+from quart import Blueprint, jsonify
+
+thumbnails_bp = Blueprint("thumbnails", __name__, url_prefix="/api/thumbnails")
+
+
+@thumbnails_bp.route("/backfill", methods=["POST"])
+async def trigger_backfill():
+    from ..tasks.thumbnail import backfill_thumbnails
+
+    r = backfill_thumbnails.delay()
+    return jsonify({"celery_task_id": r.id}), 202

backend/app/models/image_provenance.py

@@ -1,14 +1,18 @@
 """ImageProvenance — links an ImageRecord to a Post.
 
-Many-to-one (one image, many provenance rows) enables the enrich-on-duplicate
-rule (spec §3): when a downloaded image is a pHash dupe of an existing
-record, we append a new provenance row to the existing record rather than
-dropping the metadata.
+One image can have many provenance rows — different posts each contribute
+metadata (enrich-on-duplicate rule, spec §3: a downloaded image that is a
+pHash dupe of an existing record gets a NEW provenance row for the new post
+appended, rather than the metadata being dropped). But the (image, post)
+pair is unique — alembic 0021 enforces uq_image_provenance_image_post
+after operator-flagged 2026-05-26 saw _apply_sidecar's existence-check +
+INSERT race plant duplicates that then broke .scalar_one_or_none() on
+every later deep-scan rederive (MultipleResultsFound).
 """
 
 from datetime import datetime
 
-from sqlalchemy import JSON, DateTime, ForeignKey, Integer, func
+from sqlalchemy import JSON, DateTime, ForeignKey, Integer, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column
 
 from .base import Base
@@ -16,6 +20,12 @@ from .base import Base
 
 class ImageProvenance(Base):
     __tablename__ = "image_provenance"
+    __table_args__ = (
+        UniqueConstraint(
+            "image_record_id", "post_id",
+            name="uq_image_provenance_image_post",
+        ),
+    )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     image_record_id: Mapped[int] = mapped_column(

backend/app/models/tag.py

@@ -35,8 +35,10 @@ class TagKind(StrEnum):
     series = "series"
     archive = "archive"
     post = "post"
-    meta = "meta"
-    rating = "rating"
+    # `meta` and `rating` retired by operator 2026-05-26 (alembic 0023).
+    # `artist` retired in FC-2d-vii-c — artists are first-class entities
+    # via Artist/Source rows now, not tags — but the enum value stays
+    # to keep historic tag rows queryable.
 
 
 image_tag = Table(

backend/app/services/artist_service.py

@@ -111,12 +111,22 @@ class ArtistService:
             )
         ).all()
 
+        post_count = (
+            await self.session.execute(
+                select(func.count(func.distinct(Post.id)))
+                .select_from(Post)
+                .join(Source, Source.id == Post.source_id)
+                .where(Source.artist_id == aid)
+            )
+        ).scalar_one()
+
         return {
             "id": artist.id,
             "name": artist.name,
             "slug": artist.slug,
             "is_subscription": bool(artist.is_subscription),
             "image_count": int(image_count),
+            "post_count": int(post_count),
             "date_range": {
                 "min": dmin.isoformat() if dmin else None,
                 "max": dmax.isoformat() if dmax else None,

backend/app/services/extension_service.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import re
 
 from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ..models import Artist, Source
@@ -97,20 +98,40 @@ class ExtensionService:
         raise UnknownPlatformError(f"no platform pattern matched {url!r}")
 
     async def _find_or_create_artist(self, raw_name: str) -> tuple[Artist, bool]:
+        """Race-safe find-or-create on Artist by slug. Mirrors the
+        savepoint + IntegrityError recovery pattern used in
+        Importer._find_or_create_source/post (see
+        reference_scalar_one_or_none_duplicates memory). Without this,
+        two concurrent quick-add-source calls hitting the same artist
+        would both miss the existence check and the second INSERT would
+        500 against uq_artist_slug.
+        """
         slug = slugify(raw_name)
         existing = (await self.session.execute(
             select(Artist).where(Artist.slug == slug)
         )).scalar_one_or_none()
         if existing is not None:
             return existing, False
-        artist = Artist(name=raw_name, slug=slug, is_subscription=True)
-        self.session.add(artist)
-        await self.session.flush()
-        return artist, True
+        sp = await self.session.begin_nested()
+        try:
+            artist = Artist(name=raw_name, slug=slug, is_subscription=True)
+            self.session.add(artist)
+            await self.session.flush()
+            await sp.commit()
+            return artist, True
+        except IntegrityError:
+            await sp.rollback()
+            recovered = (await self.session.execute(
+                select(Artist).where(Artist.slug == slug)
+            )).scalar_one()
+            return recovered, False
 
     async def _find_or_create_source(
         self, *, artist_id: int, platform: str, url: str,
     ) -> tuple[Source, bool]:
+        """Race-safe — same pattern as _find_or_create_artist above. The
+        uq_source_artist_platform_url constraint catches the duplicate
+        insert; we roll the savepoint back and re-select."""
         existing = (await self.session.execute(
             select(Source).where(
                 Source.artist_id == artist_id,
@@ -120,8 +141,24 @@ class ExtensionService:
         )).scalar_one_or_none()
         if existing is not None:
             return existing, False
-        src = Source(artist_id=artist_id, platform=platform, url=url, enabled=True)
-        self.session.add(src)
-        await self.session.flush()
+        sp = await self.session.begin_nested()
+        try:
+            src = Source(
+                artist_id=artist_id, platform=platform,
+                url=url, enabled=True,
+            )
+            self.session.add(src)
+            await self.session.flush()
+            await sp.commit()
+        except IntegrityError:
+            await sp.rollback()
+            recovered = (await self.session.execute(
+                select(Source).where(
+                    Source.artist_id == artist_id,
+                    Source.platform == platform,
+                    Source.url == url,
+                )
+            )).scalar_one()
+            return recovered, False
         await self.session.commit()
         return src, True

backend/app/services/importer.py

@@ -247,6 +247,62 @@ class Importer:
                 )
             ).scalar_one()
 
+    def _source_for_sidecar(
+        self, *, artist_id: int, platform: str, artist_slug: str,
+    ) -> Source:
+        """Filesystem-import sidecar Source resolver.
+
+        Source represents a subscription feed (one per artist+platform — the
+        gallery-dl URL polled by the FC-3 downloader). The filesystem importer
+        used to call _find_or_create_source(url=sd.post_url), which created
+        one Source row per post URL — 100s of junk Sources per artist, all
+        with enabled=True, polluting the artist detail page and tricking the
+        subscription checker into trying to poll patreon post URLs as feeds.
+        Operator-flagged 2026-05-26.
+
+        New behaviour: if any Source row exists for (artist_id, platform),
+        reuse it regardless of its URL — the artist's real subscription Source
+        (created by the downloader / extension / UI) is the canonical
+        attachment point for filesystem-imported posts. If none exists, create
+        ONE synthetic anchor with url='sidecar:<platform>:<artist_slug>' and
+        enabled=False (so the subscription checker doesn't poll it).
+        """
+        existing = self.session.execute(
+            select(Source)
+            .where(
+                Source.artist_id == artist_id,
+                Source.platform == platform,
+            )
+            .order_by(Source.id.asc())
+            .limit(1)
+        ).scalar_one_or_none()
+        if existing is not None:
+            return existing
+        synthetic_url = f"sidecar:{platform}:{artist_slug}"
+        sp = self.session.begin_nested()
+        try:
+            row = Source(
+                artist_id=artist_id,
+                platform=platform,
+                url=synthetic_url,
+                enabled=False,
+            )
+            self.session.add(row)
+            self.session.flush()
+            sp.commit()
+            return row
+        except IntegrityError:
+            sp.rollback()
+            return self.session.execute(
+                select(Source)
+                .where(
+                    Source.artist_id == artist_id,
+                    Source.platform == platform,
+                )
+                .order_by(Source.id.asc())
+                .limit(1)
+            ).scalar_one()
+
     def _find_or_create_post(
         self, *, source_id: int, external_post_id: str,
     ) -> Post:
@@ -315,9 +371,8 @@ class Importer:
             return None
         sd = parse_sidecar(data)
         platform = sd.platform or "unknown"
-        url = sd.post_url or f"sidecar:{platform}"
-        src = self._find_or_create_source(
-            artist_id=artist.id, platform=platform, url=url,
+        src = self._source_for_sidecar(
+            artist_id=artist.id, platform=platform, artist_slug=artist.slug,
         )
         epid = sd.external_post_id or sc.stem
         return self._find_or_create_post(
@@ -763,9 +818,9 @@ class Importer:
             src = explicit_source
         else:
             platform = sd.platform or "unknown"
-            url = sd.post_url or f"sidecar:{platform}"
-            src = self._find_or_create_source(
-                artist_id=artist.id, platform=platform, url=url,
+            src = self._source_for_sidecar(
+                artist_id=artist.id, platform=platform,
+                artist_slug=artist.slug,
             )
 
         epid = sd.external_post_id or sc.stem
@@ -784,6 +839,15 @@ class Importer:
             post.attachment_count = sd.attachment_count
         post.raw_metadata = sd.raw
 
+        # Race-safe (image_record_id, post_id) upsert — mirrors the
+        # _find_or_create_source/post savepoint pattern. The plain
+        # SELECT-then-INSERT pattern lost a race when two workers ran
+        # _apply_sidecar on the same (image, post) pair (e.g. the 5-min
+        # recovery sweep re-enqueued a still-running long import), planting
+        # duplicates that then broke .scalar_one_or_none() on every later
+        # deep-scan rederive (MultipleResultsFound). Alembic 0021 adds the
+        # uq_image_provenance_image_post UNIQUE so this savepoint actually
+        # trips on collision.
         exists = self.session.execute(
             select(ImageProvenance.id).where(
                 ImageProvenance.image_record_id == record.id,
@@ -791,14 +855,20 @@ class Importer:
             )
         ).scalar_one_or_none()
         if exists is None:
-            self.session.add(
-                ImageProvenance(
-                    image_record_id=record.id,
-                    post_id=post.id,
-                    source_id=src.id,
-                    captured_metadata=sd.raw,
+            sp = self.session.begin_nested()
+            try:
+                self.session.add(
+                    ImageProvenance(
+                        image_record_id=record.id,
+                        post_id=post.id,
+                        source_id=src.id,
+                        captured_metadata=sd.raw,
+                    )
                 )
-            )
+                self.session.flush()
+                sp.commit()
+            except IntegrityError:
+                sp.rollback()
         if record.primary_post_id is None:
             record.primary_post_id = post.id
         self.session.flush()

backend/app/services/post_feed_service.py

@@ -109,7 +109,10 @@ class PostFeedService:
         if row is None:
             return None
         post, artist, source = row
-        thumbs_map = await self._thumbnails_for([post.id])
+        # Detail endpoint returns the FULL image list for PostModal's
+        # masonry grid — feed query still caps at THUMBNAIL_LIMIT via
+        # the default arg.
+        thumbs_map = await self._thumbnails_for([post.id], limit=None)
         atts_map = await self._attachments_for([post.id])
         item = self._to_dict(post, artist, source, thumbs_map, atts_map)
         item["description_full"] = html_to_plain(post.description)
@@ -117,15 +120,21 @@ class PostFeedService:
 
     # --- composition helpers ---------------------------------------------
 
-    async def _thumbnails_for(self, post_ids: list[int]) -> dict[int, dict]:
-        """post_id -> {"thumbs": [...up to 6], "more": int}.
+    async def _thumbnails_for(
+        self, post_ids: list[int], *, limit: int | None = THUMBNAIL_LIMIT,
+    ) -> dict[int, dict]:
+        """post_id -> {"thumbs": [...up to limit], "more": int}.
 
-        Selects THUMBNAIL_LIMIT+1 images per post via window function so we
-        can detect overflow in a single query.
+        Selects up to `limit` images per post via window function so we
+        can detect overflow in a single query. Pass `limit=None` to
+        return ALL thumbnails per post (used by `get_post` for PostModal's
+        masonry grid; the feed pass keeps the default cap so payloads
+        stay small).
         """
         if not post_ids:
             return {}
-        # Rank images within each post and fetch only the top THUMBNAIL_LIMIT+1.
+        # Rank images within each post; cap at `limit` rows per post when
+        # limit is set, return all when limit is None.
         ranked = (
             select(
                 ImageRecord.id,
@@ -143,12 +152,13 @@ class PostFeedService:
             .where(ImageRecord.primary_post_id.in_(post_ids))
             .subquery()
         )
-        rows = (await self.session.execute(
-            select(
-                ranked.c.id, ranked.c.primary_post_id,
-                ranked.c.sha256, ranked.c.mime, ranked.c.total,
-            ).where(ranked.c.rn <= THUMBNAIL_LIMIT)
-        )).all()
+        stmt = select(
+            ranked.c.id, ranked.c.primary_post_id,
+            ranked.c.sha256, ranked.c.mime, ranked.c.total,
+        )
+        if limit is not None:
+            stmt = stmt.where(ranked.c.rn <= limit)
+        rows = (await self.session.execute(stmt)).all()
 
         out: dict[int, dict] = {pid: {"thumbs": [], "more": 0} for pid in post_ids}
         for img_id, pid, sha, mime, total in rows:

backend/app/tasks/maintenance.py

@@ -54,41 +54,40 @@ def recover_interrupted_tasks() -> int:
     processing_cutoff = now - timedelta(minutes=STUCK_THRESHOLD_MINUTES)
     orphan_cutoff = now - timedelta(minutes=ORPHAN_PENDING_THRESHOLD_MINUTES)
     with SessionLocal() as session:
-        stuck_ids = session.execute(
-            select(ImportTask.id)
+        # Both sweeps used to be SELECT ids → UPDATE WHERE id IN (...) which
+        # blew past psycopg's 65535-parameter ceiling once a sweep covered
+        # tens of thousands of rows (operator hit it 2026-05-26 after the
+        # /import deep scan piled up orphans). Folding the SELECT into the
+        # UPDATE eliminates the IN-list entirely. RETURNING gives us back
+        # exactly the ids that flipped so the stuck sweep can still
+        # .delay() each one.
+        stuck_result = session.execute(
+            update(ImportTask)
             .where(ImportTask.status == "processing")
             .where(ImportTask.started_at < processing_cutoff)
-        ).scalars().all()
+            .values(
+                status="queued",
+                started_at=None,
+                error="recovered from stuck state",
+            )
+            .returning(ImportTask.id)
+        )
+        stuck_ids = [row[0] for row in stuck_result.all()]
 
-        orphan_ids = session.execute(
-            select(ImportTask.id)
+        orphan_result = session.execute(
+            update(ImportTask)
             .where(ImportTask.status.in_(["pending", "queued"]))
             .where(ImportTask.created_at < orphan_cutoff)
-        ).scalars().all()
-
-        if not stuck_ids and not orphan_ids:
-            return 0
-
-        if stuck_ids:
-            session.execute(
-                update(ImportTask)
-                .where(ImportTask.id.in_(stuck_ids))
-                .values(status="queued", started_at=None, error="recovered from stuck state")
-            )
-
-        if orphan_ids:
-            session.execute(
-                update(ImportTask)
-                .where(ImportTask.id.in_(orphan_ids))
-                .values(
-                    status="failed",
-                    error=(
-                        "orphan pending/queued swept by recover_interrupted_tasks "
-                        "(scanner likely crashed mid-enqueue); retry via "
-                        "/api/import/retry-failed"
-                    ),
-                )
+            .values(
+                status="failed",
+                error=(
+                    "orphan pending/queued swept by recover_interrupted_tasks "
+                    "(scanner likely crashed mid-enqueue); retry via "
+                    "/api/import/retry-failed"
+                ),
             )
+        )
+        orphan_count = orphan_result.rowcount or 0
 
         session.commit()
 
@@ -97,7 +96,7 @@ def recover_interrupted_tasks() -> int:
             for tid in stuck_ids:
                 import_media_file.delay(tid)
 
-        return len(stuck_ids) + len(orphan_ids)
+        return len(stuck_ids) + orphan_count
 
 
 @celery.task(name="backend.app.tasks.maintenance.cleanup_old_tasks")

backend/app/tasks/thumbnail.py

@@ -17,6 +17,30 @@ from ._sync_engine import sync_session_factory as _sync_session_factory
 
 IMAGES_ROOT = Path("/images")
 
+THUMB_MAGIC_JPEG = b"\xff\xd8\xff"
+THUMB_MAGIC_PNG = b"\x89PNG\r\n\x1a\n"
+
+
+def _thumb_is_valid(path: Path) -> bool:
+    """Return True iff `path` exists and starts with a JPEG or PNG magic header.
+
+    The on-disk thumbnail format is set by services/thumbnailer.py — JPEG for
+    opaque sources, PNG for alpha sources. Anything else (missing file, OSError,
+    truncated, wrong magic) is invalid.
+    """
+    try:
+        with path.open("rb") as f:
+            head = f.read(12)
+    except OSError:
+        return False
+    if len(head) < 8:
+        return False
+    if head[:3] == THUMB_MAGIC_JPEG:
+        return True
+    if head[:8] == THUMB_MAGIC_PNG:
+        return True
+    return False
+
 
 @celery.task(
     name="backend.app.tasks.thumbnail.generate_thumbnail",
@@ -50,3 +74,58 @@ def generate_thumbnail(self, image_id: int) -> dict:
         session.add(record)
         session.commit()
         return {"status": "ok", "image_id": image_id, "path": str(result.path)}
+
+
+@celery.task(
+    name="backend.app.tasks.thumbnail.backfill_thumbnails",
+    bind=True,
+)
+def backfill_thumbnails(self) -> dict:
+    """Scan ImageRecord and enqueue generate_thumbnail for rows whose
+    thumbnail is missing, gone from disk, or has wrong magic bytes.
+
+    Keyset paginates by id ASC, page size 500. NULLs out thumbnail_path for
+    rows that point at a missing or corrupt file before enqueueing — keeps
+    the DB self-consistent on partial runs and makes re-runs safe.
+
+    Returns {"enqueued": N, "ok": M, "regenerated": K} where:
+      - enqueued = total generate_thumbnail.delay() calls
+      - ok       = rows whose existing thumbnail file is valid (skipped)
+      - regenerated = subset of enqueued that had a non-NULL thumbnail_path
+                      cleared (i.e. missing + corrupt)
+    """
+    from sqlalchemy import select, update
+
+    SessionLocal = _sync_session_factory()
+    enqueued = 0
+    ok = 0
+    regenerated = 0
+    last_id = 0
+    with SessionLocal() as session:
+        while True:
+            rows = session.execute(
+                select(ImageRecord.id, ImageRecord.thumbnail_path)
+                .where(ImageRecord.id > last_id)
+                .order_by(ImageRecord.id.asc())
+                .limit(500)
+            ).all()
+            if not rows:
+                break
+            for image_id, thumb_path in rows:
+                if thumb_path is None:
+                    generate_thumbnail.delay(image_id)
+                    enqueued += 1
+                elif _thumb_is_valid(Path(thumb_path)):
+                    ok += 1
+                else:
+                    session.execute(
+                        update(ImageRecord)
+                        .where(ImageRecord.id == image_id)
+                        .values(thumbnail_path=None)
+                    )
+                    generate_thumbnail.delay(image_id)
+                    enqueued += 1
+                    regenerated += 1
+            session.commit()
+            last_id = rows[-1][0]
+    return {"enqueued": enqueued, "ok": ok, "regenerated": regenerated}

backend/app/utils/tag_prefix.py

@@ -0,0 +1,46 @@
+"""Parse the user-facing `kind:name` shortcut used by the add-tag input.
+
+Mirrors IR's app/utils/tag_prefix.py. Tag.name in FC is stored bare;
+the `kind:` prefix only exists as an input convention at user-facing
+places (image-modal add-tag input, future bulk-add forms). The parser
+is the single owner of the kind-string list — anything not in
+KNOWN_KINDS keeps its colon as literal text.
+"""
+
+from __future__ import annotations
+
+# Kinds the user can type as a prefix at the input boundary.
+# Exclusions:
+#   - `general` is the default for un-prefixed input (never typed as prefix)
+#   - `archive`, `post` are system-managed
+#   - `artist` was retired in FC-2d-vii-c — artists are first-class
+#     entities (Artist row + ImageRecord.artist_id), browsed via the
+#     provenance axis rather than as tags. See project_provenance_separation.
+#   - `meta`, `rating` retired as user-typeable per operator 2026-05-26 —
+#     content classification only needs character/fandom/series.
+KNOWN_KINDS: frozenset[str] = frozenset({
+    "character",
+    "fandom",
+    "series",
+})
+
+
+def parse_kind_prefix(raw: str) -> tuple[str | None, str]:
+    """Split a raw user-typed tag string into (kind, name).
+
+    Returns (kind, name) where kind is lowercase canonical and in
+    KNOWN_KINDS, or (None, raw.strip()) if no recognized prefix is
+    present. `name` is always whitespace-stripped.
+
+    Examples:
+        parse_kind_prefix("character:Saber") -> ("character", "Saber")
+        parse_kind_prefix("Character:Saber") -> ("character", "Saber")
+        parse_kind_prefix("sunset")          -> (None, "sunset")
+        parse_kind_prefix("http://example")  -> (None, "http://example")
+        parse_kind_prefix("fandom: FSN ")    -> ("fandom", "FSN")
+    """
+    if ":" in raw:
+        prefix, rest = raw.split(":", 1)
+        if prefix.lower() in KNOWN_KINDS:
+            return prefix.lower(), rest.strip()
+    return None, raw.strip()

extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "FabledCurator",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Export cookies from supported platforms to FabledCurator and add creators as sources in one click.",
 
   "browser_specific_settings": {
@@ -11,6 +11,11 @@
     }
   },
 
+  "content_security_policy": {
+    "_comment": "Override the MV3 default CSP to OMIT upgrade-insecure-requests. FC runs over plain HTTP per the homelab posture (feedback_homelab_http), and the default MV3 CSP would silently upgrade every fetch(http://curator.../...) to https:// and fail with NS_ERROR_GENERATE_FAILURE. Operator-flagged 2026-05-26 after the 'Test connection' button errored despite a working CORS preflight on the backend.",
+    "extension_pages": "script-src 'self'; object-src 'self';"
+  },
+
   "permissions": [
     "cookies",
     "storage",

extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fabledcurator-extension",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "private": true,
   "description": "Firefox extension for FabledCurator",
   "scripts": {

frontend/src/App.vue

@@ -4,6 +4,7 @@
       <RouterView />
     </AppShell>
     <ImageViewer v-if="modal.isOpen" @close="modal.close()" />
+    <PostModal />
     <AppSnackbar ref="snackbar" />
   </v-app>
 </template>
@@ -13,6 +14,7 @@ import { onMounted, ref } from 'vue'
 import AppShell from './components/AppShell.vue'
 import AppSnackbar from './components/AppSnackbar.vue'
 import ImageViewer from './components/modal/ImageViewer.vue'
+import PostModal from './components/posts/PostModal.vue'
 import { useModalStore } from './stores/modal.js'
 
 const modal = useModalStore()

frontend/src/components/artist/ArtistGalleryTab.vue

@@ -0,0 +1,48 @@
+<template>
+  <div class="fc-artist-gallery">
+    <MasonryGrid
+      :items="store.images"
+      :loading="store.imagesLoading"
+      :has-more="store.hasMoreImages"
+      @load-more="store.loadMoreImages(props.slug)"
+      @open="openImage"
+    />
+  </div>
+</template>
+
+<script setup>
+import { onMounted, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+
+import { useArtistStore } from '../../stores/artist.js'
+import { useModalStore } from '../../stores/modal.js'
+import MasonryGrid from '../discovery/MasonryGrid.vue'
+
+const props = defineProps({
+  slug: { type: String, required: true },
+})
+
+const store = useArtistStore()
+const modal = useModalStore()
+const route = useRoute()
+const router = useRouter()
+
+onMounted(() => {
+  const initial = parseInt(route.query.image, 10)
+  if (!isNaN(initial)) modal.open(initial)
+})
+
+watch(() => route.query.image, (q) => {
+  const id = parseInt(q, 10)
+  if (!isNaN(id) && id !== modal.currentImageId) modal.open(id)
+  else if (isNaN(id) && modal.currentImageId !== null) modal.close()
+})
+
+function openImage (id) {
+  router.push({ query: { ...route.query, image: id } })
+}
+</script>
+
+<style scoped>
+.fc-artist-gallery { min-width: 0; }
+</style>

frontend/src/components/artist/ArtistHeader.vue

@@ -0,0 +1,128 @@
+<template>
+  <header class="fc-artist-header">
+    <div class="fc-artist-header__left">
+      <h1 class="fc-artist-header__name">{{ name }}</h1>
+      <span v-if="stats" class="fc-artist-header__stats">{{ stats }}</span>
+    </div>
+    <v-tabs
+      :model-value="modelValue"
+      color="accent"
+      density="compact"
+      class="fc-artist-header__tabs"
+      @update:model-value="$emit('update:modelValue', $event)"
+    >
+      <v-tab value="posts">
+        Posts
+        <span v-if="postCount != null" class="fc-artist-header__tab-count">
+          ({{ postCount }})
+        </span>
+      </v-tab>
+      <v-tab value="gallery">
+        Gallery
+        <span v-if="imageCount != null" class="fc-artist-header__tab-count">
+          ({{ imageCount }})
+        </span>
+      </v-tab>
+      <v-tab value="management">Management</v-tab>
+    </v-tabs>
+
+    <!-- Right-side spacer: balances the left cell's flex weight so the
+         centered tabs stay geometrically centered regardless of the
+         artist-name length. Mirrors TopNav's 1fr | auto | 1fr layout. -->
+    <div class="fc-artist-header__right" />
+  </header>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+
+const props = defineProps({
+  name:        { type: String, required: true },
+  imageCount:  { type: Number, default: null },
+  postCount:   { type: Number, default: null },
+  lastAdded:   { type: String, default: null },
+  modelValue:  { type: String, required: true },
+})
+
+defineEmits(['update:modelValue'])
+
+const stats = computed(() => {
+  const parts = []
+  if (props.imageCount != null) {
+    parts.push(`${props.imageCount} image${props.imageCount === 1 ? '' : 's'}`)
+  }
+  if (props.lastAdded) {
+    parts.push(`last added ${props.lastAdded.slice(0, 10)}`)
+  }
+  return parts.join(' · ')
+})
+</script>
+
+<style scoped>
+/* Matches TopNav.vue's frosted recipe exactly. top:48px parks it flush
+   against TopNav's bottom edge (TopNav is 0.75rem padding + ~24px content
+   = ~48px tall; operator-flagged 2026-05-26 that top:64px left a visible
+   gap). The two bars now read as one continuous frosted strip. */
+.fc-artist-header {
+  position: sticky;
+  top: 48px;
+  z-index: 4;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.5rem 1rem;
+  background: linear-gradient(
+    to bottom,
+    rgba(20, 23, 26, 0.92) 0%,
+    rgba(20, 23, 26, 0.65) 60%,
+    rgba(20, 23, 26, 0) 100%
+  );
+  backdrop-filter: blur(2px);
+  -webkit-backdrop-filter: blur(2px);
+}
+
+.fc-artist-header__left {
+  flex: 1 1 0;
+  min-width: 0;
+  display: flex;
+  align-items: baseline;
+  gap: 12px;
+  overflow: hidden;
+}
+
+.fc-artist-header__name {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 24px;
+  font-weight: 500;
+  margin: 0;
+  color: rgb(var(--v-theme-on-surface));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.fc-artist-header__stats {
+  font-size: 13px;
+  color: rgb(var(--v-theme-on-surface-variant));
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.fc-artist-header__tabs {
+  flex: 0 0 auto;
+}
+
+.fc-artist-header__right {
+  flex: 1 1 0;
+  min-width: 0;
+}
+
+.fc-artist-header__tab-count {
+  margin-left: 4px;
+  font-size: 12px;
+  color: rgb(var(--v-theme-on-surface-variant));
+  font-variant-numeric: tabular-nums;
+}
+</style>

frontend/src/components/artist/ArtistManagementTab.vue

@@ -0,0 +1,133 @@
+<template>
+  <div class="fc-artist-mgmt">
+    <section class="fc-artist-mgmt__sec">
+      <h2 class="fc-h2">Overview</h2>
+      <div class="fc-artist-mgmt__chips">
+        <v-chip
+          size="small"
+          :variant="overview.is_subscription ? 'flat' : 'outlined'"
+          :color="overview.is_subscription ? 'accent' : undefined"
+          prepend-icon="mdi-rss"
+        >{{ overview.is_subscription ? 'Subscription' : 'One-off' }}</v-chip>
+        <v-chip
+          size="small" variant="outlined" prepend-icon="mdi-link-variant"
+          :to="`/subscriptions?artist_id=${overview.id}`"
+        >{{ overview.sources.length }} subscription{{ overview.sources.length === 1 ? '' : 's' }}</v-chip>
+      </div>
+    </section>
+
+    <section v-if="overview.cooccurring_tags.length" class="fc-artist-mgmt__sec">
+      <h2 class="fc-h2">Frequent tags</h2>
+      <div class="fc-artist-mgmt__tags">
+        <v-chip
+          v-for="t in overview.cooccurring_tags" :key="t.id"
+          size="small" @click="openTag(t.id)"
+        >{{ t.name }} <span class="fc-artist-mgmt__tagc">{{ t.count }}</span></v-chip>
+      </div>
+    </section>
+
+    <section v-if="overview.activity.length" class="fc-artist-mgmt__sec">
+      <h2 class="fc-h2">Activity</h2>
+      <svg
+        class="fc-artist-mgmt__spark" :viewBox="`0 0 ${sparkW} ${sparkH}`"
+        preserveAspectRatio="none" role="img" aria-label="posts over time"
+      >
+        <polyline :points="sparkPoints" fill="none"
+                  stroke="rgb(var(--v-theme-accent))" stroke-width="2" />
+      </svg>
+    </section>
+
+    <section v-if="overview.sources.length" class="fc-artist-mgmt__sec">
+      <div class="fc-artist-mgmt__sec-head">
+        <h2 class="fc-h2">Subscriptions</h2>
+        <RouterLink
+          :to="`/subscriptions?artist_id=${overview.id}`"
+          class="fc-artist-mgmt__manage"
+        >Manage subscriptions →</RouterLink>
+      </div>
+      <v-table density="compact">
+        <thead>
+          <tr><th>Platform</th><th>URL</th><th class="text-right">Images</th></tr>
+        </thead>
+        <tbody>
+          <tr v-for="s in overview.sources" :key="s.id">
+            <td>{{ s.platform }}</td>
+            <td class="fc-artist-mgmt__url">{{ s.url }}</td>
+            <td class="text-right">{{ s.image_count }}</td>
+          </tr>
+        </tbody>
+      </v-table>
+    </section>
+
+    <section class="fc-artist-mgmt__sec">
+      <h2 class="fc-h2">Danger zone</h2>
+      <ArtistDangerZone
+        :slug="overview.slug"
+        :artist-id="overview.id"
+        :artist-name="overview.name"
+      />
+    </section>
+  </div>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+import { useRouter, RouterLink } from 'vue-router'
+
+import ArtistDangerZone from './ArtistDangerZone.vue'
+
+const props = defineProps({
+  overview: { type: Object, required: true },
+})
+
+const router = useRouter()
+
+const sparkW = 600
+const sparkH = 80
+const sparkPoints = computed(() => {
+  const a = props.overview.activity ?? []
+  if (a.length === 0) return ''
+  const max = Math.max(...a.map(p => p.count), 1)
+  const stepX = a.length > 1 ? sparkW / (a.length - 1) : 0
+  return a.map((p, i) => {
+    const x = i * stepX
+    const y = sparkH - (p.count / max) * (sparkH - 4) - 2
+    return `${x.toFixed(1)},${y.toFixed(1)}`
+  }).join(' ')
+})
+
+function openTag (tagId) {
+  router.push({ name: 'gallery', query: { tag_id: tagId } })
+}
+</script>
+
+<style scoped>
+.fc-artist-mgmt { padding-top: 1rem; }
+.fc-h2 {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 20px; font-weight: 500; margin-bottom: 8px;
+}
+.fc-artist-mgmt__sec { margin-bottom: 28px; }
+.fc-artist-mgmt__chips { display: flex; gap: 8px; flex-wrap: wrap; }
+.fc-artist-mgmt__tags { display: flex; flex-wrap: wrap; gap: 6px; }
+.fc-artist-mgmt__tagc {
+  color: rgb(var(--v-theme-on-surface-variant));
+  margin-left: 4px;
+  font-variant-numeric: tabular-nums;
+}
+.fc-artist-mgmt__spark { width: 100%; height: 80px; }
+.fc-artist-mgmt__url {
+  max-width: 380px; overflow: hidden; text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.fc-artist-mgmt__sec-head {
+  display: flex; align-items: baseline; justify-content: space-between;
+  margin-bottom: 0.25rem;
+}
+.fc-artist-mgmt__manage {
+  font-size: 0.85rem;
+  color: rgb(var(--v-theme-accent));
+  text-decoration: none;
+}
+.fc-artist-mgmt__manage:hover { text-decoration: underline; }
+</style>

frontend/src/components/artist/ArtistPostsTab.vue

@@ -0,0 +1,90 @@
+<template>
+  <div class="fc-artist-posts">
+    <v-alert v-if="store.error" type="error" variant="tonal" closable class="mb-3">
+      {{ String(store.error) }}
+    </v-alert>
+
+    <div v-if="store.loading && store.items.length === 0" class="fc-artist-posts__loading">
+      <v-progress-circular indeterminate color="accent" size="36" />
+    </div>
+
+    <div v-else-if="store.items.length === 0 && store.done" class="fc-artist-posts__empty">
+      <p>No posts for this artist yet. Switch to
+        <a href="#" @click.prevent="$emit('switch-tab', 'gallery')">Gallery</a>
+        to see imported images, or visit
+        <RouterLink to="/subscriptions">Subscriptions</RouterLink>
+        to start capturing posts.
+      </p>
+    </div>
+
+    <div v-else>
+      <PostCard v-for="p in store.items" :key="p.id" :post="p" />
+      <div ref="sentinel" class="fc-artist-posts__sentinel">
+        <v-progress-circular v-if="store.loading" indeterminate color="accent" size="24" />
+        <span v-else-if="store.done" class="fc-artist-posts__end">End of stream</span>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { onMounted, onUnmounted, ref, watch } from 'vue'
+import { RouterLink } from 'vue-router'
+
+import { usePostsStore } from '../../stores/posts.js'
+import PostCard from '../posts/PostCard.vue'
+
+const props = defineProps({
+  artistId: { type: Number, required: true },
+})
+
+defineEmits(['switch-tab'])
+
+const store = usePostsStore()
+const sentinel = ref(null)
+let observer = null
+
+async function reload () {
+  await store.loadInitial({ artist_id: props.artistId, platform: null })
+}
+
+watch(() => props.artistId, reload)
+
+onMounted(async () => {
+  await reload()
+  observer = new IntersectionObserver((entries) => {
+    if (entries.some(e => e.isIntersecting)) {
+      store.loadMore()
+    }
+  }, { rootMargin: '400px 0px' })
+  if (sentinel.value) observer.observe(sentinel.value)
+})
+
+onUnmounted(() => {
+  if (observer) observer.disconnect()
+})
+</script>
+
+<style scoped>
+.fc-artist-posts {
+  max-width: 1600px;
+  margin: 0 auto;
+}
+.fc-artist-posts__loading,
+.fc-artist-posts__empty {
+  display: flex;
+  justify-content: center;
+  padding: 2rem;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+.fc-artist-posts__sentinel {
+  display: flex;
+  justify-content: center;
+  padding: 1.5rem 0;
+  min-height: 2rem;
+}
+.fc-artist-posts__end {
+  color: rgb(var(--v-theme-on-surface-variant));
+  font-size: 0.85rem;
+}
+</style>

frontend/src/components/common/ErrorDetailModal.vue

@@ -4,14 +4,20 @@
     <v-card>
       <v-card-title class="d-flex align-center" style="gap: 12px;">
         <v-icon icon="mdi-alert-circle-outline" color="error" />
-        <span>{{ title }}</span>
+        <span>{{ displayTitle }}</span>
         <v-spacer />
         <v-btn icon variant="text" size="small" @click="close">
           <v-icon>mdi-close</v-icon>
         </v-btn>
       </v-card-title>
       <v-card-text>
-        <pre class="fc-err-pre">{{ message || '(no error message)' }}</pre>
+        <dl v-if="contextRows.length" class="fc-err-context">
+          <template v-for="(row, idx) in contextRows" :key="idx">
+            <dt>{{ row[0] }}</dt>
+            <dd>{{ row[1] }}</dd>
+          </template>
+        </dl>
+        <pre class="fc-err-pre">{{ displayMessage || '(no error message)' }}</pre>
       </v-card-text>
       <v-card-actions>
         <v-btn
@@ -27,12 +33,21 @@
 </template>
 
 <script setup>
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
+
+import { copyText } from '../../utils/clipboard.js'
 
 const props = defineProps({
   modelValue: { type: Boolean, default: false },
+  // Legacy mode: pass title + message strings. Used by callers whose row
+  // shape lacks structured context (e.g. ImportTaskList where `error` is
+  // a plain string on the import_task row, not a TaskRun).
   title: { type: String, default: 'Error details' },
   message: { type: String, default: '' },
+  // Row mode: pass the full TaskRun-shaped dict from /api/system_activity.
+  // When set, displayTitle/displayMessage derive from the row and a context
+  // panel of task_name/queue/target/duration/etc. renders above the error.
+  row: { type: Object, default: null },
 })
 
 const emit = defineEmits(['update:modelValue'])
@@ -40,6 +55,47 @@ const emit = defineEmits(['update:modelValue'])
 const copied = ref(false)
 let copiedTimer = null
 
+const displayTitle = computed(() => {
+  if (props.row) return props.row.error_type || 'Error details'
+  return props.title
+})
+
+const displayMessage = computed(() => {
+  if (props.row) return props.row.error_message || ''
+  return props.message
+})
+
+function _shortTaskName (name) {
+  if (!name) return ''
+  const parts = String(name).split('.')
+  return parts[parts.length - 1]
+}
+
+function _formatDuration (ms) {
+  if (ms == null) return null
+  if (ms < 1000) return `${ms} ms`
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)} s`
+  return `${(ms / 60_000).toFixed(1)} min`
+}
+
+const contextRows = computed(() => {
+  const r = props.row
+  if (!r) return []
+  const rows = []
+  if (r.task_name) rows.push(['Task', _shortTaskName(r.task_name)])
+  if (r.queue) rows.push(['Queue', r.queue])
+  if (r.target_id != null) rows.push(['Target', r.target_id])
+  const dur = _formatDuration(r.duration_ms)
+  if (dur != null) rows.push(['Duration', dur])
+  if (r.started_at) rows.push(['Started', r.started_at])
+  if (r.finished_at) rows.push(['Finished', r.finished_at])
+  if (r.retry_count) rows.push(['Retries', r.retry_count])
+  if (r.worker_hostname) rows.push(['Worker', r.worker_hostname])
+  if (r.celery_task_id) rows.push(['Celery ID', r.celery_task_id])
+  if (r.args_summary) rows.push(['Args', r.args_summary])
+  return rows
+})
+
 watch(() => props.modelValue, (open) => {
   if (!open) {
     copied.value = false
@@ -47,13 +103,18 @@ watch(() => props.modelValue, (open) => {
   }
 })
 
-function close() {
+function close () {
   emit('update:modelValue', false)
 }
 
-async function onCopy() {
+async function onCopy () {
+  let text = displayMessage.value || ''
+  if (contextRows.value.length) {
+    const header = contextRows.value.map(([k, v]) => `${k}: ${v}`).join('\n')
+    text = `${header}\n\nError: ${displayTitle.value}\n${text}`
+  }
   try {
-    await navigator.clipboard.writeText(props.message || '')
+    await copyText(text)
     copied.value = true
     if (copiedTimer) clearTimeout(copiedTimer)
     copiedTimer = setTimeout(() => { copied.value = false }, 1500)
@@ -64,19 +125,43 @@ async function onCopy() {
 </script>
 
 <style scoped>
-/* The full error often contains a SQLAlchemy statement + parameters
-   block + multi-line traceback. Pre-wrap keeps long lines readable;
-   monospace + tabular layout keeps the structure scannable. The
-   max-height + overflow-auto prevents a 50-line traceback from
-   pushing the Close button off-screen. Operator-flagged 2026-05-26:
-   the prior :title="..." tooltip was unusable for content this long. */
+/* Context panel: muted labels in vellum, crisp values in parchment. The
+   2-column key/value grid keeps rows visually scannable when there are
+   many fields (Task, Queue, Target, Duration, Started, Finished, Retries,
+   Worker, Celery ID, Args). */
+.fc-err-context {
+  display: grid;
+  grid-template-columns: max-content 1fr;
+  column-gap: 14px;
+  row-gap: 4px;
+  margin: 0 0 14px 0;
+  font-size: 13px;
+}
+.fc-err-context dt {
+  color: rgb(var(--v-theme-on-surface-variant));
+  font-weight: 500;
+  white-space: nowrap;
+}
+.fc-err-context dd {
+  color: rgb(var(--v-theme-on-surface));
+  margin: 0;
+  font-variant-numeric: tabular-nums;
+  word-break: break-all;
+}
+
+/* Error pre block: high-contrast pairing. The page's `background` token
+   (obsidian #14171A) is darker than the modal card's `surface` (iron
+   #1E2228), so parchment text reads crisply against it. The prior pairing
+   used `surface-variant` which Vuetify auto-derives to a near-parchment
+   light value in this theme — pale-on-pale and unreadable. Operator-
+   flagged 2026-05-26 ("ui contrast is poor"). */
 .fc-err-pre {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-family: 'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
   font-size: 12px;
   line-height: 1.5;
   white-space: pre-wrap;
   word-break: break-word;
-  background: rgb(var(--v-theme-surface-variant, 38 36 41));
+  background: rgb(var(--v-theme-background));
   color: rgb(var(--v-theme-on-surface));
   padding: 12px 14px;
   border-radius: 6px;

frontend/src/components/credentials/ExtensionKeyBar.vue

@@ -28,6 +28,7 @@
 <script setup>
 import { onMounted, ref } from 'vue'
 import { useCredentialsStore } from '../../stores/credentials.js'
+import { copyText } from '../../utils/clipboard.js'
 
 const store = useCredentialsStore()
 const showRotateConfirm = ref(false)
@@ -37,7 +38,7 @@ onMounted(() => store.loadKey())
 async function copyKey() {
   if (!store.extensionKey) return
   try {
-    await navigator.clipboard.writeText(store.extensionKey)
+    await copyText(store.extensionKey)
     globalThis.window?.__fcToast?.({ text: 'Copied', type: 'success' })
   } catch {
     globalThis.window?.__fcToast?.({ text: 'Copy failed', type: 'error' })

frontend/src/components/modal/TagAutocomplete.vue

@@ -1,17 +1,18 @@
 <template>
   <div class="fc-tag-autocomplete">
-    <div class="d-flex" style="gap: 6px;">
-      <v-select
-        v-model="kind" :items="kindOptions" :item-title="(k) => k.label" :item-value="(k) => k.value"
-        density="compact" hide-details style="max-width: 140px;"
-      />
-      <v-text-field
-        v-model="query" placeholder="Add tag…" density="compact" hide-details
-        @keydown.down.prevent="moveHighlight(1)" @keydown.up.prevent="moveHighlight(-1)"
-        @keydown.enter.prevent="onEnter" @keydown.esc="$emit('cancel')"
-      />
-    </div>
-    <v-list v-if="hits.length || allowCreate" density="compact" class="fc-tag-autocomplete__list">
+    <v-text-field
+      v-model="query"
+      placeholder="Add tag (or kind:name — character/fandom/series)"
+      density="compact" hide-details
+      @keydown.down.prevent="moveHighlight(1)"
+      @keydown.up.prevent="moveHighlight(-1)"
+      @keydown.enter.prevent="onEnter"
+      @keydown.esc="$emit('cancel')"
+    />
+    <v-list
+      v-if="hits.length || allowCreate"
+      density="compact" class="fc-tag-autocomplete__list"
+    >
       <v-list-item
         v-for="(h, idx) in hits" :key="h.id"
         :active="idx === highlight" @click="onPick(h)"
@@ -26,7 +27,7 @@
           <span v-if="h.fandom_name" class="text-caption">— {{ h.fandom_name }}</span>
         </v-list-item-title>
         <template #append>
-          <span class="text-caption">{{ h.image_count }}</span>
+          <span class="text-caption">{{ h.kind }}</span>
         </template>
       </v-list-item>
       <v-list-item
@@ -34,9 +35,13 @@
         @click="onCreate"
       >
         <template #prepend>
-          <v-icon size="small" :color="store.colorFor(kind)">{{ iconFor(kind) }}</v-icon>
+          <v-icon size="small" :color="store.colorFor(parsedKind)">
+            {{ iconFor(parsedKind) }}
+          </v-icon>
         </template>
-        <v-list-item-title>Create "{{ query }}" as {{ kind }}</v-list-item-title>
+        <v-list-item-title>
+          Create "{{ parsedName }}" as {{ parsedKind }}
+        </v-list-item-title>
       </v-list-item>
     </v-list>
 
@@ -54,65 +59,95 @@ import FandomPicker from './FandomPicker.vue'
 const emit = defineEmits(['pick-existing', 'pick-new', 'cancel'])
 const store = useTagStore()
 
-const kind = ref('general')
+// Single text input; no kind dropdown. Client-side mirror of the
+// backend's parse_kind_prefix lives below — kept in sync with
+// KNOWN_KINDS in backend/app/utils/tag_prefix.py. The backend is the
+// canonical parser; this mirror just powers the live Create-label
+// preview ("Create 'Eric' as artist") and the autocomplete query.
 const query = ref('')
 const hits = ref([])
 const highlight = ref(0)
 const fandomDialog = ref(false)
 let pendingNewName = null
 
-const kindOptions = store.kindOptions()
+const KNOWN_KINDS = new Set([
+  'character', 'fandom', 'series',
+])
 const KIND_ICONS = {
-  general: 'mdi-tag', artist: 'mdi-palette', character: 'mdi-account-circle',
+  general: 'mdi-tag', character: 'mdi-account-circle',
   fandom: 'mdi-book-open-page-variant', series: 'mdi-bookshelf',
-  meta: 'mdi-cog-outline', rating: 'mdi-shield-check-outline'
 }
-function iconFor(k) { return KIND_ICONS[k] || 'mdi-tag' }
+function iconFor (k) { return KIND_ICONS[k] || 'mdi-tag' }
+
+const parsed = computed(() => {
+  const raw = query.value.trim()
+  if (raw.includes(':')) {
+    const idx = raw.indexOf(':')
+    const prefix = raw.slice(0, idx).toLowerCase()
+    if (KNOWN_KINDS.has(prefix)) {
+      return { kind: prefix, name: raw.slice(idx + 1).trim() }
+    }
+  }
+  return { kind: 'general', name: raw }
+})
+const parsedKind = computed(() => parsed.value.kind)
+const parsedName = computed(() => parsed.value.name)
 
 let debounceId = null
-watch([query, kind], () => {
+watch(query, () => {
   highlight.value = 0
   if (debounceId) clearTimeout(debounceId)
   debounceId = setTimeout(async () => {
-    const q = query.value.trim()
+    const q = parsedName.value
     if (!q) { hits.value = []; return }
-    hits.value = await store.autocomplete(q, kind.value, 10)
+    // Autocomplete across ALL kinds. When the user typed a prefix the
+    // matches list is naturally narrower because the parsed name is
+    // shorter; we don't filter server-side by kind.
+    hits.value = await store.autocomplete(q, null, 10)
   }, 200)
 })
 
 const allowCreate = computed(() => {
-  const q = query.value.trim()
-  return q && !hits.value.some(h => h.name.toLowerCase() === q.toLowerCase() && h.kind === kind.value)
+  const q = parsedName.value
+  if (!q) return false
+  return !hits.value.some(h =>
+    h.name.toLowerCase() === q.toLowerCase() && h.kind === parsedKind.value,
+  )
 })
 
-function moveHighlight(delta) {
+function moveHighlight (delta) {
   const total = hits.value.length + (allowCreate.value ? 1 : 0)
   if (total === 0) return
   highlight.value = (highlight.value + delta + total) % total
 }
 
-function onPick(hit) { emit('pick-existing', hit); reset() }
+function onPick (hit) { emit('pick-existing', hit); reset() }
 
-function onCreate() {
-  const name = query.value.trim()
-  if (kind.value === 'character') {
-    // Character requires a fandom — open the picker.
+function onCreate () {
+  const name = parsedName.value
+  const kind = parsedKind.value
+  if (kind === 'character') {
     pendingNewName = name
     fandomDialog.value = true
     return
   }
-  emit('pick-new', { name, kind: kind.value, fandom_id: null })
+  // Pass explicit kind here; the backend accepts both shapes. Passing
+  // it makes the parsed kind preview match the actual server outcome
+  // for users who didn't use a prefix (general goes through cleanly).
+  emit('pick-new', { name, kind, fandom_id: null })
   reset()
 }
 
-function onFandomChosen(fandom) {
+function onFandomChosen (fandom) {
   fandomDialog.value = false
-  emit('pick-new', { name: pendingNewName, kind: 'character', fandom_id: fandom.id })
+  emit('pick-new', {
+    name: pendingNewName, kind: 'character', fandom_id: fandom.id,
+  })
   pendingNewName = null
   reset()
 }
 
-function onEnter() {
+function onEnter () {
   if (highlight.value < hits.value.length) {
     onPick(hits.value[highlight.value])
   } else if (allowCreate.value) {
@@ -120,7 +155,7 @@ function onEnter() {
   }
 }
 
-function reset() { query.value = ''; hits.value = []; highlight.value = 0 }
+function reset () { query.value = ''; hits.value = []; highlight.value = 0 }
 </script>
 
 <style scoped>

frontend/src/components/posts/PostCard.vue

@@ -1,10 +1,17 @@
 <template>
-  <v-card class="fc-post-card" variant="outlined">
+  <v-card
+    class="fc-post-card"
+    variant="outlined"
+    tabindex="0"
+    @click="onCardClick"
+    @keydown.enter="onCardClick"
+  >
     <div class="fc-post-card__head">
       <v-chip size="x-small" variant="tonal">{{ post.source.platform }}</v-chip>
       <RouterLink
         :to="{ name: 'artist', params: { slug: post.artist.slug } }"
         class="fc-post-card__artist"
+        @click.stop
       >{{ post.artist.name }}</RouterLink>
       <span class="fc-post-card__date" :title="absoluteDate">{{ relativeDate }}</span>
       <v-spacer />
@@ -13,72 +20,74 @@
         :href="post.post_url" target="_blank" rel="noopener"
         icon="mdi-open-in-new" size="x-small" variant="text"
         :aria-label="`open original post on ${post.source.platform}`"
+        @click.stop
       />
     </div>
 
-    <h3 v-if="post.post_title" class="fc-post-card__title">{{ post.post_title }}</h3>
+    <div class="fc-post-card__body">
+      <div class="fc-post-card__media">
+        <template v-if="post.thumbnails?.length">
+          <div class="fc-post-card__hero">
+            <img :src="hero.thumbnail_url" :alt="`hero thumbnail`" loading="lazy" />
+          </div>
+          <div v-if="rail.length" class="fc-post-card__rail">
+            <div v-for="t in rail" :key="t.image_id" class="fc-post-card__rail-cell">
+              <img :src="t.thumbnail_url" :alt="`thumbnail`" loading="lazy" />
+            </div>
+            <div v-if="moreCount > 0" class="fc-post-card__rail-more">
+              +{{ moreCount }}
+            </div>
+          </div>
+        </template>
+        <PostEmptyThumbs v-else />
+      </div>
 
-    <div v-if="descriptionToShow" class="fc-post-card__desc">
-      <span class="fc-post-card__desc-text">{{ descriptionToShow }}</span>
-      <button
-        v-if="post.description_truncated && !expanded"
-        class="fc-post-card__more" type="button"
-        @click="expand"
-      >Show more</button>
-      <button
-        v-if="expanded"
-        class="fc-post-card__more" type="button"
-        @click="expanded = false"
-      >Show less</button>
-    </div>
+      <div class="fc-post-card__text">
+        <h3 v-if="post.post_title" class="fc-post-card__title">
+          {{ post.post_title }}
+        </h3>
+        <h3 v-else class="fc-post-card__title fc-post-card__title--missing">
+          Post {{ post.external_post_id }}
+        </h3>
 
-    <div v-if="post.thumbnails.length" class="fc-post-card__thumbs">
-      <RouterLink
-        v-for="t in post.thumbnails"
-        :key="t.image_id"
-        :to="{ path: '/gallery', query: { post_id: post.id } }"
-        class="fc-post-card__thumb"
-      >
-        <v-img
-          :src="t.thumbnail_url" cover :alt="`thumbnail`"
-          width="96" height="96" class="fc-post-card__thumb-img"
-        />
-      </RouterLink>
-      <RouterLink
-        v-if="post.thumbnails_more > 0"
-        :to="{ path: '/gallery', query: { post_id: post.id } }"
-        class="fc-post-card__more-thumbs"
-      >+{{ post.thumbnails_more }} more</RouterLink>
-    </div>
+        <p v-if="post.description_plain" class="fc-post-card__desc">
+          {{ post.description_plain }}
+        </p>
+        <p v-else class="fc-post-card__desc fc-post-card__desc--missing">
+          (no description)
+        </p>
 
-    <div v-if="post.attachments.length" class="fc-post-card__attachments">
-      <a
-        v-for="att in post.attachments"
-        :key="att.id"
-        :href="att.download_url"
-        download
-        class="fc-post-card__att"
-      >
-        <v-icon size="small" class="fc-post-card__att-icon">mdi-paperclip</v-icon>
-        <span class="fc-post-card__att-name">{{ att.original_filename }}</span>
-        <span class="fc-post-card__att-size">({{ formatBytes(att.size_bytes) }})</span>
-      </a>
+        <div v-if="post.attachments?.length" class="fc-post-card__atts">
+          <v-icon size="small" class="fc-post-card__att-icon">mdi-paperclip</v-icon>
+          {{ post.attachments.length }} attachment{{ post.attachments.length === 1 ? '' : 's' }}
+        </div>
+      </div>
     </div>
   </v-card>
 </template>
 
 <script setup>
-import { computed, ref } from 'vue'
-import { usePostsStore } from '../../stores/posts.js'
+import { computed } from 'vue'
+import { RouterLink } from 'vue-router'
+
+import { usePostModalStore } from '../../stores/postModal.js'
+import PostEmptyThumbs from './PostEmptyThumbs.vue'
 
 const props = defineProps({
   post: { type: Object, required: true },
 })
 
-const postsStore = usePostsStore()
+const postModal = usePostModalStore()
 
-const expanded = ref(false)
-const fullDescription = ref(null)
+const hero = computed(() => props.post.thumbnails?.[0])
+const rail = computed(() => (props.post.thumbnails || []).slice(1, 4))
+const moreCount = computed(() => {
+  const more = props.post.thumbnails_more || 0
+  const railLen = rail.value.length
+  // If feed returned more than (1 hero + 3 rail = 4), extra spills into "+N".
+  const extraShown = Math.max(0, (props.post.thumbnails?.length || 0) - 1 - railLen)
+  return more + extraShown
+})
 
 const sortDateIso = computed(() => props.post.post_date || props.post.downloaded_at)
 const absoluteDate = computed(() => new Date(sortDateIso.value).toLocaleString())
@@ -92,25 +101,8 @@ const relativeDate = computed(() => {
   return new Date(sortDateIso.value).toLocaleDateString()
 })
 
-const descriptionToShow = computed(() => {
-  if (expanded.value && fullDescription.value) return fullDescription.value
-  return props.post.description_plain
-})
-
-async function expand() {
-  if (!fullDescription.value) {
-    const detail = await postsStore.getPostFull(props.post.id)
-    fullDescription.value = detail?.description_full || props.post.description_plain
-  }
-  expanded.value = true
-}
-
-function formatBytes(n) {
-  if (!n) return '0 B'
-  if (n < 1024) return `${n} B`
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
-  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`
-  return `${(n / 1024 / 1024 / 1024).toFixed(1)} GB`
+function onCardClick () {
+  postModal.open(props.post)
 }
 </script>
 
@@ -118,13 +110,25 @@ function formatBytes(n) {
 .fc-post-card {
   padding: 1rem;
   margin-bottom: 1rem;
+  cursor: pointer;
+  container-type: inline-size;
+  transition: border-color 0.15s ease;
 }
+.fc-post-card:hover {
+  border-color: rgb(var(--v-theme-accent));
+}
+.fc-post-card:focus-visible {
+  outline: 2px solid rgb(var(--v-theme-accent));
+  outline-offset: 2px;
+}
+
 .fc-post-card__head {
   display: flex;
   align-items: center;
   gap: 0.6rem;
-  font-size: 0.85rem;
+  font-size: 0.8rem;
   color: rgb(var(--v-theme-on-surface-variant));
+  margin-bottom: 12px;
 }
 .fc-post-card__artist {
   color: rgb(var(--v-theme-on-surface));
@@ -133,72 +137,118 @@ function formatBytes(n) {
 }
 .fc-post-card__artist:hover { color: rgb(var(--v-theme-accent)); }
 .fc-post-card__date { white-space: nowrap; }
-.fc-post-card__title {
-  font-size: 1.05rem;
-  margin: 0.6rem 0 0.4rem;
-}
-.fc-post-card__desc {
-  white-space: pre-wrap;
-  font-size: 0.92rem;
-  color: rgb(var(--v-theme-on-surface));
-  margin-bottom: 0.6rem;
-}
-.fc-post-card__more {
-  background: none;
-  border: none;
-  color: rgb(var(--v-theme-accent));
-  cursor: pointer;
-  padding: 0 0.25rem;
-  font-size: inherit;
-}
-.fc-post-card__thumbs {
+
+.fc-post-card__body {
   display: flex;
-  flex-wrap: wrap;
-  gap: 0.4rem;
-  align-items: center;
-  margin: 0.5rem 0;
+  flex-direction: column;
+  gap: 16px;
 }
-.fc-post-card__thumb { line-height: 0; }
-.fc-post-card__thumb-img {
-  border-radius: 4px;
+@container (min-width: 800px) {
+  .fc-post-card__body {
+    flex-direction: row;
+    gap: 24px;
+  }
+  .fc-post-card__media {
+    flex: 0 0 50%;
+  }
+  .fc-post-card__text {
+    flex: 1 1 0;
+    min-width: 0;
+  }
+}
+
+.fc-post-card__hero {
+  width: 100%;
+  aspect-ratio: 16 / 10;
   overflow: hidden;
+  border-radius: 6px;
 }
-.fc-post-card__more-thumbs {
-  display: inline-flex;
+.fc-post-card__hero img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+
+.fc-post-card__rail {
+  display: flex;
+  gap: 6px;
+  margin-top: 6px;
+}
+.fc-post-card__rail-cell {
+  width: 80px;
+  height: 80px;
+  overflow: hidden;
+  border-radius: 4px;
+}
+.fc-post-card__rail-cell img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+.fc-post-card__rail-more {
+  width: 80px;
+  height: 80px;
+  display: flex;
   align-items: center;
   justify-content: center;
-  width: 96px;
-  height: 96px;
   border: 1px dashed rgb(var(--v-theme-on-surface-variant));
   border-radius: 4px;
   color: rgb(var(--v-theme-on-surface-variant));
-  text-decoration: none;
   font-size: 0.85rem;
 }
-.fc-post-card__more-thumbs:hover {
-  color: rgb(var(--v-theme-accent));
-  border-color: rgb(var(--v-theme-accent));
+
+.fc-post-card__title {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 18px;
+  font-weight: 500;
+  margin: 0 0 8px 0;
+  color: rgb(var(--v-theme-on-surface));
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
 }
-.fc-post-card__attachments {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.4rem;
-  margin-top: 0.6rem;
+.fc-post-card__title--missing {
+  font-style: italic;
+  color: rgb(var(--v-theme-on-surface-variant));
 }
-.fc-post-card__att {
+@container (min-width: 800px) {
+  .fc-post-card__title {
+    font-size: 20px;
+    -webkit-line-clamp: 1;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+  }
+}
+
+.fc-post-card__desc {
+  font-size: 0.9rem;
+  line-height: 1.5;
+  color: rgb(var(--v-theme-on-surface));
+  margin: 0 0 12px 0;
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+.fc-post-card__desc--missing {
+  font-style: italic;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+@container (min-width: 800px) {
+  .fc-post-card__desc {
+    -webkit-line-clamp: 5;
+  }
+}
+
+.fc-post-card__atts {
   display: inline-flex;
   align-items: center;
-  gap: 0.35rem;
-  padding: 0.2rem 0.5rem;
-  border: 1px solid rgb(var(--v-theme-on-surface-variant));
-  border-radius: 999px;
-  color: rgb(var(--v-theme-on-surface));
-  text-decoration: none;
-  font-size: 0.82rem;
+  gap: 6px;
+  font-size: 0.85rem;
+  color: rgb(var(--v-theme-on-surface-variant));
 }
-.fc-post-card__att:hover {
-  color: rgb(var(--v-theme-accent));
-  border-color: rgb(var(--v-theme-accent));
-}
-.fc-post-card__att-size { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-post-card__att-icon { color: rgb(var(--v-theme-on-surface-variant)); }
 </style>

frontend/src/components/posts/PostEmptyThumbs.vue

@@ -0,0 +1,35 @@
+<template>
+  <div class="fc-post-empty">
+    <v-icon size="48" class="fc-post-empty__icon">mdi-image-off-outline</v-icon>
+    <div class="fc-post-empty__text">No images attached to this post</div>
+  </div>
+</template>
+
+<script setup>
+// No props — pure presentational placeholder.
+</script>
+
+<style scoped>
+.fc-post-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+  padding: 32px 16px;
+  border: 1px dashed rgb(var(--v-theme-on-surface-variant));
+  border-radius: 8px;
+  background: rgba(20, 23, 26, 0.3);
+  width: 100%;
+  height: 100%;
+  min-height: 200px;
+}
+.fc-post-empty__icon {
+  color: rgb(var(--v-theme-on-surface-variant));
+  opacity: 0.6;
+}
+.fc-post-empty__text {
+  color: rgb(var(--v-theme-on-surface-variant));
+  font-size: 0.9rem;
+}
+</style>

frontend/src/components/posts/PostImageGrid.vue

@@ -0,0 +1,63 @@
+<template>
+  <div class="fc-post-grid">
+    <button
+      v-for="(t, idx) in thumbnails"
+      :key="t.image_id"
+      type="button"
+      class="fc-post-grid__cell"
+      :aria-label="`Open image ${idx + 1} of ${thumbnails.length}`"
+      @click="openImage(t.image_id, idx)"
+    >
+      <img
+        :src="t.thumbnail_url"
+        :alt="`thumbnail ${idx + 1}`"
+        loading="lazy"
+      />
+    </button>
+  </div>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+import { useModalStore } from '../../stores/modal.js'
+
+const props = defineProps({
+  thumbnails: { type: Array, required: true },  // [{ image_id, thumbnail_url, ... }]
+})
+
+const modal = useModalStore()
+
+const imageIds = computed(() => props.thumbnails.map(t => t.image_id))
+
+function openImage (id, idx) {
+  modal.open(id, { postImageIds: imageIds.value, initialIndex: idx })
+}
+</script>
+
+<style scoped>
+.fc-post-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 6px;
+}
+.fc-post-grid__cell {
+  aspect-ratio: 4 / 3;
+  overflow: hidden;
+  border-radius: 4px;
+  cursor: pointer;
+  border: 0;
+  padding: 0;
+  background: rgb(var(--v-theme-background));
+  transition: transform 0.15s ease, box-shadow 0.15s ease;
+}
+.fc-post-grid__cell:hover {
+  transform: scale(1.02);
+  box-shadow: 0 0 0 2px rgb(var(--v-theme-accent));
+}
+.fc-post-grid__cell img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  display: block;
+}
+</style>

frontend/src/components/posts/PostModal.vue

@@ -0,0 +1,211 @@
+<template>
+  <v-dialog
+    :model-value="store.isOpen"
+    max-width="1100"
+    scrollable
+    @update:model-value="(v) => { if (!v) close() }"
+  >
+    <v-card v-if="store.currentPost" class="fc-post-modal">
+      <div class="fc-post-modal__head">
+        <v-chip size="x-small" variant="tonal">{{ post.source.platform }}</v-chip>
+        <RouterLink
+          :to="{ name: 'artist', params: { slug: post.artist.slug } }"
+          class="fc-post-modal__artist"
+          @click="close"
+        >{{ post.artist.name }}</RouterLink>
+        <span class="fc-post-modal__date" :title="absoluteDate">
+          {{ relativeDate }}
+        </span>
+        <span v-if="post.thumbnails?.length" class="fc-post-modal__meta">
+          · {{ post.thumbnails.length }} image{{ post.thumbnails.length === 1 ? '' : 's' }}
+        </span>
+        <span v-if="post.attachments?.length" class="fc-post-modal__meta">
+          · {{ post.attachments.length }} attachment{{ post.attachments.length === 1 ? '' : 's' }}
+        </span>
+        <v-spacer />
+        <v-btn
+          v-if="post.post_url"
+          :href="post.post_url" target="_blank" rel="noopener"
+          icon="mdi-open-in-new" size="small" variant="text"
+          :aria-label="`open original post on ${post.source.platform}`"
+        />
+        <v-btn
+          icon="mdi-close" size="small" variant="text"
+          aria-label="Close"
+          @click="close"
+        />
+      </div>
+
+      <v-card-text class="fc-post-modal__body">
+        <section v-if="post.thumbnails?.length" class="fc-post-modal__sec">
+          <PostImageGrid :thumbnails="post.thumbnails" />
+          <div v-if="!store.detailLoaded" class="fc-post-modal__loading-hint">
+            Loading full image list…
+          </div>
+        </section>
+
+        <section v-if="post.post_title" class="fc-post-modal__sec">
+          <h2 class="fc-post-modal__title">{{ post.post_title }}</h2>
+        </section>
+
+        <section v-if="descriptionHtml" class="fc-post-modal__sec">
+          <div class="fc-post-modal__desc" v-html="descriptionHtml" />
+        </section>
+
+        <section v-if="post.attachments?.length" class="fc-post-modal__sec">
+          <h3 class="fc-post-modal__h3">Attachments</h3>
+          <div class="fc-post-modal__atts">
+            <a
+              v-for="att in post.attachments" :key="att.id"
+              :href="att.download_url" download
+              class="fc-post-modal__att"
+            >
+              <v-icon size="small" class="fc-post-modal__att-icon">mdi-paperclip</v-icon>
+              <span class="fc-post-modal__att-name">{{ att.original_filename }}</span>
+              <span class="fc-post-modal__att-size">({{ formatBytes(att.size_bytes) }})</span>
+            </a>
+          </div>
+        </section>
+      </v-card-text>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+import { RouterLink } from 'vue-router'
+
+import { usePostModalStore } from '../../stores/postModal.js'
+import { sanitizeHtml } from '../../utils/htmlSanitize.js'
+import PostImageGrid from './PostImageGrid.vue'
+
+const store = usePostModalStore()
+const post = computed(() => store.currentPost || {})
+
+const sortDateIso = computed(() => post.value.post_date || post.value.downloaded_at)
+const absoluteDate = computed(() => sortDateIso.value
+  ? new Date(sortDateIso.value).toLocaleString()
+  : '')
+const relativeDate = computed(() => {
+  if (!sortDateIso.value) return ''
+  const then = new Date(sortDateIso.value).getTime()
+  const diff = (Date.now() - then) / 1000
+  if (diff < 60) return `${Math.floor(diff)}s ago`
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
+  if (diff < 86400 * 30) return `${Math.floor(diff / 86400)}d ago`
+  return new Date(sortDateIso.value).toLocaleDateString()
+})
+
+const descriptionHtml = computed(() => {
+  // Detail endpoint returns description_full as plain text (the
+  // existing service uses html_to_plain on the stored description).
+  // Render the plain text in <p> wrappers; the sanitizer below is
+  // defensive for the case where the backend ever switches to raw HTML.
+  const raw = post.value.description_full || post.value.description_plain
+  if (!raw) return ''
+  if (/[<>]/.test(raw)) return sanitizeHtml(raw)
+  const esc = raw
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+  return esc
+    .split(/\n\s*\n/)
+    .map(p => `<p>${p.replace(/\n/g, '<br>')}</p>`)
+    .join('')
+})
+
+function close () {
+  store.close()
+}
+
+function formatBytes (n) {
+  if (!n) return '0 B'
+  if (n < 1024) return `${n} B`
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`
+  return `${(n / 1024 / 1024 / 1024).toFixed(1)} GB`
+}
+</script>
+
+<style scoped>
+.fc-post-modal {
+  background: rgb(var(--v-theme-surface));
+  max-height: 90vh;
+  display: flex;
+  flex-direction: column;
+}
+.fc-post-modal__head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 12px 16px;
+  font-size: 0.85rem;
+  color: rgb(var(--v-theme-on-surface-variant));
+  border-bottom: 1px solid rgb(var(--v-theme-on-surface-variant) / 0.15);
+}
+.fc-post-modal__artist {
+  color: rgb(var(--v-theme-on-surface));
+  text-decoration: none;
+  font-weight: 600;
+}
+.fc-post-modal__artist:hover { color: rgb(var(--v-theme-accent)); }
+.fc-post-modal__date { white-space: nowrap; }
+.fc-post-modal__meta { white-space: nowrap; }
+.fc-post-modal__body {
+  padding: 16px;
+  overflow-y: auto;
+  flex: 1 1 auto;
+}
+.fc-post-modal__sec {
+  margin-bottom: 24px;
+}
+.fc-post-modal__sec:last-child { margin-bottom: 0; }
+.fc-post-modal__title {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 24px;
+  font-weight: 500;
+  margin: 0;
+  color: rgb(var(--v-theme-on-surface));
+}
+.fc-post-modal__h3 {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 16px;
+  font-weight: 500;
+  margin: 0 0 8px 0;
+  color: rgb(var(--v-theme-on-surface));
+}
+.fc-post-modal__desc {
+  font-size: 0.95rem;
+  line-height: 1.55;
+  color: rgb(var(--v-theme-on-surface));
+}
+.fc-post-modal__desc :deep(p) { margin: 0 0 12px 0; }
+.fc-post-modal__desc :deep(a) { color: rgb(var(--v-theme-accent)); }
+.fc-post-modal__loading-hint {
+  margin-top: 8px;
+  font-size: 0.8rem;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+.fc-post-modal__atts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+.fc-post-modal__att {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 12px;
+  border: 1px solid rgb(var(--v-theme-on-surface-variant));
+  border-radius: 999px;
+  color: rgb(var(--v-theme-on-surface));
+  text-decoration: none;
+  font-size: 0.85rem;
+}
+.fc-post-modal__att:hover {
+  color: rgb(var(--v-theme-accent));
+  border-color: rgb(var(--v-theme-accent));
+}
+.fc-post-modal__att-size { color: rgb(var(--v-theme-on-surface-variant)); }
+</style>

frontend/src/components/settings/BrowserExtensionCard.vue

@@ -110,6 +110,7 @@
 <script setup>
 import { computed, onMounted, ref } from 'vue'
 import { useApi } from '../../composables/useApi.js'
+import { copyText } from '../../utils/clipboard.js'
 
 const api = useApi()
 
@@ -172,7 +173,7 @@ async function rotateKey() {
 
 async function copy(text, label) {
   try {
-    await navigator.clipboard.writeText(text)
+    await copyText(text)
     window.__fcToast?.({ text: `${label} copied.`, type: 'success' })
   } catch (e) {
     window.__fcToast?.({ text: `Copy failed: ${e.message}`, type: 'error' })

frontend/src/components/settings/MaintenancePanel.vue

@@ -1,13 +1,15 @@
 <template>
   <div class="fc-maint">
     <p class="text-body-2 mb-4">
-      Machine-assisted tagging controls. Backfill and centroid recompute run
-      nightly automatically; the allowlist auto-applies accepted tags to new
-      and existing images.
+      Operational backfills and tagging controls. The ML backfill and centroid
+      recompute run nightly automatically; the allowlist auto-applies accepted
+      tags to new and existing images. Use the cards below to trigger a
+      one-off pass.
     </p>
     <div class="fc-maint__grid">
       <MLBackfillCard />
       <CentroidRecomputeCard />
+      <ThumbnailBackfillCard />
     </div>
     <MLThresholdSliders class="mt-4" />
     <AllowlistTable class="mt-4" />
@@ -23,6 +25,7 @@
 <script setup>
 import MLBackfillCard from './MLBackfillCard.vue'
 import CentroidRecomputeCard from './CentroidRecomputeCard.vue'
+import ThumbnailBackfillCard from './ThumbnailBackfillCard.vue'
 import MLThresholdSliders from './MLThresholdSliders.vue'
 import AllowlistTable from './AllowlistTable.vue'
 import AliasTable from './AliasTable.vue'

frontend/src/components/settings/SystemActivityTab.vue

@@ -62,7 +62,7 @@
               <td>
                 <button
                   type="button" class="fc-err-link"
-                  @click="openError(r.error_type, r.error_message)"
+                  @click="openError(r)"
                   :title="'Click for full error'"
                 >{{ r.error_type }}</button>
               </td>
@@ -145,8 +145,7 @@
 
     <ErrorDetailModal
       v-model="showErrorModal"
-      :title="errorModalTitle"
-      :message="errorModalMessage"
+      :row="errorModalRow"
     />
   </div>
 </template>
@@ -163,12 +162,10 @@ import QueuesTable from './QueuesTable.vue'
 // rollback + traceback content rendered as a cramped browser tooltip
 // you couldn't copy from or scroll within).
 const showErrorModal = ref(false)
-const errorModalTitle = ref('')
-const errorModalMessage = ref('')
+const errorModalRow = ref(null)
 
-function openError(title, message) {
-  errorModalTitle.value = title || 'Error details'
-  errorModalMessage.value = message || ''
+function openError(row) {
+  errorModalRow.value = row
   showErrorModal.value = true
 }
 

frontend/src/components/settings/ThumbnailBackfillCard.vue

@@ -0,0 +1,30 @@
+<template>
+  <v-card>
+    <v-card-title>Thumbnail backfill</v-card-title>
+    <v-card-text>
+      <p class="text-body-2 mb-3">
+        Scan the library for images with no thumbnail, or whose thumbnail file
+        is missing or corrupt on disk. Repair candidates are re-enqueued for
+        thumbnail generation. Safe to re-run.
+      </p>
+      <v-btn color="primary" rounded="pill" :loading="busy" @click="run">
+        <v-icon start>mdi-image-refresh</v-icon> Run backfill now
+      </v-btn>
+      <span v-if="done" class="ml-3 text-caption">Enqueued.</span>
+    </v-card-text>
+  </v-card>
+</template>
+
+<script setup>
+import { ref } from 'vue'
+import { useThumbnailsStore } from '../../stores/thumbnails.js'
+const store = useThumbnailsStore()
+const busy = ref(false)
+const done = ref(false)
+async function run () {
+  busy.value = true
+  try { await store.triggerBackfill(); done.value = true }
+  catch (e) { window.__fcToast?.({ text: e.message, type: 'error' }) }
+  finally { busy.value = false }
+}
+</script>

frontend/src/stores/artist.js

@@ -1,6 +1,7 @@
 import { defineStore } from 'pinia'
 import { ref, computed } from 'vue'
 import { useApi } from '../composables/useApi.js'
+import { usePostsStore } from './posts.js'
 
 const PAGE = 60
 
@@ -15,7 +16,11 @@ export const useArtistStore = defineStore('artist', () => {
   const notFound = ref(false)
   let started = false
 
-  async function load(slug) {
+  async function load (slug) {
+    // Cross-artist reset: clear this store AND the posts store so the new
+    // artist doesn't briefly render with the previous artist's content
+    // when the user is on the Posts tab. (Gallery tab uses this artist
+    // store's own images list — cleared above.)
     overview.value = null
     images.value = []
     nextCursor.value = null
@@ -23,6 +28,7 @@ export const useArtistStore = defineStore('artist', () => {
     started = false
     error.value = null
     loading.value = true
+    usePostsStore().$reset?.()
     try {
       overview.value = await api.get(`/api/artist/${encodeURIComponent(slug)}`)
       await loadMoreImages(slug)
@@ -34,7 +40,7 @@ export const useArtistStore = defineStore('artist', () => {
     }
   }
 
-  async function loadMoreImages(slug) {
+  async function loadMoreImages (slug) {
     if (imagesLoading.value) return
     if (started && nextCursor.value === null) return
     imagesLoading.value = true
@@ -55,9 +61,13 @@ export const useArtistStore = defineStore('artist', () => {
   }
 
   const hasMoreImages = computed(() => !started || nextCursor.value !== null)
+  const postCount = computed(() => overview.value?.post_count ?? null)
+  const imageCount = computed(() => overview.value?.image_count ?? null)
+  const lastAdded = computed(() => overview.value?.date_range?.max ?? null)
 
   return {
     overview, images, loading, imagesLoading, error, notFound,
-    hasMoreImages, load, loadMoreImages
+    hasMoreImages, postCount, imageCount, lastAdded,
+    load, loadMoreImages,
   }
 })

frontend/src/stores/modal.js

@@ -6,14 +6,31 @@ export const useModalStore = defineStore('modal', () => {
   const api = useApi()
 
   const currentImageId = ref(null)
-  const current = ref(null)        // full image detail from API
+  const current = ref(null)
   const loading = ref(false)
   const error = ref(null)
 
-  async function open(id) {
+  // Post-scoped cycle. When set, prev/next cycles within this array
+  // (used by PostModal's PostImageGrid clicks). When null, prev/next
+  // falls back to current.value.neighbors (the gallery-store-driven
+  // /api/gallery/image/<id> neighbors).
+  const postImageIds = ref(null)
+  const postImageIndex = ref(0)
+
+  async function open (id, opts = {}) {
     currentImageId.value = id
     loading.value = true
     error.value = null
+    // Update post-scoped state if caller passed it; otherwise clear so
+    // the next open() from gallery context uses neighbors mode.
+    if (opts.postImageIds != null) {
+      postImageIds.value = opts.postImageIds
+      postImageIndex.value = opts.postImageIds.indexOf(id)
+      if (postImageIndex.value < 0) postImageIndex.value = 0
+    } else if (opts.clearPostScope !== false && postImageIds.value != null) {
+      postImageIds.value = null
+      postImageIndex.value = 0
+    }
     try {
       current.value = await api.get(`/api/gallery/image/${id}`)
     } catch (e) {
@@ -24,41 +41,58 @@ export const useModalStore = defineStore('modal', () => {
     }
   }
 
-  async function close() {
+  async function close () {
     currentImageId.value = null
     current.value = null
     error.value = null
+    postImageIds.value = null
+    postImageIndex.value = 0
   }
 
-  async function goPrev() {
-    if (current.value && current.value.neighbors.prev_id) {
+  async function goPrev () {
+    if (postImageIds.value != null) {
+      if (postImageIndex.value > 0) {
+        const newIdx = postImageIndex.value - 1
+        const newId = postImageIds.value[newIdx]
+        postImageIndex.value = newIdx
+        await open(newId, { postImageIds: postImageIds.value })
+      }
+      return
+    }
+    if (current.value && current.value.neighbors?.prev_id) {
       await open(current.value.neighbors.prev_id)
     }
   }
-  async function goNext() {
-    if (current.value && current.value.neighbors.next_id) {
+
+  async function goNext () {
+    if (postImageIds.value != null) {
+      if (postImageIndex.value < postImageIds.value.length - 1) {
+        const newIdx = postImageIndex.value + 1
+        const newId = postImageIds.value[newIdx]
+        postImageIndex.value = newIdx
+        await open(newId, { postImageIds: postImageIds.value })
+      }
+      return
+    }
+    if (current.value && current.value.neighbors?.next_id) {
       await open(current.value.neighbors.next_id)
     }
   }
 
-  async function reloadTags() {
+  async function reloadTags () {
     if (!currentImageId.value) return
     const tags = await api.get(`/api/images/${currentImageId.value}/tags`)
     if (current.value) current.value.tags = tags
   }
 
-  async function removeTag(tagId) {
+  async function removeTag (tagId) {
     if (!currentImageId.value) return
-    // Optimistic UI: remove locally first, restore on error.
     const prev = current.value.tags
     current.value.tags = current.value.tags.filter(t => t.id !== tagId)
     try {
-      // FC-2b: removal also records a per-image rejection (suggestions/dismiss
-      // is the rejection-recording endpoint) so the allowlist maintenance
-      // task won't re-apply this tag to this image.
       await api.delete(`/api/images/${currentImageId.value}/tags/${tagId}`)
       await api.post(`/api/images/${currentImageId.value}/suggestions/dismiss`, {
-        body: { tag_id: tagId }
+        body: { tag_id: tagId },
       })
     } catch (e) {
       current.value.tags = prev
@@ -67,25 +101,36 @@ export const useModalStore = defineStore('modal', () => {
     }
   }
 
-  async function addExistingTag(tagId) {
+  async function addExistingTag (tagId) {
     if (!currentImageId.value) return
     await api.post(`/api/images/${currentImageId.value}/tags`, {
-      body: { tag_id: tagId, source: 'manual' }
+      body: { tag_id: tagId, source: 'manual' },
     })
     await reloadTags()
   }
 
-  async function createAndAdd({ name, kind, fandom_id = null }) {
+  async function createAndAdd ({ name, kind, fandom_id = null }) {
     const tag = await api.post('/api/tags', { body: { name, kind, fandom_id } })
     await addExistingTag(tag.id)
   }
 
   const isOpen = computed(() => currentImageId.value !== null)
-  const canPrev = computed(() => current.value?.neighbors?.prev_id != null)
-  const canNext = computed(() => current.value?.neighbors?.next_id != null)
+  const canPrev = computed(() => {
+    if (postImageIds.value != null) return postImageIndex.value > 0
+    return current.value?.neighbors?.prev_id != null
+  })
+  const canNext = computed(() => {
+    if (postImageIds.value != null) {
+      return postImageIndex.value < (postImageIds.value.length - 1)
+    }
+    return current.value?.neighbors?.next_id != null
+  })
 
   return {
-    currentImageId, current, loading, error, isOpen, canPrev, canNext,
-    open, close, goPrev, goNext, reloadTags, removeTag, addExistingTag, createAndAdd
+    currentImageId, current, loading, error,
+    postImageIds, postImageIndex,
+    isOpen, canPrev, canNext,
+    open, close, goPrev, goNext,
+    reloadTags, removeTag, addExistingTag, createAndAdd,
   }
 })

frontend/src/stores/postModal.js

@@ -0,0 +1,39 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import { usePostsStore } from './posts.js'
+
+export const usePostModalStore = defineStore('postModal', () => {
+  const postsStore = usePostsStore()
+
+  // Feed-shape on open; upgraded to detail shape (full description +
+  // uncapped thumbnails) once getPostFull resolves.
+  const currentPost = ref(null)
+  const detailLoaded = ref(false)
+  const error = ref(null)
+  const isOpen = computed(() => currentPost.value !== null)
+
+  async function open (post) {
+    currentPost.value = post
+    detailLoaded.value = false
+    error.value = null
+    try {
+      const detail = await postsStore.getPostFull(post.id)
+      if (currentPost.value?.id === post.id) {
+        currentPost.value = detail
+        detailLoaded.value = true
+      }
+    } catch (e) {
+      // Keep feed-shape data; PostModal can still render title + truncated
+      // description + the up-to-6 feed thumbnails. Just surface the error.
+      error.value = e.message
+    }
+  }
+
+  function close () {
+    currentPost.value = null
+    detailLoaded.value = false
+    error.value = null
+  }
+
+  return { currentPost, detailLoaded, error, isOpen, open, close }
+})

frontend/src/stores/tags.js

@@ -2,24 +2,22 @@ import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import { useApi } from '../composables/useApi.js'
 
+// `artist` retired in FC-2d-vii-c (provenance is its own axis), `meta` +
+// `rating` retired by operator 2026-05-26 (alembic 0023 drops them from
+// the enum). KIND_COLOR keeps `archive` + `post` so any legacy
+// system-managed tag still renders with a neutral color.
 const KIND_OPTIONS = [
   { value: 'general',   label: 'General',   icon: 'mdi-tag' },
-  { value: 'artist',    label: 'Artist',    icon: 'mdi-palette' },
   { value: 'character', label: 'Character', icon: 'mdi-account-circle' },
   { value: 'fandom',    label: 'Fandom',    icon: 'mdi-book-open-page-variant' },
-  { value: 'series',    label: 'Series',    icon: 'mdi-bookshelf' },
-  { value: 'meta',      label: 'Meta',      icon: 'mdi-cog-outline' },
-  { value: 'rating',    label: 'Rating',    icon: 'mdi-shield-check-outline' }
+  { value: 'series',    label: 'Series',    icon: 'mdi-bookshelf' }
 ]
 
 const KIND_COLOR = {
-  artist:    'accent',
   character: 'info',
   fandom:    'secondary',
   series:    'warning',
   general:   'on-surface',
-  meta:      'on-surface',
-  rating:    'on-surface',
   archive:   'on-surface',
   post:      'on-surface'
 }

frontend/src/stores/thumbnails.js

@@ -0,0 +1,12 @@
+import { defineStore } from 'pinia'
+import { useApi } from '../composables/useApi.js'
+
+export const useThumbnailsStore = defineStore('thumbnails', () => {
+  const api = useApi()
+
+  async function triggerBackfill () {
+    await api.post('/api/thumbnails/backfill')
+  }
+
+  return { triggerBackfill }
+})

frontend/src/utils/clipboard.js

@@ -0,0 +1,35 @@
+// Clipboard write that works on plain-HTTP self-hosted deployments.
+//
+// navigator.clipboard is gated by the browser's Secure Context restriction
+// (HTTPS or localhost only). FabledCurator runs over plain HTTP per the
+// homelab posture, so the modern API is undefined in production. We fall
+// back to the legacy execCommand('copy') path via a temporary off-screen
+// textarea — wide browser support, no HTTPS requirement.
+
+export async function copyText (text) {
+  const str = text == null ? '' : String(text)
+  if (typeof navigator !== 'undefined' && navigator.clipboard?.writeText) {
+    try {
+      await navigator.clipboard.writeText(str)
+      return
+    } catch {
+      // Fall through to the legacy path. Some browsers throw even when
+      // the API exists (permission denied, focus loss, etc.).
+    }
+  }
+  const ta = document.createElement('textarea')
+  ta.value = str
+  ta.setAttribute('readonly', '')
+  ta.style.position = 'fixed'
+  ta.style.top = '0'
+  ta.style.left = '0'
+  ta.style.opacity = '0'
+  ta.style.pointerEvents = 'none'
+  document.body.appendChild(ta)
+  ta.select()
+  ta.setSelectionRange(0, str.length)
+  let ok = false
+  try { ok = document.execCommand('copy') } catch { ok = false }
+  document.body.removeChild(ta)
+  if (!ok) throw new Error('clipboard copy not supported')
+}

frontend/src/utils/htmlSanitize.js

@@ -0,0 +1,61 @@
+// Whitelist-based HTML sanitizer for rendering third-party post
+// descriptions (e.g. Patreon) via v-html. Strips script/style/iframe
+// + event handlers + dangerous hrefs. Tag whitelist covers what
+// Patreon, SubscribeStar, and similar platforms ship in normal posts.
+//
+// Not a substitute for server-side sanitization in higher-stakes
+// contexts. This is for FC's single-operator homelab posture where
+// the content source is the operator's own subscriptions.
+
+const ALLOWED_TAGS = new Set([
+  'a', 'b', 'blockquote', 'br', 'code', 'div', 'em', 'figure',
+  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'li',
+  'ol', 'p', 'pre', 's', 'span', 'strong', 'sub', 'sup', 'u', 'ul',
+])
+
+const ALLOWED_ATTRS = {
+  a: new Set(['href', 'title', 'rel', 'target']),
+  img: new Set(['src', 'alt', 'title', 'width', 'height']),
+  // any tag → these always allowed
+  '*': new Set(['class']),
+}
+
+const SAFE_URL_RE = /^(https?:|mailto:|#|\/)/i
+
+export function sanitizeHtml (html) {
+  if (typeof html !== 'string' || !html) return ''
+  const doc = new DOMParser().parseFromString(html, 'text/html')
+  _scrubNode(doc.body)
+  return doc.body.innerHTML
+}
+
+function _scrubNode (node) {
+  const children = Array.from(node.children)
+  for (const child of children) {
+    const tag = child.tagName.toLowerCase()
+    if (!ALLOWED_TAGS.has(tag)) {
+      // Strip the tag but keep its text content as a fallback.
+      const text = document.createTextNode(child.textContent || '')
+      child.replaceWith(text)
+      continue
+    }
+    const allowed = new Set([
+      ...(ALLOWED_ATTRS[tag] || []),
+      ...(ALLOWED_ATTRS['*'] || []),
+    ])
+    for (const attr of Array.from(child.attributes)) {
+      const name = attr.name.toLowerCase()
+      if (name.startsWith('on') || !allowed.has(name)) {
+        child.removeAttribute(attr.name)
+        continue
+      }
+      if ((name === 'href' || name === 'src') && !SAFE_URL_RE.test(attr.value)) {
+        child.removeAttribute(attr.name)
+      }
+    }
+    if (tag === 'a' && child.getAttribute('target') === '_blank') {
+      child.setAttribute('rel', 'noopener noreferrer')
+    }
+    _scrubNode(child)
+  }
+}

frontend/src/views/ArtistView.vue

@@ -1,220 +1,96 @@
 <template>
-  <v-container fluid class="py-6">
-    <div v-if="store.loading && !store.overview" class="fc-artist__loading">
-      <v-progress-circular indeterminate color="accent" size="36" />
-    </div>
+  <div v-if="store.loading && !store.overview" class="fc-artist__loading">
+    <v-progress-circular indeterminate color="accent" size="36" />
+  </div>
 
-    <v-alert v-else-if="store.notFound" type="warning" variant="tonal">
-      Artist not found.
-    </v-alert>
+  <v-container v-else-if="store.notFound" class="pt-2 pb-6">
+    <v-alert type="warning" variant="tonal">Artist not found.</v-alert>
+  </v-container>
 
-    <v-alert v-else-if="store.error" type="error" variant="tonal" closable>
-      {{ store.error }}
-    </v-alert>
-
-    <template v-else-if="store.overview">
-      <header class="fc-artist__head">
-        <h1 class="fc-h1">{{ store.overview.name }}</h1>
-        <div class="fc-artist__stats">
-          <span>{{ store.overview.image_count }} images</span>
-          <span v-if="dateRange">· {{ dateRange }}</span>
-        </div>
-      </header>
-
-      <div class="fc-artist__fc4">
-        <v-chip
-          size="small"
-          :variant="store.overview.is_subscription ? 'flat' : 'outlined'"
-          :color="store.overview.is_subscription ? 'accent' : undefined"
-          prepend-icon="mdi-rss"
-        >{{ store.overview.is_subscription ? 'Subscription' : 'One-off' }}</v-chip>
-
-        <v-chip
-          size="small" variant="outlined" prepend-icon="mdi-link-variant"
-          :to="`/subscriptions?artist_id=${store.overview.id}`"
-        >{{ store.overview.sources.length }} source{{ store.overview.sources.length === 1 ? '' : 's' }}</v-chip>
-
-        <v-chip
-          size="small" variant="outlined" prepend-icon="mdi-rss"
-          :to="`/posts?artist_id=${store.overview.id}`"
-        >View posts</v-chip>
-
-        <v-chip
-          size="small" variant="outlined" disabled
-          prepend-icon="mdi-clock-outline"
-        >Credential health · FC-3b</v-chip>
-      </div>
-
-      <!-- Tabs split (2026-05-25): Settings was previously slotted at the
-           bottom of the page after the infinite-scroll image grid, which
-           made it effectively unreachable for any artist with more than
-           a couple of pages of content. The Settings tab now hosts
-           destructive admin actions (artist+content cascade-delete) and
-           any future per-artist management UI. v-tabs is `position:
-           sticky; top: 64px` (under the 64px AppShell TopNav) so it
-           stays parked while the gallery scrolls. -->
-      <v-tabs
-        v-model="tab" color="accent" class="mb-4"
-        style="position: sticky; top: 64px; z-index: 4;
-               background: rgb(var(--v-theme-surface));"
-      >
-        <v-tab value="overview">Overview</v-tab>
-        <v-tab value="settings">Settings</v-tab>
-      </v-tabs>
+  <v-container v-else-if="store.error && !store.overview" class="pt-2 pb-6">
+    <v-alert type="error" variant="tonal" closable>{{ store.error }}</v-alert>
+  </v-container>
 
+  <template v-else-if="store.overview">
+    <ArtistHeader
+      v-model="tab"
+      :name="store.overview.name"
+      :image-count="store.imageCount"
+      :post-count="store.postCount"
+      :last-added="store.lastAdded"
+    />
+    <v-container fluid class="pt-2 pb-4">
       <v-window v-model="tab">
-        <v-window-item value="overview">
-          <section v-if="store.overview.cooccurring_tags.length" class="fc-artist__sec">
-            <h2 class="fc-h2">Frequent tags</h2>
-            <div class="fc-artist__tags">
-              <v-chip
-                v-for="t in store.overview.cooccurring_tags" :key="t.id"
-                size="small" @click="openTag(t.id)"
-              >{{ t.name }} <span class="fc-artist__tagc">{{ t.count }}</span></v-chip>
-            </div>
-          </section>
-
-          <section v-if="store.overview.activity.length" class="fc-artist__sec">
-            <h2 class="fc-h2">Activity</h2>
-            <svg class="fc-artist__spark" :viewBox="`0 0 ${sparkW} ${sparkH}`"
-                 preserveAspectRatio="none" role="img" aria-label="posts over time">
-              <polyline :points="sparkPoints" fill="none"
-                        stroke="rgb(var(--v-theme-accent))" stroke-width="2" />
-            </svg>
-          </section>
-
-          <section v-if="store.overview.sources.length" class="fc-artist__sec">
-            <div class="fc-artist__sec-head">
-              <h2 class="fc-h2">Sources</h2>
-              <RouterLink
-                :to="`/subscriptions?artist_id=${store.overview.id}`"
-                class="fc-artist__manage"
-              >Manage subscriptions →</RouterLink>
-            </div>
-            <v-table density="compact">
-              <thead>
-                <tr><th>Platform</th><th>URL</th><th class="text-right">Images</th></tr>
-              </thead>
-              <tbody>
-                <tr v-for="s in store.overview.sources" :key="s.id">
-                  <td>{{ s.platform }}</td>
-                  <td class="fc-artist__url">{{ s.url }}</td>
-                  <td class="text-right">{{ s.image_count }}</td>
-                </tr>
-              </tbody>
-            </v-table>
-          </section>
-
-          <section class="fc-artist__sec">
-            <h2 class="fc-h2">Images</h2>
-            <MasonryGrid
-              :items="store.images"
-              :loading="store.imagesLoading"
-              :has-more="store.hasMoreImages"
-              @load-more="store.loadMoreImages(slug)"
-              @open="openImage"
-            />
-          </section>
-        </v-window-item>
-
-        <v-window-item value="settings">
-          <ArtistDangerZone
-            :slug="slug"
+        <v-window-item value="posts">
+          <ArtistPostsTab
             :artist-id="store.overview.id"
-            :artist-name="store.overview.name"
+            @switch-tab="(t) => tab = t"
           />
         </v-window-item>
+        <v-window-item value="gallery">
+          <ArtistGalleryTab :slug="slug" />
+        </v-window-item>
+        <v-window-item value="management">
+          <ArtistManagementTab :overview="store.overview" />
+        </v-window-item>
       </v-window>
-    </template>
-  </v-container>
+    </v-container>
+  </template>
 </template>
 
 <script setup>
 import { computed, ref, watch } from 'vue'
-import { useRoute, useRouter, RouterLink } from 'vue-router'
+import { useRoute, useRouter } from 'vue-router'
+
 import { useArtistStore } from '../stores/artist.js'
-import { useModalStore } from '../stores/modal.js'
-import MasonryGrid from '../components/discovery/MasonryGrid.vue'
-import ArtistDangerZone from '../components/artist/ArtistDangerZone.vue'
+import ArtistHeader from '../components/artist/ArtistHeader.vue'
+import ArtistPostsTab from '../components/artist/ArtistPostsTab.vue'
+import ArtistGalleryTab from '../components/artist/ArtistGalleryTab.vue'
+import ArtistManagementTab from '../components/artist/ArtistManagementTab.vue'
+
+const VALID_TABS = ['posts', 'gallery', 'management']
 
 const route = useRoute()
 const router = useRouter()
 const store = useArtistStore()
-const modal = useModalStore()
 
 const slug = computed(() => route.params.slug)
-// Per-artist tab — defaults to Overview. Settings tab hosts destructive
-// admin actions (DangerZone). Switching artists resets to Overview so the
-// destructive surface isn't re-shown by accident when navigating between
-// artists.
-const tab = ref('overview')
+const tab = ref('posts')
 
-watch(slug, (s) => {
-  if (s) {
-    store.load(s)
-    tab.value = 'overview'
-  }
+function resolveDefaultTab () {
+  const fromUrl = route.query.tab
+  if (VALID_TABS.includes(fromUrl)) return fromUrl
+  if ((store.postCount ?? 0) > 0) return 'posts'
+  return 'gallery'
+}
+
+watch(slug, async (s) => {
+  if (!s) return
+  await store.load(s)
+  document.title = store.overview
+    ? `${store.overview.name} — FabledCurator`
+    : 'FabledCurator'
+  tab.value = resolveDefaultTab()
 }, { immediate: true })
 
-const dateRange = computed(() => {
-  const r = store.overview?.date_range
-  if (!r || !r.min) return null
-  const fmt = (iso) => iso.slice(0, 10)
-  return r.min === r.max ? fmt(r.min) : `${fmt(r.min)} → ${fmt(r.max)}`
+// Reflect tab changes back into the URL so refresh/back/forward work.
+watch(tab, (newTab) => {
+  if (route.query.tab === newTab) return
+  router.replace({
+    query: { ...route.query, tab: newTab },
+  })
 })
 
-const sparkW = 600
-const sparkH = 80
-const sparkPoints = computed(() => {
-  const a = store.overview?.activity ?? []
-  if (a.length === 0) return ''
-  const max = Math.max(...a.map(p => p.count), 1)
-  const stepX = a.length > 1 ? sparkW / (a.length - 1) : 0
-  return a.map((p, i) => {
-    const x = i * stepX
-    const y = sparkH - (p.count / max) * (sparkH - 4) - 2
-    return `${x.toFixed(1)},${y.toFixed(1)}`
-  }).join(' ')
+// React to URL-tab changes (e.g., back/forward).
+watch(() => route.query.tab, (q) => {
+  if (q && VALID_TABS.includes(q) && tab.value !== q) {
+    tab.value = q
+  }
 })
-
-function openImage(id) {
-  modal.open(id)
-}
-function openTag(tagId) {
-  router.push({ name: 'gallery', query: { tag_id: tagId } })
-}
 </script>
 
 <style scoped>
-.fc-h1 {
-  font-family: 'Fraunces', Georgia, serif;
-  font-size: 32px; font-weight: 500;
-  color: rgb(var(--v-theme-on-surface));
+.fc-artist__loading {
+  display: flex; justify-content: center; padding: 64px 0;
 }
-.fc-h2 {
-  font-family: 'Fraunces', Georgia, serif;
-  font-size: 20px; font-weight: 500; margin-bottom: 8px;
-}
-.fc-artist__loading { display: flex; justify-content: center; padding: 64px 0; }
-.fc-artist__head { margin-bottom: 12px; }
-.fc-artist__stats { opacity: 0.75; margin-top: 4px; }
-.fc-artist__fc4 { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 24px; }
-.fc-artist__sec { margin-bottom: 28px; }
-.fc-artist__tags { display: flex; flex-wrap: wrap; gap: 6px; }
-.fc-artist__tagc { opacity: 0.6; margin-left: 4px; font-variant-numeric: tabular-nums; }
-.fc-artist__spark { width: 100%; height: 80px; }
-.fc-artist__url {
-  max-width: 380px; overflow: hidden; text-overflow: ellipsis;
-  white-space: nowrap;
-}
-.fc-artist__sec-head {
-  display: flex; align-items: baseline; justify-content: space-between;
-  margin-bottom: 0.25rem;
-}
-.fc-artist__manage {
-  font-size: 0.85rem;
-  color: rgb(var(--v-theme-accent));
-  text-decoration: none;
-}
-.fc-artist__manage:hover { text-decoration: underline; }
 </style>

frontend/src/views/ArtistsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
 
     <div class="fc-artists__controls">
       <v-text-field

frontend/src/views/CredentialsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <ExtensionKeyBar />
 
     <v-alert v-if="credentialsStore.error" type="error" variant="tonal" closable class="mb-4">

frontend/src/views/DownloadsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <FilterPills v-model="pill" />
 
     <v-alert v-if="store.error" type="error" variant="tonal" closable class="my-4">

frontend/src/views/GalleryView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <Teleport to="#fc-nav-actions">
       <v-btn
         :color="sel.isSelectMode ? 'accent' : undefined"

frontend/src/views/PlaceholderView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container class="py-8">
+  <v-container class="pt-3 pb-8">
     <h1 class="fc-h1 mb-4">{{ title }}</h1>
     <v-alert type="info" variant="tonal" icon="mdi-toolbox">
       This surface is a placeholder. It will be implemented in

frontend/src/views/PostsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container class="py-6" max-width="900">
+  <v-container class="pt-2 pb-6" max-width="900">
     <PostsFilterBar
       :artist-id="artistFilter"
       :platform="platformFilter"

frontend/src/views/SeriesManageView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <div class="fc-series__head">
       <span class="fc-series__name">{{ store.series?.name || 'Series' }}</span>
       <span class="fc-series__count">{{ store.pages.length }} page(s)</span>

frontend/src/views/SettingsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <!-- Sticky tabs: operator-flagged 2026-05-25 — long Import / Maintenance
          panels pushed the tab strip out of the viewport, forcing a scroll-
          to-top just to change tab. AppShell's TopNav is 64px sticky, so the

frontend/src/views/ShowcaseView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <Teleport to="#fc-nav-actions">
       <v-btn
         prepend-icon="mdi-shuffle-variant" variant="tonal" color="accent"

frontend/src/views/SubscriptionsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
     <div class="fc-subs__bar">
       <v-btn color="accent" prepend-icon="mdi-plus" @click="openAddSource(null)">
         Add subscription

frontend/src/views/TagsView.vue

@@ -1,5 +1,5 @@
 <template>
-  <v-container fluid class="py-6">
+  <v-container fluid class="pt-2 pb-6">
 
     <div class="fc-tags__controls">
       <v-text-field
@@ -99,10 +99,11 @@ import MergeConfirmDialog from '../components/discovery/MergeConfirmDialog.vue'
 import DestructiveConfirmModal from '../components/modal/DestructiveConfirmModal.vue'
 
 // Must stay a subset of the backend TagKind enum (character, fandom,
-// general, series, archive, post, meta, rating). 'fandom' is this
-// model's copyright/franchise concept (characters link via fandom_id).
-// 'artist' retired in FC-2d-vii-c — artists are the Artist row, not a tag.
-const KINDS = ['character', 'fandom', 'general', 'series', 'meta']
+// general, series, archive, post). 'fandom' is this model's
+// copyright/franchise concept (characters link via fandom_id).
+// 'artist' retired in FC-2d-vii-c — artists are the Artist row, not
+// a tag. 'meta' + 'rating' retired by operator 2026-05-26 (alembic 0023).
+const KINDS = ['character', 'fandom', 'general', 'series']
 const store = useTagDirectoryStore()
 const router = useRouter()
 

tests/test_api_artist.py

@@ -29,6 +29,30 @@ async def test_artist_overview_ok(client, db):
     body = await resp.get_json()
     assert body["name"] == "Mira"
     assert body["image_count"] == 0
+    assert body["post_count"] == 0
+
+
+@pytest.mark.asyncio
+async def test_artist_overview_post_count(client, db):
+    from backend.app.models import Post, Source
+
+    a = Artist(name="Lyra", slug="lyra")
+    db.add(a)
+    await db.flush()
+    s = Source(
+        artist_id=a.id, platform="patreon",
+        url="https://patreon.com/cw/lyra", enabled=True,
+    )
+    db.add(s)
+    await db.flush()
+    db.add(Post(source_id=s.id, external_post_id="p1"))
+    db.add(Post(source_id=s.id, external_post_id="p2"))
+    await db.flush()
+    await db.commit()
+    resp = await client.get("/api/artist/lyra")
+    assert resp.status_code == 200
+    body = await resp.get_json()
+    assert body["post_count"] == 2
 
 
 @pytest.mark.asyncio

tests/test_api_posts.py

@@ -117,3 +117,50 @@ async def test_detail_404_for_unknown(client):
     assert resp.status_code == 404
     body = await resp.get_json()
     assert body["error"] == "not_found"
+
+
+@pytest.mark.asyncio
+async def test_detail_returns_uncapped_thumbnails(client, db):
+    """Feed query caps thumbnails at 6 for previews; detail endpoint
+    returns the full list so PostModal can render the masonry grid."""
+    from backend.app.models import ImageRecord
+
+    a = Artist(name="yuki-api", slug="yuki-api")
+    db.add(a)
+    await db.flush()
+    s = Source(
+        artist_id=a.id, platform="patreon",
+        url="https://patreon.com/cw/yuki-api", enabled=True,
+    )
+    db.add(s)
+    await db.flush()
+    p = Post(
+        source_id=s.id, external_post_id="DETAIL10",
+        post_title="big post", description="<p>body</p>",
+    )
+    db.add(p)
+    await db.flush()
+    # Seed 10 ImageRecord rows linked to this post via primary_post_id.
+    for i in range(10):
+        sha = f"y{i:x}".ljust(64, "0")[:64]
+        rec = ImageRecord(
+            path=f"/images/test-yuki-{i}.jpg",
+            sha256=sha,
+            size_bytes=1,
+            mime="image/jpeg",
+            width=64,
+            height=64,
+            origin="downloaded",
+            integrity_status="unknown",
+            primary_post_id=p.id,
+            artist_id=a.id,
+        )
+        db.add(rec)
+    await db.commit()
+
+    resp = await client.get(f"/api/posts/{p.id}")
+    assert resp.status_code == 200
+    body = await resp.get_json()
+    # Detail returns ALL 10 thumbnails (feed would return 6 + thumbnails_more).
+    assert len(body["thumbnails"]) == 10
+    assert body["description_full"] == "body"

tests/test_api_tags.py

@@ -55,6 +55,52 @@ async def test_create_character_with_bad_fandom_id(client):
 
 
 @pytest.mark.asyncio
-async def test_create_tag_missing_required(client):
-    resp = await client.post("/api/tags", json={"name": "Bob"})
+async def test_create_tag_missing_name_400(client):
+    """name is still required; only `kind` became optional."""
+    resp = await client.post("/api/tags", json={})
     assert resp.status_code == 400
+    resp = await client.post("/api/tags", json={"kind": "artist"})
+    assert resp.status_code == 400
+
+
+@pytest.mark.asyncio
+async def test_create_tag_name_only_defaults_to_general(client):
+    """IR-style: name without kind and without `kind:` prefix → general."""
+    resp = await client.post("/api/tags", json={"name": "sunset"})
+    assert resp.status_code == 201
+    body = await resp.get_json()
+    assert body["name"] == "sunset"
+    assert body["kind"] == "general"
+
+
+@pytest.mark.asyncio
+async def test_create_tag_with_kind_prefix(client):
+    """IR-style: `name="character:Saber"` without explicit kind → parsed as character."""
+    resp = await client.post("/api/tags", json={"name": "character:Saber"})
+    assert resp.status_code == 201
+    body = await resp.get_json()
+    assert body["name"] == "Saber"
+    assert body["kind"] == "character"
+
+
+@pytest.mark.asyncio
+async def test_explicit_kind_overrides_prefix_parsing(client):
+    """If caller passes explicit kind, don't re-parse the name —
+    colon and prefix stay literal."""
+    resp = await client.post(
+        "/api/tags", json={"name": "character:Saber", "kind": "general"}
+    )
+    assert resp.status_code == 201
+    body = await resp.get_json()
+    assert body["name"] == "character:Saber"
+    assert body["kind"] == "general"
+
+
+@pytest.mark.asyncio
+async def test_unknown_prefix_kept_literal(client):
+    """`http:example` — `http` not in KNOWN_KINDS → kind=general, literal name."""
+    resp = await client.post("/api/tags", json={"name": "http://example.com"})
+    assert resp.status_code == 201
+    body = await resp.get_json()
+    assert body["name"] == "http://example.com"
+    assert body["kind"] == "general"

tests/test_api_thumbnails.py

@@ -0,0 +1,32 @@
+import pytest
+
+from backend.app import create_app
+from backend.app.celery_app import celery
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture(autouse=True)
+def eager():
+    celery.conf.task_always_eager = True
+    yield
+    celery.conf.task_always_eager = False
+
+
+@pytest.fixture
+async def app():
+    return create_app()
+
+
+@pytest.fixture
+async def client(app):
+    async with app.test_client() as c:
+        yield c
+
+
+@pytest.mark.asyncio
+async def test_trigger_thumbnail_backfill(client):
+    r = await client.post("/api/thumbnails/backfill")
+    assert r.status_code == 202
+    body = await r.get_json()
+    assert "celery_task_id" in body

tests/test_backfill_thumbnails.py

@@ -0,0 +1,242 @@
+"""Thumbnail backfill: _thumb_is_valid helper + backfill_thumbnails planner."""
+
+from pathlib import Path
+
+import pytest
+
+from backend.app.models import ImageRecord
+from backend.app.tasks.thumbnail import _thumb_is_valid
+
+pytestmark = pytest.mark.integration
+
+
+def test_thumb_is_valid_jpeg(tmp_path):
+    p = tmp_path / "good.jpg"
+    p.write_bytes(b"\xff\xd8\xff\xe0" + b"\x00" * 100)
+    assert _thumb_is_valid(p) is True
+
+
+def test_thumb_is_valid_png(tmp_path):
+    p = tmp_path / "good.png"
+    p.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 100)
+    assert _thumb_is_valid(p) is True
+
+
+def test_thumb_is_valid_too_short(tmp_path):
+    p = tmp_path / "tiny"
+    p.write_bytes(b"\xff\xd8")
+    assert _thumb_is_valid(p) is False
+
+
+def test_thumb_is_valid_wrong_magic(tmp_path):
+    p = tmp_path / "garbage"
+    p.write_bytes(b"\x00" * 12)
+    assert _thumb_is_valid(p) is False
+
+
+def test_thumb_is_valid_missing_file(tmp_path):
+    assert _thumb_is_valid(tmp_path / "nope") is False
+
+
+# --- backfill_thumbnails planner tests ------------------------------------
+
+
+class _Ctx:
+    def __init__(self, s):
+        self.s = s
+
+    def __enter__(self):
+        return self.s
+
+    def __exit__(self, *a):
+        return False
+
+
+def _sf(db_sync):
+    """sessionmaker-like returning the test's bound session, matching the
+    pattern in tests/test_backfill_phash.py."""
+    class _SM:
+        def __call__(self):
+            return _Ctx(db_sync)
+
+    return _SM()
+
+
+def _sha(prefix: str) -> str:
+    return f"{prefix}".ljust(64, "0")[:64]
+
+
+def _rec(db_sync, path, *, sha, thumb_path=None, mime="image/jpeg"):
+    rec = ImageRecord(
+        path=str(path), sha256=sha, size_bytes=1, mime=mime,
+        width=64, height=64, origin="imported_filesystem",
+        integrity_status="unknown",
+        thumbnail_path=str(thumb_path) if thumb_path is not None else None,
+    )
+    db_sync.add(rec)
+    db_sync.flush()
+    return rec
+
+
+def _write_jpeg(p: Path) -> Path:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_bytes(b"\xff\xd8\xff\xe0" + b"\x00" * 100)
+    return p
+
+
+def _write_png(p: Path) -> Path:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 100)
+    return p
+
+
+def _write_garbage(p: Path) -> Path:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_bytes(b"\x00" * 12)
+    return p
+
+
+def test_backfill_null_path_enqueued(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src = tmp_path / "a.bin"
+    src.write_bytes(b"x")
+    rec = _rec(db_sync, src, sha=_sha("a"), thumb_path=None)
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    assert result == {"enqueued": 1, "ok": 0, "regenerated": 0}
+    assert delayed == [rec.id]
+
+
+def test_backfill_missing_file_clears_and_enqueues(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src = tmp_path / "b.bin"
+    src.write_bytes(b"x")
+    rec = _rec(
+        db_sync, src, sha=_sha("b"),
+        thumb_path=tmp_path / "thumbs" / "missing.jpg",
+    )
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    db_sync.expire_all()
+    assert result == {"enqueued": 1, "ok": 0, "regenerated": 1}
+    assert delayed == [rec.id]
+    assert db_sync.get(ImageRecord, rec.id).thumbnail_path is None
+
+
+def test_backfill_valid_jpeg_skipped(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src = tmp_path / "c.bin"
+    src.write_bytes(b"x")
+    thumb = _write_jpeg(tmp_path / "thumbs" / "c.jpg")
+    rec = _rec(db_sync, src, sha=_sha("c"), thumb_path=thumb)
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    db_sync.expire_all()
+    assert result == {"enqueued": 0, "ok": 1, "regenerated": 0}
+    assert delayed == []
+    assert db_sync.get(ImageRecord, rec.id).thumbnail_path == str(thumb)
+
+
+def test_backfill_valid_png_skipped(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src = tmp_path / "d.bin"
+    src.write_bytes(b"x")
+    thumb = _write_png(tmp_path / "thumbs" / "d.png")
+    _rec(db_sync, src, sha=_sha("d"), thumb_path=thumb)
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    assert result == {"enqueued": 0, "ok": 1, "regenerated": 0}
+    assert delayed == []
+
+
+def test_backfill_corrupt_magic_clears_and_enqueues(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src = tmp_path / "e.bin"
+    src.write_bytes(b"x")
+    thumb = _write_garbage(tmp_path / "thumbs" / "e.jpg")
+    rec = _rec(db_sync, src, sha=_sha("e"), thumb_path=thumb)
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    db_sync.expire_all()
+    assert result == {"enqueued": 1, "ok": 0, "regenerated": 1}
+    assert delayed == [rec.id]
+    assert db_sync.get(ImageRecord, rec.id).thumbnail_path is None
+
+
+def test_backfill_mixed_aggregate(db_sync, tmp_path, monkeypatch):
+    from backend.app.tasks import thumbnail as m
+
+    src_null = tmp_path / "src_null.bin"
+    src_null.write_bytes(b"x")
+    src_jpeg = tmp_path / "src_jpeg.bin"
+    src_jpeg.write_bytes(b"x")
+    src_png = tmp_path / "src_png.bin"
+    src_png.write_bytes(b"x")
+    src_missing = tmp_path / "src_missing.bin"
+    src_missing.write_bytes(b"x")
+    src_bad = tmp_path / "src_bad.bin"
+    src_bad.write_bytes(b"x")
+
+    jpeg = _write_jpeg(tmp_path / "thumbs" / "ok.jpg")
+    png = _write_png(tmp_path / "thumbs" / "ok.png")
+    bad = _write_garbage(tmp_path / "thumbs" / "bad.jpg")
+
+    r_null = _rec(db_sync, src_null, sha=_sha("aa"), thumb_path=None)
+    _rec(db_sync, src_jpeg, sha=_sha("bb"), thumb_path=jpeg)
+    _rec(db_sync, src_png, sha=_sha("cc"), thumb_path=png)
+    r_missing = _rec(
+        db_sync, src_missing, sha=_sha("dd"),
+        thumb_path=tmp_path / "thumbs" / "missing.jpg",
+    )
+    r_bad = _rec(db_sync, src_bad, sha=_sha("ee"), thumb_path=bad)
+    db_sync.commit()
+
+    monkeypatch.setattr(m, "_sync_session_factory", lambda: _sf(db_sync))
+    delayed: list[int] = []
+    monkeypatch.setattr(
+        m.generate_thumbnail, "delay", lambda image_id: delayed.append(image_id)
+    )
+
+    result = m.backfill_thumbnails()
+    assert result == {"enqueued": 3, "ok": 2, "regenerated": 2}
+    assert sorted(delayed) == sorted([r_null.id, r_missing.id, r_bad.id])

tests/test_extension_cors.py

@@ -0,0 +1,86 @@
+"""CORS preflight + response headers for moz-extension:// + chrome-extension://.
+
+Operator-flagged 2026-05-26: extension's first 'Test connection' tap
+returned `NetworkError` because /api/credentials had no OPTIONS handler
+and no Access-Control-Allow-Origin response header. Browser preflight
+failed → fetch blocked.
+
+These tests pin the contract: any request from a moz-extension:// or
+chrome-extension:// origin gets the right ACL headers. Plain browser
+requests (no Origin header, or a regular https:// Origin) get nothing
+— we don't want to open CORS up generally.
+"""
+
+import pytest
+
+from backend.app import create_app
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+async def client():
+    app = create_app()
+    async with app.test_client() as c:
+        yield c
+
+
+@pytest.mark.asyncio
+async def test_extension_preflight_returns_204_with_acl_headers(client):
+    resp = await client.options(
+        "/api/credentials",
+        headers={
+            "Origin": "moz-extension://abcd1234-uuid-fake",
+            "Access-Control-Request-Method": "GET",
+            "Access-Control-Request-Headers": "X-Extension-Key",
+        },
+    )
+    assert resp.status_code == 204
+    assert resp.headers["Access-Control-Allow-Origin"] == "moz-extension://abcd1234-uuid-fake"
+    assert "OPTIONS" in resp.headers["Access-Control-Allow-Methods"]
+    assert "X-Extension-Key" in resp.headers["Access-Control-Allow-Headers"]
+
+
+@pytest.mark.asyncio
+async def test_extension_get_carries_acl_headers(client):
+    # The actual response (post-preflight) also needs ACL headers — the
+    # browser checks them again before exposing the response body.
+    resp = await client.get(
+        "/api/credentials",
+        headers={"Origin": "moz-extension://abcd1234-uuid-fake"},
+    )
+    # 200 with empty list (no creds seeded) — what matters here is the
+    # CORS header is present.
+    assert resp.headers["Access-Control-Allow-Origin"] == "moz-extension://abcd1234-uuid-fake"
+
+
+@pytest.mark.asyncio
+async def test_chrome_extension_origin_also_allowed(client):
+    resp = await client.options(
+        "/api/credentials",
+        headers={
+            "Origin": "chrome-extension://abcd1234-uuid-fake",
+            "Access-Control-Request-Method": "POST",
+        },
+    )
+    assert resp.status_code == 204
+    assert resp.headers["Access-Control-Allow-Origin"] == "chrome-extension://abcd1234-uuid-fake"
+
+
+@pytest.mark.asyncio
+async def test_normal_browser_request_gets_no_cors_headers(client):
+    # A regular browser tab (https://example.com / file:// / no Origin
+    # at all) should NOT get any Access-Control-Allow-* — the extension
+    # whitelist is intentionally narrow.
+    resp = await client.get(
+        "/api/credentials",
+        headers={"Origin": "https://evil.example.com"},
+    )
+    assert "Access-Control-Allow-Origin" not in resp.headers
+
+
+@pytest.mark.asyncio
+async def test_no_origin_header_unaffected(client):
+    # Same-origin requests (no Origin header) — unaffected.
+    resp = await client.get("/api/credentials")
+    assert "Access-Control-Allow-Origin" not in resp.headers

tests/test_gallery_provenance_filter.py

@@ -69,20 +69,13 @@ async def test_scroll_post_id_filter(db):
     assert {x.id for x in page.images} == {i1.id, i2.id}
 
 
-@pytest.mark.asyncio
-async def test_scroll_post_id_dedups_multi_rows(db):
-    i1 = await _img(db, 1)
-    _, s, p = await _post(db, "A", "a", "10")
-    # two provenance rows, same image+post (enrich-on-duplicate shape)
-    db.add(ImageProvenance(image_record_id=i1.id, post_id=p.id,
-                           source_id=s.id))
-    await db.flush()
-    db.add(ImageProvenance(image_record_id=i1.id, post_id=p.id,
-                           source_id=s.id))
-    await db.flush()
-    svc = GalleryService(db)
-    page = await svc.scroll(cursor=None, limit=10, post_id=p.id)
-    assert [x.id for x in page.images] == [i1.id]  # appears once
+# test_scroll_post_id_dedups_multi_rows removed 2026-05-26: it deliberately
+# inserted two ImageProvenance rows with the same (image_record_id, post_id),
+# now prevented at the DB layer by uq_image_provenance_image_post (alembic
+# 0021). The EXISTS-based dedup in _provenance_clause is still useful for the
+# artist-id filter (one image legitimately joins many provenance rows via
+# different posts under the same artist), so the gallery_service logic is
+# unchanged.
 
 
 @pytest.mark.asyncio

tests/test_importer_provenance_race.py

@@ -0,0 +1,184 @@
+"""Race-safe ImageProvenance insert in Importer._apply_sidecar.
+
+Operator-flagged 2026-05-26: the prior SELECT-then-INSERT pattern lost a
+race when two workers ran _apply_sidecar on the same (image, post) pair
+(plausibly seeded when the 5-min recovery sweep re-enqueued a still-running
+long import). Duplicates then broke .scalar_one_or_none() on every later
+deep-scan rederive (MultipleResultsFound). Alembic 0021 added
+uq_image_provenance_image_post; the importer's new savepoint+IntegrityError
+recovery path now trips on collision and gracefully recovers.
+
+Tests cover:
+  - idempotent: re-running _apply_sidecar via _deep_rederive produces
+    exactly one ImageProvenance row.
+  - IntegrityError recovery: pre-seed a provenance row, force the first
+    SELECT to return None (simulating the race window where two workers
+    both observed no row), call _apply_sidecar — the savepoint INSERT
+    trips uq_image_provenance_image_post, gets rolled back, no exception
+    escapes, still exactly one row.
+"""
+
+import json
+from pathlib import Path
+
+import pytest
+from PIL import Image
+from sqlalchemy import func, select
+
+from backend.app.models import (
+    ImageProvenance,
+    ImageRecord,
+    ImportSettings,
+    Source,
+)
+from backend.app.services.importer import Importer
+from backend.app.services.thumbnailer import Thumbnailer
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+def import_layout(tmp_path):
+    import_root = tmp_path / "import"
+    images_root = tmp_path / "images"
+    import_root.mkdir()
+    images_root.mkdir()
+    return import_root, images_root
+
+
+@pytest.fixture
+def importer(db_sync, import_layout):
+    import_root, images_root = import_layout
+    settings = db_sync.execute(
+        select(ImportSettings).where(ImportSettings.id == 1)
+    ).scalar_one()
+    return Importer(
+        session=db_sync,
+        images_root=images_root,
+        import_root=import_root,
+        thumbnailer=Thumbnailer(images_root=images_root),
+        settings=settings,
+    )
+
+
+@pytest.fixture
+def deep_importer(db_sync, import_layout):
+    import_root, images_root = import_layout
+    settings = db_sync.execute(
+        select(ImportSettings).where(ImportSettings.id == 1)
+    ).scalar_one()
+    return Importer(
+        session=db_sync,
+        images_root=images_root,
+        import_root=import_root,
+        thumbnailer=Thumbnailer(images_root=images_root),
+        settings=settings,
+        deep=True,
+    )
+
+
+def _split(path: Path, orient, size=(256, 256)):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    w, h = size
+    im = Image.new("L", size, 0)
+    px = im.load()
+    for y in range(h):
+        for x in range(w):
+            if (x / w if orient == "v" else y / h) >= 0.5:
+                px[x, y] = 255
+    im.convert("RGB").save(path, "JPEG")
+
+
+def _sidecar(media: Path, payload: dict):
+    media.with_suffix(".json").write_text(json.dumps(payload))
+
+
+def test_apply_sidecar_idempotent_on_deep_rederive(
+    importer, deep_importer, import_layout,
+):
+    """Normal-flow path: deep rederive on an already-imported image finds
+    the existing provenance row via .scalar_one_or_none() and skips the
+    insert. Exactly one ImageProvenance row after both runs."""
+    import_root, _ = import_layout
+    m = import_root / "Alice" / "a.jpg"
+    _split(m, "v")
+    _sidecar(m, {
+        "category": "patreon", "id": 555,
+        "url": "https://patreon.com/posts/555", "title": "Set 1",
+    })
+    r = importer.import_one(m)
+    assert r.status == "imported"
+
+    # Re-import via deep mode — sha matches → _deep_rederive → _apply_sidecar.
+    r2 = deep_importer.import_one(m)
+    assert r2.status == "refreshed"
+
+    count = importer.session.execute(
+        select(func.count()).select_from(ImageProvenance)
+    ).scalar_one()
+    assert count == 1
+
+
+def test_apply_sidecar_recovers_from_integrity_error(
+    importer, deep_importer, import_layout, db_sync, monkeypatch,
+):
+    """Race recovery: a row already exists for (image, post). We force the
+    importer's existence-check SELECT to return None for one call, mimicking
+    the race window where two workers both saw no row. The savepoint INSERT
+    then trips uq_image_provenance_image_post; the helper rolls the
+    savepoint back, no exception escapes, and the row count stays at 1.
+    """
+    import_root, _ = import_layout
+    m = import_root / "Bob" / "b.jpg"
+    _split(m, "v")
+    _sidecar(m, {
+        "category": "patreon", "id": 777,
+        "url": "https://patreon.com/posts/777", "title": "Set 2",
+    })
+    # First import lays the canonical provenance row.
+    r = importer.import_one(m)
+    assert r.status == "imported"
+    rec = importer.session.get(ImageRecord, r.image_id)
+    src = importer.session.execute(select(Source)).scalar_one()
+    assert rec is not None
+    assert src is not None
+
+    # Monkeypatch session.execute so the FIRST select inside _apply_sidecar's
+    # existence-check returns a "no row" wrapper. Subsequent selects (e.g.
+    # the find_or_create_source / find_or_create_post existence checks
+    # earlier in _apply_sidecar) all run normally; we intercept only the
+    # ImageProvenance lookup, identified by the SELECT's target columns
+    # mentioning image_provenance.
+    real_execute = db_sync.execute
+    intercepted = [False]
+
+    def _intercepting_execute(stmt, *args, **kwargs):
+        text = str(stmt)
+        if (
+            not intercepted[0]
+            and "image_provenance" in text
+            and "image_record_id" in text
+            and "post_id" in text
+        ):
+            intercepted[0] = True
+
+            class _ForcedMiss:
+                def scalar_one_or_none(self):
+                    return None
+            return _ForcedMiss()
+        return real_execute(stmt, *args, **kwargs)
+
+    monkeypatch.setattr(db_sync, "execute", _intercepting_execute)
+
+    # Re-import via deep mode → _deep_rederive → _apply_sidecar. With the
+    # provenance-SELECT forced to miss, the helper will attempt the INSERT,
+    # trip uq_image_provenance_image_post, catch IntegrityError, and recover.
+    r2 = deep_importer.import_one(m)
+    assert r2.status == "refreshed"
+
+    # Lift the intercept, then verify the row count.
+    monkeypatch.undo()
+    count = db_sync.execute(
+        select(func.count()).select_from(ImageProvenance)
+    ).scalar_one()
+    assert count == 1

tests/test_importer_upsert_helpers.py

@@ -145,3 +145,68 @@ def test_find_or_create_source_recovers_from_integrity_error(
         artist_id=artist_row.id, platform="patreon", url=canonical_url,
     )
     assert recovered.id == pre_existing.id
+
+
+def test_source_for_sidecar_reuses_existing_subscription(
+    importer, artist_row, db_sync,
+):
+    """The filesystem-import sidecar resolver should attach to whatever
+    Source already exists for (artist, platform) — the canonical subscription
+    Source — regardless of its URL. Without this, every imported post
+    spawned its own Source row.
+    """
+    canonical = Source(
+        artist_id=artist_row.id, platform="patreon",
+        url="https://www.patreon.com/cw/testartist", enabled=True,
+    )
+    db_sync.add(canonical)
+    db_sync.flush()
+
+    resolved = importer._source_for_sidecar(
+        artist_id=artist_row.id, platform="patreon",
+        artist_slug=artist_row.slug,
+    )
+    assert resolved.id == canonical.id
+
+
+def test_source_for_sidecar_creates_synthetic_anchor_when_none_exists(
+    importer, artist_row, db_sync,
+):
+    """No subscription Source for this (artist, platform) yet. The helper
+    creates one synthetic anchor (enabled=False, url='sidecar:<plat>:<slug>')
+    so subsequent imports reuse it instead of spawning per-post Sources.
+    """
+    resolved = importer._source_for_sidecar(
+        artist_id=artist_row.id, platform="pixiv",
+        artist_slug=artist_row.slug,
+    )
+    assert resolved.url == f"sidecar:pixiv:{artist_row.slug}"
+    assert resolved.enabled is False
+    assert resolved.artist_id == artist_row.id
+    assert resolved.platform == "pixiv"
+
+    # Second call returns the same row (no new Source spawned).
+    again = importer._source_for_sidecar(
+        artist_id=artist_row.id, platform="pixiv",
+        artist_slug=artist_row.slug,
+    )
+    assert again.id == resolved.id
+
+
+def test_source_for_sidecar_distinct_platforms_distinct_anchors(
+    importer, artist_row, db_sync,
+):
+    """One synthetic anchor per (artist, platform). Different platforms get
+    different anchors even when no campaign Source exists for either.
+    """
+    p = importer._source_for_sidecar(
+        artist_id=artist_row.id, platform="patreon",
+        artist_slug=artist_row.slug,
+    )
+    x = importer._source_for_sidecar(
+        artist_id=artist_row.id, platform="pixiv",
+        artist_slug=artist_row.slug,
+    )
+    assert p.id != x.id
+    assert p.platform == "patreon"
+    assert x.platform == "pixiv"

tests/test_migration_0002.py

@@ -25,6 +25,10 @@ def test_tag_has_kind_and_fandom_id():
 
 
 def test_tag_kind_enum_values():
+    # Current TagKind enum after alembic 0023 dropped meta + rating
+    # (operator-retired 2026-05-26). `artist` is still in the enum
+    # for backward-compat with historical rows, though new artist
+    # tags don't get created (Artist row is canonical per FC-2d-vii-c).
     expected = {
         "artist",
         "character",
@@ -33,8 +37,6 @@ def test_tag_kind_enum_values():
         "series",
         "archive",
         "post",
-        "meta",
-        "rating",
     }
     assert {k.value for k in TagKind} == expected
 

tests/test_tag_prefix.py

@@ -0,0 +1,54 @@
+"""parse_kind_prefix — IR-style `kind:name` shortcut at the input boundary."""
+
+from backend.app.utils.tag_prefix import KNOWN_KINDS, parse_kind_prefix
+
+
+def test_recognized_kinds_match_user_input_set():
+    # Excluded: archive + post (system-managed), general (default for
+    # un-prefixed input), artist (retired in FC-2d-vii-c — first-class
+    # entities now), meta + rating (retired as user-typeable per
+    # operator 2026-05-26).
+    assert KNOWN_KINDS == frozenset({
+        "character", "fandom", "series",
+    })
+
+
+def test_character_prefix_parsed():
+    assert parse_kind_prefix("character:Saber") == ("character", "Saber")
+
+
+def test_case_insensitive_prefix():
+    assert parse_kind_prefix("Character:Saber") == ("character", "Saber")
+    assert parse_kind_prefix("CHARACTER:Saber") == ("character", "Saber")
+
+
+def test_no_prefix_returns_none_kind():
+    assert parse_kind_prefix("sunset") == (None, "sunset")
+
+
+def test_unknown_prefix_kept_as_literal():
+    # 'http' is not a known kind — preserve the literal text.
+    assert parse_kind_prefix("http://example.com") == (None, "http://example.com")
+
+
+def test_retired_prefixes_kept_as_literal():
+    # `artist:`, `meta:`, `rating:` are no longer recognized — they
+    # parse as literal text so the operator's input is preserved (and
+    # serves as a nudge to use the appropriate dedicated UI instead).
+    assert parse_kind_prefix("artist:Eric") == (None, "artist:Eric")
+    assert parse_kind_prefix("meta:wide") == (None, "meta:wide")
+    assert parse_kind_prefix("rating:safe") == (None, "rating:safe")
+
+
+def test_whitespace_stripped():
+    assert parse_kind_prefix("series: Bleach ") == ("series", "Bleach")
+    assert parse_kind_prefix("  sunset  ") == (None, "sunset")
+
+
+def test_empty_string():
+    assert parse_kind_prefix("") == (None, "")
+
+
+def test_just_colon():
+    # Empty prefix → "" not in KNOWN_KINDS → falls through to (None, "...")
+    assert parse_kind_prefix(":foo") == (None, ":foo")

tests/test_tasks_register.py

@@ -23,3 +23,7 @@ def test_import_media_file_registered():
 
 def test_generate_thumbnail_registered():
     assert "backend.app.tasks.thumbnail.generate_thumbnail" in celery.tasks
+
+
+def test_backfill_thumbnails_registered():
+    assert "backend.app.tasks.thumbnail.backfill_thumbnails" in celery.tasks