Merge pull request 'fix(ext-ci): jq→python + bump ext to 1.0.3 + rollback-on-upload-failure' (#18) from dev into main

_apply_sidecar is additive: it find-or-creates Post/Source/ImageProvenance
and sets primary_post_id NULL-only, so any IR-migration provenance on the
existing row survives untouched and the new GS sidecar adds a second
ImageProvenance pointing at the freshly-created Post.

Wrapped in try/except so a malformed sidecar can't unwind the file-swap
commit — the file replacement is the critical operation.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.forgejo/workflows/build.yml

@@ -6,18 +6,183 @@ on:
 
 # Requires repo secret RELEASE_TOKEN — a Forgejo PAT with scopes:
 #   - write:package, read:package  (for docker push to git.fabledsword.com)
-#   - write:release                (for future release-cutting workflows)
+#   - write:release                (for ext-<version> release asset cache)
 #   - write:issue                  (for future issue-management automation)
 # The injected GITHUB_TOKEN cannot be used — it lacks write:package.
 
 jobs:
-  build-web:
+  # Sign-or-fetch-from-cache: signs the extension via AMO if no ext-<version>
+  # Forgejo release exists yet, otherwise downloads the cached signed XPI.
+  # Result is uploaded as an Actions artifact for build-web to consume.
+  #
+  # Why this lives in build.yml (not a separate workflow): the merge-commit's
+  # docker image tagged `:latest` MUST carry the XPI. A separate sign workflow
+  # racing build.yml leaves `:latest` without the XPI for ~5min (until the
+  # commit-back triggers another build). Inline ordering eliminates the race.
+  # Cache strategy: Forgejo Release Assets — picked 2026-05-25 over Generic
+  # Packages (cleaner API surface) and commit-back-to-side-branch (no extra
+  # branch to manage). AMO blocks re-signing the same version (returns 409),
+  # so signing is intentionally one-shot per version bump.
+  sign-extension:
+    if: github.ref == 'refs/heads/main'
     runs-on: python-ci
     container:
       image: git.fabledsword.com/bvandeusen/ci-python:3.14
     steps:
       - uses: actions/checkout@v4
 
+      - name: Resolve extension version
+        id: extver
+        run: |
+          VERSION=$(grep -E '"version"' extension/package.json | head -1 | sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Resolved extension version: $VERSION"
+
+      - name: Check Forgejo release-asset cache
+        id: cache
+        env:
+          TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        run: |
+          set -eu
+          VERSION=${{ steps.extver.outputs.version }}
+          STATUS=$(curl -s -o release.json -w "%{http_code}" \
+            -H "Authorization: token $TOKEN" \
+            "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases/tags/ext-$VERSION" || echo 000)
+          echo "Tag lookup HTTP status: $STATUS"
+          # JSON parsing via python (ci-python:3.14 has stdlib json; jq is
+          # not in the image and adding it per ci-requirements.md is not
+          # warranted for a single consumer — operator-flagged 2026-05-26
+          # after a sign job failed with `jq: not found`).
+          if [ "$STATUS" = "200" ]; then
+            ASSET_ID=$(python3 -c "import json; r=json.load(open('release.json')); xpis=[a for a in r.get('assets', []) if a.get('name','').endswith('.xpi')]; print(xpis[0]['id'] if xpis else '')")
+            if [ -n "$ASSET_ID" ]; then
+              echo "cached=true" >> "$GITHUB_OUTPUT"
+              echo "asset_id=$ASSET_ID" >> "$GITHUB_OUTPUT"
+              echo "Cached XPI exists at ext-$VERSION (asset id $ASSET_ID); skipping AMO sign"
+            else
+              echo "cached=false" >> "$GITHUB_OUTPUT"
+              echo "Release ext-$VERSION exists but has no .xpi asset; will re-sign + re-upload"
+            fi
+          else
+            echo "cached=false" >> "$GITHUB_OUTPUT"
+            echo "No release named ext-$VERSION; will sign via AMO and upload"
+          fi
+
+      - name: Download cached signed XPI (cache hit)
+        if: steps.cache.outputs.cached == 'true'
+        env:
+          TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        run: |
+          set -eu
+          mkdir -p extension/web-ext-artifacts
+          curl -sL -H "Authorization: token $TOKEN" \
+            -o "extension/web-ext-artifacts/fabledcurator-${{ steps.extver.outputs.version }}.xpi" \
+            "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases/assets/${{ steps.cache.outputs.asset_id }}"
+          ls -la extension/web-ext-artifacts/
+
+      - name: Sign via AMO (cache miss)
+        if: steps.cache.outputs.cached != 'true'
+        run: |
+          cd extension && npm install --no-save --no-audit --no-fund && npm run sign
+        env:
+          WEB_EXT_API_KEY: ${{ secrets.MOZILLA_AMO_JWT_KEY }}
+          WEB_EXT_API_SECRET: ${{ secrets.MOZILLA_AMO_JWT_SECRET }}
+
+      - name: Upload signed XPI to ext-<version> release (cache miss)
+        if: steps.cache.outputs.cached != 'true'
+        env:
+          TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        run: |
+          set -eux
+          VERSION=${{ steps.extver.outputs.version }}
+          # AMO renames signed XPIs with its internal addon-id-safe-string;
+          # canonicalize to fabledcurator-<version>.xpi so the FC server's
+          # whitelist (backend/app/frontend.py expects 'fabledcurator-*.xpi')
+          # keeps working.
+          SIGNED=$(ls extension/web-ext-artifacts/*.xpi | head -1)
+          XPI="extension/web-ext-artifacts/fabledcurator-$VERSION.xpi"
+          cp "$SIGNED" "$XPI"
+          # Find-or-create the ext-<version> release. Track whether WE
+          # created it so an upload failure below can roll back (don't
+          # leave an empty release tombstone that the next run's
+          # cache-check mistakes for a partial-failure state).
+          STATUS=$(curl -s -o release.json -w "%{http_code}" \
+            -H "Authorization: token $TOKEN" \
+            "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases/tags/ext-$VERSION" || echo 000)
+          if [ "$STATUS" = "200" ]; then
+            CREATED_BY_US=false
+          else
+            curl -s -X POST -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d "{\"tag_name\":\"ext-$VERSION\",\"name\":\"Extension $VERSION (signed XPI cache)\",\"body\":\"Internal cache for the signed XPI consumed by build.yml's build-web job. Not a user-facing FC release.\",\"target_commitish\":\"main\"}" \
+              -o release.json \
+              "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases"
+            CREATED_BY_US=true
+          fi
+          RELEASE_ID=$(python3 -c "import json; print(json.load(open('release.json'))['id'])")
+          test -n "$RELEASE_ID"
+          # Rollback-on-failure: if the asset upload fails AND we just
+          # created the release in this run, delete it. Prevents an empty
+          # ext-<version> release from poisoning the next workflow run
+          # (operator-flagged 2026-05-26 — without rollback the next run
+          # saw 'release exists, no asset → cache miss → sign' which AMO
+          # then rejected with 409 'Version already exists').
+          rollback_if_we_created() {
+            if [ "$CREATED_BY_US" = "true" ]; then
+              echo "Rolling back: deleting just-created release $RELEASE_ID"
+              curl -s -X DELETE -H "Authorization: token $TOKEN" \
+                "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases/$RELEASE_ID" || true
+              curl -s -X DELETE -H "Authorization: token $TOKEN" \
+                "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/tags/ext-$VERSION" || true
+            fi
+          }
+          trap 'rollback_if_we_created' EXIT
+          HTTP_CODE=$(curl -s -X POST -H "Authorization: token $TOKEN" \
+            -F "attachment=@$XPI" \
+            -o /dev/null -w "%{http_code}" \
+            "https://git.fabledsword.com/api/v1/repos/bvandeusen/FabledCurator/releases/$RELEASE_ID/assets?name=fabledcurator-$VERSION.xpi")
+          if [ "$HTTP_CODE" != "201" ] && [ "$HTTP_CODE" != "200" ]; then
+            echo "Asset upload failed with HTTP $HTTP_CODE"
+            exit 1
+          fi
+          # Upload succeeded — clear the rollback trap.
+          trap - EXIT
+          echo "Uploaded fabledcurator-$VERSION.xpi to ext-$VERSION release"
+
+      - name: Upload XPI as Actions artifact (handoff to build-web)
+        uses: actions/upload-artifact@v4
+        with:
+          name: signed-extension
+          path: extension/web-ext-artifacts/fabledcurator-*.xpi
+          retention-days: 1
+
+  build-web:
+    needs: [sign-extension]
+    # sign-extension is main-only; on dev it's skipped, build-web still runs.
+    if: always() && (needs.sign-extension.result == 'success' || needs.sign-extension.result == 'skipped')
+    runs-on: python-ci
+    container:
+      image: git.fabledsword.com/bvandeusen/ci-python:3.14
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download signed extension (main only)
+        if: github.ref == 'refs/heads/main'
+        uses: actions/download-artifact@v4
+        with:
+          name: signed-extension
+          path: extension/web-ext-artifacts/
+
+      - name: Place signed XPI in build context (main only)
+        if: github.ref == 'refs/heads/main'
+        run: |
+          set -eux
+          VERSION=$(grep -E '"version"' extension/package.json | head -1 | sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')
+          XPI=$(ls extension/web-ext-artifacts/*.xpi | head -1)
+          mkdir -p frontend/public/extension
+          cp "$XPI" "frontend/public/extension/fabledcurator-$VERSION.xpi"
+          cp "$XPI" "frontend/public/extension/fabledcurator-latest.xpi"
+          ls -la frontend/public/extension/
+
       - name: Determine tag
         id: tag
         run: |

.forgejo/workflows/ci.yml

@@ -24,11 +24,26 @@ 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-
+
       - name: Install Python deps
         # ruff is pre-installed in the ci-python image (see CI-Runner/CI-python/
         # Dockerfile's RUFF_VERSION). Per FabledRulebook ci-runners.md, toolchain
         # versions live on the runner image, not here.
-        run: pip install -r requirements.txt pytest pytest-asyncio
+        # uv: 5-10x faster wheel resolve than pip for cold caches.
+        # Falls back to pip install on uv-missing runners (older images).
+        run: |
+          if command -v uv >/dev/null 2>&1; then
+            uv pip install --system -r requirements.txt pytest pytest-asyncio
+          else
+            pip install -r requirements.txt pytest pytest-asyncio
+          fi
 
       - name: Ruff lint
         run: ruff check backend/ tests/ alembic/
@@ -57,17 +72,28 @@ jobs:
       - run: npm run test:unit
       - run: npm run build
 
-  integration:
+  # Integration suite split into THREE parallel shards (2026-05-25, runner
-    # This act_runner (swarm-runner v0.6.1) puts service containers on the
+  # capacity bumped 2→6). Each shard gets its own Postgres + Redis service
-    # default bridge with NO service-name DNS, and publishing fixed host
+  # set and runs alembic + a disjoint subset of integration tests. Shards
-    # ports collides with the operator's running docker-compose dev stack on
+  # share no DB state, so the autouse TRUNCATE fixture in tests/conftest.py
-    # the same shared daemon. Workaround: publish NO host ports, and reach
+  # stays single-threaded per shard but multiple shards run in parallel
-    # each service by its bridge IP — discovered at runtime via the mounted
+  # wall-clock. Approximate split — rebalance once --durations=15 output
-    # docker socket (the ci-python image ships /usr/bin/docker). Default-bridge
+  # reveals which shard is the long pole.
-    # containers can talk by IP (only embedded DNS is missing), so IP
+  #
-    # addressing is reliable here. Everything runs in ONE step so resolved
+  # Each shard's docker-ps filter uses its own unique job name to scope
-    # values don't depend on cross-step env passing. Pattern documented in
+  # service-container resolution. act_runner appears to strip underscores
-    # FabledRulebook/forgejo.md "CI philosophy".
+  # from job names when building container labels — `int_api` yielded
+  # zero matches on 2026-05-25 — so shards use no-separator names
+  # (`intapi`, `intimp`, `intcore`) instead. Each step prints
+  # `docker ps -a` first so a future naming-convention shift surfaces in
+  # the log without another guess-and-push cycle.
+  #
+  # Pre-baking requirements.txt into ci-python:3.14 is intentionally NOT
+  # done — per ci-requirements.md, FC is the only Python consumer of that
+  # image and the CI-Runner project's "add deps to image when used by >1
+  # project" rule keeps the install per-job.
+
+  intapi:
     runs-on: python-ci
     container:
       image: git.fabledsword.com/bvandeusen/ci-python:3.14
@@ -98,15 +124,21 @@ jobs:
           --health-retries 10
     steps:
       - uses: actions/checkout@v4
-
+      - name: Cache pip wheels
-      - name: Integration suite (resolve service IPs, migrate, test)
+        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
-          # Scope to THIS job's service containers (act_runner names them
+          echo "=== container landscape (diagnostic for filter scoping) ==="
-          # ...JOB-integration...); the operator's compose stack uses the
+          docker ps -a --format '{{.ID}} {{.Image}} -> {{.Names}}'
-          # same images but different names, so it won't match.
+          echo "=== end landscape ==="
-          PG=$(docker ps --filter "name=JOB-integration" --filter "ancestor=pgvector/pgvector:pg16" -q | head -n1)
+          PG=$(docker ps --filter "name=intapi" --filter "ancestor=pgvector/pgvector:pg16" -q | head -n1)
-          RD=$(docker ps --filter "name=JOB-integration" --filter "ancestor=redis:7-alpine" -q | head -n1)
+          RD=$(docker ps --filter "name=intapi" --filter "ancestor=redis:7-alpine" -q | head -n1)
           test -n "$PG" && test -n "$RD"
           PG_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$PG")
           RD_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$RD")
@@ -114,11 +146,153 @@ jobs:
           export DB_HOST="$PG_IP"
           export CELERY_BROKER_URL="redis://$RD_IP:6379/0"
           export CELERY_RESULT_BACKEND="redis://$RD_IP:6379/0"
-          # Wait for Postgres to accept TCP (bash /dev/tcp; no extra tools).
           for i in $(seq 1 60); do
             (echo > "/dev/tcp/$PG_IP/5432") >/dev/null 2>&1 && break
             sleep 2
           done
-          pip install -r requirements.txt pytest pytest-asyncio
+          if command -v uv >/dev/null 2>&1; then
+            uv pip install --system -r requirements.txt pytest pytest-asyncio
+          else
+            pip install -r requirements.txt pytest pytest-asyncio
+          fi
           alembic upgrade head
-          pytest tests/ -v -m integration
+          pytest tests/test_api_*.py -v -m integration --durations=15
+
+  intimp:
+    runs-on: python-ci
+    container:
+      image: git.fabledsword.com/bvandeusen/ci-python:3.14
+    env:
+      DB_USER: fabledcurator
+      DB_PASSWORD: ci_integration
+      DB_PORT: "5432"
+      DB_NAME: fabledcurator_test
+      SECRET_KEY: ci_integration_placeholder
+    services:
+      postgres:
+        image: pgvector/pgvector:pg16
+        env:
+          POSTGRES_USER: fabledcurator
+          POSTGRES_PASSWORD: ci_integration
+          POSTGRES_DB: fabledcurator_test
+        options: >-
+          --health-cmd "pg_isready -U fabledcurator"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+      redis:
+        image: redis:7-alpine
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --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
+          echo "=== container landscape (diagnostic for filter scoping) ==="
+          docker ps -a --format '{{.ID}} {{.Image}} -> {{.Names}}'
+          echo "=== end landscape ==="
+          PG=$(docker ps --filter "name=intimp" --filter "ancestor=pgvector/pgvector:pg16" -q | head -n1)
+          RD=$(docker ps --filter "name=intimp" --filter "ancestor=redis:7-alpine" -q | head -n1)
+          test -n "$PG" && test -n "$RD"
+          PG_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$PG")
+          RD_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$RD")
+          test -n "$PG_IP" && test -n "$RD_IP"
+          export DB_HOST="$PG_IP"
+          export CELERY_BROKER_URL="redis://$RD_IP:6379/0"
+          export CELERY_RESULT_BACKEND="redis://$RD_IP:6379/0"
+          for i in $(seq 1 60); do
+            (echo > "/dev/tcp/$PG_IP/5432") >/dev/null 2>&1 && break
+            sleep 2
+          done
+          if command -v uv >/dev/null 2>&1; then
+            uv pip install --system -r requirements.txt pytest pytest-asyncio
+          else
+            pip install -r requirements.txt pytest pytest-asyncio
+          fi
+          alembic upgrade head
+          pytest tests/test_importer*.py tests/test_import_*.py tests/test_migration_*.py tests/test_phash_*.py tests/test_sidecar_*.py tests/test_scan_*.py tests/test_archive_extractor.py tests/test_backfill_phash.py -v -m integration --durations=15
+
+  intcore:
+    runs-on: python-ci
+    container:
+      image: git.fabledsword.com/bvandeusen/ci-python:3.14
+    env:
+      DB_USER: fabledcurator
+      DB_PASSWORD: ci_integration
+      DB_PORT: "5432"
+      DB_NAME: fabledcurator_test
+      SECRET_KEY: ci_integration_placeholder
+    services:
+      postgres:
+        image: pgvector/pgvector:pg16
+        env:
+          POSTGRES_USER: fabledcurator
+          POSTGRES_PASSWORD: ci_integration
+          POSTGRES_DB: fabledcurator_test
+        options: >-
+          --health-cmd "pg_isready -U fabledcurator"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 10
+      redis:
+        image: redis:7-alpine
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --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
+          echo "=== container landscape (diagnostic for filter scoping) ==="
+          docker ps -a --format '{{.ID}} {{.Image}} -> {{.Names}}'
+          echo "=== end landscape ==="
+          PG=$(docker ps --filter "name=intcore" --filter "ancestor=pgvector/pgvector:pg16" -q | head -n1)
+          RD=$(docker ps --filter "name=intcore" --filter "ancestor=redis:7-alpine" -q | head -n1)
+          test -n "$PG" && test -n "$RD"
+          PG_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$PG")
+          RD_IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$RD")
+          test -n "$PG_IP" && test -n "$RD_IP"
+          export DB_HOST="$PG_IP"
+          export CELERY_BROKER_URL="redis://$RD_IP:6379/0"
+          export CELERY_RESULT_BACKEND="redis://$RD_IP:6379/0"
+          for i in $(seq 1 60); do
+            (echo > "/dev/tcp/$PG_IP/5432") >/dev/null 2>&1 && break
+            sleep 2
+          done
+          if command -v uv >/dev/null 2>&1; then
+            uv pip install --system -r requirements.txt pytest pytest-asyncio
+          else
+            pip install -r requirements.txt pytest pytest-asyncio
+          fi
+          alembic upgrade head
+          pytest tests/ -v -m integration --durations=15 \
+            --ignore-glob='tests/test_api_*.py' \
+            --ignore-glob='tests/test_importer*.py' \
+            --ignore-glob='tests/test_import_*.py' \
+            --ignore-glob='tests/test_migration_*.py' \
+            --ignore-glob='tests/test_phash_*.py' \
+            --ignore-glob='tests/test_sidecar_*.py' \
+            --ignore-glob='tests/test_scan_*.py' \
+            --ignore-glob='tests/test_archive_extractor.py' \
+            --ignore-glob='tests/test_backfill_phash.py'

.forgejo/workflows/extension.yml

@@ -0,0 +1,29 @@
+name: extension
+# Lint-only workflow. The sign-and-publish dance moved into build.yml's
+# `sign-extension` job (2026-05-25) — `:latest` now always bundles the XPI
+# because sign-extension runs as a build-web dependency in the SAME workflow,
+# eliminating the prior race between build.yml and a separate extension.yml.
+# Signed XPIs are cached in Forgejo Release Assets named `ext-<version>`.
+on:
+  push:
+    branches: [dev, main]
+    paths:
+      - 'extension/**'
+      - '.forgejo/workflows/extension.yml'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'extension/**'
+  workflow_dispatch:
+
+jobs:
+  lint:
+    runs-on: python-ci
+    container:
+      image: node:22-bookworm-slim
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install web-ext
+        run: cd extension && npm install --no-save --no-audit --no-fund
+      - name: Lint
+        run: cd extension && npm run lint

Dockerfile

@@ -16,12 +16,15 @@ ENV PYTHONUNBUFFERED=1 \
     PIP_NO_CACHE_DIR=1 \
     PIP_DISABLE_PIP_VERSION_CHECK=1
 
-# System deps: ffmpeg (transcode + thumbnails, used in FC-2), unar (archives, FC-2),
+# System deps: ffmpeg (transcode + thumbnails, FC-2), unar (archives, FC-2),
-# libpq for psycopg, image libs.
+# libpq for psycopg, postgresql-client + zstd for FC-5 backup/restore
+# (pg_dump + tar --zstd), image libs.
 RUN apt-get update && apt-get install -y --no-install-recommends \
         ffmpeg \
         unar \
         libpq5 \
+        postgresql-client \
+        zstd \
         libjpeg62-turbo \
         libwebp7 \
         libpng16-16 \

alembic/versions/0016_fc3i_task_run.py

@@ -0,0 +1,86 @@
+"""fc3i: task_run table
+
+Revision ID: 0016
+Revises: 0015
+Create Date: 2026-05-24
+
+Additive only. New table records every Celery task attempt via signal
+handlers (backend.app.celery_signals). Status is plain String(16) not
+Postgres ENUM (per feedback_check_existing_enums: ENUM columns hard-
+fail at INSERT, String columns extend cleanly).
+
+Composite indexes anticipate the three dashboard panes:
+- (queue, started_at desc)   — per-lane recent activity
+- (status, started_at desc)  — recent failures pane
+- (task_name, started_at desc) — drill-down by task
+
+Indexed columns get individual indexes via `index=True` on the model;
+the composites below cover the multi-column lookups.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0016"
+down_revision: Union[str, None] = "0015"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "task_run",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("celery_task_id", sa.String(length=64), nullable=False),
+        sa.Column("queue", sa.String(length=32), nullable=False),
+        sa.Column("task_name", sa.String(length=128), nullable=False),
+        sa.Column("target_id", sa.Integer(), nullable=True),
+        sa.Column("started_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("finished_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("duration_ms", sa.Integer(), nullable=True),
+        sa.Column(
+            "status", sa.String(length=16), nullable=False,
+            server_default="running",
+        ),
+        sa.Column("error_type", sa.String(length=128), nullable=True),
+        sa.Column("error_message", sa.Text(), nullable=True),
+        sa.Column("retry_count", sa.Integer(), nullable=True),
+        sa.Column("worker_hostname", sa.String(length=128), nullable=True),
+        sa.Column("args_summary", sa.String(length=255), nullable=True),
+    )
+
+    # Single-column indexes (matches Mapped[...].index=True on model).
+    op.create_index("ix_task_run_celery_task_id", "task_run", ["celery_task_id"])
+    op.create_index("ix_task_run_queue", "task_run", ["queue"])
+    op.create_index("ix_task_run_task_name", "task_run", ["task_name"])
+    op.create_index("ix_task_run_started_at", "task_run", ["started_at"])
+    op.create_index("ix_task_run_finished_at", "task_run", ["finished_at"])
+    op.create_index("ix_task_run_status", "task_run", ["status"])
+
+    # Composite indexes for dashboard query patterns.
+    op.create_index(
+        "ix_task_run_queue_started",
+        "task_run", ["queue", sa.text("started_at DESC")],
+    )
+    op.create_index(
+        "ix_task_run_status_started",
+        "task_run", ["status", sa.text("started_at DESC")],
+    )
+    op.create_index(
+        "ix_task_run_name_started",
+        "task_run", ["task_name", sa.text("started_at DESC")],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_task_run_name_started", table_name="task_run")
+    op.drop_index("ix_task_run_status_started", table_name="task_run")
+    op.drop_index("ix_task_run_queue_started", table_name="task_run")
+    op.drop_index("ix_task_run_status", table_name="task_run")
+    op.drop_index("ix_task_run_finished_at", table_name="task_run")
+    op.drop_index("ix_task_run_started_at", table_name="task_run")
+    op.drop_index("ix_task_run_task_name", table_name="task_run")
+    op.drop_index("ix_task_run_queue", table_name="task_run")
+    op.drop_index("ix_task_run_celery_task_id", table_name="task_run")
+    op.drop_table("task_run")

alembic/versions/0017_fc3h_backup_run.py

@@ -0,0 +1,82 @@
+"""fc3h: backup_run table
+
+Revision ID: 0017
+Revises: 0016
+Create Date: 2026-05-24
+
+Additive. New table records every backup/restore attempt with artifact
+metadata. Lifecycle tracking lives in task_run from FC-3i; this is
+artifact-only (paths, sizes, tag, restore lineage).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0017"
+down_revision: Union[str, None] = "0016"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "backup_run",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("kind", sa.String(length=16), nullable=False),
+        sa.Column(
+            "status", sa.String(length=16), nullable=False,
+            server_default="pending",
+        ),
+        sa.Column("tag", sa.String(length=64), nullable=True),
+        sa.Column("triggered_by", sa.String(length=32), nullable=False),
+        sa.Column("started_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("finished_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("sql_path", sa.Text(), nullable=True),
+        sa.Column("tar_path", sa.Text(), nullable=True),
+        sa.Column("size_bytes", sa.BigInteger(), nullable=True),
+        sa.Column("error", sa.Text(), nullable=True),
+        sa.Column(
+            "manifest", sa.JSON(), nullable=False, server_default="{}",
+        ),
+        sa.Column(
+            "restored_from_id", sa.Integer(),
+            sa.ForeignKey("backup_run.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+    )
+
+    # Single-column indexes (matches Mapped[...].index=True).
+    op.create_index("ix_backup_run_kind", "backup_run", ["kind"])
+    op.create_index("ix_backup_run_status", "backup_run", ["status"])
+    op.create_index("ix_backup_run_tag", "backup_run", ["tag"])
+    op.create_index("ix_backup_run_started_at", "backup_run", ["started_at"])
+    op.create_index("ix_backup_run_finished_at", "backup_run", ["finished_at"])
+
+    # Composite indexes for dashboard query patterns.
+    op.create_index(
+        "ix_backup_run_kind_started",
+        "backup_run", ["kind", sa.text("started_at DESC")],
+    )
+    op.create_index(
+        "ix_backup_run_status_finished",
+        "backup_run", ["status", sa.text("finished_at DESC")],
+    )
+    # Partial index: only tagged rows participate in retention-exempt query.
+    op.create_index(
+        "ix_backup_run_tag_partial",
+        "backup_run", ["tag"],
+        postgresql_where=sa.text("tag IS NOT NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_backup_run_tag_partial", table_name="backup_run")
+    op.drop_index("ix_backup_run_status_finished", table_name="backup_run")
+    op.drop_index("ix_backup_run_kind_started", table_name="backup_run")
+    op.drop_index("ix_backup_run_finished_at", table_name="backup_run")
+    op.drop_index("ix_backup_run_started_at", table_name="backup_run")
+    op.drop_index("ix_backup_run_tag", table_name="backup_run")
+    op.drop_index("ix_backup_run_status", table_name="backup_run")
+    op.drop_index("ix_backup_run_kind", table_name="backup_run")
+    op.drop_table("backup_run")

alembic/versions/0018_fc3h_backup_settings.py

@@ -0,0 +1,62 @@
+"""fc3h: backup_* knobs on import_settings
+
+Revision ID: 0018
+Revises: 0017
+Create Date: 2026-05-24
+
+Adds four columns to the singleton import_settings row:
+  - backup_db_nightly_enabled (default False — opt-in)
+  - backup_db_nightly_hour_utc (default 3)
+  - backup_db_keep_last_n (default 14)
+  - backup_images_keep_last_n (default 3)
+
+server_default ensures the singleton row is backfilled in place
+without an UPDATE statement.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0018"
+down_revision: Union[str, None] = "0017"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "import_settings",
+        sa.Column(
+            "backup_db_nightly_enabled", sa.Boolean(),
+            nullable=False, server_default=sa.false(),
+        ),
+    )
+    op.add_column(
+        "import_settings",
+        sa.Column(
+            "backup_db_nightly_hour_utc", sa.Integer(),
+            nullable=False, server_default="3",
+        ),
+    )
+    op.add_column(
+        "import_settings",
+        sa.Column(
+            "backup_db_keep_last_n", sa.Integer(),
+            nullable=False, server_default="14",
+        ),
+    )
+    op.add_column(
+        "import_settings",
+        sa.Column(
+            "backup_images_keep_last_n", sa.Integer(),
+            nullable=False, server_default="3",
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("import_settings", "backup_images_keep_last_n")
+    op.drop_column("import_settings", "backup_db_keep_last_n")
+    op.drop_column("import_settings", "backup_db_nightly_hour_utc")
+    op.drop_column("import_settings", "backup_db_nightly_enabled")

alembic/versions/0019_import_batch_refreshed.py

@@ -0,0 +1,38 @@
+"""import_batch.refreshed counter for deep-scan sidecar re-application
+
+Revision ID: 0019
+Revises: 0018
+Create Date: 2026-05-25
+
+Adds a `refreshed` counter to `import_batch`, mirroring the existing
+`imported`/`skipped`/`failed`/`attachments` columns. Deep scan now
+re-applies sidecar metadata to already-imported files (the IR feature
+that didn't make the FC port the first time); a "refreshed" outcome
+increments this counter so the UI can surface "X new, Y refreshed"
+instead of the misleading "Scan complete — no new files" message.
+
+server_default=0 backfills existing rows in place — no UPDATE needed.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0019"
+down_revision: Union[str, None] = "0018"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "import_batch",
+        sa.Column(
+            "refreshed", sa.Integer(),
+            nullable=False, server_default=sa.text("0"),
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("import_batch", "refreshed")

backend/app/__init__.py

@@ -23,6 +23,12 @@ def create_app() -> Quart:
 
     app = Quart(__name__)
     app.secret_key = cfg.secret_key
+    # FC-5: legacy IR ingest JSON can run to tens of MB (hundreds of
+    # thousands of image_tag_associations). Werkzeug's default form
+    # memory cap is 500KB; raise both ceilings so the multipart upload
+    # for /api/migrate/ir_ingest doesn't 413.
+    app.config["MAX_CONTENT_LENGTH"] = 1024 * 1024 * 1024   # 1 GB
+    app.config["MAX_FORM_MEMORY_SIZE"] = 1024 * 1024 * 1024  # 1 GB
 
     for bp in all_blueprints():
         app.register_blueprint(bp)

backend/app/api/__init__.py

@@ -14,6 +14,7 @@ api_bp.add_url_rule("/health", view_func=health.get_health, methods=["GET"])
 
 
 def all_blueprints() -> list[Blueprint]:
+    from .admin import admin_bp
     from .aliases import aliases_bp
     from .allowlist import allowlist_bp
     from .artist import artist_bp
@@ -21,6 +22,7 @@ def all_blueprints() -> list[Blueprint]:
     from .attachments import attachments_bp
     from .credentials import credentials_bp
     from .downloads import downloads_bp
+    from .extension import extension_bp
     from .gallery import gallery_bp
     from .import_admin import import_admin_bp
     from .migrate import migrate_bp
@@ -32,6 +34,8 @@ def all_blueprints() -> list[Blueprint]:
     from .showcase import showcase_bp
     from .sources import sources_bp
     from .suggestions import suggestions_bp
+    from .system_activity import system_activity_bp
+    from .system_backup import system_backup_bp
     from .tags import tags_bp
     return [
         api_bp,
@@ -43,6 +47,9 @@ def all_blueprints() -> list[Blueprint]:
         artists_bp,
         showcase_bp,
         settings_bp,
+        system_activity_bp,
+        system_backup_bp,
+        admin_bp,
         import_admin_bp,
         migrate_bp,
         suggestions_bp,
@@ -53,5 +60,6 @@ def all_blueprints() -> list[Blueprint]:
         platforms_bp,
         posts_bp,
         credentials_bp,
+        extension_bp,
         downloads_bp,
     ]

backend/app/api/admin.py

@@ -0,0 +1,200 @@
+"""FC-3k: /api/admin — destructive admin actions.
+
+Five action surfaces:
+  POST   /api/admin/artists/<slug>/cascade-delete  (Tier C)
+  POST   /api/admin/images/bulk-delete             (Tier C)
+  DELETE /api/admin/tags/<int:tag_id>              (Tier B)
+  POST   /api/admin/tags/<int:dest_id>/merge       (Tier B)
+  POST   /api/admin/tags/prune-unused              (Tier A)
+  GET    /api/admin/tags/<int:tag_id>/usage-count  (helper)
+
+Tier-C ops take a dry_run body flag (returns projection inline,
+no dispatch) and a confirm body field (server-recomputed token).
+Long-running ops dispatch a maintenance-queue Celery task; the UI
+tails FC-3i's /api/system/activity/runs to surface progress.
+"""
+from __future__ import annotations
+
+import hashlib
+
+from quart import Blueprint, jsonify, request
+from sqlalchemy import select
+
+from ..extensions import get_session
+from ..models import Artist
+from ..services.cleanup_service import project_artist_cascade, project_bulk_image_delete
+
+admin_bp = Blueprint("admin", __name__, url_prefix="/api/admin")
+
+
+def _bad(error: str, *, status: int = 400, **extra):
+    body = {"error": error}
+    body.update(extra)
+    return jsonify(body), status
+
+
+def _bulk_image_confirm_token(image_ids: list[int]) -> str:
+    """Stable 8-hex token derived from the sorted id list. Mutates
+    when the selection changes; stays the same across modal opens of
+    the same selection so the operator can paste without confusion."""
+    canon = ",".join(str(i) for i in sorted(image_ids))
+    digest = hashlib.sha256(canon.encode("utf-8")).hexdigest()
+    return digest[:8]
+
+
+@admin_bp.route("/artists/<slug>/cascade-delete", methods=["POST"])
+async def artist_cascade_delete(slug: str):
+    body = await request.get_json(silent=True) or {}
+    dry_run = bool(body.get("dry_run", False))
+    supplied_confirm = body.get("confirm", "")
+
+    async with get_session() as session:
+        artist = (await session.execute(
+            select(Artist).where(Artist.slug == slug)
+        )).scalar_one_or_none()
+        if artist is None:
+            return _bad("not_found", status=404)
+        artist_id = artist.id
+
+        projected = await session.run_sync(
+            lambda sync_sess: project_artist_cascade(sync_sess, slug=slug)
+        )
+
+    if dry_run:
+        return jsonify(projected)
+
+    expected = f"delete-artist-{artist_id}"
+    if supplied_confirm != expected:
+        return _bad(
+            "confirm_mismatch",
+            detail=f"confirm must equal {expected!r}",
+            expected=expected,
+        )
+
+    from ..tasks.admin import delete_artist_cascade_task
+    async_result = delete_artist_cascade_task.delay(artist_id=artist_id)
+    return jsonify({"task_id": async_result.id}), 202
+
+
+@admin_bp.route("/images/bulk-delete", methods=["POST"])
+async def images_bulk_delete():
+    body = await request.get_json(silent=True) or {}
+    image_ids = body.get("image_ids")
+    if not isinstance(image_ids, list) or not image_ids:
+        return _bad("invalid_image_ids", detail="image_ids must be non-empty list of int")
+    try:
+        image_ids = [int(i) for i in image_ids]
+    except (TypeError, ValueError):
+        return _bad("invalid_image_ids", detail="image_ids must contain only ints")
+
+    dry_run = bool(body.get("dry_run", False))
+    supplied_confirm = body.get("confirm", "")
+
+    async with get_session() as session:
+        projected = await session.run_sync(
+            lambda sync_sess: project_bulk_image_delete(
+                sync_sess, image_ids=image_ids,
+            )
+        )
+
+    if dry_run:
+        return jsonify(projected)
+
+    sha8 = _bulk_image_confirm_token(image_ids)
+    expected = f"delete-images-{sha8}"
+    if supplied_confirm != expected:
+        return _bad(
+            "confirm_mismatch",
+            detail=f"confirm must equal {expected!r}",
+            expected=expected,
+        )
+
+    from ..tasks.admin import bulk_delete_images_task
+    async_result = bulk_delete_images_task.delay(image_ids=image_ids)
+    return jsonify({"task_id": async_result.id}), 202
+
+
+@admin_bp.route("/tags/<int:tag_id>", methods=["DELETE"])
+async def tag_delete(tag_id: int):
+    """Tier-B sync delete. UI yes/no modal is the only confirmation."""
+    from ..services.cleanup_service import delete_tag
+
+    async with get_session() as session:
+        try:
+            result = await session.run_sync(
+                lambda sync_sess: delete_tag(sync_sess, tag_id=tag_id)
+            )
+        except LookupError:
+            return _bad("not_found", status=404)
+    return jsonify(result)
+
+
+@admin_bp.route("/tags/<int:dest_id>/merge", methods=["POST"])
+async def tag_merge(dest_id: int):
+    """Wraps TagService.merge. Source repoints to dest, dest survives,
+    source row deleted, protective alias auto-created if source was
+    ML-applied or allowlisted."""
+    from ..services.tag_service import TagMergeConflict, TagService, TagValidationError
+
+    body = await request.get_json(silent=True) or {}
+    source_id = body.get("source_id")
+    if not isinstance(source_id, int) or source_id == dest_id:
+        return _bad("invalid_source_id", detail="source_id must be int and differ from dest")
+
+    async with get_session() as session:
+        try:
+            result = await TagService(session).merge(
+                source_id=source_id, target_id=dest_id,
+            )
+        except TagMergeConflict as exc:
+            return _bad("merge_conflict", status=409, detail=str(exc))
+        except TagValidationError as exc:
+            return _bad("tag_kind_mismatch", detail=str(exc))
+        except LookupError:
+            return _bad("not_found", status=404)
+
+    # MergeResult is a frozen dataclass — flatten to dict.
+    return jsonify({
+        "result": {
+            "target_id": result.target_id,
+            "target_name": result.target_name,
+            "target_kind": result.target_kind,
+            "merged_count": result.merged_count,
+            "alias_created": result.alias_created,
+            "source_deleted": result.source_deleted,
+        },
+    })
+
+
+@admin_bp.route("/tags/<int:tag_id>/usage-count", methods=["GET"])
+async def tag_usage_count(tag_id: int):
+    """Helper for the Tier-B yes/no prompt; surfaces "N associations"
+    in the dialog so the operator knows what they're nuking."""
+    from ..services.cleanup_service import count_tag_associations
+
+    async with get_session() as session:
+        count = await session.run_sync(
+            lambda sync_sess: count_tag_associations(
+                sync_sess, tag_id=tag_id,
+            )
+        )
+    return jsonify({"count": count})
+
+
+@admin_bp.route("/tags/prune-unused", methods=["POST"])
+async def tags_prune_unused():
+    """Tier-A: dry-run preview list IS the prompt. UI calls with
+    dry_run=true first, shows the list, operator clicks button to
+    re-call with dry_run=false."""
+    from ..services.cleanup_service import prune_unused_tags
+
+    body = await request.get_json(silent=True) or {}
+    dry_run = bool(body.get("dry_run", False))
+
+    async with get_session() as session:
+        result = await session.run_sync(
+            lambda sync_sess: prune_unused_tags(
+                sync_sess, dry_run=dry_run,
+            )
+        )
+    return jsonify(result)

backend/app/api/extension.py

@@ -0,0 +1,114 @@
+"""FC-3g: /api/extension — quick-add-source for the Firefox extension
++ install-time manifest for the Settings card.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import re
+from pathlib import Path
+
+from quart import Blueprint, jsonify, request
+from sqlalchemy import select
+
+from ..extensions import get_session
+from ..models import AppSetting
+from ..services.extension_service import (
+    ExtensionService,
+    InvalidUrlError,
+    UnknownPlatformError,
+)
+from ..services.source_service import KNOWN_PLATFORMS
+
+extension_bp = Blueprint("extension", __name__, url_prefix="/api/extension")
+
+# Default XPI directory; tests override via monkeypatching this module-
+# level constant.
+XPI_DIR = Path("/app/frontend/dist/extension")
+
+_XPI_VERSION_RE = re.compile(r"fabledcurator-(?P<version>[\w.-]+)\.xpi$")
+
+
+def _bad(error: str, *, status: int = 400, **extra):
+    body = {"error": error}
+    body.update(extra)
+    return jsonify(body), status
+
+
+async def _ext_key_required(session) -> bool:
+    """Unlike /api/credentials (which accepts the browser path with no
+    header), quick-add-source writes server state and must be explicitly
+    authenticated."""
+    supplied = request.headers.get("X-Extension-Key")
+    if supplied is None:
+        return False
+    stored = (await session.execute(
+        select(AppSetting.value).where(AppSetting.key == "extension_api_key")
+    )).scalar_one_or_none()
+    return stored is not None and supplied == stored
+
+
+def _extract_version(xpi_name: str) -> str:
+    m = _XPI_VERSION_RE.search(xpi_name)
+    return m.group("version") if m else "unknown"
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fp:
+        for chunk in iter(lambda: fp.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+@extension_bp.route("/quick-add-source", methods=["POST"])
+async def quick_add_source():
+    body = await request.get_json(silent=True)
+    if not isinstance(body, dict):
+        return _bad("invalid_body", detail="body must be a JSON object")
+    url = body.get("url")
+    if not isinstance(url, str) or not url.strip():
+        return _bad("invalid_body", detail="url is required")
+
+    async with get_session() as session:
+        if not await _ext_key_required(session):
+            return _bad("unauthorized", status=401)
+        try:
+            result = await ExtensionService(session).quick_add_source(url)
+        except UnknownPlatformError as exc:
+            return _bad(
+                "unknown_platform",
+                detail=str(exc),
+                known=sorted(KNOWN_PLATFORMS),
+            )
+        except InvalidUrlError as exc:
+            return _bad("invalid_url", detail=str(exc))
+    return jsonify(result), (201 if result["created_source"] else 200)
+
+
+def _read_manifest_sync() -> dict | None:
+    """All the filesystem-touching work for /api/extension/manifest,
+    in a sync helper so the async route can dispatch it via
+    asyncio.to_thread (ASYNC240: no pathlib I/O in async functions)."""
+    if not XPI_DIR.is_dir():
+        return None
+    xpis = sorted(XPI_DIR.glob("fabledcurator-*.xpi"), key=lambda p: p.stat().st_mtime)
+    if not xpis:
+        return None
+    latest = xpis[-1]
+    return {
+        "installed": True,
+        "version": _extract_version(latest.name),
+        "xpi_url": f"/extension/{latest.name}",
+        "latest_url": "/extension/fabledcurator-latest.xpi",
+        "sha256": _sha256(latest),
+    }
+
+
+@extension_bp.route("/manifest", methods=["GET"])
+async def extension_manifest():
+    info = await asyncio.to_thread(_read_manifest_sync)
+    if info is None:
+        return jsonify({"installed": False}), 404
+    return jsonify(info)

backend/app/api/gallery.py

@@ -42,6 +42,8 @@ async def scroll():
                     "width": i.width,
                     "height": i.height,
                     "created_at": i.created_at.isoformat(),
+                    "posted_at": i.posted_at.isoformat() if i.posted_at else None,
+                    "effective_date": i.effective_date.isoformat(),
                     "thumbnail_url": i.thumbnail_url,
                     "artist": i.artist,
                 }

backend/app/api/import_admin.py

@@ -47,10 +47,13 @@ async def status():
         if active:
             payload["active_batch"] = {
                 "id": active.id,
+                "source_path": active.source_path,
+                "scan_mode": active.scan_mode,
                 "total_files": active.total_files,
                 "imported": active.imported,
                 "skipped": active.skipped,
                 "failed": active.failed,
+                "refreshed": active.refreshed,
                 "started_at": active.started_at.isoformat(),
             }
         return jsonify(payload)
@@ -120,6 +123,83 @@ async def retry_failed():
     return jsonify({"retried": len(failed_ids)})
 
 
+@import_admin_bp.route("/clear-stuck", methods=["POST"])
+async def clear_stuck():
+    """Force any non-terminal ImportTask (status in pending/queued/
+    processing) to 'failed' AND finalize any ImportBatch that ends up
+    with no active children. Escape hatch for the operator when the
+    automatic recover_interrupted_tasks sweep keeps re-queueing the
+    same stuck row forever (e.g., underlying file is genuinely broken
+    and the import keeps OSError-looping at PIL load).
+
+    Idempotent + non-destructive: rows survive as 'failed' so the
+    Retry-Failed button can re-attempt them once whatever was broken
+    is fixed. Banked 2026-05-25 — operator hit 3 large PNGs that
+    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"])
+                )
+            )
+        ).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"
+                    ),
+                )
+            )
+
+        # Finalize any 'running' ImportBatch that no longer has any
+        # active children. The "Scanning..." banner is driven by
+        # /api/import/status finding a running batch; left untouched,
+        # it would persist forever after the stuck-task clear.
+        running_batches = (
+            await session.execute(
+                select(ImportBatch.id).where(ImportBatch.status == "running")
+            )
+        ).scalars().all()
+        finalized_batches = 0
+        for batch_id in running_batches:
+            still_active = (
+                await session.execute(
+                    select(ImportTask.id)
+                    .where(ImportTask.batch_id == batch_id)
+                    .where(ImportTask.status.in_(
+                        ["pending", "queued", "processing"]
+                    ))
+                    .limit(1)
+                )
+            ).scalar_one_or_none()
+            if still_active is None:
+                await session.execute(
+                    update(ImportBatch)
+                    .where(ImportBatch.id == batch_id)
+                    .values(
+                        status="complete",
+                        finished_at=datetime.now(UTC),
+                    )
+                )
+                finalized_batches += 1
+        await session.commit()
+
+    return jsonify({
+        "tasks_failed": len(stuck_ids),
+        "batches_finalized": finalized_batches,
+    })
+
+
 @import_admin_bp.route("/clear-completed", methods=["POST"])
 async def clear_completed():
     body = await request.get_json(silent=True) or {}

backend/app/api/migrate.py

@@ -1,14 +1,11 @@
 """FC-5: /api/migrate — trigger and poll migration runs.
 
 Ingest kinds (gs_ingest, ir_ingest) accept multipart/form-data with an
-`export_file` field. All other kinds accept JSON. Apply-without-backup
+`export_file` field. All other kinds accept JSON. Backup + rollback
-guard rejects non-dry-run ingests unless a pre_migration-tagged backup
+were retired in FC-3h (2026-05-24); use /api/system/backup/* instead.
-exists in the last 24h (override with body.force=true).
 """
 
 import json
-from datetime import UTC, datetime, timedelta
-from pathlib import Path
 
 from quart import Blueprint, jsonify, request
 from sqlalchemy import select
@@ -19,12 +16,12 @@ from ..tasks.migration import run_migration
 
 migrate_bp = Blueprint("migrate", __name__, url_prefix="/api/migrate")
 
+# 'backup' + 'rollback' retired 2026-05-24 (FC-3h); see /api/system/backup/*.
 _VALID_KINDS = frozenset({
-    "backup", "gs_ingest", "ir_ingest", "tag_apply",
+    "gs_ingest", "ir_ingest", "tag_apply",
-    "ml_queue", "verify", "rollback",
+    "ml_queue", "verify", "cleanup",
 })
 _INGEST_KINDS = frozenset({"gs_ingest", "ir_ingest"})
-_APPLY_KINDS = frozenset({"gs_ingest", "ir_ingest", "tag_apply", "rollback"})
 
 
 def _bad(error: str, *, status: int = 400, **extra):
@@ -33,19 +30,6 @@ def _bad(error: str, *, status: int = 400, **extra):
     return jsonify(body), status
 
 
-def _has_recent_pre_migration_backup() -> bool:
-    from ..services.migrators import backup as backup_mod
-    images_root = Path("/images")
-    manifest = backup_mod.find_latest_backup(images_root, tag="pre_migration")
-    if manifest is None:
-        return False
-    created_at_str = manifest.get("created_at")
-    if not created_at_str:
-        return False
-    created_at = datetime.fromisoformat(created_at_str)
-    return (datetime.now(UTC) - created_at) < timedelta(hours=24)
-
-
 def _run_to_dict(run: MigrationRun) -> dict:
     return {
         "id": run.id,
@@ -78,7 +62,6 @@ async def create_run(kind: str):
         except (UnicodeDecodeError, json.JSONDecodeError) as exc:
             return _bad("invalid_export_file", detail=str(exc))
         dry_run = str(form.get("dry_run", "false")).lower() in ("true", "1", "yes")
-        force = str(form.get("force", "false")).lower() in ("true", "1", "yes")
         params: dict = {"data": data, "dry_run": dry_run}
     else:
         body = await request.get_json()
@@ -87,20 +70,8 @@ async def create_run(kind: str):
         if not isinstance(body, dict):
             return _bad("invalid_body")
         dry_run = bool(body.get("dry_run", False))
-        force = bool(body.get("force", False))
         params = dict(body)
 
-    is_apply = (kind in _APPLY_KINDS) and not dry_run
-    if is_apply and not force and not _has_recent_pre_migration_backup():
-        return _bad(
-            "no_backup",
-            detail="apply action requires a pre_migration-tagged backup "
-                   "in the last 24h (or force=true).",
-        )
-
-    if kind == "backup":
-        params.setdefault("tag", "pre_migration")
-
     async with get_session() as session:
         run = MigrationRun(kind=kind, status="pending", dry_run=dry_run)
         session.add(run)

backend/app/api/settings.py

@@ -6,7 +6,7 @@ from quart import Blueprint, jsonify, request
 from sqlalchemy import func, select
 
 from ..extensions import get_session
-from ..models import AppSetting, ImageRecord, ImportBatch, ImportSettings, ImportTask, Tag
+from ..models import AppSetting, Artist, ImageRecord, ImportBatch, ImportSettings, ImportTask, Tag
 
 settings_bp = Blueprint("settings", __name__, url_prefix="/api")
 
@@ -118,6 +118,9 @@ async def system_stats():
         storage_bytes = (
             (await session.execute(select(func.coalesce(func.sum(ImageRecord.size_bytes), 0)))).scalar_one()
         )
+        subscription_count = (await session.execute(
+            select(func.count(Artist.id)).where(Artist.is_subscription.is_(True))
+        )).scalar_one()
 
         # Task counts grouped by status
         status_rows = (
@@ -138,11 +141,23 @@ async def system_stats():
         ).all()
         integrity_counts = {row[0]: row[1] for row in integrity_rows}
 
-        # Active batch (most recent running)
+        # Active batch = running batch that still has outstanding work.
+        # Plain "most recent running" picks a freshly-created scan that
+        # enqueued zero new files and hides the older batch that's
+        # actually being processed; the EXISTS clause filters those
+        # empty batches out.
         active_batch_row = (
             await session.execute(
                 select(ImportBatch)
-                .where(ImportBatch.status == "running")
+                .where(
+                    ImportBatch.status == "running",
+                    select(ImportTask.id)
+                    .where(
+                        ImportTask.batch_id == ImportBatch.id,
+                        ImportTask.status.in_(["pending", "queued", "processing"]),
+                    )
+                    .exists(),
+                )
                 .order_by(ImportBatch.started_at.desc())
                 .limit(1)
             )
@@ -163,6 +178,7 @@ async def system_stats():
         "total_images": total_images,
         "total_tags": total_tags,
         "storage_bytes": storage_bytes,
+        "subscription_count": int(subscription_count),
         "tasks": {
             "pending": status_counts.get("pending", 0),
             "queued": status_counts.get("queued", 0),

backend/app/api/system_activity.py

@@ -0,0 +1,209 @@
+"""FC-3i: system activity dashboard endpoints.
+
+Read-only. Combines Redis-broker queue depths (LLEN per queue),
+Celery worker introspection (celery inspect), and the task_run DB
+history into the surfaces the SystemActivityTab UI consumes.
+
+All filesystem/sync-client work goes through asyncio.to_thread per
+ASYNC230/240 (mirrors backend.app.api.extension's pattern).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import UTC, datetime, timedelta
+
+from quart import Blueprint, jsonify, request
+from sqlalchemy import desc, func, select
+
+from ..config import get_config
+from ..extensions import get_session
+from ..models import TaskRun
+
+system_activity_bp = Blueprint(
+    "system_activity", __name__, url_prefix="/api/system/activity",
+)
+
+# Canonical queue order — must match celery_app.task_routes. UI renders
+# in this order; queues with no LLEN response show as null rather than
+# absent.
+_QUEUE_NAMES = (
+    "default", "import", "thumbnail", "ml",
+    "download", "scan", "maintenance",
+)
+
+# Cache module-level so all requests share the cache between polls.
+# Tests can reset via direct dict mutation if needed.
+_QUEUE_CACHE: dict = {"ts": 0.0, "data": None}
+_WORKER_CACHE: dict = {"ts": 0.0, "data": None}
+_QUEUE_CACHE_TTL = 2.0
+_WORKER_CACHE_TTL = 5.0
+
+
+def _read_queues_sync() -> dict:
+    """Reads each queue's LLEN from the broker. Sync — caller wraps in
+    asyncio.to_thread. Per-queue try/except returns None on failure so
+    one bad queue doesn't break the whole response."""
+    import redis  # local import; only this endpoint needs it
+
+    cfg = get_config()
+    client = redis.Redis.from_url(cfg.celery_broker_url)
+    out: dict = {}
+    for name in _QUEUE_NAMES:
+        try:
+            out[name] = int(client.llen(name))
+        except Exception:  # noqa: BLE001 — broker hiccup shouldn't break UI
+            out[name] = None
+    return {
+        "queues": out,
+        "fetched_at": datetime.now(UTC).isoformat(),
+    }
+
+
+def _read_workers_sync() -> dict:
+    """celery inspect active_queues + active. Returns per-worker info."""
+    from ..celery_app import celery as celery_app
+
+    insp = celery_app.control.inspect(timeout=2.0)
+    active_queues = insp.active_queues() or {}
+    active_tasks = insp.active() or {}
+
+    workers: dict = {}
+    for hostname, queues in active_queues.items():
+        workers[hostname] = {
+            "queues": sorted({q["name"] for q in queues}),
+            "active_count": len(active_tasks.get(hostname, [])),
+        }
+    return {
+        "workers": workers,
+        "fetched_at": datetime.now(UTC).isoformat(),
+    }
+
+
+@system_activity_bp.route("/queues", methods=["GET"])
+async def get_queues():
+    """Per-queue Redis LLEN. Cached 2s.
+
+    Response: {queues: {name: depth_or_null}, fetched_at: iso8601}
+    """
+    now = time.time()
+    if _QUEUE_CACHE["data"] is None or (now - _QUEUE_CACHE["ts"]) > _QUEUE_CACHE_TTL:
+        _QUEUE_CACHE["data"] = await asyncio.to_thread(_read_queues_sync)
+        _QUEUE_CACHE["ts"] = now
+    return jsonify(_QUEUE_CACHE["data"])
+
+
+@system_activity_bp.route("/workers", methods=["GET"])
+async def get_workers():
+    """Live celery inspect. Cached 5s.
+
+    Response: {workers: {hostname: {queues, active_count}}, fetched_at}
+    """
+    now = time.time()
+    if _WORKER_CACHE["data"] is None or (now - _WORKER_CACHE["ts"]) > _WORKER_CACHE_TTL:
+        _WORKER_CACHE["data"] = await asyncio.to_thread(_read_workers_sync)
+        _WORKER_CACHE["ts"] = now
+    return jsonify(_WORKER_CACHE["data"])
+
+
+@system_activity_bp.route("/runs", methods=["GET"])
+async def list_runs():
+    """Paginated task_run history. Query params:
+      queue=<name>     filter to one queue
+      status=<status>  filter to one status (running/ok/error/timeout/retry)
+      limit=<int>      default 50, max 200
+      before_id=<int>  cursor for keyset pagination
+
+    Response: {runs: [...], next_cursor: id|null}
+    """
+    try:
+        limit = min(int(request.args.get("limit", "50")), 200)
+    except ValueError:
+        return jsonify({"error": "invalid_limit"}), 400
+    if limit < 1:
+        return jsonify({"error": "invalid_limit"}), 400
+
+    queue = request.args.get("queue")
+    status = request.args.get("status")
+    before_id_raw = request.args.get("before_id")
+    before_id = int(before_id_raw) if before_id_raw else None
+
+    async with get_session() as session:
+        stmt = select(TaskRun).order_by(desc(TaskRun.id))
+        if queue:
+            stmt = stmt.where(TaskRun.queue == queue)
+        if status:
+            stmt = stmt.where(TaskRun.status == status)
+        if before_id is not None:
+            stmt = stmt.where(TaskRun.id < before_id)
+        stmt = stmt.limit(limit + 1)
+        rows = (await session.execute(stmt)).scalars().all()
+
+    has_more = len(rows) > limit
+    rows = rows[:limit]
+    return jsonify({
+        "runs": [_row_to_dict(r) for r in rows],
+        "next_cursor": rows[-1].id if has_more and rows else None,
+    })
+
+
+@system_activity_bp.route("/failures", methods=["GET"])
+async def list_failures():
+    """Recent failures across all lanes (24h window).
+
+    Response: {recent: [...], count_by_type: {ErrorClass: n}, since}
+    """
+    try:
+        limit = min(int(request.args.get("limit", "50")), 200)
+    except ValueError:
+        return jsonify({"error": "invalid_limit"}), 400
+
+    since = datetime.now(UTC) - timedelta(hours=24)
+
+    async with get_session() as session:
+        recent_stmt = (
+            select(TaskRun)
+            .where(TaskRun.status.in_(["error", "timeout"]))
+            .where(TaskRun.finished_at >= since)
+            .order_by(desc(TaskRun.finished_at))
+            .limit(limit)
+        )
+        recent = (await session.execute(recent_stmt)).scalars().all()
+
+        count_stmt = (
+            select(TaskRun.error_type, func.count(TaskRun.id))
+            .where(TaskRun.status.in_(["error", "timeout"]))
+            .where(TaskRun.finished_at >= since)
+            .group_by(TaskRun.error_type)
+            .order_by(desc(func.count(TaskRun.id)))
+        )
+        counts = (await session.execute(count_stmt)).all()
+
+    return jsonify({
+        "recent": [_row_to_dict(r) for r in recent],
+        "count_by_type": {
+            (row[0] or "Unknown"): row[1]
+            for row in counts
+        },
+        "since": since.isoformat(),
+    })
+
+
+def _row_to_dict(r: TaskRun) -> dict:
+    return {
+        "id": r.id,
+        "queue": r.queue,
+        "task_name": r.task_name,
+        "target_id": r.target_id,
+        "celery_task_id": r.celery_task_id,
+        "started_at": r.started_at.isoformat() if r.started_at else None,
+        "finished_at": r.finished_at.isoformat() if r.finished_at else None,
+        "duration_ms": r.duration_ms,
+        "status": r.status,
+        "error_type": r.error_type,
+        "error_message": r.error_message,
+        "retry_count": r.retry_count,
+        "worker_hostname": r.worker_hostname,
+        "args_summary": r.args_summary,
+    }

backend/app/api/system_backup.py

@@ -0,0 +1,264 @@
+"""FC-3h: /api/system/backup — create/list/restore/delete/tag for
+DB + image backups.
+
+Read endpoints are public on FC (operator-facing internal API; same
+posture as /api/system/activity). Write endpoints take a typed
+`confirm` body field that must match a server-generated token for
+that backup row, to prevent click-to-destroy by stale browser tabs
+or accidental cURL.
+"""
+from __future__ import annotations
+
+from quart import Blueprint, jsonify, request
+from sqlalchemy import desc, select
+
+from ..extensions import get_session
+from ..models import BackupRun, ImportSettings
+
+system_backup_bp = Blueprint(
+    "system_backup", __name__, url_prefix="/api/system/backup",
+)
+
+_KINDS = frozenset({"db", "images"})
+_TAG_MAX_LEN = 64
+_BACKUP_SETTINGS_FIELDS = (
+    "backup_db_nightly_enabled",
+    "backup_db_nightly_hour_utc",
+    "backup_db_keep_last_n",
+    "backup_images_keep_last_n",
+)
+
+
+def _bad(error: str, *, status: int = 400, **extra):
+    body = {"error": error}
+    body.update(extra)
+    return jsonify(body), status
+
+
+def _row_to_dict(r: BackupRun) -> dict:
+    return {
+        "id": r.id,
+        "kind": r.kind,
+        "status": r.status,
+        "tag": r.tag,
+        "triggered_by": r.triggered_by,
+        "started_at": r.started_at.isoformat() if r.started_at else None,
+        "finished_at": r.finished_at.isoformat() if r.finished_at else None,
+        "duration_seconds": (
+            int((r.finished_at - r.started_at).total_seconds())
+            if r.finished_at and r.started_at else None
+        ),
+        "sql_path": r.sql_path,
+        "tar_path": r.tar_path,
+        "size_bytes": r.size_bytes,
+        "error": r.error,
+        "restored_from_id": r.restored_from_id,
+        "manifest": r.manifest or {},
+    }
+
+
+def _validate_tag(tag):
+    if tag is None:
+        return None
+    if not isinstance(tag, str):
+        return _bad("invalid_tag", detail="tag must be string or null")
+    tag = tag.strip()
+    if not tag:
+        return None
+    if len(tag) > _TAG_MAX_LEN:
+        return _bad("invalid_tag", detail=f"tag too long (max {_TAG_MAX_LEN})")
+    return tag
+
+
+def _validate_backup_settings_patch(body: dict):
+    if "backup_db_nightly_enabled" in body and not isinstance(
+        body["backup_db_nightly_enabled"], bool,
+    ):
+        return _bad("invalid_value", detail="backup_db_nightly_enabled must be bool")
+    if "backup_db_nightly_hour_utc" in body:
+        v = body["backup_db_nightly_hour_utc"]
+        if not isinstance(v, int) or isinstance(v, bool) or not (0 <= v <= 23):
+            return _bad("invalid_value", detail="backup_db_nightly_hour_utc must be 0..23")
+    if "backup_db_keep_last_n" in body:
+        v = body["backup_db_keep_last_n"]
+        if not isinstance(v, int) or isinstance(v, bool) or not (1 <= v <= 365):
+            return _bad("invalid_value", detail="backup_db_keep_last_n must be 1..365")
+    if "backup_images_keep_last_n" in body:
+        v = body["backup_images_keep_last_n"]
+        if not isinstance(v, int) or isinstance(v, bool) or not (1 <= v <= 100):
+            return _bad("invalid_value", detail="backup_images_keep_last_n must be 1..100")
+    return None
+
+
+@system_backup_bp.route("/db", methods=["POST"])
+async def trigger_db_backup():
+    body = await request.get_json(silent=True) or {}
+    tag = _validate_tag(body.get("tag"))
+    if isinstance(tag, tuple):
+        return tag
+    from ..tasks.backup import backup_db_task
+    backup_db_task.delay(tag=tag, triggered_by="manual")
+    return jsonify({"status": "dispatched"}), 202
+
+
+@system_backup_bp.route("/images", methods=["POST"])
+async def trigger_images_backup():
+    body = await request.get_json(silent=True) or {}
+    tag = _validate_tag(body.get("tag"))
+    if isinstance(tag, tuple):
+        return tag
+    from ..tasks.backup import backup_images_task
+    backup_images_task.delay(tag=tag, triggered_by="manual")
+    return jsonify({"status": "dispatched"}), 202
+
+
+@system_backup_bp.route("/runs", methods=["GET"])
+async def list_runs():
+    try:
+        limit = min(int(request.args.get("limit", "50")), 200)
+    except ValueError:
+        return _bad("invalid_limit")
+    if limit < 1:
+        return _bad("invalid_limit")
+    kind = request.args.get("kind")
+    if kind is not None and kind not in _KINDS:
+        return _bad("invalid_kind", detail=f"kind must be one of {sorted(_KINDS)}")
+    before_id_raw = request.args.get("before_id")
+    before_id = int(before_id_raw) if before_id_raw else None
+
+    async with get_session() as session:
+        stmt = select(BackupRun).order_by(desc(BackupRun.id))
+        if kind:
+            stmt = stmt.where(BackupRun.kind == kind)
+        if before_id is not None:
+            stmt = stmt.where(BackupRun.id < before_id)
+        stmt = stmt.limit(limit + 1)
+        rows = (await session.execute(stmt)).scalars().all()
+
+    has_more = len(rows) > limit
+    rows = rows[:limit]
+    return jsonify({
+        "runs": [_row_to_dict(r) for r in rows],
+        "next_cursor": rows[-1].id if has_more and rows else None,
+    })
+
+
+@system_backup_bp.route("/runs/<int:run_id>", methods=["GET"])
+async def get_run(run_id: int):
+    async with get_session() as session:
+        row = await session.get(BackupRun, run_id)
+    if row is None:
+        return _bad("not_found", status=404)
+    return jsonify(_row_to_dict(row))
+
+
+@system_backup_bp.route("/runs/<int:run_id>", methods=["PATCH"])
+async def patch_run(run_id: int):
+    body = await request.get_json(silent=True) or {}
+    if "tag" not in body:
+        return _bad("invalid_body", detail="tag required")
+    tag = _validate_tag(body["tag"])
+    if isinstance(tag, tuple):
+        return tag
+
+    async with get_session() as session:
+        row = await session.get(BackupRun, run_id)
+        if row is None:
+            return _bad("not_found", status=404)
+        row.tag = tag
+        await session.commit()
+        await session.refresh(row)
+    return jsonify(_row_to_dict(row))
+
+
+@system_backup_bp.route("/runs/<int:run_id>/restore", methods=["POST"])
+async def trigger_restore(run_id: int):
+    body = await request.get_json(silent=True) or {}
+    supplied = body.get("confirm", "")
+
+    async with get_session() as session:
+        row = await session.get(BackupRun, run_id)
+        if row is None:
+            return _bad("not_found", status=404)
+        if row.status != "ok":
+            return _bad(
+                "not_restorable",
+                detail=f"source backup status={row.status!r}; only 'ok' rows are restorable",
+            )
+        expected = f"restore-{row.kind}-{row.id}"
+        if supplied != expected:
+            return _bad(
+                "confirm_mismatch",
+                detail=f"confirm must equal {expected!r}",
+                expected=expected,
+            )
+        kind = row.kind
+
+    if kind == "db":
+        from ..tasks.backup import restore_db_task
+        restore_db_task.delay(source_backup_run_id=run_id)
+    else:  # 'images' (the only other value _KINDS allows via the trigger path)
+        from ..tasks.backup import restore_images_task
+        restore_images_task.delay(source_backup_run_id=run_id)
+    return jsonify({"status": "dispatched", "kind": kind}), 202
+
+
+@system_backup_bp.route("/runs/<int:run_id>", methods=["DELETE"])
+async def delete_run(run_id: int):
+    body = await request.get_json(silent=True) or {}
+    supplied = body.get("confirm", "")
+
+    async with get_session() as session:
+        row = await session.get(BackupRun, run_id)
+        if row is None:
+            return _bad("not_found", status=404)
+        expected = f"delete-{row.kind}-{row.id}"
+        if supplied != expected:
+            return _bad(
+                "confirm_mismatch",
+                detail=f"confirm must equal {expected!r}",
+                expected=expected,
+            )
+        from ..services import backup_service
+        backup_service.unlink_artifact_files(
+            sql_path=row.sql_path, tar_path=row.tar_path,
+            manifest_path=(row.manifest or {}).get("manifest_path"),
+        )
+        await session.delete(row)
+        await session.commit()
+    return "", 204
+
+
+@system_backup_bp.route("/settings", methods=["GET"])
+async def get_settings():
+    async with get_session() as session:
+        row = (await session.execute(
+            select(ImportSettings).where(ImportSettings.id == 1)
+        )).scalar_one()
+    return jsonify({
+        "backup_db_nightly_enabled": row.backup_db_nightly_enabled,
+        "backup_db_nightly_hour_utc": row.backup_db_nightly_hour_utc,
+        "backup_db_keep_last_n": row.backup_db_keep_last_n,
+        "backup_images_keep_last_n": row.backup_images_keep_last_n,
+    })
+
+
+@system_backup_bp.route("/settings", methods=["PATCH"])
+async def patch_settings():
+    body = await request.get_json(silent=True)
+    if not isinstance(body, dict):
+        return _bad("invalid_body", detail="body must be a JSON object")
+
+    err = _validate_backup_settings_patch(body)
+    if err is not None:
+        return err
+
+    async with get_session() as session:
+        row = (await session.execute(
+            select(ImportSettings).where(ImportSettings.id == 1)
+        )).scalar_one()
+        for field in _BACKUP_SETTINGS_FIELDS:
+            if field in body:
+                setattr(row, field, body[field])
+        await session.commit()
+    return await get_settings()

backend/app/celery_app.py

@@ -31,6 +31,8 @@ def make_celery() -> Celery:
             "backend.app.tasks.migration",
             "backend.app.tasks.ml",
             "backend.app.tasks.download",
+            "backend.app.tasks.backup",
+            "backend.app.tasks.admin",
         ],
     )
     app.conf.update(
@@ -43,6 +45,8 @@ def make_celery() -> Celery:
             "backend.app.tasks.scan.*": {"queue": "scan"},
             "backend.app.tasks.maintenance.*": {"queue": "maintenance"},
             "backend.app.tasks.migration.*": {"queue": "maintenance"},
+            "backend.app.tasks.backup.*": {"queue": "maintenance"},
+            "backend.app.tasks.admin.*": {"queue": "maintenance"},
         },
         # Heavy ML tasks need fair dispatch — see ImageRepo's precedent.
         task_acks_late=True,
@@ -81,9 +85,28 @@ def make_celery() -> Celery:
                 "task": "backend.app.tasks.maintenance.cleanup_old_download_events",
                 "schedule": 86400.0,  # daily
             },
+            "recover-stalled-task-runs": {
+                "task": "backend.app.tasks.maintenance.recover_stalled_task_runs",
+                "schedule": 300.0,  # every 5 min, matches recover-interrupted-tasks
+            },
+            "prune-task-runs": {
+                "task": "backend.app.tasks.maintenance.prune_task_runs",
+                "schedule": 86400.0,  # daily
+            },
+            "fc3h-backup-db-nightly": {
+                "task": "backend.app.tasks.backup.backup_db_nightly",
+                "schedule": 3600.0,  # hourly tick; task self-gates on configured UTC hour
+            },
+            "fc3h-prune-backups": {
+                "task": "backend.app.tasks.backup.prune_backups",
+                "schedule": 86400.0,  # daily
+            },
         },
         timezone="UTC",
     )
+    # FC-3i: register task_run signal handlers (side-effect import).
+    from . import celery_signals  # noqa: F401
+
     return app
 
 

backend/app/celery_signals.py

@@ -0,0 +1,210 @@
+"""FC-3i: task_run lifecycle via Celery signals.
+
+Subscribes to task_prerun / task_postrun / task_failure / task_retry
+and persists one task_run row per task attempt. Drop-in for every
+existing and future Celery task — no per-task instrumentation.
+
+Signal handlers run inside the worker process (sync context); DB
+writes go through the existing shared sync engine
+(backend.app.tasks._sync_engine.sync_session_factory) — one engine
+per worker process, not per-task, so we don't blow Postgres
+max_connections under load (the reason FC-3g shared-engine fix
+existed).
+
+Failure-mode discipline (operator-pressed point): every handler is
+wrapped in try/except that swallows + logs. If the DB is down or the
+handler has a bug, the real task still runs — the dashboard goes
+dark for that interval. Monitoring NEVER breaks the thing it's
+monitoring.
+"""
+
+import logging
+from datetime import UTC, datetime
+
+from celery.exceptions import SoftTimeLimitExceeded
+from celery.signals import task_failure, task_postrun, task_prerun, task_retry
+
+from .models import TaskRun
+from .tasks._sync_engine import sync_session_factory
+
+log = logging.getLogger(__name__)
+
+# Celery-internal tasks that would generate dashboard noise without
+# operational value. Conservative list; extend only when a specific
+# task proves noisy.
+_UNTRACKED_TASK_NAMES = frozenset({
+    "celery.chord_unlock",
+    "celery.backend_cleanup",
+    "celery.chunks",
+})
+
+_MAX_ERROR_MESSAGE_LEN = 2000
+_MAX_ARGS_SUMMARY_LEN = 255
+_MAX_WORKER_HOSTNAME_LEN = 128
+
+# PostgreSQL Integer is signed 32-bit. Tasks called with a first-arg
+# int outside this range (e.g. an absurdly large mock value, or a
+# string-of-digits coercible to int but bigger than 2^31-1) would crash
+# the INSERT with NumericValueOutOfRange. Bound the recorded value to
+# the column's range; values outside become None (target_id is
+# nullable, so this is safe).
+_INT32_MAX = 2_147_483_647
+_INT32_MIN = -2_147_483_648
+
+
+def _queue_for(task) -> str:
+    """Reverse the task→queue routing from celery_app.task_routes.
+    Keep in sync if task_routes is reordered."""
+    name = getattr(task, "name", "") or ""
+    if name.startswith("backend.app.tasks.import_file."):
+        return "import"
+    if name.startswith("backend.app.tasks.ml."):
+        return "ml"
+    if name.startswith("backend.app.tasks.thumbnail."):
+        return "thumbnail"
+    if name.startswith("backend.app.tasks.download."):
+        return "download"
+    if name.startswith("backend.app.tasks.scan."):
+        return "scan"
+    if name.startswith((
+        "backend.app.tasks.maintenance.",
+        "backend.app.tasks.migration.",
+    )):
+        return "maintenance"
+    return "default"
+
+
+def _target_id_from_args(args) -> int | None:
+    """Best-effort: if the first positional arg parses as int AND fits
+    in the column's signed-32-bit range, record it as target_id
+    (image_id, source_id, etc.). Never raises."""
+    if not args:
+        return None
+    try:
+        value = int(args[0])
+    except (TypeError, ValueError):
+        return None
+    if value < _INT32_MIN or value > _INT32_MAX:
+        return None
+    return value
+
+
+def _truncate(s, limit: int) -> str | None:
+    if s is None:
+        return None
+    text = str(s)
+    return text if len(text) <= limit else text[:limit]
+
+
+def _is_tracked(task_name: str | None) -> bool:
+    return bool(task_name) and task_name not in _UNTRACKED_TASK_NAMES
+
+
+@task_prerun.connect
+def _on_prerun(sender=None, task_id=None, task=None, args=None,
+               kwargs=None, **_):
+    if not _is_tracked(getattr(task, "name", None)):
+        return
+    try:
+        Session = sync_session_factory()
+        with Session() as session:
+            session.add(TaskRun(
+                celery_task_id=task_id or "",
+                queue=_queue_for(task),
+                task_name=task.name,
+                target_id=_target_id_from_args(args),
+                started_at=datetime.now(UTC),
+                status="running",
+                args_summary=_truncate(repr(args), _MAX_ARGS_SUMMARY_LEN),
+                worker_hostname=_truncate(
+                    getattr(sender, "hostname", None),
+                    _MAX_WORKER_HOSTNAME_LEN,
+                ),
+            ))
+            session.commit()
+    except Exception:  # noqa: BLE001 — never break the worker
+        log.exception("task_run prerun insert failed (task=%s)",
+                      getattr(task, "name", "?"))
+
+
+def _finalize(task_id: str, *, status: str,
+              error_type: str | None = None,
+              error_message: str | None = None,
+              retry_count: int | None = None) -> None:
+    """Shared write path for postrun/failure/retry. Picks the most-
+    recent task_run row for this celery_task_id that's still 'running'
+    (retries reuse the same celery_task_id; each new attempt's prerun
+    inserts a fresh row, so finalize targets the latest running row)."""
+    try:
+        from sqlalchemy import select
+
+        Session = sync_session_factory()
+        now = datetime.now(UTC)
+        with Session() as session:
+            row = session.execute(
+                select(TaskRun)
+                .where(TaskRun.celery_task_id == task_id)
+                .where(TaskRun.status == "running")
+                .order_by(TaskRun.id.desc())
+                .limit(1)
+            ).scalar_one_or_none()
+            if row is None:
+                return  # no prerun row (untracked, insert failed, or already finalized)
+            row.finished_at = now
+            row.duration_ms = int(
+                (now - row.started_at).total_seconds() * 1000
+            )
+            row.status = status
+            if error_type is not None:
+                row.error_type = _truncate(error_type, 128)
+            if error_message is not None:
+                row.error_message = _truncate(error_message, _MAX_ERROR_MESSAGE_LEN)
+            if retry_count is not None:
+                row.retry_count = retry_count
+            session.commit()
+    except Exception:  # noqa: BLE001
+        log.exception("task_run finalize failed (task_id=%s)", task_id)
+
+
+@task_postrun.connect
+def _on_postrun(sender=None, task_id=None, task=None, args=None,
+                kwargs=None, retval=None, state=None, **_):
+    if not _is_tracked(getattr(task, "name", None)):
+        return
+    # state is one of SUCCESS/FAILURE/RETRY/etc. Only handle SUCCESS;
+    # task_failure handles FAILURE explicitly (with the exception).
+    if state != "SUCCESS":
+        return
+    _finalize(task_id, status="ok")
+
+
+@task_failure.connect
+def _on_failure(sender=None, task_id=None, exception=None,
+                args=None, kwargs=None, einfo=None, **_):
+    if not _is_tracked(getattr(sender, "name", None)):
+        return
+    status = ("timeout"
+              if isinstance(exception, SoftTimeLimitExceeded)
+              else "error")
+    _finalize(
+        task_id, status=status,
+        error_type=type(exception).__name__ if exception else "Unknown",
+        error_message=str(exception) if exception else None,
+    )
+
+
+@task_retry.connect
+def _on_retry(sender=None, request=None, reason=None, einfo=None, **_):
+    if not _is_tracked(getattr(sender, "name", None)):
+        return
+    task_id = getattr(request, "id", None)
+    if not task_id:
+        return
+    # Mark current attempt's row as 'retry' (terminal for this row).
+    # The next attempt's task_prerun inserts a fresh row.
+    _finalize(
+        task_id, status="retry",
+        error_type=type(reason).__name__ if reason else "Retry",
+        error_message=str(reason) if reason else None,
+        retry_count=getattr(request, "retries", 0),
+    )

backend/app/frontend.py

@@ -1,14 +1,78 @@
-"""Serves the built Vue SPA from frontend/dist/ with history-mode fallback."""
+"""Serves the built Vue SPA from frontend/dist/ with history-mode fallback,
+the on-disk image library + thumbnails from /images, and the signed
+Firefox extension XPI from frontend/dist/extension/.
+"""
 
+import re
 from pathlib import Path
 
-from quart import Blueprint, send_from_directory
+from quart import Blueprint, abort, send_file, send_from_directory
 
 FRONTEND_DIST = Path(__file__).resolve().parent.parent.parent / "frontend" / "dist"
+IMAGES_ROOT = Path("/images")
+XPI_DIR = FRONTEND_DIST / "extension"
+
+_XPI_NAME_RE = re.compile(r"^fabledcurator-[\w.-]+\.xpi$")
 
 frontend_bp = Blueprint("frontend", __name__)
 
 
+@frontend_bp.route("/images/<path:subpath>")
+async def serve_image(subpath: str):
+    """Serve a file from the /images volume (originals + thumbnails).
+
+    Without this route the SPA catch-all below would swallow image
+    requests and return index.html, leaving the browser to render the
+    aspect-ratio-shaped grey placeholder.
+    """
+    target = (IMAGES_ROOT / subpath).resolve()
+    # Defend against path-traversal: refuse anything that escapes /images.
+    try:
+        target.relative_to(IMAGES_ROOT)
+    except ValueError:
+        abort(404)
+    if not target.is_file():
+        abort(404)
+    return await send_from_directory(IMAGES_ROOT, subpath)
+
+
+@frontend_bp.route("/extension/<filename>")
+async def serve_extension(filename: str):
+    """Serve the signed FC Firefox extension XPI.
+
+    Path whitelist: filename must match fabledcurator-*.xpi. The special
+    name fabledcurator-latest.xpi serves the most-recently-modified XPI
+    in the directory.
+
+    The application/x-xpinstall MIME tells Firefox to show its native
+    install prompt instead of downloading the file as a blob.
+    """
+    if not _XPI_NAME_RE.fullmatch(filename):
+        abort(404)
+    if not XPI_DIR.is_dir():
+        abort(404)
+    if filename == "fabledcurator-latest.xpi":
+        xpis = sorted(XPI_DIR.glob("fabledcurator-*.xpi"), key=lambda p: p.stat().st_mtime)
+        if not xpis:
+            abort(404)
+        latest = xpis[-1]
+        return await send_file(
+            latest, mimetype="application/x-xpinstall",
+            attachment_filename=latest.name,
+        )
+    target = (XPI_DIR / filename).resolve()
+    try:
+        target.relative_to(XPI_DIR)
+    except ValueError:
+        abort(404)
+    if not target.is_file():
+        abort(404)
+    return await send_file(
+        target, mimetype="application/x-xpinstall",
+        attachment_filename=filename,
+    )
+
+
 @frontend_bp.route("/")
 @frontend_bp.route("/<path:subpath>")
 async def serve_spa(subpath: str = ""):

backend/app/models/__init__.py

@@ -2,6 +2,7 @@
 
 from .app_setting import AppSetting
 from .artist import Artist
+from .backup_run import BackupRun
 from .base import Base
 from .credential import Credential
 from .download_event import DownloadEvent
@@ -21,11 +22,13 @@ from .tag_alias import TagAlias
 from .tag_allowlist import TagAllowlist
 from .tag_reference_embedding import TagReferenceEmbedding
 from .tag_suggestion_rejection import TagSuggestionRejection
+from .task_run import TaskRun
 
 __all__ = [
     "Base",
     "AppSetting",
     "Artist",
+    "BackupRun",
     "Source",
     "Credential",
     "Post",
@@ -46,4 +49,5 @@ __all__ = [
     "TagAllowlist",
     "TagReferenceEmbedding",
     "TagSuggestionRejection",
+    "TaskRun",
 ]

backend/app/models/backup_run.py

@@ -0,0 +1,55 @@
+"""FC-3h: backup_run — operator-facing artifact record for a backup run.
+
+One row per backup attempt (kind='db' or 'images'). Lifecycle
+tracking (started_at/finished_at/duration_ms/exception text) lives
+in task_run from FC-3i — this row records artifact metadata: file
+paths, sizes, tag (retention protection), and restore lineage via
+restored_from_id.
+
+Status values (String, not Postgres ENUM — per
+feedback_check_existing_enums):
+  pending   — created but task hasn't started yet (rare; usually
+              status starts as 'running' from the task body).
+  running   — backup task is in flight.
+  ok        — artifact successfully written.
+  error     — task raised; error column populated.
+  restoring — this row represents a restore attempt (kind = restored
+              kind); linked to source via restored_from_id.
+  restored  — restore completed successfully.
+"""
+
+from datetime import datetime
+
+from sqlalchemy import JSON, BigInteger, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+
+
+class BackupRun(Base):
+    __tablename__ = "backup_run"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    kind: Mapped[str] = mapped_column(String(16), nullable=False, index=True)
+    status: Mapped[str] = mapped_column(
+        String(16), nullable=False, default="pending", index=True,
+    )
+    tag: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
+    triggered_by: Mapped[str] = mapped_column(String(32), nullable=False)
+    started_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, index=True,
+    )
+    finished_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True, index=True,
+    )
+    sql_path: Mapped[str | None] = mapped_column(Text, nullable=True)
+    tar_path: Mapped[str | None] = mapped_column(Text, nullable=True)
+    size_bytes: Mapped[int | None] = mapped_column(BigInteger, nullable=True)
+    error: Mapped[str | None] = mapped_column(Text, nullable=True)
+    manifest: Mapped[dict] = mapped_column(
+        JSON, nullable=False, default=dict, server_default="{}",
+    )
+    restored_from_id: Mapped[int | None] = mapped_column(
+        ForeignKey("backup_run.id", ondelete="SET NULL"),
+        nullable=True,
+    )

backend/app/models/import_batch.py

@@ -26,6 +26,10 @@ class ImportBatch(Base):
     skipped: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     failed: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     attachments: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    # Deep-scan only: count of already-imported files whose sidecar metadata
+    # got re-applied this run (post/source/provenance upsert). Stays 0 on
+    # quick-scan batches. See `Importer.import_one(deep_scan=True)`.
+    refreshed: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
 
     status: Mapped[str] = mapped_column(String(16), nullable=False, default="running", index=True)
     # running | complete | cancelled

backend/app/models/import_settings.py

@@ -49,3 +49,17 @@ class ImportSettings(Base):
     download_failure_warning_threshold: Mapped[int] = mapped_column(
         Integer, nullable=False, default=5
     )
+
+    # FC-3h backup knobs.
+    backup_db_nightly_enabled: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=False,
+    )
+    backup_db_nightly_hour_utc: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=3,
+    )
+    backup_db_keep_last_n: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=14,
+    )
+    backup_images_keep_last_n: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=3,
+    )

backend/app/models/task_run.py

@@ -0,0 +1,48 @@
+"""FC-3i: task_run — per-Celery-task lifecycle audit row.
+
+One row inserted by the task_prerun signal at task start, updated by
+task_postrun / task_failure / task_retry. The shape supports the
+SystemActivity dashboard's three panes: per-queue queue+worker summary,
+recent failures (24h, grouped by error_type), and full paginated
+activity history.
+
+Retention: ok rows pruned after 24h, error/timeout after 7d (see
+backend.app.tasks.maintenance.prune_task_runs).
+
+Recovery: rows stuck in 'running' for >5 min flipped to 'error' by
+backend.app.tasks.maintenance.recover_stalled_task_runs (Beat 5 min).
+"""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+
+
+class TaskRun(Base):
+    __tablename__ = "task_run"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    celery_task_id: Mapped[str] = mapped_column(
+        String(64), nullable=False, index=True,
+    )
+    queue: Mapped[str] = mapped_column(String(32), nullable=False, index=True)
+    task_name: Mapped[str] = mapped_column(String(128), nullable=False, index=True)
+    target_id: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    started_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, index=True,
+    )
+    finished_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True, index=True,
+    )
+    duration_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    status: Mapped[str] = mapped_column(
+        String(16), nullable=False, default="running", index=True,
+    )
+    error_type: Mapped[str | None] = mapped_column(String(128), nullable=True)
+    error_message: Mapped[str | None] = mapped_column(Text, nullable=True)
+    retry_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    worker_hostname: Mapped[str | None] = mapped_column(String(128), nullable=True)
+    args_summary: Mapped[str | None] = mapped_column(String(255), nullable=True)

backend/app/scripts/download_models.py

@@ -25,12 +25,31 @@ def _snapshot(repo_id: str, dest: Path, allow_patterns: list[str] | None) -> Non
 
 
 def ensure_camie() -> None:
+    """Fetch Camie v2 weights + metadata.
+
+    v2 layout (HuggingFace Camais03/camie-tagger-v2): the ONNX file is
+    named camie-tagger-v2.onnx (not model.onnx) and tags ship inside
+    camie-tagger-v2-metadata.json (not selected_tags.csv). Both at root.
+    The repo also contains app/, game/, training/, images/ subdirs full
+    of setup/demo files we don't need — allow_patterns scopes the fetch
+    to just the inference essentials (~790 MB instead of ~2 GB).
+    """
     dest = MODEL_ROOT / "camie"
-    if (dest / "model.onnx").is_file() and (dest / "selected_tags.csv").is_file():
+    model_file = dest / "camie-tagger-v2.onnx"
+    meta_file = dest / "camie-tagger-v2-metadata.json"
+    if model_file.is_file() and meta_file.is_file():
         print(f"[download_models] Camie present at {dest}")
         return
     print(f"[download_models] Fetching {CAMIE_REPO} -> {dest}")
-    _snapshot(CAMIE_REPO, dest, ["model.onnx", "selected_tags.csv", "*.json"])
+    _snapshot(
+        CAMIE_REPO, dest,
+        [
+            "camie-tagger-v2.onnx",
+            "camie-tagger-v2-metadata.json",
+            "config.json",
+            "config.yaml",
+        ],
+    )
 
 
 def ensure_siglip() -> None:

backend/app/services/backup_service.py

@@ -0,0 +1,196 @@
+"""FC-3h: first-class backup/restore service for FC.
+
+Two independent backup kinds:
+  - 'db'     — pg_dump only; fast; nightly via Beat (settings-gated)
+  - 'images' — tar+zstd of /images; slow; manual trigger only
+
+Files live under <images_root>/_backups/. Each backup writes:
+  fc_<kind>_<ts>.{sql|tar.zst}        — the artifact
+  fc_<kind>_<ts>.json                 — manifest (kind/tag/triggered_by)
+
+Service functions are sync (subprocess-bound). Celery tasks in
+backend.app.tasks.backup wrap each one with task_run-tracked
+lifecycle + soft/hard time limits + retention bookkeeping.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+from datetime import UTC, datetime
+from pathlib import Path
+
+_BACKUPS_DIRNAME = "_backups"
+
+# Subprocess-level guardrails BEYOND the Celery soft_time_limit. The
+# Celery soft limit signals the Python process; subprocess.Popen in a
+# blocking syscall ignores that signal. These bound the worst case.
+_DB_SUBPROCESS_TIMEOUT_S = 12 * 60        # 12 min (Celery soft is 10 min)
+_IMAGES_SUBPROCESS_TIMEOUT_S = 7 * 60 * 60  # 7 hr (Celery soft is 6 hr)
+
+
+def _libpq_url(sa_url: str) -> str:
+    """Strip SQLAlchemy +psycopg/+asyncpg driver suffix for pg_dump/psql."""
+    for driver in (
+        "postgresql+psycopg",
+        "postgresql+asyncpg",
+        "postgresql+psycopg2",
+    ):
+        if sa_url.startswith(driver + "://"):
+            return "postgresql://" + sa_url[len(driver) + 3:]
+    return sa_url
+
+
+def _backups_dir(images_root: Path) -> Path:
+    p = images_root / _BACKUPS_DIRNAME
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _now_ts() -> str:
+    return datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+
+
+def _file_size_or_none(path: Path) -> int | None:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return None
+
+
+def _write_manifest(
+    out_dir: Path, *, kind: str, ts: str,
+    tag: str | None, triggered_by: str,
+    artifact_path: Path,
+) -> Path:
+    manifest = {
+        "kind": kind,
+        "backup_id": f"fc_{kind}_{ts}",
+        "tag": tag,
+        "triggered_by": triggered_by,
+        "created_at": datetime.now(UTC).isoformat(),
+        "artifact_path": str(artifact_path),
+    }
+    mf = out_dir / f"fc_{kind}_{ts}.json"
+    mf.write_text(json.dumps(manifest, indent=2))
+    return mf
+
+
+def backup_db(
+    *, db_url: str, images_root: Path,
+    tag: str | None = None, triggered_by: str = "manual",
+) -> dict:
+    """Run pg_dump; write .sql + manifest; return dict for the caller
+    to persist into BackupRun. Raises on subprocess failure."""
+    ts = _now_ts()
+    out_dir = _backups_dir(images_root)
+    sql_path = out_dir / f"fc_db_{ts}.sql"
+    subprocess.run(
+        [
+            "pg_dump", "--no-owner", "--no-acl",
+            "-f", str(sql_path), _libpq_url(db_url),
+        ],
+        capture_output=True, check=True,
+        timeout=_DB_SUBPROCESS_TIMEOUT_S,
+    )
+    manifest_path = _write_manifest(
+        out_dir, kind="db", ts=ts, tag=tag, triggered_by=triggered_by,
+        artifact_path=sql_path,
+    )
+    return {
+        "kind": "db",
+        "ts": ts,
+        "sql_path": str(sql_path),
+        "tar_path": None,
+        "manifest_path": str(manifest_path),
+        "size_bytes": _file_size_or_none(sql_path),
+    }
+
+
+def backup_images(
+    *, images_root: Path,
+    tag: str | None = None, triggered_by: str = "manual",
+) -> dict:
+    """Run tar --zstd over images_root; write .tar.zst + manifest."""
+    ts = _now_ts()
+    out_dir = _backups_dir(images_root)
+    tar_path = out_dir / f"fc_images_{ts}.tar.zst"
+    subprocess.run(
+        [
+            "tar", "--zstd", "-cf", str(tar_path),
+            "-C", str(images_root.parent), images_root.name,
+            f"--exclude={images_root.name}/_backups",
+            f"--exclude={images_root.name}/_quarantine",
+        ],
+        capture_output=True, check=True,
+        timeout=_IMAGES_SUBPROCESS_TIMEOUT_S,
+    )
+    manifest_path = _write_manifest(
+        out_dir, kind="images", ts=ts, tag=tag, triggered_by=triggered_by,
+        artifact_path=tar_path,
+    )
+    return {
+        "kind": "images",
+        "ts": ts,
+        "sql_path": None,
+        "tar_path": str(tar_path),
+        "manifest_path": str(manifest_path),
+        "size_bytes": _file_size_or_none(tar_path),
+    }
+
+
+def restore_db(*, db_url: str, sql_path: Path) -> None:
+    """Wipe public schema, then load from .sql. Raises on subprocess
+    failure; partial-restore state is the caller's concern."""
+    libpq = _libpq_url(db_url)
+    subprocess.run(
+        [
+            "psql", libpq, "-c",
+            "DROP SCHEMA IF EXISTS public CASCADE; CREATE SCHEMA public;",
+        ],
+        capture_output=True, check=True, timeout=120,
+    )
+    subprocess.run(
+        ["psql", libpq, "-f", str(sql_path)],
+        capture_output=True, check=True,
+        timeout=_DB_SUBPROCESS_TIMEOUT_S,
+    )
+
+
+def restore_images(*, images_root: Path, tar_path: Path) -> None:
+    """Untar over images_root.parent. Additive — files NOT in the
+    tarball are NOT removed. Caller wipes first if a clean restore
+    is needed."""
+    subprocess.run(
+        [
+            "tar", "--zstd", "-xf", str(tar_path),
+            "-C", str(images_root.parent),
+        ],
+        capture_output=True, check=True,
+        timeout=_IMAGES_SUBPROCESS_TIMEOUT_S,
+    )
+
+
+def unlink_artifact_files(
+    *,
+    sql_path: str | None,
+    tar_path: str | None,
+    manifest_path: str | None,
+) -> dict:
+    """Best-effort unlink of all on-disk files for a BackupRun row.
+    Returns dict keyed by label with True/False per file. Missing
+    files count as success (missing_ok semantics)."""
+    deleted: dict = {}
+    for label, p in (
+        ("sql", sql_path),
+        ("tar", tar_path),
+        ("manifest", manifest_path),
+    ):
+        if not p:
+            continue
+        path = Path(p)
+        try:
+            path.unlink(missing_ok=True)
+            deleted[label] = True
+        except OSError:
+            deleted[label] = False
+    return deleted

backend/app/services/cleanup_service.py

@@ -0,0 +1,367 @@
+"""FC-3k: first-class admin destructive operations.
+
+Projections are pure SELECTs used by both dry-run preview endpoints
+and Tier-B count prompts. Mutations (Task 2) are called from sync
+HTTP handlers (small ops) and from Celery tasks in
+backend.app.tasks.admin (long ops).
+
+This module is the PERMANENT home of artist-cascade + image-unlink
+logic. The legacy copy at backend/app/services/migrators/cleanup.py
+stays in place until FC-3j; FC-3j will replace its body with thin
+re-exports from this module and then delete the wrapper.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from ..models import Artist, ImageRecord, Tag
+from ..models.series_page import SeriesPage
+from ..models.tag import image_tag
+
+
+def project_artist_cascade(session: Session, *, slug: str) -> dict:
+    """Read-only projection of what delete_artist_cascade would touch.
+
+    Returns:
+        {
+          "artist": {"id": int, "name": str, "slug": str},
+          "projected": {
+            "images": int,
+            "sources": int,
+            "thumbs": int,        # images with a thumbnail_path set
+            "import_tasks": int,  # ImportTask rows referencing the artist's images
+            "bytes_on_disk": int, # SUM(image_record.size_bytes) — column is NOT NULL
+          },
+        }
+    Raises LookupError if slug not found. No mutations.
+    """
+    from ..models.import_task import ImportTask
+    from ..models.source import Source
+
+    artist = session.execute(
+        select(Artist).where(Artist.slug == slug)
+    ).scalar_one_or_none()
+    if artist is None:
+        raise LookupError(f"artist slug not found: {slug!r}")
+
+    images_count = session.execute(
+        select(func.count(ImageRecord.id))
+        .where(ImageRecord.artist_id == artist.id)
+    ).scalar_one()
+    sources_count = session.execute(
+        select(func.count(Source.id))
+        .where(Source.artist_id == artist.id)
+    ).scalar_one()
+    thumbs_count = session.execute(
+        select(func.count(ImageRecord.id))
+        .where(ImageRecord.artist_id == artist.id)
+        .where(ImageRecord.thumbnail_path.is_not(None))
+    ).scalar_one()
+    import_tasks_count = session.execute(
+        select(func.count(ImportTask.id))
+        .where(
+            ImportTask.result_image_id.in_(
+                select(ImageRecord.id).where(ImageRecord.artist_id == artist.id)
+            )
+        )
+    ).scalar_one()
+    bytes_on_disk = session.execute(
+        select(func.coalesce(func.sum(ImageRecord.size_bytes), 0))
+        .where(ImageRecord.artist_id == artist.id)
+    ).scalar_one()
+
+    return {
+        "artist": {"id": artist.id, "name": artist.name, "slug": artist.slug},
+        "projected": {
+            "images": images_count,
+            "sources": sources_count,
+            "thumbs": thumbs_count,
+            "import_tasks": import_tasks_count,
+            "bytes_on_disk": int(bytes_on_disk),
+        },
+    }
+
+
+def project_bulk_image_delete(
+    session: Session, *, image_ids: list[int],
+) -> dict:
+    """Read-only projection of what delete_images would touch.
+
+    Returns:
+        {
+          "images_found": int,
+          "thumbs_to_unlink": int,
+          "bytes_on_disk": int,
+          "missing_ids": list[int],   # ids passed in that don't exist
+        }
+    No mutations.
+    """
+    if not image_ids:
+        return {
+            "images_found": 0,
+            "thumbs_to_unlink": 0,
+            "bytes_on_disk": 0,
+            "missing_ids": [],
+        }
+
+    rows = session.execute(
+        select(
+            ImageRecord.id,
+            ImageRecord.thumbnail_path,
+            ImageRecord.size_bytes,
+        ).where(ImageRecord.id.in_(image_ids))
+    ).all()
+    found_ids = {r.id for r in rows}
+    missing = sorted(set(image_ids) - found_ids)
+    return {
+        "images_found": len(rows),
+        "thumbs_to_unlink": sum(1 for r in rows if r.thumbnail_path),
+        "bytes_on_disk": sum(r.size_bytes for r in rows),
+        "missing_ids": missing,
+    }
+
+
+def count_tag_associations(session: Session, *, tag_id: int) -> int:
+    """COUNT(*) FROM image_tag WHERE tag_id=?. For Tier-B prompt."""
+    return session.execute(
+        select(func.count())
+        .select_from(image_tag)
+        .where(image_tag.c.tag_id == tag_id)
+    ).scalar_one()
+
+
+def find_unused_tags(
+    session: Session, *, limit: int | None = None,
+) -> list[Tag]:
+    """Tags with no image_tag rows AND no series_page rows.
+
+    Sorted by name. Used by both dry-run preview and the live prune.
+    A tag is "unused" iff it has zero rows in image_tag AND zero rows
+    in series_page (so we don't accidentally prune a series tag that
+    happens to have no images yet).
+    """
+    used_via_image_tag = select(image_tag.c.tag_id).distinct()
+    used_via_series = select(SeriesPage.series_tag_id).where(
+        SeriesPage.series_tag_id.is_not(None)
+    ).distinct()
+    stmt = (
+        select(Tag)
+        .where(Tag.id.not_in(used_via_image_tag))
+        .where(Tag.id.not_in(used_via_series))
+        .order_by(Tag.name)
+    )
+    if limit is not None:
+        stmt = stmt.limit(limit)
+    return list(session.execute(stmt).scalars().all())
+
+
+def unlink_image_files(
+    image: ImageRecord, images_root: Path,
+) -> dict:
+    """Best-effort unlink of all on-disk files for an ImageRecord.
+
+    Targets: image.path (original), image.thumbnail_path (cached
+    thumbnail), and the computed thumbs path at
+    /images/thumbs/<sha256[:3]>/<sha256>.(jpg|png|webp) (tries all
+    three extensions; missing extension is silently OK).
+
+    Returns {"original": bool, "thumbnail": bool}. Missing files
+    count as success (missing_ok semantics). OSErrors are swallowed
+    and reported as False so the calling DB delete still proceeds.
+    """
+    out = {"original": False, "thumbnail": False}
+    if image.path:
+        try:
+            Path(image.path).unlink(missing_ok=True)
+            out["original"] = True
+        except OSError:
+            out["original"] = False
+    # Custom thumbnail_path (when set) — try it first.
+    if image.thumbnail_path:
+        try:
+            Path(image.thumbnail_path).unlink(missing_ok=True)
+            out["thumbnail"] = True
+        except OSError:
+            out["thumbnail"] = False
+    # Convention thumbs dir — try all extensions; missing OK.
+    if image.sha256:
+        bucket = image.sha256[:3]
+        for ext in ("jpg", "png", "webp"):
+            try:
+                (images_root / "thumbs" / bucket / f"{image.sha256}.{ext}").unlink(
+                    missing_ok=True,
+                )
+            except OSError:
+                pass
+    return out
+
+
+def delete_artist_cascade(
+    session: Session, *, artist_id: int, images_root: Path,
+) -> dict:
+    """Batched delete of an artist's images + the artist row.
+
+    Mirrors the cleanup_artist_async pattern: 500-row batches,
+    commit between batches so partial progress survives a worker
+    kill. Idempotent on missing artist (returns zeroed counts).
+    Postgres cascades handle image_tag / image_provenance /
+    series_page / tag_suggestion_rejection from ImageRecord delete,
+    and source / post / download_event / etc. from Artist delete
+    (via Artist.sources cascade="all, delete-orphan").
+    """
+    artist = session.get(Artist, artist_id)
+    if artist is None:
+        return {
+            "artist": None,
+            "summary": {
+                "images_deleted": 0,
+                "files_deleted": 0,
+                "thumbs_deleted": 0,
+                "import_tasks_nulled": 0,
+                "files_failed": 0,
+            },
+        }
+    artist_info = {"id": artist.id, "name": artist.name, "slug": artist.slug}
+
+    images_deleted = 0
+    files_deleted = 0
+    thumbs_deleted = 0
+    files_failed = 0
+
+    while True:
+        rows = session.execute(
+            select(ImageRecord)
+            .where(ImageRecord.artist_id == artist.id)
+            .limit(500)
+        ).scalars().all()
+        if not rows:
+            break
+        for img in rows:
+            unlinked = unlink_image_files(img, images_root)
+            if unlinked["original"]:
+                files_deleted += 1
+            else:
+                files_failed += 1
+            if unlinked["thumbnail"]:
+                thumbs_deleted += 1
+            session.delete(img)
+            images_deleted += 1
+        session.commit()
+
+    # ImportTask.result_image_id FK is SET NULL on image delete (Postgres
+    # handles this in the cascade above). We don't separately count those
+    # in FC-3k — the legacy cleanup_artist_async did it via
+    # source_path_prefix matching that's out of scope here.
+    import_tasks_nulled = 0
+
+    session.delete(artist)
+    session.commit()
+
+    return {
+        "artist": artist_info,
+        "summary": {
+            "images_deleted": images_deleted,
+            "files_deleted": files_deleted,
+            "thumbs_deleted": thumbs_deleted,
+            "import_tasks_nulled": import_tasks_nulled,
+            "files_failed": files_failed,
+        },
+    }
+
+
+def delete_images(
+    session: Session, *, image_ids: list[int], images_root: Path,
+) -> dict:
+    """Delete a list of images in 500-row batches with commit between.
+
+    Postgres CASCADE on image_tag / image_provenance / series_page /
+    tag_suggestion_rejection / post_attachment(FK SET NULL) handles
+    the DB side; this function handles file unlinks first then row
+    deletes. Idempotent on missing IDs (returned as missing_ids;
+    no error). On partial OSError, the row is still deleted and
+    files_failed is incremented.
+    """
+    if not image_ids:
+        return {
+            "images_deleted": 0,
+            "files_deleted": 0,
+            "thumbs_deleted": 0,
+            "files_failed": 0,
+            "missing_ids": [],
+        }
+
+    seen_ids: set[int] = set()
+    images_deleted = 0
+    files_deleted = 0
+    thumbs_deleted = 0
+    files_failed = 0
+
+    pending = list(image_ids)
+    while pending:
+        batch_ids = pending[:500]
+        pending = pending[500:]
+        rows = session.execute(
+            select(ImageRecord).where(ImageRecord.id.in_(batch_ids))
+        ).scalars().all()
+        for img in rows:
+            seen_ids.add(img.id)
+            unlinked = unlink_image_files(img, images_root)
+            if unlinked["original"]:
+                files_deleted += 1
+            else:
+                files_failed += 1
+            if unlinked["thumbnail"]:
+                thumbs_deleted += 1
+            session.delete(img)
+            images_deleted += 1
+        session.commit()
+
+    missing = sorted(set(image_ids) - seen_ids)
+    return {
+        "images_deleted": images_deleted,
+        "files_deleted": files_deleted,
+        "thumbs_deleted": thumbs_deleted,
+        "files_failed": files_failed,
+        "missing_ids": missing,
+    }
+
+
+def delete_tag(session: Session, *, tag_id: int) -> dict:
+    """Simple DELETE FROM tag WHERE id=?.
+
+    Postgres cascades the rest (image_tag, tag_alias, tag_allowlist,
+    tag_reference_embedding, tag_suggestion_rejection, series_page).
+    Returns counts BEFORE delete so the caller can surface them.
+    Raises LookupError if tag_id not found.
+    """
+    tag = session.get(Tag, tag_id)
+    if tag is None:
+        raise LookupError(f"tag id not found: {tag_id}")
+    associations_count = count_tag_associations(session, tag_id=tag_id)
+    info = {"id": tag.id, "name": tag.name, "kind": tag.kind.value}
+    session.delete(tag)
+    session.commit()
+    return {"deleted": info, "associations_removed": associations_count}
+
+
+def prune_unused_tags(session: Session, *, dry_run: bool = False) -> dict:
+    """Find tags with zero references and (unless dry_run) delete them.
+
+    Returns:
+      dry_run=True:  {"count": N, "sample_names": [first 50]}
+      dry_run=False: {"deleted": N, "sample_names": [first 50]}
+    """
+    unused = find_unused_tags(session)
+    sample = [t.name for t in unused[:50]]
+    if dry_run:
+        return {"count": len(unused), "sample_names": sample}
+    ids = [t.id for t in unused]
+    if ids:
+        session.execute(
+            Tag.__table__.delete().where(Tag.id.in_(ids))
+        )
+        session.commit()
+    return {"deleted": len(ids), "sample_names": sample}

backend/app/services/extension_service.py

@@ -0,0 +1,127 @@
+"""FC-3g: backend support for the Firefox extension.
+
+`ExtensionService.quick_add_source(url)` derives platform + artist
+slug from a URL using regex patterns mirrored from
+extension/lib/platforms.js, then find-or-creates Artist + Source rows
+and returns a JSON-shaped dict for the API layer.
+"""
+
+from __future__ import annotations
+
+import re
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..models import Artist, Source
+from ..utils.slug import slugify
+
+
+class UnknownPlatformError(Exception):
+    """URL didn't match any platform pattern."""
+
+
+class InvalidUrlError(Exception):
+    """URL was empty or missing a scheme."""
+
+
+# Mirrored byte-for-byte from extension/lib/platforms.js
+# PLATFORM_ARTIST_PATTERNS. Keep these two copies in sync by hand —
+# reviewers catch drift.
+_PLATFORM_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    ("patreon", re.compile(
+        r"^https?://(?:www\.)?patreon\.com/"
+        r"(?!home$|search\b|messages\b|notifications\b|library\b|settings\b|posts\b|c/)"
+        r"(?P<slug>[^/?#]+)/?$",
+        re.IGNORECASE,
+    )),
+    ("subscribestar", re.compile(
+        r"^https?://(?:www\.)?subscribestar\.(?:com|adult)/"
+        r"(?!feed$|messages$|library$)"
+        r"(?P<slug>[^/?#]+)/?$",
+        re.IGNORECASE,
+    )),
+    ("hentaifoundry", re.compile(
+        r"^https?://(?:www\.)?hentai-foundry\.com/user/(?P<slug>[^/?#]+)",
+        re.IGNORECASE,
+    )),
+    ("deviantart", re.compile(
+        r"^https?://(?:www\.)?deviantart\.com/"
+        r"(?!home$|watch\b|tag\b|browse\b)"
+        r"(?P<slug>[^/?#]+)/?$",
+        re.IGNORECASE,
+    )),
+    ("pixiv", re.compile(
+        r"^https?://(?:www\.)?pixiv\.net/(?:en/)?users/(?P<slug>\d+)",
+        re.IGNORECASE,
+    )),
+]
+
+
+class ExtensionService:
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    async def quick_add_source(self, url: str) -> dict:
+        platform, raw_slug = self._derive(url)
+        artist, created_artist = await self._find_or_create_artist(raw_slug)
+        source, created_source = await self._find_or_create_source(
+            artist_id=artist.id, platform=platform, url=url,
+        )
+        return {
+            "source": {
+                "id": source.id,
+                "artist_id": source.artist_id,
+                "platform": source.platform,
+                "url": source.url,
+                "enabled": source.enabled,
+            },
+            "artist": {
+                "id": artist.id,
+                "name": artist.name,
+                "slug": artist.slug,
+            },
+            "created_source": created_source,
+            "created_artist": created_artist,
+        }
+
+    def _derive(self, url: str) -> tuple[str, str]:
+        if not isinstance(url, str) or not url.strip():
+            raise InvalidUrlError("url is empty")
+        if not url.startswith(("http://", "https://")):
+            raise InvalidUrlError(f"url must include http:// or https:// scheme: {url!r}")
+        for platform, pattern in _PLATFORM_PATTERNS:
+            m = pattern.match(url)
+            if m:
+                return platform, m.group("slug")
+        raise UnknownPlatformError(f"no platform pattern matched {url!r}")
+
+    async def _find_or_create_artist(self, raw_name: str) -> tuple[Artist, bool]:
+        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
+
+    async def _find_or_create_source(
+        self, *, artist_id: int, platform: str, url: str,
+    ) -> tuple[Source, bool]:
+        existing = (await self.session.execute(
+            select(Source).where(
+                Source.artist_id == artist_id,
+                Source.platform == platform,
+                Source.url == url,
+            )
+        )).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()
+        await self.session.commit()
+        return src, True

backend/app/services/gallery_service.py

@@ -1,26 +1,34 @@
 """Cursor-paginated gallery queries.
 
-Cursor format: opaque base64-encoded "<iso8601_created_at>:<image_id>".
+Cursor format: opaque base64-encoded "<iso8601_effective_date>:<image_id>".
-Pagination key is (created_at DESC, id DESC) so we don't drift when new
+
-imports arrive between page loads. Decoding rejects malformed cursors with
+Pagination key is (effective_date DESC, id DESC) where effective_date is
-a ValueError; the API layer translates that to HTTP 400.
+COALESCE(post.post_date, image_record.created_at) so the gallery surfaces
+images by ORIGINAL publish date when known, falling back to FC's scan
+date. Important for migrated content: ~57k IR images scanned in a single
+week would otherwise all share the same created_at and pile up in one
+month bucket. The effective_date spreads them across the years they
+were originally published.
+
+Decoding rejects malformed cursors with a ValueError; the API layer
+translates that to HTTP 400.
 """
 
 import base64
 from dataclasses import dataclass
 from datetime import datetime
 
-from sqlalchemy import and_, exists, func, or_, select
+from sqlalchemy import Select, and_, exists, func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from ..models import Artist, ImageProvenance, ImageRecord, Source, Tag
+from ..models import Artist, ImageProvenance, ImageRecord, Post, Source, Tag
 from ..models.tag import image_tag
 
 CURSOR_SEPARATOR = "|"
 
 
-def encode_cursor(created_at: datetime, image_id: int) -> str:
+def encode_cursor(effective_date: datetime, image_id: int) -> str:
-    raw = f"{created_at.isoformat()}{CURSOR_SEPARATOR}{image_id}"
+    raw = f"{effective_date.isoformat()}{CURSOR_SEPARATOR}{image_id}"
     return base64.urlsafe_b64encode(raw.encode()).decode()
 
 
@@ -33,6 +41,26 @@ def decode_cursor(cursor: str) -> tuple[datetime, int]:
         raise ValueError(f"invalid cursor: {cursor!r}") from exc
 
 
+def _effective_date_col():
+    """SQL expression: COALESCE(post.post_date, image_record.created_at).
+
+    Used as the canonical sort/group/filter key across the gallery so
+    images backfilled with primary_post_id (e.g. via tag_apply phase 4)
+    surface at their original publish date, not their FC import date.
+    Images without a Post (or with Post.post_date NULL) fall back to
+    image_record.created_at and still order coherently against
+    post-attached ones.
+    """
+    return func.coalesce(Post.post_date, ImageRecord.created_at)
+
+
+def _outer_join_primary_post(stmt: Select) -> Select:
+    """LEFT JOIN Post on ImageRecord.primary_post_id so the COALESCE
+    above sees Post.post_date when available. Images without a post
+    survive the join as NULL on the Post side; COALESCE handles it."""
+    return stmt.outerjoin(Post, Post.id == ImageRecord.primary_post_id)
+
+
 @dataclass(frozen=True)
 class GalleryImage:
     id: int
@@ -41,7 +69,9 @@ class GalleryImage:
     mime: str
     width: int | None
     height: int | None
-    created_at: datetime
+    created_at: datetime          # FC's row-insert time
+    effective_date: datetime      # COALESCE(post.post_date, created_at)
+    posted_at: datetime | None    # post.post_date if known, else None
     thumbnail_url: str
     artist: dict | None = None
 
@@ -78,7 +108,7 @@ def _require_single_filter(tag_id, post_id, artist_id) -> None:
 def _provenance_clause(post_id, artist_id):
     """Correlated EXISTS clause (NOT a join) so an image with multiple
     matching provenance rows is returned exactly once and the
-    (created_at DESC, id DESC) cursor ordering is unaffected."""
+    (effective_date DESC, id DESC) cursor ordering is unaffected."""
     if post_id is not None:
         return exists().where(
             ImageProvenance.image_record_id == ImageRecord.id,
@@ -125,7 +155,9 @@ class GalleryService:
             raise ValueError("limit must be between 1 and 200")
         _require_single_filter(tag_id, post_id, artist_id)
 
-        stmt = select(ImageRecord)
+        eff = _effective_date_col()
+        stmt = select(ImageRecord, Post.post_date, eff.label("eff"))
+        stmt = _outer_join_primary_post(stmt)
         if tag_id is not None:
             stmt = stmt.join(image_tag, image_tag.c.image_record_id == ImageRecord.id).where(
                 image_tag.c.tag_id == tag_id
@@ -138,34 +170,38 @@ class GalleryService:
             cur_ts, cur_id = decode_cursor(cursor)
             stmt = stmt.where(
                 or_(
-                    ImageRecord.created_at < cur_ts,
+                    eff < cur_ts,
-                    and_(ImageRecord.created_at == cur_ts, ImageRecord.id < cur_id),
+                    and_(eff == cur_ts, ImageRecord.id < cur_id),
                 )
             )
 
-        stmt = stmt.order_by(ImageRecord.created_at.desc(), ImageRecord.id.desc()).limit(limit + 1)
+        stmt = stmt.order_by(eff.desc(), ImageRecord.id.desc()).limit(limit + 1)
-        rows = (await self.session.execute(stmt)).scalars().all()
+        rows = (await self.session.execute(stmt)).all()
 
         next_cursor = None
         if len(rows) > limit:
-            last = rows[limit - 1]
+            last_record, _last_posted_at, last_eff = rows[limit - 1]
-            next_cursor = encode_cursor(last.created_at, last.id)
+            next_cursor = encode_cursor(last_eff, last_record.id)
             rows = rows[:limit]
 
-        artists = await _artists_for(self.session, [r.id for r in rows])
+        artists = await _artists_for(
+            self.session, [r[0].id for r in rows]
+        )
         images = [
             GalleryImage(
-                id=r.id,
+                id=record.id,
-                path=r.path,
+                path=record.path,
-                sha256=r.sha256,
+                sha256=record.sha256,
-                mime=r.mime,
+                mime=record.mime,
-                width=r.width,
+                width=record.width,
-                height=r.height,
+                height=record.height,
-                created_at=r.created_at,
+                created_at=record.created_at,
-                thumbnail_url=thumbnail_url(r.sha256, r.mime),
+                effective_date=eff_date,
-                artist=artists.get(r.id),
+                posted_at=posted_at,
+                thumbnail_url=thumbnail_url(record.sha256, record.mime),
+                artist=artists.get(record.id),
             )
-            for r in rows
+            for record, posted_at, eff_date in rows
         ]
         return GalleryPage(
             images=images,
@@ -179,11 +215,13 @@ class GalleryService:
         post_id: int | None = None,
         artist_id: int | None = None,
     ) -> list[TimelineBucket]:
-        year_col = func.date_part("year", ImageRecord.created_at).label("yr")
+        eff = _effective_date_col()
-        month_col = func.date_part("month", ImageRecord.created_at).label("mo")
+        year_col = func.date_part("year", eff).label("yr")
+        month_col = func.date_part("month", eff).label("mo")
         stmt = select(
             year_col, month_col, func.count(ImageRecord.id).label("cnt")
         )
+        stmt = _outer_join_primary_post(stmt)
         _require_single_filter(tag_id, post_id, artist_id)
         if tag_id is not None:
             stmt = stmt.join(image_tag, image_tag.c.image_record_id == ImageRecord.id).where(
@@ -201,14 +239,17 @@ class GalleryService:
         post_id: int | None = None, artist_id: int | None = None,
     ) -> str | None:
         """Returns a cursor that, when passed to scroll(), positions at the
-        first image of the given year-month. None if the bucket is empty.
+        first image of the given year-month (by effective_date, not
+        created_at). None if the bucket is empty.
         """
         from sqlalchemy import extract
 
-        stmt = select(ImageRecord).where(
+        eff = _effective_date_col()
-            extract("year", ImageRecord.created_at) == year,
+        stmt = select(ImageRecord, eff.label("eff")).where(
-            extract("month", ImageRecord.created_at) == month,
+            extract("year", eff) == year,
+            extract("month", eff) == month,
         )
+        stmt = _outer_join_primary_post(stmt)
         _require_single_filter(tag_id, post_id, artist_id)
         if tag_id is not None:
             stmt = stmt.join(image_tag, image_tag.c.image_record_id == ImageRecord.id).where(
@@ -217,13 +258,14 @@ class GalleryService:
         prov = _provenance_clause(post_id, artist_id)
         if prov is not None:
             stmt = stmt.where(prov)
-        stmt = stmt.order_by(ImageRecord.created_at.desc(), ImageRecord.id.desc()).limit(1)
+        stmt = stmt.order_by(eff.desc(), ImageRecord.id.desc()).limit(1)
-        first = (await self.session.execute(stmt)).scalar_one_or_none()
+        first = (await self.session.execute(stmt)).first()
         if first is None:
             return None
+        record, eff_date = first
         # Cursor is exclusive; we encode a cursor with id+1 so the row itself
         # is the first result in the next scroll().
-        return encode_cursor(first.created_at, first.id + 1)
+        return encode_cursor(eff_date, record.id + 1)
 
     async def get_image_with_tags(self, image_id: int) -> dict | None:
         record = await self.session.get(ImageRecord, image_id)
@@ -236,7 +278,23 @@ class GalleryService:
             .order_by(Tag.kind.asc(), Tag.name.asc())
         )
         tags = (await self.session.execute(tag_stmt)).scalars().all()
+        # Fetch the canonical post.post_date for this image (if any) so
+        # the modal can show "Posted on <date>" alongside import date.
+        posted_at = None
+        if record.primary_post_id is not None:
+            posted_at = (await self.session.execute(
+                select(Post.post_date).where(Post.id == record.primary_post_id)
+            )).scalar_one_or_none()
         neighbors = await self._neighbors(record)
+        # Direct artist FK — used by the modal's ProvenancePanel as a
+        # fallback when ImageProvenance is empty (i.e., filesystem-
+        # imported images without a post-track provenance row). The
+        # source of truth for richer post-level data is still
+        # ImageProvenance/Post; this is just the "we at least know who
+        # made it" line.
+        artist = None
+        if record.artist_id is not None:
+            artist = await self.session.get(Artist, record.artist_id)
         return {
             "id": record.id,
             "path": record.path,
@@ -247,8 +305,13 @@ class GalleryService:
             "size_bytes": record.size_bytes,
             "integrity_status": record.integrity_status,
             "created_at": record.created_at.isoformat(),
+            "posted_at": posted_at.isoformat() if posted_at else None,
             "thumbnail_url": thumbnail_url(record.sha256, record.mime),
             "image_url": f"/images/{record.path.split('/images/', 1)[-1]}",
+            "artist": (
+                {"id": artist.id, "name": artist.name, "slug": artist.slug}
+                if artist is not None else None
+            ),
             "tags": [
                 {
                     "id": t.id,
@@ -262,34 +325,41 @@ class GalleryService:
         }
 
     async def _neighbors(self, record: ImageRecord) -> dict:
-        prev_stmt = (
+        # Compute the boundary image's effective_date in Python (one query
-            select(ImageRecord.id)
+        # below + the SELECT we already have on `record`) and use it for
-            .where(
+        # the neighbor comparison. Cheaper than re-deriving in SQL via
+        # correlated subquery.
+        boundary_eff = record.created_at
+        if record.primary_post_id is not None:
+            post_date = (await self.session.execute(
+                select(Post.post_date).where(Post.id == record.primary_post_id)
+            )).scalar_one_or_none()
+            if post_date is not None:
+                boundary_eff = post_date
+
+        eff = _effective_date_col()
+        prev_stmt = _outer_join_primary_post(
+            select(ImageRecord.id).where(
                 or_(
-                    ImageRecord.created_at > record.created_at,
+                    eff > boundary_eff,
                     and_(
-                        ImageRecord.created_at == record.created_at,
+                        eff == boundary_eff,
                         ImageRecord.id > record.id,
                     ),
                 )
             )
-            .order_by(ImageRecord.created_at.asc(), ImageRecord.id.asc())
+        ).order_by(eff.asc(), ImageRecord.id.asc()).limit(1)
-            .limit(1)
+        next_stmt = _outer_join_primary_post(
-        )
+            select(ImageRecord.id).where(
-        next_stmt = (
-            select(ImageRecord.id)
-            .where(
                 or_(
-                    ImageRecord.created_at < record.created_at,
+                    eff < boundary_eff,
                     and_(
-                        ImageRecord.created_at == record.created_at,
+                        eff == boundary_eff,
                         ImageRecord.id < record.id,
                     ),
                 )
             )
-            .order_by(ImageRecord.created_at.desc(), ImageRecord.id.desc())
+        ).order_by(eff.desc(), ImageRecord.id.desc()).limit(1)
-            .limit(1)
-        )
         prev_id = (await self.session.execute(prev_stmt)).scalar_one_or_none()
         next_id = (await self.session.execute(next_stmt)).scalar_one_or_none()
         return {"prev_id": prev_id, "next_id": next_id}
@@ -298,9 +368,11 @@ class GalleryService:
 def _group_by_year_month(
     images: list[GalleryImage],
 ) -> list[tuple[int, int, list[int]]]:
+    """Group by effective_date's year/month so migrated content surfaces
+    in the publish-date buckets, not the FC-scan-date bucket."""
     groups: list[tuple[int, int, list[int]]] = []
     for img in images:
-        y, m = img.created_at.year, img.created_at.month
+        y, m = img.effective_date.year, img.effective_date.month
         if groups and groups[-1][0] == y and groups[-1][1] == m:
             groups[-1][2].append(img.id)
         else:

backend/app/services/importer.py

@@ -51,7 +51,14 @@ class SkipReason(StrEnum):
 
 @dataclass(frozen=True)
 class ImportResult:
-    status: str  # 'imported'|'skipped'|'failed'|'superseded'|'attached'
+    # 'imported'   — new ImageRecord row created
+    # 'superseded' — existing ImageRecord row got the new file (larger) + sidecar
+    # 'attached'   — non-media saved as PostAttachment
+    # 'refreshed'  — deep scan re-applied sidecar / filled NULL phash / NULL
+    #                artist on an already-imported row (no new ImageRecord)
+    # 'skipped'    — no work done (true duplicate, too small, etc.)
+    # 'failed'     — pipeline error
+    status: str
     image_id: int | None = None
     skip_reason: SkipReason | None = None
     error: str | None = None
@@ -71,6 +78,31 @@ def is_video(path: Path) -> bool:
     return path.suffix.lower() in VIDEO_EXTS
 
 
+def _safe_ext(path: Path) -> str:
+    """Conservatively extract a file extension for PostAttachment.ext
+    (varchar(32)).
+
+    gallery-dl produces some filenames with URL-encoded query-string
+    artifacts embedded into the basename (e.g.
+    `79507046_media_..._https___www.patreon.com_media-u_Z0FBQUFBQm5q...`).
+    `Path.suffix` finds the LAST dot and returns everything after, which
+    in those cases yields a 50+ char "extension" of mostly base64-ish
+    junk. That blows the column. Operator-flagged 2026-05-25.
+
+    Real extensions are short and alphanumeric. We accept anything ≤ 16
+    chars where every post-dot character is alphanumeric; anything else
+    means the input wasn't a real extension and we return the empty
+    string. ext is nullable-ish (empty string still satisfies NOT NULL)
+    and consumers should treat "" as "no known extension".
+    """
+    suffix = path.suffix.lower()
+    if not suffix or len(suffix) > 16:
+        return ""
+    if not all(c.isalnum() for c in suffix[1:]):
+        return ""
+    return suffix
+
+
 def _mime_for(path: Path) -> str:
     suffix = path.suffix.lower()
     image_mimes = {
@@ -126,6 +158,49 @@ class Importer:
         self.settings = settings
         self.deep = deep
         self.attachments = AttachmentStore(images_root)
+        # phash near-dup candidate cache. Archive imports call _import_media
+        # per-member; without this cache the per-member SELECT *FROM
+        # image_record WHERE phash IS NOT NULL fetch repeats N times and a
+        # large library × many-member archive blew past soft_time_limit
+        # (300s) — operator-flagged 2026-05-25. Loaded lazily on first
+        # need, appended to on every imported/superseded outcome, never
+        # invalidated mid-Importer (Importer instances are per-task /
+        # per-archive-import so cross-instance staleness is harmless).
+        self._phash_candidates: list[tuple] | None = None
+
+    def _phash_candidates_cache(self) -> list[tuple]:
+        """Cached `(phash, width, height, id)` rows from image_record.
+        Loaded on first call, appended-to on subsequent imported/
+        superseded outcomes. Soft-timeout pattern: an archive with N
+        members + a library of M existing rows used to do N × M-row
+        fetches (operator-flagged 2026-05-25); now it's exactly one.
+
+        The per-task lifecycle of Importer (instantiated fresh by
+        import_media_file) bounds the cache's staleness window: cross-
+        process changes (other workers importing concurrently) won't
+        be reflected, but that's the same race the un-cached version
+        had — `find_similar` is best-effort anyway."""
+        if self._phash_candidates is None:
+            rows = self.session.execute(
+                select(
+                    ImageRecord.phash,
+                    ImageRecord.width,
+                    ImageRecord.height,
+                    ImageRecord.id,
+                ).where(ImageRecord.phash.is_not(None))
+            ).all()
+            self._phash_candidates = [
+                (r.phash, r.width or 0, r.height or 0, r.id) for r in rows
+            ]
+        return self._phash_candidates
+
+    def _phash_cache_append(self, phash, width, height, image_id) -> None:
+        """Append a freshly-imported row to the cache so subsequent
+        members of the same archive can match against it."""
+        if self._phash_candidates is not None and phash is not None:
+            self._phash_candidates.append(
+                (phash, width or 0, height or 0, image_id)
+            )
 
     def import_one(self, source: Path) -> ImportResult:
         """Dispatch by kind. Media → normal pipeline. Archive → extract
@@ -209,7 +284,7 @@ class Importer:
                 sha256=sha,
                 path=stored,
                 original_filename=source.name,
-                ext=source.suffix.lower(),
+                ext=_safe_ext(source),
                 mime=_mime_for(source),
                 size_bytes=source.stat().st_size,
             ))
@@ -280,7 +355,18 @@ class Importer:
                 )
 
             if self.settings.skip_transparent and has_alpha:
-                pct = self._transparency_pct(source)
+                try:
+                    pct = self._transparency_pct(source)
+                except OSError as exc:
+                    # PIL.verify() at line 263 only validates header structure;
+                    # truncated/corrupt pixel data only surfaces when load()
+                    # actually decodes (here via getchannel('A')). Convert to
+                    # invalid_image skip so the Celery autoretry loop doesn't
+                    # bounce the same broken file forever.
+                    return ImportResult(
+                        status="skipped", skip_reason=SkipReason.invalid_image,
+                        error=f"PIL load failed during transparency check: {exc}",
+                    )
                 if pct >= self.settings.transparency_threshold:
                     return ImportResult(
                         status="skipped", skip_reason=SkipReason.too_transparent,
@@ -302,21 +388,18 @@ class Importer:
         # Perceptual near-dup (images only; videos keep phash NULL).
         phash = None
         if not is_video(source):
-            with Image.open(source) as im:
+            try:
-                phash = compute_phash(im)
+                with Image.open(source) as im:
+                    phash = compute_phash(im)
+            except OSError as exc:
+                # Same rationale as the transparency-check guard above:
+                # broken-pixel-data files pass verify() but blow up here.
+                return ImportResult(
+                    status="skipped", skip_reason=SkipReason.invalid_image,
+                    error=f"PIL load failed during phash compute: {exc}",
+                )
             if phash is not None:
-                cand_rows = self.session.execute(
+                candidates = self._phash_candidates_cache()
-                    select(
-                        ImageRecord.phash,
-                        ImageRecord.width,
-                        ImageRecord.height,
-                        ImageRecord.id,
-                    ).where(ImageRecord.phash.is_not(None))
-                ).all()
-                candidates = [
-                    (c.phash, c.width or 0, c.height or 0, c.id)
-                    for c in cand_rows
-                ]
                 rel, match_id = find_similar(
                     phash, width or 0, height or 0,
                     candidates, self.settings.phash_threshold,
@@ -350,6 +433,7 @@ class Importer:
         )
         self.session.add(record)
         self.session.flush()
+        self._phash_cache_append(phash, width, height, record.id)
 
         # Folder→artist (anchored to attribution_path).
         artist = None
@@ -373,13 +457,27 @@ class Importer:
     ) -> ImportResult:
         """Deep scan: backfill phash/provenance/artist on an
         already-imported record. METADATA ONLY — never re-runs the pHash
-        near-dup / supersede path. NULL-only, idempotent."""
+        near-dup / supersede path. NULL-only on phash/artist, additive on
+        sidecar Post/Source/ImageProvenance (via _apply_sidecar).
+        Idempotent: a second deep-scan over the same file finds nothing
+        to refresh and is a no-op.
+
+        Returns status="refreshed" so the UI can surface the work done
+        instead of the prior misleading "skipped/duplicate_hash" reading.
+        Operator-flagged 2026-05-25 — IR has had this; FC inherited it
+        as a no-op skip during the original port and the UI showed deep
+        scan as "completed with no changes" even when sidecar metadata
+        actually got re-applied to N existing rows.
+        """
         if existing.phash is None and not is_video(source):
             try:
                 with Image.open(source) as im:
                     ph = compute_phash(im)
                 if ph is not None:
                     existing.phash = ph
+                    # Promoted from NULL to non-NULL → cache is now stale
+                    # (this row would newly qualify for the candidates set).
+                    self._phash_candidates = None
             except Exception as exc:
                 log.warning("deep rephash failed for %s: %s", source, exc)
 
@@ -392,10 +490,7 @@ class Importer:
 
         self._apply_sidecar(existing, attribution_path, artist)
         self.session.commit()
-        return ImportResult(
+        return ImportResult(status="refreshed", image_id=existing.id)
-            status="skipped", skip_reason=SkipReason.duplicate_hash,
-            image_id=existing.id, error="deep: re-derived",
-        )
 
     def attach_in_place(
         self,
@@ -479,18 +574,7 @@ class Importer:
             except Exception:
                 phash = None
             if phash is not None:
-                cand_rows = self.session.execute(
+                candidates = self._phash_candidates_cache()
-                    select(
-                        ImageRecord.phash,
-                        ImageRecord.width,
-                        ImageRecord.height,
-                        ImageRecord.id,
-                    ).where(ImageRecord.phash.is_not(None))
-                ).all()
-                candidates = [
-                    (c.phash, c.width or 0, c.height or 0, c.id)
-                    for c in cand_rows
-                ]
                 rel, match_id = find_similar(
                     phash, width or 0, height or 0,
                     candidates, self.settings.phash_threshold,
@@ -525,6 +609,7 @@ class Importer:
             record.artist_id = artist.id
         self.session.add(record)
         self.session.flush()
+        self._phash_cache_append(phash, width, height, record.id)
 
         # Sidecar provenance (best-effort). When `source` is passed, link
         # the post to that subscription Source instead of creating a new
@@ -703,6 +788,15 @@ class Importer:
         row id (so tags/series/curation stay attached). ML is cleared so
         the import task re-derives it on the new pixels.
 
+        After the file swap, the new file's adjacent gallery-dl sidecar
+        (if any) is applied via _apply_sidecar — operator-flagged
+        2026-05-25: scanning a GS download dir with smaller IR-migrated
+        images on the receiving end used to swap files but lose the GS
+        sidecar's post metadata entirely. _apply_sidecar is additive
+        (find-or-create Post / Source / ImageProvenance, NULL-only
+        primary_post_id update) so any pre-existing Post linkage
+        survives untouched.
+
         If `new_path` is provided, `source` is assumed to ALREADY be at
         that path (FC-3c attach_in_place case) — skip the copy step.
         Otherwise the file is copied via _copy_to_library."""
@@ -731,6 +825,26 @@ class Importer:
         # created_at intentionally preserved; updated_at auto-bumps.
         self.session.flush()
         self.session.commit()
+        # The phash candidate cache (used to avoid N+1 selects during
+        # archive imports) is now stale for `existing.id` — the row's
+        # phash/dimensions changed. Invalidate; the next call re-fetches.
+        self._phash_candidates = None
+
+        # Sidecar enrichment from the new (larger) file's location.
+        # _apply_sidecar resolves artist from the sidecar itself if the
+        # existing row has none, and is internally guarded against
+        # missing-or-malformed sidecars (silent return).
+        try:
+            self._apply_sidecar(existing, source, None)
+        except Exception as exc:
+            # Don't unwind the supersede DB swap if sidecar parsing
+            # blows up unexpectedly — the file replacement is the
+            # critical operation, sidecar is enrichment.
+            log.warning(
+                "sidecar enrichment failed during supersede of "
+                "image_record.id=%s from %s: %s",
+                existing.id, source, exc,
+            )
 
         for stale in (old_path, old_thumb):
             if not stale or stale == str(dest):

backend/app/services/migrators/__init__.py

@@ -1,6 +1,10 @@
 """FC-5 migration tooling.
 
-One module per concern (backup/rollback/gs/ir/overlap/ml_queue/verify).
+One module per concern (gs/ir/overlap/ml_queue/verify/cleanup).
 Each migrator returns a counts dict; the run_migration task wires
 that dict into MigrationRun.counts so the UI polling shows progress.
+
+backup + rollback were retired in FC-3h (2026-05-24); first-class
+backup lives at backend/app/services/backup_service.py and exposes
+its own /api/system/backup/* surface.
 """

backend/app/services/migrators/backup.py

@@ -1,124 +0,0 @@
-"""pg_dump + tar.zst-based backup, restorable via pair of subprocess calls.
-
-Backups live under <images_root>/_backups/. Each backup is two files
-(SQL + tarball) plus a manifest JSON. Tagged backups (e.g. tag='pre_migration')
-are how rollback.py finds the most recent restorable snapshot.
-"""
-from __future__ import annotations
-
-import json
-import shutil
-import subprocess
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Any
-
-_BACKUPS_DIRNAME = "_backups"
-
-
-def _backups_dir(images_root: Path | None = None) -> Path:
-    # Overridable for tests via monkeypatch.
-    root = images_root if images_root is not None else Path("/images")
-    p = root / _BACKUPS_DIRNAME
-    p.mkdir(parents=True, exist_ok=True)
-    return p
-
-
-def _run_subprocess(cmd: list[str], **kwargs: Any):
-    # Overridable for tests via monkeypatch.
-    return subprocess.run(
-        cmd,
-        capture_output=True,
-        check=True,
-        **{k: v for k, v in kwargs.items() if not k.startswith("_")},
-    )
-
-
-def create_backup(
-    *, db_url: str, images_root: Path, tag: str = "manual",
-) -> dict:
-    """Create a backup: pg_dump SQL + tar.zst of images.
-
-    Returns a manifest dict. Writes <ts>.sql, <ts>.tar.zst, <ts>.json into
-    <images_root>/_backups/.
-    """
-    ts = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
-    out_dir = _backups_dir(images_root)
-    sql_path = out_dir / f"fc_{ts}.sql"
-    tar_path = out_dir / f"fc_{ts}.tar.zst"
-    manifest_path = out_dir / f"fc_{ts}.json"
-
-    _run_subprocess(
-        ["pg_dump", "--no-owner", "--no-acl", "-f", str(sql_path), db_url],
-        _test_ts=ts,
-    )
-    _run_subprocess(
-        [
-            "tar", "--zstd", "-cf", str(tar_path),
-            "-C", str(images_root.parent), images_root.name,
-            f"--exclude={images_root.name}/_backups",
-            f"--exclude={images_root.name}/_quarantine",
-        ],
-        _test_ts=ts,
-    )
-
-    manifest = {
-        "backup_id": ts,
-        "tag": tag,
-        "created_at": datetime.now(UTC).isoformat(),
-        "sql_path": str(sql_path),
-        "tar_path": str(tar_path),
-    }
-    manifest_path.write_text(json.dumps(manifest, indent=2))
-    return manifest
-
-
-def list_backups(images_root: Path) -> list[dict]:
-    out_dir = _backups_dir(images_root)
-    items = []
-    for mf in sorted(out_dir.glob("fc_*.json"), reverse=True):
-        try:
-            items.append(json.loads(mf.read_text()))
-        except Exception:
-            continue
-    return items
-
-
-def find_latest_backup(images_root: Path, *, tag: str) -> dict | None:
-    for mf in list_backups(images_root):
-        if mf.get("tag") == tag:
-            return mf
-    return None
-
-
-def restore_backup(
-    *, manifest: dict, db_url: str, images_root: Path,
-) -> dict:
-    """Restore from a backup manifest.
-
-    1. Replay the .sql via psql.
-    2. Wipe /images/ contents (except _backups/, which holds the file we're using).
-    3. Untar the .tar.zst into /images/.
-    """
-    sql_path = Path(manifest["sql_path"])
-    tar_path = Path(manifest["tar_path"])
-
-    _run_subprocess(
-        ["psql", "-d", db_url, "-f", str(sql_path)],
-    )
-
-    # Wipe everything in images_root EXCEPT _backups/ (we'd delete the backup
-    # we're restoring from!).
-    for entry in images_root.iterdir():
-        if entry.name == _BACKUPS_DIRNAME:
-            continue
-        if entry.is_dir():
-            shutil.rmtree(entry)
-        else:
-            entry.unlink()
-
-    _run_subprocess(
-        ["tar", "--zstd", "-xf", str(tar_path), "-C", str(images_root.parent)],
-    )
-
-    return {"restored_from": manifest["backup_id"]}

backend/app/services/migrators/cleanup.py

@@ -0,0 +1,182 @@
+"""Targeted cleanup migrator: delete every image attributed to one Artist.
+
+Built for the IR-migration rescue case where the filesystem scan derived
+a bogus 'imagerepo' artist from a mismatched bind-mount layout. Every
+image attributed to that artist (40k+ rows) needs to be removed — DB
+rows, original files under `/images/<bucket>/...`, and thumbnails under
+`/images/thumbs/...` — before the operator remounts and re-scans.
+
+CASCADE handles image_tag, image_provenance, series_page, and
+tag_suggestion_rejection child rows; import_task.result_image_id is
+SET NULL by FK. We also delete ImportTask rows whose source_path starts
+with the (still-existing) IR scan prefix so the next scan isn't fooled
+by them.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from sqlalchemy import delete, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ...models import Artist, ImageRecord, ImportBatch, ImportTask
+
+log = logging.getLogger(__name__)
+
+_BATCH_SIZE = 500
+
+
+def _zero_counts() -> dict:
+    return {
+        "rows_processed": 0, "rows_inserted": 0, "rows_skipped": 0,
+        "files_copied": 0, "bytes_copied": 0, "conflicts": 0,
+    }
+
+
+def _thumb_path(images_root: Path, sha256_hex: str) -> tuple[Path, Path]:
+    """Return both possible thumbnail paths (.jpg and .png). We try both
+    because the extension is chosen at generate-time based on the source
+    image's mode (alpha → .png, otherwise → .jpg)."""
+    bucket = sha256_hex[:3]
+    base = images_root / "thumbs" / bucket / sha256_hex
+    return base.with_suffix(".jpg"), base.with_suffix(".png")
+
+
+def _delete_file(path: Path) -> bool:
+    """Best-effort unlink; True if the file was actually removed."""
+    try:
+        path.unlink(missing_ok=True)
+        return True
+    except OSError as exc:
+        log.warning("cleanup: failed to unlink %s: %s", path, exc)
+        return False
+
+
+async def cleanup_artist_async(
+    db: AsyncSession,
+    *,
+    slug: str,
+    images_root: Path | None = None,
+    dry_run: bool = False,
+    source_path_prefix: str | None = None,
+) -> dict:
+    """Delete every image attributed to the Artist with this slug,
+    along with the artist row itself and any associated import tasks.
+
+    Args:
+        slug: artist.slug to target (e.g. 'imagerepo').
+        images_root: defaults to /images.
+        dry_run: skip filesystem + DB writes; still walk rows for counts.
+        source_path_prefix: if set, ImportTask rows whose source_path
+            starts with this string are deleted too (use the IR scan
+            mount prefix, e.g. '/import/imagerepo').
+    """
+    root = images_root if images_root is not None else Path("/images")
+
+    artist = (await db.execute(
+        select(Artist).where(Artist.slug == slug)
+    )).scalar_one_or_none()
+    if artist is None:
+        raise ValueError(f"no Artist with slug={slug!r}")
+
+    artist_id = artist.id
+    artist_name = artist.name
+
+    total_images = (await db.execute(
+        select(func.count(ImageRecord.id)).where(ImageRecord.artist_id == artist_id)
+    )).scalar_one()
+
+    counts = _zero_counts()
+    files_deleted = 0
+    thumbs_deleted = 0
+    images_deleted = 0
+
+    # Batched delete loop. CASCADE handles image_tag, image_provenance,
+    # series_page, tag_suggestion_rejection. import_task.result_image_id
+    # is SET NULL by FK.
+    while True:
+        rows = (await db.execute(
+            select(ImageRecord.id, ImageRecord.path, ImageRecord.sha256)
+            .where(ImageRecord.artist_id == artist_id)
+            .limit(_BATCH_SIZE)
+        )).all()
+        if not rows:
+            break
+
+        ids = [r.id for r in rows]
+        counts["rows_processed"] += len(ids)
+
+        if not dry_run:
+            for r in rows:
+                if r.path:
+                    if _delete_file(Path(r.path)):
+                        files_deleted += 1
+                if r.sha256:
+                    jpg, png = _thumb_path(root, r.sha256)
+                    if _delete_file(jpg):
+                        thumbs_deleted += 1
+                    if _delete_file(png):
+                        thumbs_deleted += 1
+
+            await db.execute(
+                delete(ImageRecord).where(ImageRecord.id.in_(ids))
+            )
+            await db.commit()
+
+        images_deleted += len(ids)
+
+        if dry_run:
+            # Nothing was actually deleted from the DB; bail after one
+            # pass so we don't loop forever.
+            break
+
+    import_tasks_deleted = 0
+    if source_path_prefix and not dry_run:
+        # Delete ImportTask rows whose source_path is under the bad mount
+        # prefix. These are mostly orphaned now (result_image_id was set
+        # NULL by CASCADE) but their presence still blocks the
+        # idempotency check in scan_directory if the operator remounts
+        # the same prefix.
+        like_pattern = source_path_prefix.rstrip("/") + "/%"
+        result = await db.execute(
+            delete(ImportTask).where(ImportTask.source_path.like(like_pattern))
+        )
+        import_tasks_deleted = result.rowcount or 0
+        await db.commit()
+
+    # Sweep ImportBatch rows that are now empty.
+    empty_batches_deleted = 0
+    if not dry_run:
+        empty_batch_ids = (await db.execute(
+            select(ImportBatch.id).where(
+                ~select(ImportTask.id)
+                .where(ImportTask.batch_id == ImportBatch.id)
+                .exists()
+            )
+        )).scalars().all()
+        if empty_batch_ids:
+            result = await db.execute(
+                delete(ImportBatch).where(ImportBatch.id.in_(empty_batch_ids))
+            )
+            empty_batches_deleted = result.rowcount or 0
+            await db.commit()
+
+    # Finally, the artist row.
+    if not dry_run:
+        await db.execute(delete(Artist).where(Artist.id == artist_id))
+        await db.commit()
+
+    return {
+        "counts": counts,
+        "artist": {"id": artist_id, "name": artist_name, "slug": slug},
+        "summary": {
+            "images_targeted": total_images,
+            "images_deleted": images_deleted,
+            "files_deleted": files_deleted,
+            "thumbs_deleted": thumbs_deleted,
+            "import_tasks_deleted": import_tasks_deleted,
+            "empty_batches_deleted": empty_batches_deleted,
+            "dry_run": dry_run,
+        },
+    }

backend/app/services/migrators/ir_ingest.py

@@ -70,7 +70,7 @@ async def migrate_async(
     """
     if data.get("source_app") != "imagerepo":
         raise ValueError("export source_app must be 'imagerepo'")
-    if data.get("schema_version") != 1:
+    if data.get("schema_version") not in (1, 2):
         raise ValueError(f"unsupported schema_version: {data.get('schema_version')}")
 
     counts = _zero_counts()
@@ -126,15 +126,20 @@ async def migrate_async(
         await db.commit()
 
     # Phase 2: write the per-image manifest for tag_apply.py to consume later.
+    # schema_version 2 (added 2026-05-24) carries `image_posts` for
+    # Post + Source + ImageProvenance restore; schema 1 manifests
+    # without it stay valid (tag_apply treats the missing field as []).
     manifest = {
-        "schema_version": 1,
+        "schema_version": data.get("schema_version", 1),
         "image_artist_assignments": data.get("image_artist_assignments", []),
         "image_tag_associations": data.get("image_tag_associations", []),
         "series_pages": data.get("series_pages", []),
+        "image_posts": data.get("image_posts", []),
     }
     counts["rows_processed"] += len(manifest["image_artist_assignments"])
     counts["rows_processed"] += len(manifest["image_tag_associations"])
     counts["rows_processed"] += len(manifest["series_pages"])
+    counts["rows_processed"] += len(manifest["image_posts"])
     if not dry_run:
         manifest_path(images_root).write_text(json.dumps(manifest, indent=2))
 

backend/app/services/migrators/rollback.py

@@ -1,21 +0,0 @@
-"""Restore from the most recent 'pre_migration'-tagged backup."""
-from __future__ import annotations
-
-from pathlib import Path
-
-from . import backup as backup_mod
-
-
-class NoBackupFoundError(Exception):
-    """Raised when rollback() is called with no pre_migration backup on disk."""
-
-
-def rollback_to_pre_migration(*, db_url: str, images_root: Path) -> dict:
-    manifest = backup_mod.find_latest_backup(images_root, tag="pre_migration")
-    if manifest is None:
-        raise NoBackupFoundError(
-            "no pre_migration-tagged backup found under <images_root>/_backups/"
-        )
-    return backup_mod.restore_backup(
-        manifest=manifest, db_url=db_url, images_root=images_root,
-    )

backend/app/services/migrators/tag_apply.py

@@ -7,6 +7,7 @@ FC's filesystem scan over the mounted IR images dir).
 - image_artist_assignments → ImageRecord.artist_id (find_or_create Artist by slug).
 - image_tag_associations  → image_tag insert (idempotent).
 - series_pages            → series_page insert (idempotent on image_id unique).
+- image_posts (schema v2) → Source + Post + ImageProvenance restore.
 
 Unmatched sha256s are logged into the result's `unmatched` list so the
 Celery task can drop them into MigrationRun.metadata for the operator
@@ -15,15 +16,149 @@ to inspect.
 from __future__ import annotations
 
 import json
+from datetime import datetime
 from pathlib import Path
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from ...models import Artist, ImageRecord, SeriesPage, Tag, TagKind, image_tag
+from ...models import (
+    Artist,
+    ImageProvenance,
+    ImageRecord,
+    Post,
+    SeriesPage,
+    Source,
+    Tag,
+    TagKind,
+    image_tag,
+)
 from ...utils.slug import slugify
 from .ir_ingest import manifest_path
 
+# Per-platform artist-profile URL — used as Source.url when restoring
+# IR PostMetadata into FC. Must cover every platform that
+# backend/app/services/extension_service.py:_PLATFORM_PATTERNS
+# recognizes; an entry missing here silently drops ALL PostMetadata for
+# that platform during phase 4 (operator hit this 2026-05-25:
+# DeviantArt + Pixiv posts in the IR migration produced empty
+# ImageProvenance because they fell through this table).
+#
+# Pixiv caveat: the real profile URL takes a numeric user_id
+# (https://www.pixiv.net/users/12345), but IR's PostMetadata.artist
+# stores the display name not the id. We use the slugified name here
+# so we preserve the artist→post→image linkage; the resulting Source.url
+# won't resolve in a browser and the operator may want to manually fix
+# it via Settings → Subscriptions once the migration lands.
+_PLATFORM_PROFILE_URL = {
+    "patreon":       "https://www.patreon.com/{slug}",
+    "subscribestar": "https://www.subscribestar.com/{slug}",
+    "hentaifoundry": "https://www.hentai-foundry.com/user/{slug}",
+    "deviantart":    "https://www.deviantart.com/{slug}",
+    "pixiv":         "https://www.pixiv.net/users/{slug}",
+}
+
+
+def _profile_url(platform: str, artist_slug: str) -> str | None:
+    fmt = _PLATFORM_PROFILE_URL.get(platform)
+    return fmt.format(slug=artist_slug) if fmt else None
+
+
+async def _find_or_create_source(
+    db: AsyncSession, *, artist_id: int, platform: str, url: str, dry_run: bool,
+) -> int | None:
+    existing = (await db.execute(
+        select(Source.id).where(
+            Source.artist_id == artist_id,
+            Source.platform == platform,
+            Source.url == url,
+        )
+    )).scalar_one_or_none()
+    if existing is not None:
+        return existing
+    if dry_run:
+        return None
+    s = Source(artist_id=artist_id, platform=platform, url=url, enabled=False)
+    db.add(s)
+    await db.flush()
+    return s.id
+
+
+async def _find_or_create_post(
+    db: AsyncSession, *,
+    source_id: int, external_post_id: str,
+    title: str | None, description: str | None, post_url: str | None,
+    post_date_iso: str | None, attachment_count: int, dry_run: bool,
+) -> int | None:
+    existing = (await db.execute(
+        select(Post.id).where(
+            Post.source_id == source_id,
+            Post.external_post_id == external_post_id,
+        )
+    )).scalar_one_or_none()
+    if existing is not None:
+        return existing
+    if dry_run:
+        return None
+    post_date = None
+    if post_date_iso:
+        post_date = datetime.fromisoformat(post_date_iso)
+    p = Post(
+        source_id=source_id,
+        external_post_id=external_post_id,
+        post_title=title,
+        description=description,
+        post_url=post_url,
+        post_date=post_date,
+        attachment_count=attachment_count,
+        raw_metadata={"migrated_from": "imagerepo"},
+    )
+    db.add(p)
+    await db.flush()
+    return p.id
+
+
+async def _ensure_provenance(
+    db: AsyncSession, *,
+    image_id: int, post_id: int, source_id: int, dry_run: bool,
+) -> bool:
+    """Returns True if a new ImageProvenance row was inserted.
+
+    Also sets ImageRecord.primary_post_id to this post if the image
+    doesn't already have one — preserves any primary_post_id already
+    assigned at download time by the importer (don't clobber). This is
+    the linkage gallery_service.py uses to surface Post.post_date as
+    the image's effective date for sort/group/jump/neighbor nav.
+    """
+    existing = (await db.execute(
+        select(ImageProvenance.id).where(
+            ImageProvenance.image_record_id == image_id,
+            ImageProvenance.post_id == post_id,
+            ImageProvenance.source_id == source_id,
+        )
+    )).scalar_one_or_none()
+
+    # Whether-or-not the provenance row already exists, ensure the
+    # image's primary_post_id is set so the gallery date-coalesce works.
+    # Idempotent: only writes when currently NULL.
+    if not dry_run:
+        await db.execute(
+            ImageRecord.__table__.update()
+            .where(ImageRecord.id == image_id)
+            .where(ImageRecord.primary_post_id.is_(None))
+            .values(primary_post_id=post_id)
+        )
+
+    if existing is not None:
+        return False
+    if dry_run:
+        return True
+    db.add(ImageProvenance(
+        image_record_id=image_id, post_id=post_id, source_id=source_id,
+    ))
+    await db.flush()
+    return True
+
 
 def _zero_counts() -> dict:
     return {
@@ -167,6 +302,67 @@ async def apply_async(
         ))
         counts["rows_inserted"] += 1
 
+    # 4. Image posts (schema v2) → Source + Post + ImageProvenance.
+    # Restores IR PostMetadata as FC's downloader-track provenance,
+    # so the modal's ProvenancePanel surfaces title/description/
+    # source URL/publish date the same way it does for live
+    # gallery-dl downloads.
+    for entry in manifest.get("image_posts", []):
+        counts["rows_processed"] += 1
+        platform = entry.get("platform")
+        artist_name = entry.get("artist")
+        if not platform or not artist_name:
+            counts["rows_skipped"] += 1
+            continue
+
+        aid = await _ensure_artist_id(db, artist_name, dry_run)
+        if aid is None:
+            counts["rows_skipped"] += 1
+            continue
+
+        url = _profile_url(platform, slugify(artist_name))
+        if url is None:
+            counts["rows_skipped"] += 1
+            continue
+
+        source_id = await _find_or_create_source(
+            db, artist_id=aid, platform=platform, url=url, dry_run=dry_run,
+        )
+        if source_id is None:
+            counts["rows_skipped"] += 1
+            continue
+
+        post_id = await _find_or_create_post(
+            db, source_id=source_id,
+            external_post_id=entry.get("post_id") or "",
+            title=entry.get("title"),
+            description=entry.get("description"),
+            post_url=entry.get("source_url"),
+            post_date_iso=entry.get("published_at"),
+            attachment_count=entry.get("attachment_count") or 0,
+            dry_run=dry_run,
+        )
+        if post_id is None:
+            counts["rows_skipped"] += 1
+            continue
+
+        for sha in entry.get("image_sha256s", []):
+            img_id = await _sha_to_image_id(db, sha)
+            if img_id is None:
+                unmatched.append({
+                    "kind": "post", "sha256": sha,
+                    "post_id": entry.get("post_id"),
+                })
+                continue
+            inserted = await _ensure_provenance(
+                db, image_id=img_id, post_id=post_id,
+                source_id=source_id, dry_run=dry_run,
+            )
+            if inserted:
+                counts["rows_inserted"] += 1
+            else:
+                counts["rows_skipped"] += 1
+
     if not dry_run:
         await db.commit()
     return {"counts": counts, "unmatched": unmatched}

backend/app/services/ml/embedder.py

@@ -34,10 +34,21 @@ class Embedder:
         if self._model is not None:
             return
         import torch
-        from transformers import AutoModel, AutoProcessor
+        from transformers import AutoModel, SiglipImageProcessor
 
         self._torch = torch
-        self._processor = AutoProcessor.from_pretrained(str(self._model_dir))
+        # FC's embedder only does IMAGE inference — never text. AutoProcessor
+        # loads the full processor including SiglipTokenizer, which requires
+        # the sentencepiece library at import time even if we never call it.
+        # SiglipImageProcessor loads ONLY preprocessor_config.json (image
+        # side) and skips the tokenizer config entirely. Operator hit the
+        # ImportError 2026-05-25 once the ml-worker started actually running
+        # tag_and_embed; switching to the image-only loader avoids the
+        # tokenizer dep without adding ~30 MB of unused C++ build to the
+        # lean ml-worker image.
+        self._processor = SiglipImageProcessor.from_pretrained(
+            str(self._model_dir)
+        )
         self._model = AutoModel.from_pretrained(str(self._model_dir))
         self._model.eval()
 

backend/app/services/ml/tagger.py

@@ -4,12 +4,14 @@ CPU-only, single-image at a time. Loaded lazily inside the ml-worker
 process; NOT thread-safe — the ml queue worker must run --concurrency=1
 (set by the FC-1 entrypoint).
 
-Camie's selected_tags.csv columns: tag_id,name,category,count
+v2 layout reference: HuggingFace Camais03/camie-tagger-v2 root has
-where category is a string: general|character|copyright|artist|meta|rating|year
+camie-tagger-v2.onnx (789 MB) + camie-tagger-v2-metadata.json (7.77 MB)
-(unlike WD14's integer Danbooru category ids).
++ config.json. Tags ship as nested JSON, not CSV. Preprocessing and
+output handling follow the published onnx_inference.py reference:
+ImageNet normalize, NCHW layout, sigmoid on refined logits (output[1]).
 """
 
-import csv
+import json
 import os
 from dataclasses import dataclass
 from pathlib import Path
@@ -28,6 +30,8 @@ ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 MODEL_NAME = os.environ.get("CAMIE_MODEL_NAME", "camie-tagger-v2")
 _MODEL_DIR = Path(os.environ.get("ML_MODEL_DIR", "/models")) / "camie"
+_MODEL_FILE = f"{MODEL_NAME}.onnx"
+_METADATA_FILE = f"{MODEL_NAME}-metadata.json"
 
 # Below this confidence, predictions aren't stored (keeps the JSON compact).
 STORE_FLOOR = float(os.environ.get("TAGGER_STORE_FLOOR", "0.05"))
@@ -39,6 +43,12 @@ STORE_FLOOR = float(os.environ.get("TAGGER_STORE_FLOOR", "0.05"))
 # stored at STORE_FLOOR but artist never surfaces.
 SURFACED_CATEGORIES = {"character", "copyright", "general"}
 
+# ImageNet preprocessing constants (per Camie v2 onnx_inference.py).
+_IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+_IMAGENET_STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+# Square-pad color ≈ ImageNet mean × 255 (matches reference inference).
+_PAD_COLOR = (124, 116, 104)
+
 
 @dataclass(frozen=True)
 class TagPrediction:
@@ -51,34 +61,48 @@ class Tagger:
     def __init__(self, model_dir: Path | None = None):
         self._model_dir = model_dir or _MODEL_DIR
         self._session = None  # onnxruntime.InferenceSession once load()ed
-        self._tag_meta: list[dict] | None = None
+        self._tag_names: list[str] | None = None
+        self._tag_categories: list[str] | None = None
         self._input_name: str | None = None
-        self._output_name: str | None = None
+        self._input_size: int = 512
-        self._input_size: int = 448
 
     def load(self) -> None:
         if self._session is not None:
             return
-        model_path = self._model_dir / "model.onnx"
+        model_path = self._model_dir / _MODEL_FILE
-        tags_path = self._model_dir / "selected_tags.csv"
+        meta_path = self._model_dir / _METADATA_FILE
         if not model_path.is_file():
             raise RuntimeError(
-                f"Camie model.onnx missing at {model_path}. "
+                f"Camie {_MODEL_FILE} missing at {model_path}. "
                 f"Populate /models via the ml-worker downloader."
             )
-        if not tags_path.is_file():
+        if not meta_path.is_file():
             raise RuntimeError(
-                f"Camie selected_tags.csv missing at {tags_path}. "
+                f"Camie {_METADATA_FILE} missing at {meta_path}. "
                 f"Populate /models via the ml-worker downloader."
             )
 
-        tag_meta: list[dict] = []
+        with open(meta_path) as f:
-        with open(tags_path, newline="") as f:
+            metadata = json.load(f)
-            reader = csv.DictReader(f)
+
-            for row in reader:
+        # Per Camie v2 onnx_inference.py: idx_to_tag is keyed by str(idx);
-                tag_meta.append(
+        # tag_to_category maps tag_name -> category. Project to two parallel
-                    {"name": row["name"], "category": row["category"]}
+        # lists indexed by output position for O(1) lookup in the hot path.
-                )
+        ds = metadata["dataset_info"]
+        idx_to_tag = ds["tag_mapping"]["idx_to_tag"]
+        tag_to_category = ds["tag_mapping"]["tag_to_category"]
+        total = ds["total_tags"]
+        names: list[str] = []
+        cats: list[str] = []
+        for i in range(total):
+            name = idx_to_tag.get(str(i), f"unknown-{i}")
+            names.append(name)
+            cats.append(tag_to_category.get(name, "general"))
+
+        # Input size from metadata; fall back to 512 (the v2 default).
+        self._input_size = int(
+            metadata.get("model_info", {}).get("img_size", 512)
+        )
 
         # Lazy import — kept after the file-existence checks so the
         # missing-model RuntimeError still fires first in environments
@@ -89,51 +113,65 @@ class Tagger:
             str(model_path), providers=["CPUExecutionProvider"]
         )
         self._input_name = session.get_inputs()[0].name
-        self._output_name = session.get_outputs()[0].name
-        input_shape = session.get_inputs()[0].shape
-        for dim in input_shape:
-            if isinstance(dim, int) and dim > 1:
-                self._input_size = dim
-                break
         # Assign sentinels last so a partial load isn't observable.
-        self._tag_meta = tag_meta
+        self._tag_names = names
+        self._tag_categories = cats
         self._session = session
 
     def _preprocess(self, image_path: Path) -> np.ndarray:
         img = Image.open(image_path)
-        # Camie handles RGBA natively but we still composite onto white so
+        # Composite RGBA onto neutral so transparency doesn't bias the model.
-        # transparency doesn't bias the model (same as IR's WD14 path).
+        if img.mode == "RGBA":
-        if img.mode != "RGBA":
+            bg = Image.new("RGBA", img.size, (255, 255, 255, 255))
-            img = img.convert("RGBA")
+            bg.paste(img, mask=img.split()[3])
-        bg = Image.new("RGBA", img.size, (255, 255, 255, 255))
+            img = bg.convert("RGB")
-        bg.paste(img, mask=img.split()[3])
+        elif img.mode != "RGB":
-        img = bg.convert("RGB")
+            img = img.convert("RGB")
 
+        # Pad to square with ImageNet-mean color, then bicubic resize.
         w, h = img.size
         side = max(w, h)
-        square = Image.new("RGB", (side, side), (255, 255, 255))
+        square = Image.new("RGB", (side, side), _PAD_COLOR)
         square.paste(img, ((side - w) // 2, (side - h) // 2))
         square = square.resize(
             (self._input_size, self._input_size), Image.BICUBIC
         )
-        arr = np.array(square, dtype=np.float32)
+
-        return arr[np.newaxis, :, :, :]  # NHWC
+        arr = np.array(square, dtype=np.float32) / 255.0   # HWC, [0,1]
+        arr = (arr - _IMAGENET_MEAN) / _IMAGENET_STD        # ImageNet normalize
+        arr = arr.transpose(2, 0, 1)                        # HWC -> CHW
+        return arr[np.newaxis, :, :, :]                     # NCHW
 
     def infer(self, image_path: Path) -> dict[str, TagPrediction]:
-        """Run Camie on one image. Returns {name: TagPrediction}, only
+        """Run Camie v2 on one image. Returns {name: TagPrediction} with
-        entries with confidence >= STORE_FLOOR (across all categories —
+        confidence >= STORE_FLOOR (across all categories — the suggestion
-        the suggestion service does category filtering later)."""
+        service does category filtering later).
+
+        v2 emits multiple outputs; we use the refined predictions
+        (output[1] per onnx_inference.py). Sigmoid is applied to raw
+        logits to produce [0,1] confidence scores.
+        """
         self.load()
         x = self._preprocess(image_path)
-        out = self._session.run([self._output_name], {self._input_name: x})[0][0]
+        outputs = self._session.run(None, {self._input_name: x})
+        # Refined predictions if present (v2 emits initial + refined),
+        # fall back to initial for single-output forks.
+        logits = outputs[1] if len(outputs) > 1 else outputs[0]
+        # Squeeze batch dim, apply sigmoid.
+        probs = 1.0 / (1.0 + np.exp(-logits[0]))
         results: dict[str, TagPrediction] = {}
-        for idx, score in enumerate(out):
+        names = self._tag_names
+        cats = self._tag_categories
+        for idx, score in enumerate(probs):
             conf = float(score)
             if conf < STORE_FLOOR:
                 continue
-            meta = self._tag_meta[idx]
+            if idx >= len(names):
-            results[meta["name"]] = TagPrediction(
+                # Output longer than metadata declared — shouldn't happen but
-                name=meta["name"], category=meta["category"], confidence=conf
+                # don't crash the import pipeline if v2 metadata desynchronizes.
+                continue
+            results[names[idx]] = TagPrediction(
+                name=names[idx], category=cats[idx], confidence=conf
             )
         return results
 

backend/app/tasks/_sync_engine.py

@@ -0,0 +1,36 @@
+"""Process-level sync engine for Celery task modules.
+
+Each task module used to call ``create_engine(...)`` on every invocation,
+which leaked engines (and Postgres connections) — high-fire-rate tasks
+like ``import_media_file`` would exhaust ``max_connections`` within
+minutes during a bulk migration.
+
+This module owns one engine per process. Celery prefork forks before any
+task runs, so each worker process lazily initializes its own engine on
+the first task and reuses it for the rest of its life.
+"""
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from ..config import get_config
+
+_ENGINE = None
+_SESSIONMAKER = None
+
+
+def sync_session_factory():
+    """Return a process-wide ``sessionmaker`` bound to a single engine."""
+    global _ENGINE, _SESSIONMAKER
+    if _SESSIONMAKER is None:
+        cfg = get_config()
+        _ENGINE = create_engine(
+            cfg.database_url_sync,
+            future=True,
+            pool_pre_ping=True,
+            pool_size=5,
+            max_overflow=5,
+            pool_recycle=300,
+        )
+        _SESSIONMAKER = sessionmaker(_ENGINE, expire_on_commit=False)
+    return _SESSIONMAKER

backend/app/tasks/admin.py

@@ -0,0 +1,57 @@
+"""FC-3k: admin destructive Celery tasks.
+
+Two long-running ops on the maintenance queue. task_run lifecycle is
+captured automatically by FC-3i signals — these tasks just return
+their summary dict so it lands in task_run.metadata (via Celery's
+result backend) for the dashboard to surface.
+
+Soft/hard time limits inherit the FC-3i recovery sweep: a runaway
+task gets killed and flipped to status='timeout' by
+recover_stalled_task_runs.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from sqlalchemy.exc import DBAPIError, OperationalError
+
+from ..celery_app import celery
+from ..services import cleanup_service
+from ._sync_engine import sync_session_factory as _sync_session_factory
+
+log = logging.getLogger(__name__)
+IMAGES_ROOT = Path("/images")
+
+
+@celery.task(
+    name="backend.app.tasks.admin.delete_artist_cascade_task",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError),
+    retry_backoff=15, retry_backoff_max=180, max_retries=1,
+    soft_time_limit=1800, time_limit=2400,  # 30 min / 40 min
+)
+def delete_artist_cascade_task(self, *, artist_id: int) -> dict:
+    """Wraps cleanup_service.delete_artist_cascade. Returns the
+    service's summary dict for FC-3i task_run.metadata capture."""
+    SessionLocal = _sync_session_factory()
+    with SessionLocal() as session:
+        return cleanup_service.delete_artist_cascade(
+            session, artist_id=artist_id, images_root=IMAGES_ROOT,
+        )
+
+
+@celery.task(
+    name="backend.app.tasks.admin.bulk_delete_images_task",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError),
+    retry_backoff=15, retry_backoff_max=180, max_retries=1,
+    soft_time_limit=900, time_limit=1200,  # 15 min / 20 min
+)
+def bulk_delete_images_task(self, *, image_ids: list[int]) -> dict:
+    """Wraps cleanup_service.delete_images."""
+    SessionLocal = _sync_session_factory()
+    with SessionLocal() as session:
+        return cleanup_service.delete_images(
+            session, image_ids=image_ids, images_root=IMAGES_ROOT,
+        )

backend/app/tasks/backup.py

@@ -0,0 +1,300 @@
+"""FC-3h: backup/restore Celery tasks.
+
+All tasks live on the maintenance queue (per celery_app.task_routes).
+task_run lifecycle tracking is automatic via FC-3i signals — these
+tasks just record the operator-facing artifact metadata into
+BackupRun.
+"""
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+
+from celery.exceptions import SoftTimeLimitExceeded
+from sqlalchemy import select
+from sqlalchemy.exc import DBAPIError, OperationalError
+
+from ..celery_app import celery
+from ..config import get_config
+from ..models import BackupRun, ImportSettings
+from ..services import backup_service
+from ._sync_engine import sync_session_factory as _sync_session_factory
+
+log = logging.getLogger(__name__)
+IMAGES_ROOT = Path("/images")
+
+
+def _mark_failed(session, row: BackupRun, exc: BaseException) -> None:
+    """Flip a BackupRun row from running/restoring to error with a
+    truncated error message and finished_at. Caller already holds the
+    session open."""
+    row.status = "error"
+    row.error = f"{type(exc).__name__}: {exc}"[:2000]
+    row.finished_at = datetime.now(UTC)
+    session.add(row)
+    session.commit()
+
+
+@celery.task(
+    name="backend.app.tasks.backup.backup_db_task",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError),
+    retry_backoff=10, retry_backoff_max=120, max_retries=2,
+    soft_time_limit=600, time_limit=720,
+)
+def backup_db_task(self, *, tag: str | None = None,
+                   triggered_by: str = "manual") -> dict:
+    """Create one DB backup. Returns {'backup_run_id': N}."""
+    SessionLocal = _sync_session_factory()
+    cfg = get_config()
+    now = datetime.now(UTC)
+    with SessionLocal() as session:
+        row = BackupRun(
+            kind="db", status="running", tag=tag,
+            triggered_by=triggered_by, started_at=now, manifest={},
+        )
+        session.add(row)
+        session.commit()
+        session.refresh(row)
+        run_id = row.id
+
+    try:
+        result = backup_service.backup_db(
+            db_url=cfg.database_url_sync, images_root=IMAGES_ROOT,
+            tag=tag, triggered_by=triggered_by,
+        )
+    except (SoftTimeLimitExceeded, Exception) as exc:
+        with SessionLocal() as session:
+            row = session.get(BackupRun, run_id)
+            if row is not None:
+                _mark_failed(session, row, exc)
+        raise
+
+    with SessionLocal() as session:
+        row = session.get(BackupRun, run_id)
+        row.status = "ok"
+        row.finished_at = datetime.now(UTC)
+        row.sql_path = result["sql_path"]
+        row.size_bytes = result["size_bytes"]
+        row.manifest = {
+            "manifest_path": result["manifest_path"],
+            "ts": result["ts"],
+        }
+        session.commit()
+    return {"backup_run_id": run_id}
+
+
+@celery.task(
+    name="backend.app.tasks.backup.backup_images_task",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError),
+    retry_backoff=30, retry_backoff_max=300, max_retries=1,
+    soft_time_limit=21600, time_limit=23400,
+)
+def backup_images_task(self, *, tag: str | None = None,
+                       triggered_by: str = "manual") -> dict:
+    """Create one images backup. Same shape as backup_db_task; uses
+    tar_path instead of sql_path."""
+    SessionLocal = _sync_session_factory()
+    now = datetime.now(UTC)
+    with SessionLocal() as session:
+        row = BackupRun(
+            kind="images", status="running", tag=tag,
+            triggered_by=triggered_by, started_at=now, manifest={},
+        )
+        session.add(row)
+        session.commit()
+        session.refresh(row)
+        run_id = row.id
+
+    try:
+        result = backup_service.backup_images(
+            images_root=IMAGES_ROOT,
+            tag=tag, triggered_by=triggered_by,
+        )
+    except (SoftTimeLimitExceeded, Exception) as exc:
+        with SessionLocal() as session:
+            row = session.get(BackupRun, run_id)
+            if row is not None:
+                _mark_failed(session, row, exc)
+        raise
+
+    with SessionLocal() as session:
+        row = session.get(BackupRun, run_id)
+        row.status = "ok"
+        row.finished_at = datetime.now(UTC)
+        row.tar_path = result["tar_path"]
+        row.size_bytes = result["size_bytes"]
+        row.manifest = {
+            "manifest_path": result["manifest_path"],
+            "ts": result["ts"],
+        }
+        session.commit()
+    return {"backup_run_id": run_id}
+
+
+@celery.task(
+    name="backend.app.tasks.backup.restore_db_task",
+    bind=True,
+    max_retries=0,  # NEVER auto-retry a half-applied restore.
+    soft_time_limit=1200, time_limit=1800,
+)
+def restore_db_task(self, *, source_backup_run_id: int) -> dict:
+    """Restore from a previous DB backup. Inserts a NEW BackupRun row
+    (kind='db', status='restoring') linked to the source via
+    restored_from_id; flips to 'restored' on success or 'error' on
+    failure. Operator sees the restore as a row in the dashboard."""
+    SessionLocal = _sync_session_factory()
+    cfg = get_config()
+    now = datetime.now(UTC)
+    with SessionLocal() as session:
+        src = session.get(BackupRun, source_backup_run_id)
+        if src is None or src.kind != "db" or not src.sql_path:
+            raise ValueError(
+                f"BackupRun id={source_backup_run_id} is not a valid DB backup"
+            )
+        marker = BackupRun(
+            kind="db", status="restoring",
+            triggered_by="restore", started_at=now,
+            restored_from_id=src.id,
+            manifest={"source_sql_path": src.sql_path},
+        )
+        session.add(marker)
+        session.commit()
+        session.refresh(marker)
+        marker_id = marker.id
+        sql_path = src.sql_path
+
+    try:
+        backup_service.restore_db(
+            db_url=cfg.database_url_sync, sql_path=Path(sql_path),
+        )
+    except (SoftTimeLimitExceeded, Exception) as exc:
+        with SessionLocal() as session:
+            row = session.get(BackupRun, marker_id)
+            if row is not None:
+                _mark_failed(session, row, exc)
+        raise
+
+    with SessionLocal() as session:
+        row = session.get(BackupRun, marker_id)
+        row.status = "restored"
+        row.finished_at = datetime.now(UTC)
+        session.commit()
+    return {"backup_run_id": marker_id}
+
+
+@celery.task(
+    name="backend.app.tasks.backup.restore_images_task",
+    bind=True, max_retries=0,
+    soft_time_limit=21600, time_limit=23400,
+)
+def restore_images_task(self, *, source_backup_run_id: int) -> dict:
+    """Mirrors restore_db_task; uses backup_service.restore_images."""
+    SessionLocal = _sync_session_factory()
+    now = datetime.now(UTC)
+    with SessionLocal() as session:
+        src = session.get(BackupRun, source_backup_run_id)
+        if src is None or src.kind != "images" or not src.tar_path:
+            raise ValueError(
+                f"BackupRun id={source_backup_run_id} is not a valid images backup"
+            )
+        marker = BackupRun(
+            kind="images", status="restoring",
+            triggered_by="restore", started_at=now,
+            restored_from_id=src.id,
+            manifest={"source_tar_path": src.tar_path},
+        )
+        session.add(marker)
+        session.commit()
+        session.refresh(marker)
+        marker_id = marker.id
+        tar_path = src.tar_path
+
+    try:
+        backup_service.restore_images(
+            images_root=IMAGES_ROOT, tar_path=Path(tar_path),
+        )
+    except (SoftTimeLimitExceeded, Exception) as exc:
+        with SessionLocal() as session:
+            row = session.get(BackupRun, marker_id)
+            if row is not None:
+                _mark_failed(session, row, exc)
+        raise
+
+    with SessionLocal() as session:
+        row = session.get(BackupRun, marker_id)
+        row.status = "restored"
+        row.finished_at = datetime.now(UTC)
+        session.commit()
+    return {"backup_run_id": marker_id}
+
+
+@celery.task(
+    name="backend.app.tasks.backup.prune_backups",
+    soft_time_limit=300, time_limit=600,
+)
+def prune_backups() -> dict:
+    """Daily Beat. Per-kind retention from ImportSettings.
+
+    Returns {"db_deleted": N, "images_deleted": M, "files_unlinked": K}.
+    Tagged rows (tag IS NOT NULL) are never pruned.
+    Status='running' / 'restoring' rows are never pruned (recovery
+    sweep from FC-3i handles those via task_run).
+    """
+    SessionLocal = _sync_session_factory()
+    counts = {"db_deleted": 0, "images_deleted": 0, "files_unlinked": 0}
+    with SessionLocal() as session:
+        s = session.execute(
+            select(ImportSettings).where(ImportSettings.id == 1)
+        ).scalar_one()
+        for kind, keep in (
+            ("db", s.backup_db_keep_last_n),
+            ("images", s.backup_images_keep_last_n),
+        ):
+            candidates = session.execute(
+                select(BackupRun)
+                .where(BackupRun.kind == kind)
+                .where(BackupRun.tag.is_(None))
+                .where(BackupRun.status.in_(["ok", "error"]))
+                .order_by(BackupRun.started_at.desc())
+                .offset(keep)
+            ).scalars().all()
+            for row in candidates:
+                result = backup_service.unlink_artifact_files(
+                    sql_path=row.sql_path,
+                    tar_path=row.tar_path,
+                    manifest_path=(row.manifest or {}).get("manifest_path"),
+                )
+                counts["files_unlinked"] += sum(
+                    1 for v in result.values() if v
+                )
+                session.delete(row)
+                counts[f"{kind}_deleted"] += 1
+        session.commit()
+    return counts
+
+
+@celery.task(
+    name="backend.app.tasks.backup.backup_db_nightly",
+    soft_time_limit=60, time_limit=120,
+)
+def backup_db_nightly() -> dict:
+    """Hourly tick. Dispatches a real backup ONLY if the configured
+    UTC hour matches and the nightly setting is enabled. Returns
+    either {'skipped': '<reason>'} or {'dispatched': '<task_id>'}."""
+    SessionLocal = _sync_session_factory()
+    with SessionLocal() as session:
+        s = session.execute(
+            select(ImportSettings).where(ImportSettings.id == 1)
+        ).scalar_one()
+        nightly_enabled = s.backup_db_nightly_enabled
+        configured_hour = s.backup_db_nightly_hour_utc
+    if not nightly_enabled:
+        return {"skipped": "nightly disabled"}
+    now_hour = datetime.now(UTC).hour
+    if now_hour != configured_hour:
+        return {"skipped": f"hour={now_hour} != configured={configured_hour}"}
+    res = backup_db_task.delay(triggered_by="nightly")
+    return {"dispatched": res.id}

backend/app/tasks/download.py

@@ -4,6 +4,7 @@ import asyncio
 from pathlib import Path
 
 from sqlalchemy import select
+from sqlalchemy.exc import DBAPIError, OperationalError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
 from ..celery_app import celery
@@ -27,7 +28,18 @@ def _async_session_factory():
     return async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False), engine
 
 
-@celery.task(name="backend.app.tasks.download.download_source", bind=True, acks_late=True)
+@celery.task(
+    name="backend.app.tasks.download.download_source",
+    bind=True,
+    acks_late=True,
+    autoretry_for=(OperationalError, DBAPIError, OSError),
+    retry_backoff=10,
+    retry_backoff_max=120,
+    retry_jitter=True,
+    max_retries=3,
+    soft_time_limit=900,
+    time_limit=1200,
+)
 def download_source(self, source_id: int) -> int:
     """Returns the DownloadEvent.id."""
 

backend/app/tasks/import_file.py

@@ -1,25 +1,27 @@
 """import_media_file task: imports one file via the Importer service and
 updates the ImportTask state machine + ImportBatch counters atomically.
+
+Resilience contract (2026-05-24, operator-mandated): once a row has been
+flipped to 'processing' inside this task, EVERY exit path MUST flip it
+to a terminal state (complete / skipped / failed) or rely on Celery's
+autoretry to attempt the work again. No exit path is allowed to leave
+the row stuck in 'processing'. The `recover_interrupted_tasks`
+maintenance sweep is the safety net (5 min threshold) for the case
+where even the failure-marking commit can't be written.
 """
 
 from datetime import UTC, datetime
 from pathlib import Path
 
-from sqlalchemy import create_engine, select, update
+from celery.exceptions import SoftTimeLimitExceeded
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy import select, update
+from sqlalchemy.exc import DBAPIError, OperationalError
 
 from ..celery_app import celery
-from ..config import get_config
 from ..models import ImportBatch, ImportSettings, ImportTask
 from ..services.importer import Importer
 from ..services.thumbnailer import Thumbnailer
-
+from ._sync_engine import sync_session_factory as _sync_session_factory
-
-def _sync_session_factory():
-    cfg = get_config()
-    engine = create_engine(cfg.database_url_sync, future=True, pool_pre_ping=True)
-    return sessionmaker(engine, expire_on_commit=False)
-
 
 IMAGES_ROOT = Path("/images")
 
@@ -27,19 +29,66 @@ IMAGES_ROOT = Path("/images")
 def _map_result_to_status(result):
     """(ImportTask.status, should_requeue_ml_and_thumb) for an ImportResult.
     'superseded' = the kept row's file/ML changed → complete + re-derive.
-    'attached' = a non-art file preserved → complete, no ML/thumb."""
+    'attached' = a non-art file preserved → complete, no ML/thumb.
+    'refreshed' = deep scan refreshed sidecar/phash on an existing row →
+    complete, no ML/thumb re-derive (file/pixels unchanged)."""
     if result.status in ("imported", "superseded"):
         return ("complete", True)
-    if result.status == "attached":
+    if result.status in ("attached", "refreshed"):
         return ("complete", False)
     if result.status == "skipped":
         return ("skipped", False)
     return ("failed", False)
 
 
-@celery.task(name="backend.app.tasks.import_file.import_media_file", bind=True)
+def _mark_failed(session, task, error_msg: str) -> None:
+    """Best-effort flip of a 'processing' row to 'failed' + batch counter
+    increment. Wrapped in its own try because if the DB is what just
+    broke, this commit will also fail — that's why the maintenance sweep
+    exists as a backstop."""
+    try:
+        task.status = "failed"
+        task.error = error_msg
+        task.finished_at = datetime.now(UTC)
+        session.add(task)
+        session.execute(
+            update(ImportBatch)
+            .where(ImportBatch.id == task.batch_id)
+            .values(failed=ImportBatch.failed + 1)
+        )
+        session.commit()
+    except Exception:  # noqa: BLE001 — best-effort, sweep catches the rest
+        try:
+            session.rollback()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+@celery.task(
+    name="backend.app.tasks.import_file.import_media_file",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError, OSError),
+    retry_backoff=5,
+    retry_backoff_max=60,
+    retry_jitter=True,
+    max_retries=3,
+    soft_time_limit=300,
+    time_limit=360,
+)
 def import_media_file(self, import_task_id: int) -> dict:
-    """Returns a dict so the eager-mode tests can assert without DB."""
+    """Returns a dict so the eager-mode tests can assert without DB.
+
+    Decorator notes:
+      - autoretry_for: transient DB / filesystem errors retry with
+        exponential backoff (5s base, jitter, max 3 attempts). On final
+        give-up the task raises and acks_late=True (set globally on the
+        Celery app) does NOT redeliver — the recovery sweep catches the
+        row instead.
+      - soft_time_limit (300s) raises SoftTimeLimitExceeded in this
+        process so the task can mark its row failed before being killed.
+      - time_limit (360s) is the hard cap; SIGKILL if the soft signal
+        was swallowed.
+    """
     SessionLocal = _sync_session_factory()
     with SessionLocal() as session:
         task = session.get(ImportTask, import_task_id)
@@ -51,99 +100,113 @@ def import_media_file(self, import_task_id: int) -> dict:
         session.add(task)
         session.commit()
 
-        settings = session.execute(
-            select(ImportSettings).where(ImportSettings.id == 1)
-        ).scalar_one()
-        import_root = Path(settings.import_scan_path)
-        batch = session.get(ImportBatch, task.batch_id)
-        deep = bool(batch and batch.scan_mode == "deep")
-        importer = Importer(
-            session=session,
-            images_root=IMAGES_ROOT,
-            import_root=import_root,
-            thumbnailer=Thumbnailer(images_root=IMAGES_ROOT),
-            settings=settings,
-            deep=deep,
-        )
-
         try:
-            result = importer.import_one(Path(task.source_path))
+            return _do_import(session, task, import_task_id)
-        except Exception as exc:  # pragma: no cover — pipeline crash
+        except SoftTimeLimitExceeded:
-            task.status = "failed"
+            _mark_failed(session, task, "soft_time_limit exceeded (>300s)")
-            task.error = f"{type(exc).__name__}: {exc}"
+            raise
-            task.finished_at = datetime.now(UTC)
+        except (OperationalError, DBAPIError, OSError):
-            session.execute(
+            # Retryable per the decorator; do NOT mark failed (let
-                update(ImportBatch)
+            # autoretry have a clean go at it). If autoretry exhausts,
-                .where(ImportBatch.id == task.batch_id)
+            # the row stays 'processing' and the maintenance sweep
-                .values(failed=ImportBatch.failed + 1)
+            # flips it within 5 min.
-            )
+            raise
-            session.add(task)
+        except Exception as exc:  # noqa: BLE001 — pipeline crash, mark + re-raise
-            session.commit()
+            _mark_failed(session, task, f"{type(exc).__name__}: {exc}")
             raise
 
-        if result.status in ("imported", "superseded"):
-            task.status = "complete"
-            task.result_image_id = result.image_id
-            counter_col_name = "imported"
-            counter_col = ImportBatch.imported
-        elif result.status == "attached":
-            task.status = "complete"
-            counter_col_name = "attachments"
-            counter_col = ImportBatch.attachments
-        elif result.status == "skipped":
-            task.status = "skipped"
-            task.error = (
-                f"{result.skip_reason.value}: {result.error}"
-                if result.skip_reason
-                else result.error
-            )
-            task.result_image_id = result.image_id
-            counter_col_name = "skipped"
-            counter_col = ImportBatch.skipped
-        else:
-            task.status = "failed"
-            task.error = result.error
-            counter_col_name = "failed"
-            counter_col = ImportBatch.failed
 
-        task.finished_at = datetime.now(UTC)
+def _do_import(session, task, import_task_id: int) -> dict:
+    """Actual work, called from inside the resilience wrapper."""
+    settings = session.execute(
+        select(ImportSettings).where(ImportSettings.id == 1)
+    ).scalar_one()
+    import_root = Path(settings.import_scan_path)
+    batch = session.get(ImportBatch, task.batch_id)
+    deep = bool(batch and batch.scan_mode == "deep")
+    importer = Importer(
+        session=session,
+        images_root=IMAGES_ROOT,
+        import_root=import_root,
+        thumbnailer=Thumbnailer(images_root=IMAGES_ROOT),
+        settings=settings,
+        deep=deep,
+    )
+
+    result = importer.import_one(Path(task.source_path))
+
+    if result.status in ("imported", "superseded"):
+        task.status = "complete"
+        task.result_image_id = result.image_id
+        counter_col_name = "imported"
+        counter_col = ImportBatch.imported
+    elif result.status == "refreshed":
+        # Deep-scan rederive: existing row got phash/artist/sidecar
+        # refreshed. Task is complete (no further work), but counted in
+        # `refreshed` not `imported` so the UI can surface the actual
+        # work done. operator-flagged 2026-05-25.
+        task.status = "complete"
+        task.result_image_id = result.image_id
+        counter_col_name = "refreshed"
+        counter_col = ImportBatch.refreshed
+    elif result.status == "attached":
+        task.status = "complete"
+        counter_col_name = "attachments"
+        counter_col = ImportBatch.attachments
+    elif result.status == "skipped":
+        task.status = "skipped"
+        task.error = (
+            f"{result.skip_reason.value}: {result.error}"
+            if result.skip_reason
+            else result.error
+        )
+        task.result_image_id = result.image_id
+        counter_col_name = "skipped"
+        counter_col = ImportBatch.skipped
+    else:
+        task.status = "failed"
+        task.error = result.error
+        counter_col_name = "failed"
+        counter_col = ImportBatch.failed
+
+    task.finished_at = datetime.now(UTC)
+    session.execute(
+        update(ImportBatch)
+        .where(ImportBatch.id == task.batch_id)
+        .values({counter_col_name: counter_col + 1})
+    )
+    session.add(task)
+    session.commit()
+
+    # Enqueue thumbnail + ML for newly imported AND superseded images
+    # (a superseded row has cleared ML + no thumbnail).
+    if result.status in ("imported", "superseded"):
+        from .ml import tag_and_embed
+        from .thumbnail import generate_thumbnail
+
+        ids = list(result.member_image_ids)
+        if result.image_id is not None and result.image_id not in ids:
+            ids.append(result.image_id)
+        for img_id in ids:
+            generate_thumbnail.delay(img_id)
+            tag_and_embed.delay(img_id)
+
+    # If this was the last task in the batch, mark the batch complete.
+    remaining = session.execute(
+        select(ImportTask.id)
+        .where(ImportTask.batch_id == task.batch_id)
+        .where(ImportTask.status.in_(["pending", "queued", "processing"]))
+        .limit(1)
+    ).scalar_one_or_none()
+    if remaining is None:
         session.execute(
             update(ImportBatch)
             .where(ImportBatch.id == task.batch_id)
-            .values({counter_col_name: counter_col + 1})
+            .values(
+                status="complete",
+                finished_at=datetime.now(UTC),
+            )
         )
-        session.add(task)
         session.commit()
 
-        # Enqueue thumbnail + ML for newly imported AND superseded images
+    return {"task_id": import_task_id, "status": task.status}
-        # (a superseded row has cleared ML + no thumbnail).
-        if result.status in ("imported", "superseded"):
-            from .ml import tag_and_embed
-            from .thumbnail import generate_thumbnail
-
-            ids = list(result.member_image_ids)
-            if result.image_id is not None and result.image_id not in ids:
-                ids.append(result.image_id)
-            for img_id in ids:
-                generate_thumbnail.delay(img_id)
-                tag_and_embed.delay(img_id)
-
-        # If this was the last task in the batch, mark the batch complete.
-        remaining = session.execute(
-            select(ImportTask.id)
-            .where(ImportTask.batch_id == task.batch_id)
-            .where(ImportTask.status.in_(["pending", "queued", "processing"]))
-            .limit(1)
-        ).scalar_one_or_none()
-        if remaining is None:
-            session.execute(
-                update(ImportBatch)
-                .where(ImportBatch.id == task.batch_id)
-                .values(
-                    status="complete",
-                    finished_at=datetime.now(UTC),
-                )
-            )
-            session.commit()
-
-        return {"task_id": import_task_id, "status": task.status}

backend/app/tasks/maintenance.py

@@ -6,61 +6,98 @@ from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
 from PIL import Image
-from sqlalchemy import create_engine, delete, select, update
+from sqlalchemy import delete, select, update
-from sqlalchemy.orm import sessionmaker
 
 from ..celery_app import celery
-from ..config import get_config
+from ..models import DownloadEvent, ImageRecord, ImportSettings, ImportTask, TaskRun
-from ..models import DownloadEvent, ImageRecord, ImportSettings, ImportTask
 from ..utils.phash import compute_phash
+from ._sync_engine import sync_session_factory as _sync_session_factory
 
 log = logging.getLogger(__name__)
 
-STUCK_THRESHOLD_MINUTES = 30
+STUCK_THRESHOLD_MINUTES = 5
+ORPHAN_PENDING_THRESHOLD_MINUTES = 30
 OLD_TASK_DAYS = 7
 PHASH_PAGE = 500
 VERIFY_PAGE = 200
 FFPROBE_TIMEOUT_SECONDS = 10
-
+TASK_RUN_KEEP_OK_SECONDS = 24 * 3600       # 24 h
-
+TASK_RUN_KEEP_FAILURE_SECONDS = 7 * 24 * 3600  # 7 days
-def _sync_session_factory():
-    cfg = get_config()
-    engine = create_engine(cfg.database_url_sync, future=True, pool_pre_ping=True)
-    return sessionmaker(engine, expire_on_commit=False)
 
 
 @celery.task(name="backend.app.tasks.maintenance.recover_interrupted_tasks")
 def recover_interrupted_tasks() -> int:
-    """Find ImportTask rows stuck in 'processing' for >30 min and re-queue them.
+    """Recover stuck ImportTask rows. Two distinct stuck states:
 
-    Why 30 min: large videos can legitimately take many minutes to import;
+    1. 'processing' > 5 min — worker crash mid-import. Re-queue via
-    30 is a safe gate that catches actual crashes (which leave the row stuck
+       .delay() and let the import retry. Was 30 min historically;
-    forever) without resetting slow-but-still-running jobs.
+       tightened 2026-05-24 after operator hit a 2224-row zombie pile.
+       import_media_file is sub-second for the vast majority of files and
+       capped at the per-task soft_time_limit (5 min), so anything still
+       'processing' after that window is a confirmed crash.
+
+    2. 'pending' or 'queued' > 30 min — enqueue-phase crash. scan_directory
+       creates rows with status='pending' (commit), then in a second pass
+       transitions to 'queued' and calls .delay() (commit). If the scanner
+       crashes between those two commits, rows are orphaned in 'pending'
+       (never enqueued) with no recovery path — invisible to the
+       'processing' sweep above. Flagged 2026-05-25 by operator hitting a
+       5490-row orphan pile. Flip these to 'failed' (not re-enqueue) so
+       the operator drains them via /api/import/retry-failed at their own
+       pace; bulk-re-enqueueing 5000+ rows would thundering-herd the
+       import worker.
+
+    Returns total rows touched (recovered + marked failed).
     """
     SessionLocal = _sync_session_factory()
-    cutoff = datetime.now(UTC) - timedelta(minutes=STUCK_THRESHOLD_MINUTES)
+    now = datetime.now(UTC)
+    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)
             .where(ImportTask.status == "processing")
-            .where(ImportTask.started_at < cutoff)
+            .where(ImportTask.started_at < processing_cutoff)
         ).scalars().all()
 
-        if not stuck_ids:
+        orphan_ids = session.execute(
+            select(ImportTask.id)
+            .where(ImportTask.status.in_(["pending", "queued"]))
+            .where(ImportTask.created_at < orphan_cutoff)
+        ).scalars().all()
+
+        if not stuck_ids and not orphan_ids:
             return 0
 
-        session.execute(
+        if stuck_ids:
-            update(ImportTask)
+            session.execute(
-            .where(ImportTask.id.in_(stuck_ids))
+                update(ImportTask)
-            .values(status="queued", started_at=None, error="recovered from stuck state")
+                .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"
+                    ),
+                )
+            )
+
         session.commit()
 
-        from .import_file import import_media_file
+        if stuck_ids:
-        for tid in stuck_ids:
+            from .import_file import import_media_file
-            import_media_file.delay(tid)
+            for tid in stuck_ids:
+                import_media_file.delay(tid)
 
-        return len(stuck_ids)
+        return len(stuck_ids) + len(orphan_ids)
 
 
 @celery.task(name="backend.app.tasks.maintenance.cleanup_old_tasks")
@@ -83,6 +120,71 @@ def cleanup_old_tasks() -> int:
         return result.rowcount or 0
 
 
+@celery.task(name="backend.app.tasks.maintenance.recover_stalled_task_runs")
+def recover_stalled_task_runs() -> int:
+    """Flip task_run rows stuck in 'running' for >STUCK_THRESHOLD_MINUTES
+    to 'error'. FC-3i.
+
+    A row gets stuck when the worker dies without emitting
+    task_postrun / task_failure (e.g. OOM, container restart between
+    signals, signal handler raised+logged). Shares the 5-min threshold
+    with recover_interrupted_tasks for consistency.
+    """
+    SessionLocal = _sync_session_factory()
+    cutoff = datetime.now(UTC) - timedelta(minutes=STUCK_THRESHOLD_MINUTES)
+    with SessionLocal() as session:
+        result = session.execute(
+            update(TaskRun)
+            .where(TaskRun.status == "running")
+            .where(TaskRun.started_at < cutoff)
+            .values(
+                status="error",
+                error_type="RecoverySweep",
+                error_message=(
+                    f"no completion signal received within "
+                    f"{STUCK_THRESHOLD_MINUTES} min"
+                ),
+                finished_at=datetime.now(UTC),
+            )
+        )
+        session.commit()
+        return result.rowcount or 0
+
+
+@celery.task(name="backend.app.tasks.maintenance.prune_task_runs")
+def prune_task_runs() -> dict:
+    """Daily retention for task_run rows. FC-3i.
+
+    - 'ok' rows: deleted after TASK_RUN_KEEP_OK_SECONDS (24h default).
+      Success is high-volume, not interesting after a day.
+    - 'error' / 'timeout' rows: deleted after TASK_RUN_KEEP_FAILURE_SECONDS
+      (7 days default). Failures are operationally interesting longer.
+    - 'running' rows: NEVER deleted by this task. The recovery sweep
+      (recover_stalled_task_runs) is the mechanism that flips them to
+      terminal state; prune doesn't touch in-flight state.
+    - 'retry' rows: treated as failures (>7d).
+
+    Returns dict of how many rows were deleted in each bucket.
+    """
+    SessionLocal = _sync_session_factory()
+    now = datetime.now(UTC)
+    ok_cutoff = now - timedelta(seconds=TASK_RUN_KEEP_OK_SECONDS)
+    fail_cutoff = now - timedelta(seconds=TASK_RUN_KEEP_FAILURE_SECONDS)
+    with SessionLocal() as session:
+        ok_deleted = session.execute(
+            delete(TaskRun)
+            .where(TaskRun.status == "ok")
+            .where(TaskRun.finished_at < ok_cutoff)
+        ).rowcount or 0
+        fail_deleted = session.execute(
+            delete(TaskRun)
+            .where(TaskRun.status.in_(["error", "timeout", "retry"]))
+            .where(TaskRun.finished_at < fail_cutoff)
+        ).rowcount or 0
+        session.commit()
+        return {"ok_deleted": ok_deleted, "failures_deleted": fail_deleted}
+
+
 @celery.task(name="backend.app.tasks.maintenance.backfill_phash")
 def backfill_phash() -> int:
     """Recompute phash for stored images that have none (imported before

backend/app/tasks/migration.py

@@ -4,7 +4,8 @@ Dispatches to the right migrator based on `kind`. Updates MigrationRun
 row's status/counts/finished_at as it runs. Failures set status='error'
 with the error message preserved.
 
-kinds: backup, gs_ingest, ir_ingest, tag_apply, ml_queue, verify, rollback
+kinds: gs_ingest, ir_ingest, tag_apply, ml_queue, verify, cleanup
+(backup + rollback retired 2026-05-24 → see /api/system/backup/*)
 """
 from __future__ import annotations
 
@@ -20,9 +21,8 @@ from ..celery_app import celery
 from ..config import get_config
 from ..models import MigrationRun
 from ..services.credential_crypto import CredentialCrypto
-from ..services.migrators import backup as backup_mod
+from ..services.migrators import cleanup as cleanup_mod
 from ..services.migrators import gs_ingest, ir_ingest, ml_queue, tag_apply, verify
-from ..services.migrators import rollback as rollback_mod
 
 log = logging.getLogger(__name__)
 
@@ -64,21 +64,11 @@ async def _run_async(run_id: int, kind: str, params: dict) -> dict:
         async with factory() as db:
             await _update_run(db, run_id, status="running")
             try:
-                if kind == "backup":
+                if kind in ("backup", "rollback"):
-                    manifest = backup_mod.create_backup(
+                    raise ValueError(
-                        db_url=get_config().database_url_sync,
+                        f"kind {kind!r} retired in FC-3h; "
-                        images_root=IMAGES_ROOT,
+                        "use /api/system/backup/* instead"
-                        tag=params.get("tag", "manual"),
                     )
-                    await _update_run(
-                        db, run_id, status="ok",
-                        counts={"rows_processed": 0, "rows_inserted": 0,
-                                "rows_skipped": 0, "files_copied": 0,
-                                "bytes_copied": 0, "conflicts": 0},
-                        finished_at=datetime.now(UTC),
-                        metadata_patch={"manifest": manifest},
-                    )
-                    return manifest
 
                 elif kind == "gs_ingest":
                     fc_crypto = CredentialCrypto(_KEY_PATH)
@@ -145,18 +135,23 @@ async def _run_async(run_id: int, kind: str, params: dict) -> dict:
                     )
                     return {"checks": checks, "sample": sample}
 
-                elif kind == "rollback":
+                elif kind == "cleanup":
-                    result = rollback_mod.rollback_to_pre_migration(
+                    slug = params.get("slug")
-                        db_url=get_config().database_url_sync,
+                    if not slug:
-                        images_root=IMAGES_ROOT,
+                        raise ValueError("cleanup requires params.slug")
+                    result = await cleanup_mod.cleanup_artist_async(
+                        db, slug=slug, images_root=IMAGES_ROOT,
+                        dry_run=params.get("dry_run", False),
+                        source_path_prefix=params.get("source_path_prefix"),
                     )
                     await _update_run(
                         db, run_id, status="ok",
-                        counts={"rows_processed": 0, "rows_inserted": 0,
+                        counts=result["counts"],
-                                "rows_skipped": 0, "files_copied": 0,
-                                "bytes_copied": 0, "conflicts": 0},
                         finished_at=datetime.now(UTC),
-                        metadata_patch={"rollback_result": result},
+                        metadata_patch={
+                            "artist": result["artist"],
+                            "summary": result["summary"],
+                        },
                     )
                     return result
 

backend/app/tasks/ml.py

@@ -8,28 +8,32 @@ apply_allowlist_tags sweeps which are 'maintenance' lane. Sync sessions
 
 from pathlib import Path
 
-from sqlalchemy import create_engine, select
+from sqlalchemy import select
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.exc import DBAPIError, OperationalError
 
 from ..celery_app import celery
-from ..config import get_config
 from ..models import ImageRecord, MLSettings
+from ._sync_engine import sync_session_factory as _sync_session_factory
 
 IMAGES_ROOT = Path("/images")
 VIDEO_EXTS = {".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v", ".wmv", ".flv"}
 
 
-def _sync_session_factory():
-    cfg = get_config()
-    engine = create_engine(cfg.database_url_sync, future=True, pool_pre_ping=True)
-    return sessionmaker(engine, expire_on_commit=False)
-
-
 def _is_video(path: Path) -> bool:
     return path.suffix.lower() in VIDEO_EXTS
 
 
-@celery.task(name="backend.app.tasks.ml.tag_and_embed", bind=True)
+@celery.task(
+    name="backend.app.tasks.ml.tag_and_embed",
+    bind=True,
+    autoretry_for=(OperationalError, DBAPIError, OSError),
+    retry_backoff=5,
+    retry_backoff_max=60,
+    retry_jitter=True,
+    max_retries=3,
+    soft_time_limit=300,
+    time_limit=420,
+)
 def tag_and_embed(self, image_id: int) -> dict:
     """Run Camie + SigLIP on one image; store predictions + embedding;
     then enqueue per-image allowlist application.

backend/app/tasks/scan.py

@@ -11,14 +11,14 @@ import asyncio
 from datetime import UTC, datetime
 from pathlib import Path
 
-from sqlalchemy import create_engine, select
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import sessionmaker
 
 from ..celery_app import celery
 from ..config import get_config
 from ..models import DownloadEvent, ImportBatch, ImportSettings, ImportTask
 from ..services.scheduler_service import select_due_sources
+from ._sync_engine import sync_session_factory as _sync_session_factory
 
 
 def _iter_import_files(import_root: Path):
@@ -35,12 +35,6 @@ def _iter_import_files(import_root: Path):
         yield entry
 
 
-def _sync_session_factory():
-    cfg = get_config()
-    engine = create_engine(cfg.database_url_sync, future=True, pool_pre_ping=True)
-    return sessionmaker(engine, expire_on_commit=False)
-
-
 @celery.task(name="backend.app.tasks.scan.scan_directory", bind=True)
 def scan_directory(self, triggered_by: str = "manual",
                    mode: str = "quick") -> int:
@@ -65,16 +59,43 @@ def scan_directory(self, triggered_by: str = "manual",
         session.flush()
         batch_id = batch.id
 
+        # Skip-set behavior splits by mode (operator-flagged 2026-05-25):
+        #
+        # quick: any non-failed prior ImportTask (active OR finished) is
+        #   skipped — quick scan only does new-file enqueue, so re-touching
+        #   already-imported files is wasted work.
+        #
+        # deep: ONLY currently-in-flight tasks (pending/queued/processing)
+        #   are skipped. Completed and skipped tasks ARE re-queued because
+        #   deep scan exists precisely to re-touch already-imported files
+        #   (refresh sidecar metadata, fill NULL phash, fill NULL artist
+        #   via Importer._deep_rederive). Matches IR's deep-scan behavior.
+        active_statuses = ["pending", "queued", "processing"]
+        if mode == "deep":
+            skip_statuses = active_statuses
+        else:
+            skip_statuses = active_statuses + ["complete", "skipped"]
+        non_failed_existing = set(session.execute(
+            select(ImportTask.source_path).where(
+                ImportTask.status.in_(skip_statuses),
+            )
+        ).scalars().all())
+
         # Walk and enumerate.
         files_seen = 0
+        files_skipped_existing = 0
         for entry in _iter_import_files(import_root):
+            entry_str = str(entry)
+            if entry_str in non_failed_existing:
+                files_skipped_existing += 1
+                continue
             try:
                 size = entry.stat().st_size
             except OSError:
                 size = None
             task = ImportTask(
                 batch_id=batch_id,
-                source_path=str(entry),
+                source_path=entry_str,
                 task_type="media",
                 status="pending",
                 size_bytes=size,
@@ -83,6 +104,15 @@ def scan_directory(self, triggered_by: str = "manual",
             files_seen += 1
 
         batch.total_files = files_seen
+        # If the walk enqueued nothing (every file was already on a
+        # non-failed ImportTask from a prior scan), there's no
+        # import_media_file message that would ever flip this batch to
+        # 'complete' — finalize it now so the active-batch query in
+        # /api/system/stats doesn't get stuck reporting all-zero
+        # counters from an empty scan.
+        if files_seen == 0:
+            batch.status = "complete"
+            batch.finished_at = datetime.now(UTC)
         session.commit()
 
         # Now enqueue import_media_file for each pending task.

backend/app/tasks/thumbnail.py

@@ -7,25 +7,28 @@ so they deserve their own queue lane.
 
 from pathlib import Path
 
-from sqlalchemy import create_engine
+from sqlalchemy.exc import DBAPIError, OperationalError
-from sqlalchemy.orm import sessionmaker
 
 from ..celery_app import celery
-from ..config import get_config
 from ..models import ImageRecord
 from ..services.importer import is_video
 from ..services.thumbnailer import Thumbnailer
+from ._sync_engine import sync_session_factory as _sync_session_factory
 
 IMAGES_ROOT = Path("/images")
 
 
-def _sync_session_factory():
+@celery.task(
-    cfg = get_config()
+    name="backend.app.tasks.thumbnail.generate_thumbnail",
-    engine = create_engine(cfg.database_url_sync, future=True, pool_pre_ping=True)
+    bind=True,
-    return sessionmaker(engine, expire_on_commit=False)
+    autoretry_for=(OperationalError, DBAPIError, OSError),
-
+    retry_backoff=5,
-
+    retry_backoff_max=60,
-@celery.task(name="backend.app.tasks.thumbnail.generate_thumbnail", bind=True)
+    retry_jitter=True,
+    max_retries=3,
+    soft_time_limit=120,
+    time_limit=180,
+)
 def generate_thumbnail(self, image_id: int) -> dict:
     SessionLocal = _sync_session_factory()
     with SessionLocal() as session:

extension/.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+web-ext-artifacts/
+.web-ext-id
+.amo-upload-uuid

extension/README.md

@@ -0,0 +1,45 @@
+# FabledCurator Firefox Extension
+
+Self-hosted Firefox extension that pushes session cookies from supported
+platforms (Patreon, SubscribeStar, Hentai-Foundry, Discord, Pixiv,
+DeviantArt) into FabledCurator, and lets you add a creator as a Source
+from their page in one click.
+
+## Install (operator)
+
+The signed XPI is bundled into the FC Docker image. Open FC →
+Settings → Maintenance → Browser extension → click "Install Firefox
+extension". Firefox shows its native install prompt. After installing,
+open the extension's options page (about:addons → FabledCurator →
+Preferences) and paste in the FC URL + extension API key shown on the
+same card.
+
+## Develop
+
+```sh
+cd extension/
+npm install --no-save        # web-ext only
+npm run lint                 # web-ext lint
+npm run start                # launches Firefox with extension loaded
+npm run build                # unsigned XPI in web-ext-artifacts/
+```
+
+## Smoke checklist (after every release that touches `extension/**`)
+
+- [ ] `npm run lint` passes
+- [ ] `npm run start` loads the extension in a clean Firefox profile
+- [ ] Options page accepts FC URL + key, indicator turns green
+- [ ] Cookie export: log into patreon.com, click Patreon card → "X cookies exported"
+- [ ] Discord token: open discord.com, click Discord card → "Token captured"
+- [ ] Pixiv OAuth: click Pixiv card → login redirects, token stored
+- [ ] Add as source: visit patreon.com/<creator>, click floating button → toast
+- [ ] Subscriptions list: popup → "Sources" tab → list renders
+- [ ] Check now: click play icon on source row → no error toast
+
+## Release
+
+Bump `manifest.json` + `package.json` SemVer (both files) and commit
+under `extension/**`. The `.forgejo/workflows/extension.yml` workflow
+runs `web-ext sign` on main, commits the signed XPI to
+`frontend/public/extension/`, and the next FC server build bundles it
+into the Docker image.

extension/background/background.js

@@ -0,0 +1,265 @@
+/**
+ * Background script — message router + Discord token capture
+ * (webRequest) + Pixiv PKCE OAuth. Direct port of GS background.js;
+ * api.js client points at FC instead of GS.
+ */
+
+let discordToken = null;
+let discordTokenCapturedAt = null;
+
+let pixivRefreshToken = null;
+let pixivTokenCapturedAt = null;
+let pixivOAuthPending = null;
+
+const PIXIV_CLIENT_ID = 'MOBrBDS8blbauoSck0ZfDbtuzpyT';
+const PIXIV_CLIENT_SECRET = 'lsACyCD94FhDUtGTXi3QzcFE2uU1hqtDaKeqrdwj';
+const PIXIV_OAUTH_URL = 'https://app-api.pixiv.net/web/v1/login';
+const PIXIV_TOKEN_URL = 'https://oauth.secure.pixiv.net/auth/token';
+const PIXIV_REDIRECT_URI = 'https://app-api.pixiv.net/web/v1/users/auth/pixiv/callback';
+
+let initialized = false;
+
+async function ensureInitialized() {
+  if (initialized) return;
+  await api.init();
+  await loadDiscordToken();
+  await loadPixivToken();
+  initialized = true;
+}
+
+browser.runtime.onInstalled.addListener(() => ensureInitialized());
+browser.runtime.onStartup.addListener(() => ensureInitialized());
+ensureInitialized().catch(e => console.error('init failed:', e));
+
+// ---- Discord token capture via webRequest ----
+
+browser.webRequest.onBeforeSendHeaders.addListener(
+  (details) => {
+    const auth = details.requestHeaders?.find(h => h.name.toLowerCase() === 'authorization');
+    if (auth?.value && auth.value !== discordToken) {
+      saveDiscordToken(auth.value);
+    }
+  },
+  { urls: ['https://discord.com/api/*'] },
+  ['requestHeaders'],
+);
+
+async function loadDiscordToken() {
+  const s = await browser.storage.local.get(['discordToken', 'discordTokenCapturedAt']);
+  discordToken = s.discordToken || null;
+  discordTokenCapturedAt = s.discordTokenCapturedAt || null;
+}
+
+async function saveDiscordToken(token) {
+  discordToken = token;
+  discordTokenCapturedAt = new Date().toISOString();
+  await browser.storage.local.set({ discordToken: token, discordTokenCapturedAt });
+}
+
+// ---- Pixiv PKCE OAuth ----
+
+async function loadPixivToken() {
+  const s = await browser.storage.local.get(['pixivRefreshToken', 'pixivTokenCapturedAt']);
+  pixivRefreshToken = s.pixivRefreshToken || null;
+  pixivTokenCapturedAt = s.pixivTokenCapturedAt || null;
+}
+
+async function savePixivToken(token) {
+  pixivRefreshToken = token;
+  pixivTokenCapturedAt = new Date().toISOString();
+  await browser.storage.local.set({ pixivRefreshToken: token, pixivTokenCapturedAt });
+}
+
+function generateCodeVerifier() {
+  const a = new Uint8Array(32);
+  crypto.getRandomValues(a);
+  return base64UrlEncode(a);
+}
+
+async function generateCodeChallenge(verifier) {
+  const data = new TextEncoder().encode(verifier);
+  const hash = await crypto.subtle.digest('SHA-256', data);
+  return base64UrlEncode(new Uint8Array(hash));
+}
+
+function base64UrlEncode(buf) {
+  return btoa(String.fromCharCode(...buf)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+}
+
+async function initiatePixivOAuth() {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = await generateCodeChallenge(codeVerifier);
+
+  const params = new URLSearchParams({
+    code_challenge: codeChallenge,
+    code_challenge_method: 'S256',
+    client: 'pixiv-android',
+  });
+  const tab = await browser.tabs.create({ url: `${PIXIV_OAUTH_URL}?${params}` });
+
+  return new Promise((resolve, reject) => {
+    pixivOAuthPending = { codeVerifier, tabId: tab.id, resolve, reject };
+    setTimeout(() => {
+      if (pixivOAuthPending && pixivOAuthPending.tabId === tab.id) {
+        pixivOAuthPending = null;
+        reject(new Error('Pixiv OAuth timed out (5 min)'));
+      }
+    }, 5 * 60 * 1000);
+  });
+}
+
+browser.webRequest.onBeforeRedirect.addListener(
+  async (details) => {
+    if (!pixivOAuthPending) return;
+    if (details.tabId !== pixivOAuthPending.tabId) return;
+    const url = new URL(details.redirectUrl);
+    const code = url.searchParams.get('code');
+    if (!code) return;
+    const verifier = pixivOAuthPending.codeVerifier;
+    const resolve = pixivOAuthPending.resolve;
+    const reject = pixivOAuthPending.reject;
+    pixivOAuthPending = null;
+    try {
+      const tokenResp = await fetch(PIXIV_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+          client_id: PIXIV_CLIENT_ID,
+          client_secret: PIXIV_CLIENT_SECRET,
+          code,
+          code_verifier: verifier,
+          grant_type: 'authorization_code',
+          include_policy: 'true',
+          redirect_uri: PIXIV_REDIRECT_URI,
+        }),
+      });
+      const body = await tokenResp.json();
+      if (!body.refresh_token) {
+        reject(new Error(`Pixiv token exchange failed: ${JSON.stringify(body)}`));
+        return;
+      }
+      await savePixivToken(body.refresh_token);
+      try { await browser.tabs.remove(details.tabId); } catch {}
+      resolve(body.refresh_token);
+    } catch (e) {
+      reject(e);
+    }
+  },
+  { urls: ['https://app-api.pixiv.net/web/v1/users/auth/pixiv/callback*'] },
+);
+
+// ---- Message router ----
+
+browser.runtime.onMessage.addListener(async (msg) => {
+  await ensureInitialized();
+  switch (msg.type) {
+    case 'GET_CONFIG':
+      return { apiUrl: api.baseUrl, apiKey: api.apiKey };
+
+    case 'TEST_CONNECTION':
+      try {
+        await api.testConnection();
+        return { connected: true };
+      } catch (e) {
+        return { connected: false, error: e.message };
+      }
+
+    case 'GET_PLATFORM_STATUS': {
+      const status = {};
+      for (const key of Object.keys(PLATFORMS)) {
+        if (PLATFORMS[key].authType === 'cookies') {
+          status[key] = { hasCookies: false, cookieCount: 0 };
+          try {
+            const n = await getCookieCount(key);
+            status[key] = { hasCookies: n > 0, cookieCount: n };
+          } catch (e) {
+            status[key] = { error: e.message };
+          }
+        } else if (key === 'discord') {
+          status[key] = { hasToken: !!discordToken, capturedAt: discordTokenCapturedAt };
+        } else if (key === 'pixiv') {
+          status[key] = { hasToken: !!pixivRefreshToken, capturedAt: pixivTokenCapturedAt };
+        } else {
+          status[key] = {};
+        }
+      }
+      return status;
+    }
+
+    case 'EXPORT_COOKIES': {
+      const key = msg.platform;
+      const platform = PLATFORMS[key];
+      if (!platform) return { error: `Unknown platform: ${key}` };
+      try {
+        if (platform.authType === 'cookies') {
+          const cookies = await extractCookiesForPlatform(key);
+          if (cookies.length === 0) return { error: 'No cookies found — log in first.' };
+          const data = toNetscapeFormat(cookies);
+          await api.uploadCredentials(key, 'cookies', data);
+          return { success: true, cookieCount: cookies.length };
+        }
+        if (key === 'discord') {
+          if (!discordToken) return { error: 'Open discord.com to capture a token first.' };
+          await api.uploadCredentials('discord', 'token', discordToken);
+          return { success: true };
+        }
+        if (key === 'pixiv') {
+          if (!pixivRefreshToken) {
+            await initiatePixivOAuth();
+          }
+          await api.uploadCredentials('pixiv', 'token', pixivRefreshToken);
+          return { success: true };
+        }
+        return { error: 'Unsupported platform.' };
+      } catch (e) {
+        return { error: e.message };
+      }
+    }
+
+    case 'EXPORT_ALL_COOKIES': {
+      const results = {};
+      for (const key of Object.keys(PLATFORMS)) {
+        if (PLATFORMS[key].authType !== 'cookies') {
+          results[key] = { skipped: true };
+          continue;
+        }
+        try {
+          const cookies = await extractCookiesForPlatform(key);
+          if (cookies.length === 0) {
+            results[key] = { skipped: true, reason: 'no cookies' };
+            continue;
+          }
+          await api.uploadCredentials(key, 'cookies', toNetscapeFormat(cookies));
+          results[key] = { success: true, cookieCount: cookies.length };
+        } catch (e) {
+          results[key] = { error: e.message };
+        }
+      }
+      return results;
+    }
+
+    case 'LIST_SOURCES':
+      try {
+        return { sources: await api.listSources() };
+      } catch (e) {
+        return { error: e.message };
+      }
+
+    case 'CHECK_SOURCE':
+      try {
+        return await api.triggerSourceCheck(msg.sourceId);
+      } catch (e) {
+        return { error: e.message };
+      }
+
+    case 'ADD_AS_SOURCE':
+      try {
+        return await api.quickAddSource(msg.url);
+      } catch (e) {
+        return { error: e.message };
+      }
+
+    default:
+      return { error: `Unknown message type: ${msg.type}` };
+  }
+});

extension/content/content-script.css

@@ -0,0 +1,27 @@
+.fc-add-source-btn {
+  all: revert;
+  position: fixed; bottom: 24px; right: 24px; z-index: 2147483647;
+  padding: 10px 16px; border-radius: 999px; border: none;
+  background: rgb(20, 23, 26); color: rgb(244, 186, 122);
+  font: 500 14px/1.2 system-ui, sans-serif;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4); cursor: pointer;
+  transition: transform 100ms ease;
+}
+.fc-add-source-btn:hover { transform: translateY(-1px); }
+.fc-add-source-btn:disabled { opacity: 0.6; cursor: wait; }
+
+.fc-toast {
+  all: revert;
+  position: fixed; bottom: 84px; right: 24px; z-index: 2147483647;
+  max-width: 360px; padding: 12px 16px; border-radius: 8px;
+  background: rgb(20, 23, 26); color: rgb(232, 228, 216);
+  font: 14px/1.4 system-ui, sans-serif;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
+  animation: fc-toast-in 200ms ease;
+}
+.fc-toast--success { border-left: 3px solid rgb(244, 186, 122); }
+.fc-toast--error   { border-left: 3px solid rgb(220, 80, 80); }
+@keyframes fc-toast-in {
+  from { transform: translateY(20px); opacity: 0; }
+  to   { transform: translateY(0); opacity: 1; }
+}

extension/content/content-script.js

@@ -0,0 +1,60 @@
+(function () {
+  if (window.__fc_addsource_injected) return;
+  window.__fc_addsource_injected = true;
+
+  evaluate();
+
+  const reEval = () => evaluate();
+  window.addEventListener('popstate', reEval);
+  const origPush = history.pushState;
+  history.pushState = function () { origPush.apply(this, arguments); reEval(); };
+
+  function evaluate() {
+    const platform = getPlatformFromUrl(window.location.href);
+    const onArtist = platform && isArtistPage(window.location.href, platform);
+    let btn = document.getElementById('fc-add-source-btn');
+    if (onArtist && !btn) injectButton();
+    else if (!onArtist && btn) btn.remove();
+  }
+
+  function injectButton() {
+    const btn = document.createElement('button');
+    btn.id = 'fc-add-source-btn';
+    btn.className = 'fc-add-source-btn';
+    btn.textContent = '+ Add to FabledCurator';
+    btn.addEventListener('click', onClick);
+    document.body.appendChild(btn);
+  }
+
+  async function onClick() {
+    const btn = document.getElementById('fc-add-source-btn');
+    btn.disabled = true;
+    const original = btn.textContent;
+    btn.textContent = 'Adding…';
+    try {
+      const r = await browser.runtime.sendMessage({
+        type: 'ADD_AS_SOURCE',
+        url: window.location.href,
+      });
+      if (r.error) {
+        showToast(`Error: ${r.error}`, 'error');
+      } else {
+        const verb = r.created_source ? 'Added' : 'Already a source for';
+        showToast(`${verb} ${r.artist?.name || 'artist'} (${r.source?.platform || ''})`, 'success');
+      }
+    } catch (e) {
+      showToast(`Error: ${e.message}`, 'error');
+    } finally {
+      btn.disabled = false;
+      btn.textContent = original;
+    }
+  }
+
+  function showToast(text, kind) {
+    const t = document.createElement('div');
+    t.className = `fc-toast fc-toast--${kind}`;
+    t.textContent = text;
+    document.body.appendChild(t);
+    setTimeout(() => t.remove(), 4000);
+  }
+})();

extension/icons/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" width="96" height="96">
+  <rect width="96" height="96" rx="16" fill="#14171A"/>
+  <text x="48" y="62" font-family="Georgia, serif" font-size="56" font-weight="500"
+        fill="#F4BA7A" text-anchor="middle">F</text>
+</svg>

extension/lib/api.js

@@ -0,0 +1,93 @@
+/**
+ * FC backend client. Talks to /api/credentials (FC-3b), /api/sources
+ * (FC-3a), and the new /api/extension/* endpoints (FC-3g).
+ */
+
+class FabledCuratorAPI {
+  constructor() {
+    this.baseUrl = null;
+    this.apiKey = null;
+  }
+
+  async init() {
+    const cfg = await browser.storage.local.get(['apiUrl', 'apiKey']);
+    this.baseUrl = cfg.apiUrl || null;
+    this.apiKey = cfg.apiKey || null;
+    return this.isConfigured();
+  }
+
+  isConfigured() {
+    return !!(this.baseUrl && this.apiKey);
+  }
+
+  async request(method, endpoint, data = null) {
+    if (!this.isConfigured()) {
+      throw new Error('Not configured. Set FC URL + API key in settings.');
+    }
+    const url = `${this.baseUrl.replace(/\/+$/, '')}${endpoint}`;
+    const options = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Extension-Key': this.apiKey,
+      },
+    };
+    if (data) options.body = JSON.stringify(data);
+
+    let response;
+    try {
+      response = await fetch(url, options);
+    } catch (e) {
+      throw new Error('Cannot connect to FabledCurator. Check URL.');
+    }
+
+    if (!response.ok) {
+      let message;
+      try {
+        const body = await response.json();
+        message = body.error || `HTTP ${response.status}`;
+        if (body.detail) message += `: ${body.detail}`;
+      } catch {
+        message = `HTTP ${response.status}: ${response.statusText}`;
+      }
+      const err = new Error(message);
+      err.status = response.status;
+      throw err;
+    }
+
+    if (response.status === 204) return { success: true };
+    return response.json();
+  }
+
+  // FC-3b — credentials.
+  uploadCredentials(platform, credentialType, data) {
+    return this.request('POST', '/credentials', {
+      platform,
+      credential_type: credentialType,
+      data,
+    });
+  }
+  getCredentials() {
+    return this.request('GET', '/credentials');
+  }
+
+  // FC-3a — sources.
+  listSources() {
+    return this.request('GET', '/sources');
+  }
+  triggerSourceCheck(sourceId) {
+    return this.request('POST', `/sources/${sourceId}/check`);
+  }
+
+  // FC-3g — extension-specific.
+  quickAddSource(url) {
+    return this.request('POST', '/extension/quick-add-source', { url });
+  }
+
+  // Connection test = the cheapest read with auth.
+  testConnection() {
+    return this.request('GET', '/credentials');
+  }
+}
+
+const api = new FabledCuratorAPI();

extension/lib/cookies.js

@@ -0,0 +1,56 @@
+/**
+ * Cookie extraction + Netscape format conversion.
+ * Direct port of GS extension/lib/cookies.js.
+ */
+
+async function extractCookiesForPlatform(platformKey) {
+  const platform = PLATFORMS[platformKey];
+  if (!platform) throw new Error(`Unknown platform: ${platformKey}`);
+
+  const all = [];
+  for (const domain of platform.domains) {
+    try {
+      const cookies = await browser.cookies.getAll({ domain });
+      all.push(...cookies);
+    } catch (e) {
+      console.warn(`cookies.getAll failed for ${domain}:`, e);
+    }
+  }
+  return deduplicateCookies(all);
+}
+
+function deduplicateCookies(cookies) {
+  const seen = new Map();
+  for (const c of cookies) {
+    const key = `${c.name}|${c.domain}|${c.path}`;
+    if (!seen.has(key)) {
+      seen.set(key, c);
+    } else {
+      const existing = seen.get(key);
+      if (c.expirationDate && (!existing.expirationDate || c.expirationDate > existing.expirationDate)) {
+        seen.set(key, c);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+
+function toNetscapeFormat(cookies) {
+  const lines = ['# Netscape HTTP Cookie File'];
+  for (const c of cookies) {
+    let domain = c.domain.replace(/^\.?www\./, '.');
+    if (!domain.startsWith('.')) domain = '.' + domain;
+    const secure = c.secure ? 'TRUE' : 'FALSE';
+    const expiration = c.expirationDate ? Math.floor(c.expirationDate) : 0;
+    lines.push([domain, 'TRUE', c.path || '/', secure, String(expiration), c.name, c.value].join('\t'));
+  }
+  return lines.join('\n');
+}
+
+async function getCookieCount(platformKey) {
+  try {
+    return (await extractCookiesForPlatform(platformKey)).length;
+  } catch {
+    return 0;
+  }
+}

extension/lib/platforms.js

@@ -0,0 +1,85 @@
+/**
+ * Platform definitions — mirrored from backend/app/services/platforms.py.
+ * Two copies of these regexes (here and in backend extension_service.py)
+ * is cheaper than building a shared definition file for two short
+ * tables in different runtimes. Keep in sync by hand; reviewers catch
+ * drift.
+ */
+
+const PLATFORMS = {
+  patreon: {
+    name: 'Patreon',
+    domains: ['.patreon.com', 'www.patreon.com', 'patreon.com'],
+    authType: 'cookies',
+    color: '#FF424D',
+    urlPattern: /^https?:\/\/(www\.)?patreon\.com/,
+  },
+  subscribestar: {
+    name: 'SubscribeStar',
+    domains: [
+      '.subscribestar.com',
+      '.subscribestar.adult',
+      'www.subscribestar.com',
+      'subscribestar.com',
+      'subscribestar.adult',
+    ],
+    authType: 'cookies',
+    color: '#FFD700',
+    urlPattern: /^https?:\/\/(www\.)?subscribestar\.(com|adult)/,
+  },
+  hentaifoundry: {
+    name: 'Hentai Foundry',
+    domains: ['.hentai-foundry.com', 'www.hentai-foundry.com', 'hentai-foundry.com'],
+    authType: 'cookies',
+    color: '#9C27B0',
+    urlPattern: /^https?:\/\/(www\.)?hentai-foundry\.com/,
+  },
+  discord: {
+    name: 'Discord',
+    domains: ['.discord.com', 'discord.com'],
+    authType: 'token',
+    color: '#5865F2',
+    urlPattern: /^https?:\/\/(www\.)?discord\.com/,
+    note: 'Open Discord in browser to capture token',
+  },
+  pixiv: {
+    name: 'Pixiv',
+    domains: ['.pixiv.net', 'www.pixiv.net', 'pixiv.net'],
+    authType: 'token',
+    color: '#0096FA',
+    urlPattern: /^https?:\/\/(www\.)?pixiv\.net/,
+    note: 'Click to authenticate via OAuth',
+  },
+  deviantart: {
+    name: 'DeviantArt',
+    domains: ['.deviantart.com', 'www.deviantart.com', 'deviantart.com'],
+    authType: 'cookies',
+    color: '#05CC47',
+    urlPattern: /^https?:\/\/(www\.)?deviantart\.com/,
+  },
+};
+
+/**
+ * Per-platform artist-page URL patterns — these are STRICTER than
+ * urlPattern (which matches any URL on the domain). Used by the content
+ * script to decide whether to show the floating "Add as source" button.
+ */
+const PLATFORM_ARTIST_PATTERNS = {
+  patreon:       /^https?:\/\/(www\.)?patreon\.com\/(?!home$|search\b|messages\b|notifications\b|library\b|settings\b|posts\b|c\/)[^/?#]+\/?$/i,
+  subscribestar: /^https?:\/\/(www\.)?subscribestar\.(com|adult)\/(?!feed$|messages$|library$)[^/?#]+\/?$/i,
+  hentaifoundry: /^https?:\/\/(www\.)?hentai-foundry\.com\/user\/[^/?#]+/i,
+  deviantart:    /^https?:\/\/(www\.)?deviantart\.com\/(?!home$|watch\b|tag\b|browse\b)[^/?#]+\/?$/i,
+  pixiv:         /^https?:\/\/(www\.)?pixiv\.net\/(en\/)?users\/\d+/i,
+};
+
+function getPlatformFromUrl(url) {
+  for (const [key, platform] of Object.entries(PLATFORMS)) {
+    if (platform.urlPattern.test(url)) return key;
+  }
+  return null;
+}
+
+function isArtistPage(url, platformKey) {
+  const pattern = PLATFORM_ARTIST_PATTERNS[platformKey];
+  return pattern ? pattern.test(url) : false;
+}

extension/manifest.json

@@ -0,0 +1,71 @@
+{
+  "manifest_version": 3,
+  "name": "FabledCurator",
+  "version": "1.0.3",
+  "description": "Export cookies from supported platforms to FabledCurator and add creators as sources in one click.",
+
+  "browser_specific_settings": {
+    "gecko": {
+      "id": "fabledcurator@fabledsword.com",
+      "strict_min_version": "115.0"
+    }
+  },
+
+  "permissions": [
+    "cookies",
+    "storage",
+    "tabs",
+    "activeTab",
+    "webRequest",
+    "webRequestBlocking"
+  ],
+
+  "host_permissions": [
+    "*://*.patreon.com/*",
+    "*://*.subscribestar.com/*",
+    "*://*.subscribestar.adult/*",
+    "*://*.hentai-foundry.com/*",
+    "*://*.discord.com/*",
+    "*://*.pixiv.net/*",
+    "*://*.deviantart.com/*",
+    "*://app-api.pixiv.net/*",
+    "*://oauth.secure.pixiv.net/*",
+    "*://*/*"
+  ],
+
+  "action": {
+    "default_popup": "popup/popup.html",
+    "default_icon": "icons/icon.svg",
+    "default_title": "FabledCurator"
+  },
+
+  "background": {
+    "scripts": ["lib/platforms.js", "lib/cookies.js", "lib/api.js", "background/background.js"]
+  },
+
+  "options_ui": {
+    "page": "options/options.html",
+    "browser_style": true
+  },
+
+  "content_scripts": [
+    {
+      "matches": [
+        "*://*.patreon.com/*",
+        "*://*.subscribestar.com/*",
+        "*://*.subscribestar.adult/*",
+        "*://*.hentai-foundry.com/*",
+        "*://*.deviantart.com/*",
+        "*://*.pixiv.net/*"
+      ],
+      "js": ["lib/platforms.js", "content/content-script.js"],
+      "css": ["content/content-script.css"],
+      "run_at": "document_idle"
+    }
+  ],
+
+  "icons": {
+    "48": "icons/icon.svg",
+    "96": "icons/icon.svg"
+  }
+}

extension/options/options.html

@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>FabledCurator — Settings</title>
+  <style>
+    body { font: 14px/1.4 system-ui, sans-serif; max-width: 520px; margin: 32px auto; padding: 0 16px; }
+    h1 { font-family: Georgia, serif; font-size: 20px; }
+    label { display: block; font-weight: 500; margin: 16px 0 6px; }
+    input { width: 100%; padding: 8px; box-sizing: border-box; font: inherit; }
+    .hint { color: #666; font-size: 12px; margin-top: 4px; }
+    .row { display: flex; gap: 8px; margin-top: 16px; }
+    button { padding: 8px 16px; cursor: pointer; font: inherit; }
+    button.primary { background: #F4BA7A; color: #14171A; border: none; border-radius: 4px; }
+    button.test { background: none; border: 1px solid #ccc; border-radius: 4px; }
+    .status { margin-top: 16px; padding: 8px 12px; border-radius: 4px; }
+    .status.ok { background: #DFF5DF; color: #2B6A2B; }
+    .status.err { background: #FBE1E1; color: #862525; }
+  </style>
+</head>
+<body>
+  <h1>FabledCurator extension</h1>
+
+  <label for="api-url">FC base URL</label>
+  <input id="api-url" type="url" placeholder="http://curator.example.com/api" />
+  <div class="hint">Find this on FC → Settings → Maintenance → Browser extension.</div>
+
+  <label for="api-key">Extension API key</label>
+  <input id="api-key" type="password" placeholder="paste from FC Settings card" />
+  <div class="hint">Generate or rotate on FC → Settings → Maintenance → Browser extension.</div>
+
+  <div class="row">
+    <button class="primary" id="save-btn">Save</button>
+    <button class="test" id="test-btn">Test connection</button>
+  </div>
+
+  <div id="status" class="status" style="display:none;"></div>
+
+  <script src="options.js"></script>
+</body>
+</html>

extension/options/options.js

@@ -0,0 +1,46 @@
+document.addEventListener('DOMContentLoaded', async () => {
+  const stored = await browser.storage.local.get(['apiUrl', 'apiKey']);
+  document.getElementById('api-url').value = stored.apiUrl || '';
+  document.getElementById('api-key').value = stored.apiKey || '';
+
+  document.getElementById('save-btn').addEventListener('click', save);
+  document.getElementById('test-btn').addEventListener('click', test);
+});
+
+async function save() {
+  const apiUrl = document.getElementById('api-url').value.trim().replace(/\/+$/, '');
+  const apiKey = document.getElementById('api-key').value.trim();
+  if (!apiUrl || !apiKey) {
+    showStatus('Both fields are required.', 'err');
+    return;
+  }
+  await browser.storage.local.set({ apiUrl, apiKey });
+  await browser.storage.local.remove(['lastConnectionTest', 'lastConnectionStatus']);
+  showStatus('Saved.', 'ok');
+}
+
+async function test() {
+  const apiUrl = document.getElementById('api-url').value.trim().replace(/\/+$/, '');
+  const apiKey = document.getElementById('api-key').value.trim();
+  if (!apiUrl || !apiKey) {
+    showStatus('Fill both fields first.', 'err');
+    return;
+  }
+  try {
+    const r = await fetch(`${apiUrl}/credentials`, {
+      method: 'GET',
+      headers: { 'X-Extension-Key': apiKey },
+    });
+    if (r.ok) showStatus(`Connected — HTTP ${r.status}.`, 'ok');
+    else showStatus(`HTTP ${r.status}: ${r.statusText}`, 'err');
+  } catch (e) {
+    showStatus(`Cannot reach ${apiUrl}: ${e.message}`, 'err');
+  }
+}
+
+function showStatus(text, kind) {
+  const el = document.getElementById('status');
+  el.textContent = text;
+  el.className = `status ${kind}`;
+  el.style.display = 'block';
+}

extension/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "fabledcurator-extension",
+  "version": "1.0.3",
+  "private": true,
+  "description": "Firefox extension for FabledCurator",
+  "scripts": {
+    "lint":  "web-ext lint --source-dir=. --no-config-discovery --ignore-files package.json package-lock.json web-ext-artifacts node_modules README.md .gitignore",
+    "start": "web-ext run --source-dir=. --no-config-discovery --ignore-files package.json package-lock.json web-ext-artifacts node_modules README.md .gitignore --firefox=firefox",
+    "build": "web-ext build --source-dir=. --no-config-discovery --ignore-files package.json package-lock.json web-ext-artifacts node_modules README.md .gitignore --overwrite-dest",
+    "sign":  "web-ext sign --source-dir=. --no-config-discovery --ignore-files package.json package-lock.json web-ext-artifacts node_modules README.md .gitignore --channel=unlisted --api-key=$WEB_EXT_API_KEY --api-secret=$WEB_EXT_API_SECRET"
+  },
+  "devDependencies": {
+    "web-ext": "^8.0.0"
+  }
+}

extension/popup/popup.css

@@ -0,0 +1,94 @@
+:root {
+  --bg: #14171A;
+  --surface: #1F2428;
+  --on-surface: #E8E4D8;
+  --on-surface-variant: rgba(232, 228, 216, 0.65);
+  --accent: #F4BA7A;
+  --error: #DC5050;
+  --success: #4CAF50;
+  --warning: #FFB300;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  min-width: 340px;
+  font: 14px/1.4 system-ui, sans-serif;
+  background: var(--bg);
+  color: var(--on-surface);
+}
+.hidden { display: none !important; }
+.topbar {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 10px 14px; background: var(--surface);
+}
+.brand { font-family: Georgia, serif; font-size: 16px; font-weight: 500; color: var(--accent); }
+.dot { width: 10px; height: 10px; border-radius: 50%; background: var(--on-surface-variant); }
+.dot.connected { background: var(--success); }
+
+.setup { padding: 20px; text-align: center; }
+.alert {
+  background: var(--surface); padding: 12px; border-radius: 6px;
+  margin-bottom: 12px; border-left: 3px solid var(--accent);
+}
+.alert.alert-error { border-left-color: var(--error); }
+.alert strong { display: block; margin-bottom: 4px; }
+.alert p { margin: 0; color: var(--on-surface-variant); font-size: 13px; }
+
+.tabs { display: flex; border-bottom: 1px solid var(--surface); }
+.tab {
+  flex: 1; padding: 10px 0; background: none; border: none;
+  color: var(--on-surface-variant); cursor: pointer; font: inherit;
+  border-bottom: 2px solid transparent;
+}
+.tab.active { color: var(--accent); border-bottom-color: var(--accent); }
+.tab-panel { padding: 10px; }
+
+.platform-card, .source-row {
+  display: flex; align-items: center; gap: 10px;
+  padding: 10px; margin-bottom: 6px; background: var(--surface);
+  border-radius: 6px; cursor: pointer;
+}
+.platform-card.disabled { opacity: 0.5; cursor: not-allowed; }
+.platform-card.loading { opacity: 0.6; cursor: wait; }
+.platform-icon {
+  width: 28px; height: 28px; border-radius: 50%;
+  display: grid; place-items: center; font-weight: 600; color: white;
+}
+.info { flex: 1; min-width: 0; }
+.info .name { font-weight: 500; }
+.info .status { font-size: 12px; color: var(--on-surface-variant); }
+.info .status.ready { color: var(--success); }
+.info .status.error { color: var(--error); }
+.info .status.no-cookies { color: var(--warning); }
+.action-icon { color: var(--on-surface-variant); }
+
+.btn {
+  padding: 10px 14px; border: none; border-radius: 6px; cursor: pointer;
+  font: 500 14px/1 system-ui, sans-serif;
+}
+.btn.primary { background: var(--accent); color: var(--bg); }
+.btn.primary:hover { filter: brightness(1.05); }
+.btn.primary:disabled { opacity: 0.5; cursor: not-allowed; }
+.btn.block { display: block; width: 100%; margin-top: 8px; }
+.btn.link { background: none; color: var(--on-surface-variant); padding: 4px; }
+.btn.link:hover { color: var(--accent); }
+
+.source-row .play {
+  background: none; border: none; color: var(--on-surface-variant);
+  cursor: pointer; padding: 4px;
+}
+.source-row .play:hover { color: var(--accent); }
+.source-row .url { font-size: 11px; color: var(--on-surface-variant); word-break: break-all; }
+
+.status-message {
+  padding: 10px 14px; margin: 8px 10px; border-radius: 6px;
+  background: var(--surface); border-left: 3px solid;
+}
+.status-message.success { border-left-color: var(--success); }
+.status-message.error { border-left-color: var(--error); }
+.status-message.warning { border-left-color: var(--warning); }
+
+.footer {
+  border-top: 1px solid var(--surface);
+  padding: 6px 10px; text-align: right;
+}

extension/popup/popup.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <link rel="stylesheet" href="popup.css" />
+  <title>FabledCurator</title>
+</head>
+<body>
+  <header class="topbar">
+    <span class="brand">FabledCurator</span>
+    <span id="connection-status" class="dot" title="checking…"></span>
+  </header>
+
+  <section id="setup-required" class="setup hidden">
+    <div class="alert">
+      <strong>Setup required</strong>
+      <p>Configure the FC URL and extension API key.</p>
+    </div>
+    <button id="open-settings-btn" class="btn primary">Open settings</button>
+  </section>
+
+  <section id="main-content" class="main hidden">
+    <nav class="tabs">
+      <button class="tab active" data-tab="platforms">Platforms</button>
+      <button class="tab" data-tab="sources">Sources</button>
+    </nav>
+
+    <div id="tab-platforms" class="tab-panel">
+      <div id="platforms-list"></div>
+      <button id="export-all-btn" class="btn primary block">Export all platforms</button>
+    </div>
+
+    <div id="tab-sources" class="tab-panel hidden">
+      <div id="sources-list"></div>
+    </div>
+
+    <div id="status-message" class="status-message hidden"></div>
+
+    <footer class="footer">
+      <button id="settings-btn" class="btn link">Settings</button>
+    </footer>
+  </section>
+
+  <script src="../lib/platforms.js"></script>
+  <script src="popup.js"></script>
+</body>
+</html>

extension/popup/popup.js

@@ -0,0 +1,239 @@
+document.addEventListener('DOMContentLoaded', init);
+
+const CONNECTION_TEST_INTERVAL = 2 * 60 * 1000;
+
+async function init() {
+  try {
+    const cfg = await browser.runtime.sendMessage({ type: 'GET_CONFIG' });
+    if (!cfg || !cfg.apiUrl || !cfg.apiKey) {
+      showSetupRequired();
+      return;
+    }
+    document.getElementById('setup-required').classList.add('hidden');
+    document.getElementById('main-content').classList.remove('hidden');
+    setupEventListeners();
+    showPlatformsLoading();
+    testConnectionIfNeeded();
+    loadPlatformStatus().catch(e => showError(`Failed to load platforms: ${e.message}`));
+  } catch (e) {
+    showSetupRequired();
+    const alert = document.querySelector('#setup-required .alert');
+    alert.textContent = '';
+    const s = document.createElement('strong'); s.textContent = 'Error';
+    const p = document.createElement('p'); p.textContent = e.message;
+    alert.appendChild(s); alert.appendChild(p);
+    alert.classList.add('alert-error');
+  }
+}
+
+function showSetupRequired() {
+  document.getElementById('setup-required').classList.remove('hidden');
+  document.getElementById('main-content').classList.add('hidden');
+  document.getElementById('open-settings-btn').addEventListener('click', () => {
+    browser.runtime.openOptionsPage();
+  });
+}
+
+function showPlatformsLoading() {
+  const c = document.getElementById('platforms-list');
+  c.textContent = '';
+  const d = document.createElement('div');
+  d.style.cssText = 'text-align:center;padding:18px;color:var(--on-surface-variant);';
+  d.textContent = 'Loading platforms…';
+  c.appendChild(d);
+}
+
+async function testConnectionIfNeeded() {
+  const stored = await browser.storage.local.get(['lastConnectionTest', 'lastConnectionStatus']);
+  const now = Date.now();
+  if (now - (stored.lastConnectionTest || 0) < CONNECTION_TEST_INTERVAL && stored.lastConnectionStatus !== undefined) {
+    updateConnectionDot(stored.lastConnectionStatus);
+    if (!stored.lastConnectionStatus) showError('Cannot connect to backend (cached).');
+    return;
+  }
+  const r = await browser.runtime.sendMessage({ type: 'TEST_CONNECTION' });
+  await browser.storage.local.set({ lastConnectionTest: now, lastConnectionStatus: r.connected });
+  updateConnectionDot(r.connected);
+  if (!r.connected) showError(`Cannot connect to backend: ${r.error}`);
+}
+
+function updateConnectionDot(connected) {
+  const d = document.getElementById('connection-status');
+  d.classList.toggle('connected', connected);
+  d.title = connected ? 'Connected to FabledCurator' : 'Disconnected';
+}
+
+async function loadPlatformStatus() {
+  const status = await browser.runtime.sendMessage({ type: 'GET_PLATFORM_STATUS' });
+  const c = document.getElementById('platforms-list');
+  c.textContent = '';
+  for (const [key, platform] of Object.entries(PLATFORMS)) {
+    c.appendChild(createPlatformCard(key, platform, status[key] || {}));
+  }
+}
+
+function createPlatformCard(key, platform, status) {
+  const card = document.createElement('div');
+  card.className = 'platform-card';
+  card.dataset.platform = key;
+
+  const isTokenOnly = platform.authType === 'token' && !['discord', 'pixiv'].includes(key);
+  const discordNeedsToken = key === 'discord' && !status.hasToken;
+  if (isTokenOnly || discordNeedsToken) card.classList.add('disabled');
+
+  const icon = document.createElement('div');
+  icon.className = 'platform-icon';
+  icon.style.background = platform.color;
+  icon.textContent = platform.name[0];
+
+  const info = document.createElement('div');
+  info.className = 'info';
+  const name = document.createElement('div');
+  name.className = 'name';
+  name.textContent = platform.name;
+  const st = document.createElement('div');
+  st.className = `status ${statusClass(status, platform, key)}`;
+  st.textContent = statusText(status, platform, key);
+  info.appendChild(name); info.appendChild(st);
+
+  const act = document.createElement('span');
+  act.className = 'action-icon';
+  act.textContent = '↥';
+
+  card.appendChild(icon); card.appendChild(info); card.appendChild(act);
+
+  if (!isTokenOnly && !discordNeedsToken) {
+    card.addEventListener('click', () => exportPlatformCookies(key, card));
+  }
+  return card;
+}
+
+function statusText(s, platform, key) {
+  if (key === 'discord') return s.hasToken ? 'Token captured — ready' : 'Open Discord to capture token';
+  if (key === 'pixiv') return s.hasToken ? 'Token captured — ready' : 'Click to authenticate via OAuth';
+  if (platform.authType === 'token') return 'Manual token entry required';
+  if (s.error) return 'Error checking cookies';
+  if (!s.hasCookies || !s.cookieCount) return 'No cookies — log in first';
+  return `${s.cookieCount} cookies ready`;
+}
+function statusClass(s, platform, key) {
+  if (key === 'discord') return s.hasToken ? 'ready' : 'no-cookies';
+  if (key === 'pixiv') return s.hasToken ? 'ready' : 'no-cookies';
+  if (platform.authType === 'token') return 'no-cookies';
+  if (s.error) return 'error';
+  if (!s.hasCookies || !s.cookieCount) return 'no-cookies';
+  return 'ready';
+}
+
+async function exportPlatformCookies(key, card) {
+  card.classList.add('loading'); hideStatusMessage();
+  try {
+    const r = await browser.runtime.sendMessage({ type: 'EXPORT_COOKIES', platform: key });
+    if (r.error) showError(r.error);
+    else {
+      const n = r.cookieCount ?? null;
+      const msg = n !== null
+        ? `${PLATFORMS[key].name}: ${n} cookies exported`
+        : `${PLATFORMS[key].name}: token exported`;
+      showSuccess(msg);
+      await loadPlatformStatus();
+    }
+  } catch (e) { showError(e.message); }
+  finally { card.classList.remove('loading'); }
+}
+
+async function exportAllCookies() {
+  const btn = document.getElementById('export-all-btn');
+  btn.disabled = true; btn.textContent = 'Exporting…'; hideStatusMessage();
+  try {
+    const r = await browser.runtime.sendMessage({ type: 'EXPORT_ALL_COOKIES' });
+    const wins = Object.values(r).filter(x => x.success).length;
+    const fails = Object.values(r).filter(x => !x.success && !x.skipped).length;
+    if (wins && !fails) showSuccess(`Exported ${wins} platforms`);
+    else if (wins) showWarning(`${wins} succeeded, ${fails} failed`);
+    else if (fails) showError('All exports failed. Are you logged in?');
+    else showWarning('Nothing to export');
+    await loadPlatformStatus();
+  } catch (e) { showError(e.message); }
+  finally { btn.disabled = false; btn.textContent = 'Export all platforms'; }
+}
+
+async function loadSources() {
+  const c = document.getElementById('sources-list');
+  c.textContent = '';
+  const d = document.createElement('div');
+  d.style.cssText = 'text-align:center;padding:18px;color:var(--on-surface-variant);';
+  d.textContent = 'Loading sources…';
+  c.appendChild(d);
+  const r = await browser.runtime.sendMessage({ type: 'LIST_SOURCES' });
+  c.textContent = '';
+  if (r.error) {
+    const e = document.createElement('div');
+    e.style.cssText = 'padding:12px;color:var(--error);';
+    e.textContent = r.error;
+    c.appendChild(e);
+    return;
+  }
+  if (!r.sources || r.sources.length === 0) {
+    const empty = document.createElement('div');
+    empty.style.cssText = 'text-align:center;padding:18px;color:var(--on-surface-variant);';
+    empty.textContent = 'No sources yet.';
+    c.appendChild(empty);
+    return;
+  }
+  for (const src of r.sources) c.appendChild(createSourceRow(src));
+}
+
+function createSourceRow(src) {
+  const row = document.createElement('div');
+  row.className = 'source-row';
+  const info = document.createElement('div');
+  info.className = 'info';
+  const name = document.createElement('div');
+  name.className = 'name';
+  name.textContent = `${src.platform} · #${src.id}`;
+  const url = document.createElement('div');
+  url.className = 'url';
+  url.textContent = src.url;
+  info.appendChild(name); info.appendChild(url);
+  const play = document.createElement('button');
+  play.className = 'play';
+  play.textContent = '▶';
+  play.title = 'Check now';
+  play.addEventListener('click', async () => {
+    play.disabled = true;
+    const r = await browser.runtime.sendMessage({ type: 'CHECK_SOURCE', sourceId: src.id });
+    play.disabled = false;
+    if (r.error) showError(r.error);
+    else showSuccess(`Triggered check for source #${src.id}`);
+  });
+  row.appendChild(info); row.appendChild(play);
+  return row;
+}
+
+function setupEventListeners() {
+  document.getElementById('export-all-btn').addEventListener('click', exportAllCookies);
+  document.getElementById('settings-btn').addEventListener('click', () => browser.runtime.openOptionsPage());
+  for (const tab of document.querySelectorAll('.tab')) {
+    tab.addEventListener('click', () => {
+      for (const t of document.querySelectorAll('.tab')) t.classList.remove('active');
+      tab.classList.add('active');
+      for (const p of document.querySelectorAll('.tab-panel')) p.classList.add('hidden');
+      document.getElementById(`tab-${tab.dataset.tab}`).classList.remove('hidden');
+      if (tab.dataset.tab === 'sources') loadSources();
+    });
+  }
+}
+
+function showSuccess(m) { showStatusMessage(m, 'success'); }
+function showError(m) { showStatusMessage(m, 'error'); }
+function showWarning(m) { showStatusMessage(m, 'warning'); }
+function showStatusMessage(text, kind) {
+  const el = document.getElementById('status-message');
+  el.textContent = text;
+  el.className = `status-message ${kind}`;
+  el.classList.remove('hidden');
+}
+function hideStatusMessage() {
+  document.getElementById('status-message').classList.add('hidden');
+}

frontend/src/App.vue

@@ -3,6 +3,7 @@
     <AppShell>
       <RouterView />
     </AppShell>
+    <ImageViewer v-if="modal.isOpen" @close="modal.close()" />
     <AppSnackbar ref="snackbar" />
   </v-app>
 </template>
@@ -11,7 +12,10 @@
 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 { useModalStore } from './stores/modal.js'
 
+const modal = useModalStore()
 const snackbar = ref(null)
 
 onMounted(() => {

frontend/src/components/AppShell.vue

@@ -18,5 +18,11 @@ const route = useRoute()
 <style scoped>
 .fc-content {
   min-height: 100vh;
+  /* Push initial viewport content below the sticky TopNav. Without
+     this, some views' first rows / form fields / table headers can
+     end up obscured by the navbar (depending on parent overflow
+     context interacting with position: sticky). Scrolled-down content
+     still slides under the nav — the gradient-fade design is intact. */
+  padding-top: 64px;
 }
 </style>

frontend/src/components/TopNav.vue

@@ -55,6 +55,15 @@ const health = computed(() => {
   position: sticky;
   top: 0;
   z-index: 1000;
+  /* Both side cells use `flex: 1 1 0` — equal flex weight, basis 0 —
+     so they grow/shrink at the same rate regardless of which one has
+     content (brand vs. teleport-slot action button). The middle cell
+     is `flex: 0 0 auto` (content width), and because the side cells
+     are symmetric, the middle stays geometrically centered. Earlier
+     attempts: `flex: 1` defaults to basis 0%, which made the centered
+     links shift when actions appeared; `grid-template-columns: 1fr
+     auto 1fr` actually means `minmax(auto, 1fr)` so a wide brand
+     pushed the link block off-center on narrow viewports. */
   display: flex;
   align-items: center;
   gap: 1rem;
@@ -87,7 +96,7 @@ const health = computed(() => {
 }
 
 .fc-links {
-  flex: 1;
+  flex: 0 0 auto;
   display: flex;
   flex-wrap: wrap;
   justify-content: center;
@@ -114,10 +123,12 @@ const health = computed(() => {
 }
 
 .fc-nav-left {
+  flex: 1 1 0;
+  min-width: 0;
   display: flex;
   align-items: center;
+  justify-content: flex-start;
   gap: 8px;
-  flex-shrink: 0;
 }
 .fc-health {
   display: flex;
@@ -125,9 +136,11 @@ const health = computed(() => {
   flex-shrink: 0;
 }
 .fc-nav-actions {
+  flex: 1 1 0;
+  min-width: 0;
   display: flex;
   align-items: center;
+  justify-content: flex-end;
   gap: 0.5rem;
-  flex-shrink: 0;
 }
 </style>

frontend/src/components/artist/ArtistDangerZone.vue

@@ -0,0 +1,95 @@
+<template>
+  <v-card class="fc-danger-zone mt-8" variant="outlined">
+    <v-card-title class="d-flex align-center" style="gap: 10px;">
+      <v-icon icon="mdi-alert-octagon" color="error" size="small" />
+      <span>Danger zone</span>
+    </v-card-title>
+    <v-card-text>
+      <p class="text-body-2 fc-muted mb-4">
+        Cascade-delete this artist and every image, source, post, and
+        attachment associated with them. This cannot be undone.
+        Recoverable only from an FC-3h backup.
+      </p>
+      <v-btn
+        color="error" variant="flat" rounded="pill"
+        prepend-icon="mdi-delete-forever"
+        :loading="loading"
+        @click="onClick"
+      >Delete artist &amp; cascade</v-btn>
+
+      <DestructiveConfirmModal
+        v-model="modalOpen"
+        action="delete"
+        kind="artist"
+        :run-id="artistId"
+        tier="C"
+        :projected-counts="projectedCounts"
+        :description="modalDescription"
+        @confirm="onConfirm"
+      />
+    </v-card-text>
+  </v-card>
+</template>
+
+<script setup>
+import { computed, ref } from 'vue'
+import { useRouter } from 'vue-router'
+
+import DestructiveConfirmModal from '../modal/DestructiveConfirmModal.vue'
+import { useAdminStore } from '../../stores/admin.js'
+
+const props = defineProps({
+  slug: { type: String, required: true },
+  artistId: { type: Number, required: true },
+  artistName: { type: String, required: true },
+})
+
+const router = useRouter()
+const store = useAdminStore()
+const loading = ref(false)
+const modalOpen = ref(false)
+const projected = ref(null)
+
+const projectedCounts = computed(() => projected.value?.projected || null)
+
+const modalDescription = computed(
+  () => projected.value
+    ? `Artist “${props.artistName}” — `
+        + `${projected.value.projected.images} images, `
+        + `${projected.value.projected.sources} sources, `
+        + `${Math.round(projected.value.projected.bytes_on_disk / 1_048_576)} MiB on disk`
+    : '',
+)
+
+async function onClick() {
+  loading.value = true
+  try {
+    projected.value = await store.projectArtistCascade(props.slug)
+    modalOpen.value = true
+  } finally {
+    loading.value = false
+  }
+}
+
+async function onConfirm(token) {
+  loading.value = true
+  try {
+    const result = await store.dispatchArtistCascade(props.slug, token)
+    const taskId = result.task_id
+    router.push('/artists')
+    if (taskId) {
+      store.pollTaskUntilDone(taskId).catch(() => {})
+    }
+  } finally {
+    loading.value = false
+  }
+}
+</script>
+
+<style scoped>
+.fc-danger-zone {
+  border-color: rgb(var(--v-theme-error));
+  border-radius: 8px;
+}
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+</style>

frontend/src/components/discovery/ArtistCard.vue

@@ -38,9 +38,18 @@ function onCardClick() {
 .fc-artistcard { cursor: pointer; }
 .fc-artistcard__previews {
   display: grid; grid-template-columns: repeat(3, 1fr);
-  gap: 2px; aspect-ratio: 3 / 1; background: rgb(var(--v-theme-surface-light));
+  gap: 2px; aspect-ratio: 3 / 1;
+  /* Explicit floor + ceiling so tall source images can't escape the
+     preview slot even on browsers where aspect-ratio doesn't compute. */
+  min-height: 150px; max-height: 220px;
+  overflow: hidden;
+  background: rgb(var(--v-theme-surface-light));
+}
+.fc-artistcard__previews img {
+  display: block;
+  width: 100%; height: 100%;
+  object-fit: cover; object-position: center;
 }
-.fc-artistcard__previews img { width: 100%; height: 100%; object-fit: cover; }
 .fc-artistcard__noimg {
   grid-column: 1 / -1; display: flex; align-items: center;
   justify-content: center;

frontend/src/components/discovery/TagCard.vue

@@ -44,7 +44,31 @@
       </div>
       <div class="fc-tagcard__meta">
         <v-chip size="x-small" label>{{ card.kind }}</v-chip>
-        <span class="fc-tagcard__count">{{ card.image_count }}</span>
+        <div class="fc-tagcard__meta-right">
+          <span class="fc-tagcard__count">{{ card.image_count }}</span>
+          <v-menu>
+            <template #activator="{ props: act }">
+              <v-btn
+                class="fc-tagcard__menu"
+                icon="mdi-dots-vertical" size="x-small" variant="text"
+                v-bind="act" @click.stop
+              />
+            </template>
+            <v-list density="compact">
+              <v-list-item
+                title="Merge with…"
+                prepend-icon="mdi-call-merge"
+                @click="$emit('merge-with', card)"
+              />
+              <v-list-item
+                title="Delete tag"
+                prepend-icon="mdi-delete"
+                base-color="error"
+                @click="$emit('delete', card)"
+              />
+            </v-list>
+          </v-menu>
+        </div>
       </div>
     </v-card-text>
   </v-card>
@@ -54,7 +78,7 @@
 import { ref } from 'vue'
 
 const props = defineProps({ card: { type: Object, required: true } })
-const emit = defineEmits(['open', 'rename', 'manage', 'read'])
+const emit = defineEmits(['open', 'rename', 'manage', 'read', 'merge-with', 'delete'])
 
 const editing = ref(false)
 const draft = ref('')
@@ -82,9 +106,19 @@ function submit() {
 .fc-tagcard { cursor: pointer; }
 .fc-tagcard__previews {
   display: grid; grid-template-columns: repeat(3, 1fr);
-  gap: 2px; aspect-ratio: 3 / 1; background: rgb(var(--v-theme-surface-light));
+  gap: 2px; aspect-ratio: 3 / 1;
+  /* Explicit floor + ceiling so tall source images can't escape the
+     preview slot even on browsers where aspect-ratio doesn't compute
+     (older Safari, embedded webviews). */
+  min-height: 150px; max-height: 220px;
+  overflow: hidden;
+  background: rgb(var(--v-theme-surface-light));
+}
+.fc-tagcard__previews img {
+  display: block;
+  width: 100%; height: 100%;
+  object-fit: cover; object-position: center;
 }
-.fc-tagcard__previews img { width: 100%; height: 100%; object-fit: cover; }
 .fc-tagcard__noimg {
   grid-column: 1 / -1; display: flex; align-items: center;
   justify-content: center;
@@ -106,4 +140,13 @@ function submit() {
 }
 .fc-tagcard:hover .fc-tagcard__edit { opacity: .6; }
 .fc-tagcard__edit:hover { opacity: 1; }
+.fc-tagcard__meta-right {
+  display: flex; align-items: center; gap: 4px;
+}
+.fc-tagcard__menu {
+  opacity: 0;
+  transition: opacity .15s ease;
+}
+.fc-tagcard:hover .fc-tagcard__menu { opacity: .6; }
+.fc-tagcard__menu:hover { opacity: 1; }
 </style>

frontend/src/components/gallery/BulkEditorPanel.vue

@@ -55,19 +55,44 @@
       </template>
     </div>
 
+    <div class="fc-bulk-panel__section">
+      <h4>Destructive</h4>
+      <v-btn
+        color="error" variant="flat" rounded="pill" block
+        prepend-icon="mdi-delete-forever"
+        :disabled="!sel.count"
+        :loading="deleting"
+        @click="onDeleteClick"
+      >Delete {{ sel.count }} selected</v-btn>
+    </div>
+
     <div class="fc-bulk-panel__foot">
       <v-btn variant="text" block @click="sel.clear()">Clear selection</v-btn>
     </div>
+
+    <DestructiveConfirmModal
+      v-model="deleteModalOpen"
+      action="delete"
+      kind="images-selection"
+      :run-id="bulkToken"
+      tier="C"
+      :projected-counts="bulkProjectedCounts"
+      :description="bulkDescription"
+      @confirm="onDeleteConfirm"
+    />
   </aside>
 </template>
 
 <script setup>
-import { ref, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 import { useGallerySelectionStore } from '../../stores/gallerySelection.js'
+import { useAdminStore } from '../../stores/admin.js'
 import { useApi } from '../../composables/useApi.js'
+import DestructiveConfirmModal from '../modal/DestructiveConfirmModal.vue'
 
 const sel = useGallerySelectionStore()
 const api = useApi()
+const adminStore = useAdminStore()
 
 const addModel = ref(null)
 const addHits = ref([])
@@ -99,6 +124,66 @@ async function onAddPick(id) {
 watch(() => sel.order.length, () => {
   if (sel.isSelectMode) sel.refresh()
 })
+
+// --- FC-3k bulk delete -----------------------------------------------
+
+const deleting = ref(false)
+const deleteModalOpen = ref(false)
+const bulkProjected = ref(null)
+const bulkToken = ref('')
+
+const bulkProjectedCounts = computed(() => bulkProjected.value
+  ? {
+    images: bulkProjected.value.images_found,
+    thumbnails: bulkProjected.value.thumbs_to_unlink,
+    bytes: bulkProjected.value.bytes_on_disk,
+  }
+  : null,
+)
+const bulkDescription = computed(
+  () => bulkProjected.value
+    ? `${bulkProjected.value.images_found} images, `
+        + `${Math.round(bulkProjected.value.bytes_on_disk / 1_048_576)} MiB on disk`
+    : '',
+)
+
+async function _computeSha8(ids) {
+  const canon = [...ids].sort((a, b) => a - b).join(',')
+  const buf = new TextEncoder().encode(canon)
+  const hashBuf = await crypto.subtle.digest('SHA-256', buf)
+  const bytes = new Uint8Array(hashBuf)
+  let hex = ''
+  for (let i = 0; i < 4; i++) {
+    hex += bytes[i].toString(16).padStart(2, '0')
+  }
+  return hex
+}
+
+async function onDeleteClick() {
+  if (!sel.order.length) return
+  deleting.value = true
+  try {
+    bulkProjected.value = await adminStore.projectBulkImageDelete(sel.order)
+    bulkToken.value = await _computeSha8(sel.order)
+    deleteModalOpen.value = true
+  } finally {
+    deleting.value = false
+  }
+}
+
+async function onDeleteConfirm(token) {
+  deleting.value = true
+  try {
+    const result = await adminStore.dispatchBulkImageDelete(sel.order, token)
+    const taskId = result.task_id
+    if (taskId) {
+      adminStore.pollTaskUntilDone(taskId).catch(() => {})
+    }
+    sel.clear()
+  } finally {
+    deleting.value = false
+  }
+}
 </script>
 
 <style scoped>

frontend/src/components/gallery/GalleryGrid.vue

@@ -86,7 +86,7 @@ function imagesForGroup(group) {
 }
 .fc-gallery-grid__items {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
   gap: 8px;
 }
 .fc-gallery-grid__sentinel {
@@ -101,7 +101,7 @@ function imagesForGroup(group) {
 }
 .fc-gallery-grid__skeleton {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
   gap: 8px;
 }
 .fc-gallery-grid__skeleton-item {
@@ -124,7 +124,7 @@ function imagesForGroup(group) {
 @media (max-width: 600px) {
   .fc-gallery-grid__items,
   .fc-gallery-grid__skeleton {
-    grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
     gap: 4px;
   }
 }

frontend/src/components/modal/DestructiveConfirmModal.vue

@@ -0,0 +1,128 @@
+<template>
+  <v-dialog
+    :model-value="modelValue"
+    max-width="520" persistent
+    @update:model-value="$emit('update:modelValue', $event)"
+  >
+    <v-card>
+      <v-card-title>
+        {{ titleVerb }}
+        {{ kindLabel }}<span v-if="runId"> #{{ runId }}</span>
+      </v-card-title>
+      <v-card-text>
+        <v-alert
+          :type="alertType"
+          variant="tonal" density="compact" class="mb-3"
+        >
+          <strong>{{ warningText }}</strong>
+          <div v-if="description" class="mt-1">{{ description }}</div>
+        </v-alert>
+
+        <div v-if="projectedCounts" class="fc-counts mb-3">
+          <div v-for="(v, k) in projectedCounts" :key="k">
+            <span class="fc-counts-key">{{ k }}:</span>
+            <span class="fc-counts-val">{{ v }}</span>
+          </div>
+        </div>
+
+        <template v-if="tier === 'C'">
+          <div class="text-body-2 mb-2">Type the following to confirm:</div>
+          <div class="fc-token mb-3">{{ expectedToken }}</div>
+          <v-text-field
+            v-model="typed"
+            variant="outlined" density="compact" hide-details
+            autofocus
+            placeholder="paste the token above"
+          />
+        </template>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn variant="text" @click="onCancel">Cancel</v-btn>
+        <v-btn
+          :color="confirmColor"
+          variant="flat" rounded="pill"
+          :disabled="!canConfirm"
+          @click="onConfirm"
+        >
+          {{ titleVerb }}
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<script setup>
+import { computed, ref, watch } from 'vue'
+
+const props = defineProps({
+  modelValue: { type: Boolean, required: true },
+  action: { type: String, required: true },          // 'restore' | 'delete'
+  kind: { type: String, required: true },            // 'db' | 'images' | 'artist' | 'tag' | 'images-selection'
+  runId: { type: [Number, String], default: '' },    // numeric id or sha8 string
+  description: { type: String, default: '' },
+  tier: { type: String, default: 'C' },              // 'B' | 'C'
+  projectedCounts: { type: Object, default: null },
+})
+const emit = defineEmits(['update:modelValue', 'confirm'])
+
+const typed = ref('')
+const expectedToken = computed(
+  () => `${props.action}-${props.kind}-${props.runId}`,
+)
+const titleVerb = computed(
+  () => props.action === 'restore' ? 'Restore' : 'Delete',
+)
+const kindLabel = computed(() => ({
+  db: 'database backup',
+  images: 'images backup',
+  artist: 'artist',
+  tag: 'tag',
+  'images-selection': 'image selection',
+}[props.kind] || props.kind))
+const alertType = computed(
+  () => props.action === 'restore' ? 'warning' : 'error',
+)
+const confirmColor = computed(
+  () => props.action === 'restore' ? 'warning' : 'error',
+)
+const warningText = computed(() => (
+  props.action === 'restore'
+    ? 'This replaces current state with the backup. There is no undo.'
+    : 'This permanently deletes the listed items. Cannot be recovered.'
+))
+const canConfirm = computed(
+  () => props.tier === 'B'
+    ? true
+    : typed.value === expectedToken.value,
+)
+
+watch(() => props.modelValue, (open) => {
+  if (open) typed.value = ''
+})
+
+function onCancel() {
+  emit('update:modelValue', false)
+}
+function onConfirm() {
+  emit('confirm', expectedToken.value)
+  emit('update:modelValue', false)
+}
+</script>
+
+<style scoped>
+.fc-token {
+  font-family: 'JetBrains Mono', monospace;
+  background: rgb(var(--v-theme-surface-light));
+  padding: 6px 10px; border-radius: 4px;
+  font-size: 14px; word-break: break-all;
+}
+.fc-counts {
+  display: grid; grid-template-columns: max-content auto;
+  gap: 4px 12px;
+  font-size: 13px;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+.fc-counts-key { font-weight: 500; text-transform: capitalize; }
+.fc-counts-val { font-variant-numeric: tabular-nums; }
+</style>

frontend/src/components/modal/ImageCanvas.vue

@@ -1,14 +1,16 @@
 <template>
   <div
+    ref="canvasEl"
     class="fc-canvas"
     :class="{ 'fc-canvas--zoomed': panZoom.state.scale > 1 }"
     @wheel="panZoom.handlers.onWheel"
     @pointerdown="panZoom.handlers.onPointerDown"
     @pointermove="panZoom.handlers.onPointerMove"
     @pointerup="panZoom.handlers.onPointerUp"
-    @click="panZoom.handlers.onClick"
+    @click="onCanvasClick"
   >
     <img
+      ref="imgEl"
       :src="src" :alt="alt"
       :style="{
         transform: `translate(${panZoom.state.x}px, ${panZoom.state.y}px) scale(${panZoom.state.scale})`
@@ -19,21 +21,51 @@
 </template>
 
 <script setup>
-import { watch } from 'vue'
+import { ref, watch } from 'vue'
 import { usePanZoom } from '../../composables/usePanZoom.js'
 
 const props = defineProps({ src: String, alt: String })
+const emit = defineEmits(['close-request'])
 const panZoom = usePanZoom()
 
+const canvasEl = ref(null)
+const imgEl = ref(null)
+
 // Reset zoom when the src changes (prev/next nav).
 watch(() => props.src, () => panZoom.reset())
+
+// Click on the image → toggle zoom (IR/expected behavior). Click on
+// the haze area around the image → request close. We use the image's
+// own bounding rect rather than @click.self because the <img> sets
+// pointer-events: none for the pan-drag pathway, so the click always
+// targets the canvas div regardless of where the cursor was.
+function onCanvasClick(ev) {
+  if (panZoom.state.scale > 1) {
+    // When zoomed, any click resets zoom — preserve old behavior.
+    panZoom.handlers.onClick(ev)
+    return
+  }
+  const img = imgEl.value
+  if (!img) return
+  const r = img.getBoundingClientRect()
+  const inside =
+    ev.clientX >= r.left && ev.clientX <= r.right &&
+    ev.clientY >= r.top && ev.clientY <= r.bottom
+  if (inside) {
+    panZoom.handlers.onClick(ev)
+  } else {
+    emit('close-request')
+  }
+}
 </script>
 
 <style scoped>
 .fc-canvas {
   flex: 1;
   position: relative;
-  background: rgb(var(--v-theme-background));
+  /* Transparent so the viewer's haze shows through to the image area
+     instead of a solid panel sitting on top of it. */
+  background: transparent;
   overflow: hidden;
   cursor: zoom-in;
   user-select: none;

frontend/src/components/modal/ImageViewer.vue

@@ -2,9 +2,6 @@
   <Teleport to="body">
     <div
       class="fc-viewer" role="dialog" aria-modal="true"
-      @keydown.esc="$emit('close')"
-      @keydown.left="onArrowLeft"
-      @keydown.right="onArrowRight"
       tabindex="-1" ref="rootEl"
     >
       <button class="fc-viewer__close" @click="$emit('close')" aria-label="Close">
@@ -39,9 +36,11 @@
           <template v-else-if="modal.current">
             <ImageCanvas
               v-if="!isVideo" :src="modal.current.image_url" :alt="`Image ${modal.current.id}`"
+              @close-request="$emit('close')"
             />
             <VideoCanvas
               v-else :src="modal.current.image_url" :mime="modal.current.mime"
+              @close-request="$emit('close')"
             />
           </template>
           <v-alert v-else-if="modal.error" type="error" variant="tonal">
@@ -66,7 +65,7 @@ import VideoCanvas from './VideoCanvas.vue'
 import TagPanel from './TagPanel.vue'
 import ProvenancePanel from './ProvenancePanel.vue'
 
-defineEmits(['close'])
+const emit = defineEmits(['close'])
 
 const modal = useModalStore()
 const rootEl = ref(null)
@@ -84,14 +83,39 @@ const integrityBadge = computed(() => {
 })
 
 let prevBodyOverflow = null
+
+// Document-level keyboard handler. Bound on document (not on the modal
+// root) because <video> elements capture focus when the user interacts
+// with their controls — when video has focus, Escape and arrow keys
+// don't bubble reliably to ancestors. Listening on document side-steps
+// that. Filtered via isTextEntry so tag/comment inputs still get their
+// own keystrokes.
+function onKeyDown(ev) {
+  if (ev.key === 'Escape') {
+    if (isTextEntry(ev.target)) return
+    ev.preventDefault()
+    emit('close')
+  } else if (ev.key === 'ArrowLeft') {
+    if (isTextEntry(ev.target)) return
+    ev.preventDefault()
+    modal.goPrev()
+  } else if (ev.key === 'ArrowRight') {
+    if (isTextEntry(ev.target)) return
+    ev.preventDefault()
+    modal.goNext()
+  }
+}
+
 onMounted(async () => {
   prevBodyOverflow = document.body.style.overflow
   document.body.style.overflow = 'hidden'
+  document.addEventListener('keydown', onKeyDown, true)
   await nextFrame()
   rootEl.value?.focus()
 })
 onUnmounted(() => {
   document.body.style.overflow = prevBodyOverflow
+  document.removeEventListener('keydown', onKeyDown, true)
 })
 
 watch(() => modal.currentImageId, async () => {
@@ -103,16 +127,6 @@ function nextFrame() {
   return new Promise(resolve => requestAnimationFrame(resolve))
 }
 
-function onArrowLeft(ev) {
-  if (isTextEntry(ev.target)) return
-  ev.preventDefault()
-  modal.goPrev()
-}
-function onArrowRight(ev) {
-  if (isTextEntry(ev.target)) return
-  ev.preventDefault()
-  modal.goNext()
-}
 function isTextEntry(el) {
   if (!el) return false
   const tag = el.tagName
@@ -123,7 +137,11 @@ function isTextEntry(el) {
 <style scoped>
 .fc-viewer {
   position: fixed; inset: 0; z-index: 2000;
-  background: rgba(20, 23, 26, 0.96);
+  /* Obsidian haze (#14171A = 20,23,26) — same palette as TopNav,
+     mid-opacity + blur so the page behind shows through faintly. */
+  background: rgba(20, 23, 26, 0.65);
+  backdrop-filter: blur(8px);
+  -webkit-backdrop-filter: blur(8px);
   outline: none;
   display: flex; flex-direction: column;
 }
@@ -152,8 +170,12 @@ function isTextEntry(el) {
   flex: 1; display: flex; min-height: 0;
 }
 .fc-viewer__media {
-  flex: 1; display: flex; align-items: center; justify-content: center;
+  /* Let the canvas fill us; the canvas does its own centering. Both
-  min-width: 0;
+     min-* are needed so this child can shrink inside its flex parents
+     (without them, max-height/max-width on the <img> have nothing to
+     bound against and the image overflows the viewport). */
+  flex: 1; display: flex;
+  min-width: 0; min-height: 0;
 }
 .fc-viewer__side {
   width: 320px; flex-shrink: 0;

frontend/src/components/modal/ProvenancePanel.vue

@@ -43,6 +43,21 @@
           class="fc-prov__desc" v-html="e.post.description_html"
         />
       </article>
+
+      <!-- Fallback: image has artist_id set (folder-derived from
+           filesystem import or set by tag_apply) but no ImageProvenance
+           row exists. Show a minimal "by <artist>" line so the modal
+           isn't blank for IR-imported images that aren't in any post. -->
+      <article
+        v-if="showArtistFallback"
+        class="fc-prov__card"
+      >
+        <div class="fc-prov__meta">
+          <RouterLink :to="`/artist/${fallbackArtist.slug}`">
+            by {{ fallbackArtist.name }}
+          </RouterLink>
+        </div>
+      </article>
     </template>
 
     <div v-if="attachments.length" class="fc-prov__attach">
@@ -79,13 +94,27 @@ const state = computed(() =>
   modal.currentImageId == null ? null : prov.imageProv(modal.currentImageId)
 )
 
-// Show the panel while loading or on error, or when there is >=1 entry.
+const fallbackArtist = computed(() => modal.current?.artist || null)
-// Hide entirely when the image has zero provenance.
+
+const showArtistFallback = computed(() => {
+  const st = state.value
+  // Only show the fallback when provenance is genuinely empty (no
+  // entries, not loading, no error) AND the image has a direct
+  // artist_id we can surface.
+  if (!st || st.loading || st.error) return false
+  if (Array.isArray(st.entries) && st.entries.length > 0) return false
+  return fallbackArtist.value != null
+})
+
+// Show the panel while loading or on error, when there is >=1 entry,
+// or when the artist fallback applies (image_record.artist_id set but
+// no ImageProvenance row, e.g. filesystem-imported IR images).
 const show = computed(() => {
   const st = state.value
   if (!st) return false
   if (st.loading || st.error) return true
-  return Array.isArray(st.entries) && st.entries.length > 0
+  if (Array.isArray(st.entries) && st.entries.length > 0) return true
+  return showArtistFallback.value
 })
 
 const attachments = computed(() => state.value?.attachments || [])

frontend/src/components/modal/VideoCanvas.vue

@@ -1,10 +1,11 @@
 <template>
-  <div class="fc-canvas fc-canvas--video">
+  <div class="fc-canvas fc-canvas--video" @click.self="$emit('close-request')">
     <video
       v-if="playable" :src="src" controls playsinline preload="metadata"
       class="fc-canvas__video"
+      @click.stop
     />
-    <div v-else class="fc-canvas__unsupported">
+    <div v-else class="fc-canvas__unsupported" @click.stop>
       <v-icon size="56" icon="mdi-video-off-outline" />
       <h3 class="fc-canvas__unsupported-title">Format not browser-playable</h3>
       <p>
@@ -23,6 +24,7 @@
 <script setup>
 import { computed } from 'vue'
 
+defineEmits(['close-request'])
 const props = defineProps({ src: String, mime: String })
 
 const BROWSER_PLAYABLE = new Set([
@@ -34,7 +36,9 @@ const playable = computed(() => BROWSER_PLAYABLE.has(props.mime))
 <style scoped>
 .fc-canvas {
   flex: 1;
-  background: rgb(var(--v-theme-background));
+  /* Transparent so the viewer's haze shows through (parallels
+     ImageCanvas — both sit inside ImageViewer's blurred backdrop). */
+  background: transparent;
   display: flex; align-items: center; justify-content: center;
 }
 .fc-canvas__video { max-width: 100%; max-height: 100%; }

frontend/src/components/settings/BackupCard.vue

@@ -0,0 +1,205 @@
+<template>
+  <v-card class="fc-backup-card">
+    <v-card-title class="d-flex align-center" style="gap: 10px;">
+      <v-icon icon="mdi-database-export" size="small" />
+      <span>Backups</span>
+    </v-card-title>
+    <v-card-text>
+      <p class="fc-muted text-body-2 mb-4">
+        pg_dump for the database (fast, nightly-schedulable);
+        tar+zstd for the images (slow, manual only). Files live in
+        <code>/images/_backups/</code>. Tag a backup to protect it
+        from autoprune.
+      </p>
+
+      <v-alert
+        v-if="store.lastError"
+        type="warning" variant="tonal" density="compact" class="mb-3"
+      >
+        {{ store.lastError }}
+      </v-alert>
+
+      <!-- Database section -->
+      <h3 class="fc-section-title">Database</h3>
+      <div class="fc-settings-row mb-3">
+        <v-switch
+          :model-value="settings.backup_db_nightly_enabled"
+          color="accent" density="compact" hide-details
+          label="Nightly"
+          @update:model-value="onSettingChange('backup_db_nightly_enabled', $event)"
+        />
+        <v-text-field
+          :model-value="settings.backup_db_nightly_hour_utc"
+          label="Hour (UTC)" type="number" min="0" max="23"
+          density="compact" hide-details style="max-width: 110px;"
+          @update:model-value="onSettingChange('backup_db_nightly_hour_utc', Number($event))"
+        />
+        <v-text-field
+          :model-value="settings.backup_db_keep_last_n"
+          label="Keep last" type="number" min="1" max="365"
+          density="compact" hide-details style="max-width: 110px;"
+          @update:model-value="onSettingChange('backup_db_keep_last_n', Number($event))"
+        />
+      </div>
+      <v-btn
+        color="accent" variant="flat" rounded="pill"
+        prepend-icon="mdi-database-arrow-up" class="mb-3"
+        :loading="dbTriggering"
+        @click="onTrigger('db')"
+      >Run DB backup now</v-btn>
+
+      <BackupRunsTable
+        :runs="store.dbRuns"
+        @restore="onRestore"
+        @delete="onDelete"
+        @tag="onTag"
+      />
+
+      <v-divider class="my-4" />
+
+      <!-- Images section -->
+      <h3 class="fc-section-title">Images</h3>
+      <div class="fc-settings-row mb-3">
+        <v-text-field
+          :model-value="settings.backup_images_keep_last_n"
+          label="Keep last" type="number" min="1" max="100"
+          density="compact" hide-details style="max-width: 110px;"
+          @update:model-value="onSettingChange('backup_images_keep_last_n', Number($event))"
+        />
+      </div>
+      <v-btn
+        color="accent" variant="flat" rounded="pill"
+        prepend-icon="mdi-folder-zip" class="mb-3"
+        :loading="imagesTriggering"
+        @click="onTrigger('images')"
+      >Run images backup now</v-btn>
+      <span class="text-caption fc-muted ml-2">
+        ⓘ Hours for a 200GB+ library.
+      </span>
+
+      <BackupRunsTable
+        :runs="store.imagesRuns"
+        @restore="onRestore"
+        @delete="onDelete"
+        @tag="onTag"
+      />
+    </v-card-text>
+
+    <BackupConfirmModal
+      v-model="confirmOpen"
+      :action="confirmAction"
+      :kind="confirmKind"
+      :run-id="confirmRunId"
+      :description="confirmDescription"
+      @confirm="onConfirmSubmit"
+    />
+  </v-card>
+</template>
+
+<script setup>
+import { computed, onMounted, onUnmounted, ref } from 'vue'
+
+import { useBackupStore } from '../../stores/backup.js'
+import BackupConfirmModal from '../modal/DestructiveConfirmModal.vue'
+import BackupRunsTable from './BackupRunsTable.vue'
+
+const store = useBackupStore()
+
+const settings = computed(() => store.settings || {
+  backup_db_nightly_enabled: false,
+  backup_db_nightly_hour_utc: 3,
+  backup_db_keep_last_n: 14,
+  backup_images_keep_last_n: 3,
+})
+
+const dbTriggering = ref(false)
+const imagesTriggering = ref(false)
+const confirmOpen = ref(false)
+const confirmAction = ref('restore')
+const confirmKind = ref('db')
+const confirmRunId = ref(0)
+const confirmDescription = ref('')
+
+let pollId = null
+function pollOnce() {
+  if (document.hidden) return
+  store.loadRuns('db')
+  store.loadRuns('images')
+}
+
+onMounted(() => {
+  store.loadSettings()
+  pollOnce()
+  pollId = setInterval(pollOnce, 5000)
+})
+onUnmounted(() => {
+  if (pollId) { clearInterval(pollId); pollId = null }
+})
+
+async function onTrigger(kind) {
+  const triggeringRef = kind === 'db' ? dbTriggering : imagesTriggering
+  triggeringRef.value = true
+  try {
+    await store.triggerBackup(kind)
+    pollOnce()
+  } finally {
+    triggeringRef.value = false
+  }
+}
+
+async function onSettingChange(field, value) {
+  await store.patchSettings({ [field]: value })
+}
+
+function _openConfirm(action, run) {
+  confirmAction.value = action
+  confirmKind.value = run.kind
+  confirmRunId.value = run.id
+  confirmDescription.value = (
+    action === 'restore'
+      ? `Source artifact: ${run.kind === 'db' ? run.sql_path : run.tar_path}`
+      : 'Removes the BackupRun row and unlinks the artifact files.'
+  )
+  confirmOpen.value = true
+}
+
+function onRestore(run) { _openConfirm('restore', run) }
+function onDelete(run) { _openConfirm('delete', run) }
+
+async function onTag(run) {
+  const next = prompt(
+    `Tag for backup #${run.id} (blank to clear):`,
+    run.tag || '',
+  )
+  if (next === null) return
+  await store.setTag(run.id, next.trim() || null)
+  pollOnce()
+}
+
+async function onConfirmSubmit(token) {
+  try {
+    if (confirmAction.value === 'restore') {
+      await store.restore(confirmRunId.value, token)
+    } else {
+      await store.deleteRun(confirmRunId.value, token)
+    }
+    pollOnce()
+  } catch {
+    // store.lastError already updated; surfaced in v-alert above.
+  }
+}
+</script>
+
+<style scoped>
+.fc-backup-card { border-radius: 8px; }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-section-title {
+  font-family: 'Fraunces', Georgia, serif;
+  font-size: 16px; font-weight: 500;
+  color: rgb(var(--v-theme-on-surface));
+  margin-bottom: 8px;
+}
+.fc-settings-row {
+  display: flex; gap: 12px; align-items: center; flex-wrap: wrap;
+}
+</style>

frontend/src/components/settings/BackupRunsTable.vue

@@ -0,0 +1,109 @@
+<template>
+  <v-table density="compact" class="fc-backup-table">
+    <thead>
+      <tr>
+        <th>When</th>
+        <th>Status</th>
+        <th class="text-right">Duration</th>
+        <th class="text-right">Size</th>
+        <th>Tag</th>
+        <th class="text-right">Actions</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr v-for="r in runs" :key="r.id">
+        <td class="fc-tabular" :title="r.started_at">
+          {{ formatRelative(r.started_at) }}
+        </td>
+        <td>
+          <v-icon size="small" :color="statusColor(r.status)">
+            {{ statusIcon(r.status) }}
+          </v-icon>
+          {{ r.status }}
+        </td>
+        <td class="text-right fc-tabular">{{ formatDuration(r) }}</td>
+        <td class="text-right fc-tabular">{{ formatBytes(r.size_bytes) }}</td>
+        <td>
+          <v-chip
+            v-if="r.tag" size="x-small" color="accent" variant="tonal"
+          >{{ r.tag }}</v-chip>
+          <span v-else class="fc-muted">—</span>
+        </td>
+        <td class="text-right">
+          <v-menu>
+            <template #activator="{ props: act }">
+              <v-btn icon="mdi-dots-vertical" size="x-small" variant="text" v-bind="act" />
+            </template>
+            <v-list density="compact">
+              <v-list-item
+                :title="r.tag ? 'Untag' : 'Tag…'"
+                @click="$emit('tag', r)"
+              />
+              <v-list-item
+                title="Restore…" :disabled="r.status !== 'ok'"
+                @click="$emit('restore', r)"
+              />
+              <v-list-item
+                title="Delete…"
+                @click="$emit('delete', r)"
+              />
+            </v-list>
+          </v-menu>
+        </td>
+      </tr>
+      <tr v-if="!runs.length">
+        <td colspan="6" class="text-center fc-muted py-4">No backups yet.</td>
+      </tr>
+    </tbody>
+  </v-table>
+</template>
+
+<script setup>
+defineProps({ runs: { type: Array, default: () => [] } })
+defineEmits(['restore', 'delete', 'tag'])
+
+function statusIcon(s) {
+  return {
+    ok: 'mdi-check-circle', error: 'mdi-close-circle',
+    running: 'mdi-timer-sand', restoring: 'mdi-restore-clock',
+    restored: 'mdi-restore', pending: 'mdi-clock-outline',
+  }[s] || 'mdi-help-circle'
+}
+function statusColor(s) {
+  return {
+    ok: 'success', error: 'error',
+    running: 'accent', restoring: 'info',
+    restored: 'info', pending: 'on-surface-variant',
+  }[s] || 'on-surface-variant'
+}
+function formatDuration(r) {
+  if (r.duration_seconds == null) return '—'
+  const s = r.duration_seconds
+  if (s < 60) return `${s}s`
+  if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`
+  const h = Math.floor(s / 3600); const m = Math.floor((s % 3600) / 60)
+  return `${h}h ${m}m`
+}
+function formatBytes(b) {
+  if (b == null) return '—'
+  const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB']
+  let i = 0; let v = b
+  while (v >= 1024 && i < units.length - 1) { v /= 1024; i++ }
+  return `${v.toFixed(i === 0 ? 0 : 1)} ${units[i]}`
+}
+function formatRelative(iso) {
+  if (!iso) return '—'
+  const then = new Date(iso).getTime()
+  const diff = Math.max(0, (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`
+  return `${Math.floor(diff / 86400)}d ago`
+}
+</script>
+
+<style scoped>
+.fc-backup-table { background: transparent; }
+.fc-tabular { font-variant-numeric: tabular-nums; }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+</style>

frontend/src/components/settings/BrowserExtensionCard.vue

@@ -0,0 +1,189 @@
+<template>
+  <v-card class="fc-ext-card">
+    <v-card-title class="d-flex align-center" style="gap: 10px;">
+      <v-icon icon="mdi-puzzle" size="small" />
+      <span>Browser extension</span>
+      <span v-if="manifest?.installed" class="text-caption fc-muted">
+        · Firefox · v{{ manifest.version }}
+      </span>
+    </v-card-title>
+
+    <v-card-text>
+      <p class="fc-muted text-body-2">
+        Pushes session cookies from supported platforms
+        (patreon, subscribestar, hentaifoundry, discord, pixiv, deviantart)
+        into FabledCurator, and lets you add a creator as a source from
+        their page in one click.
+      </p>
+
+      <v-alert
+        v-if="manifestError"
+        type="warning" variant="tonal" density="compact" class="mt-3"
+      >
+        Could not load extension manifest: {{ manifestError }}
+      </v-alert>
+
+      <v-alert
+        v-else-if="manifest && !manifest.installed"
+        type="warning" variant="tonal" density="compact" class="mt-3"
+      >
+        No bundled extension found in this image. Push a release that
+        runs the extension CI workflow, or grab the XPI from the
+        FabledCurator Forgejo releases page.
+      </v-alert>
+
+      <template v-else-if="manifest?.installed">
+        <div class="fc-ext-install mt-3">
+          <v-btn
+            v-if="isFirefox"
+            color="accent" variant="flat" rounded="pill"
+            prepend-icon="mdi-firefox"
+            @click="installXpi"
+          >Install Firefox extension</v-btn>
+
+          <v-btn
+            variant="outlined" rounded="pill"
+            :href="manifest.latest_url" download
+            prepend-icon="mdi-download"
+          >Download XPI</v-btn>
+
+          <v-alert
+            v-if="!isFirefox"
+            type="info" variant="tonal" density="compact" class="mt-3"
+          >
+            Open this page in Firefox to install in one click, or use
+            "Download XPI" to install manually.
+          </v-alert>
+        </div>
+
+        <v-divider class="my-4" />
+
+        <div class="fc-muted text-body-2 mb-3">
+          After installing, open the extension's options page
+          (about:addons → FabledCurator → Preferences) and paste these:
+        </div>
+
+        <v-text-field
+          label="FC base URL" :model-value="apiUrl"
+          readonly density="compact" hide-details
+          append-inner-icon="mdi-content-copy"
+          @click:append-inner="copy(apiUrl, 'URL')"
+        />
+
+        <v-text-field
+          label="Extension API key"
+          :model-value="apiKey"
+          :type="keyShown ? 'text' : 'password'"
+          readonly density="compact" hide-details class="mt-3"
+        >
+          <template #append-inner>
+            <v-btn
+              variant="text" density="compact" size="small"
+              :icon="keyShown ? 'mdi-eye-off' : 'mdi-eye'"
+              @click="keyShown = !keyShown"
+            />
+            <v-btn
+              variant="text" density="compact" size="small"
+              icon="mdi-content-copy"
+              @click="copy(apiKey, 'API key')"
+            />
+            <v-btn
+              variant="text" density="compact" size="small"
+              icon="mdi-refresh" color="warning"
+              :loading="rotating"
+              @click="rotateKey"
+            />
+          </template>
+        </v-text-field>
+      </template>
+    </v-card-text>
+  </v-card>
+</template>
+
+<script setup>
+import { computed, onMounted, ref } from 'vue'
+import { useApi } from '../../composables/useApi.js'
+
+const api = useApi()
+
+const manifest = ref(null)
+const manifestError = ref(null)
+const apiKey = ref('')
+const keyShown = ref(false)
+const rotating = ref(false)
+
+const apiUrl = computed(() => `${window.location.origin}/api`)
+const isFirefox = computed(() => navigator.userAgent.includes('Firefox'))
+
+onMounted(async () => {
+  await Promise.all([loadManifest(), loadKey()])
+})
+
+async function loadManifest() {
+  try {
+    manifest.value = await api.get('/api/extension/manifest')
+  } catch (e) {
+    if (e.status === 404) {
+      // Backend says no XPI is bundled — surface the not-installed
+      // state, not an error.
+      manifest.value = { installed: false }
+    } else {
+      manifestError.value = e.message
+    }
+  }
+}
+
+async function loadKey() {
+  try {
+    const { key } = await api.get('/api/settings/extension_api_key')
+    apiKey.value = key
+  } catch (e) {
+    apiKey.value = ''
+    window.__fcToast?.({
+      text: `Failed to load extension API key: ${e.message}`,
+      type: 'error',
+    })
+  }
+}
+
+function installXpi() {
+  if (!manifest.value?.latest_url) return
+  window.location.assign(manifest.value.latest_url)
+}
+
+async function rotateKey() {
+  rotating.value = true
+  try {
+    const { key } = await api.post('/api/settings/extension_api_key/rotate')
+    apiKey.value = key
+    keyShown.value = true
+    window.__fcToast?.({ text: 'Extension API key rotated.', type: 'success' })
+  } catch (e) {
+    window.__fcToast?.({
+      text: `Rotate failed: ${e.message}`,
+      type: 'error',
+    })
+  } finally {
+    rotating.value = false
+  }
+}
+
+async function copy(text, label) {
+  try {
+    await navigator.clipboard.writeText(text)
+    window.__fcToast?.({ text: `${label} copied.`, type: 'success' })
+  } catch (e) {
+    window.__fcToast?.({ text: `Copy failed: ${e.message}`, type: 'error' })
+  }
+}
+</script>
+
+<style scoped>
+.fc-ext-card { border-radius: 8px; }
+.fc-ext-install {
+  display: flex; flex-wrap: wrap; gap: 8px;
+}
+.fc-muted {
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+</style>

frontend/src/components/settings/ImportTaskList.vue

@@ -17,6 +17,12 @@
       >
         Retry failed
       </v-btn>
+      <v-btn
+        variant="text" rounded="pill" size="small" color="warning"
+        :disabled="!hasStuck" @click="onClearStuckOpen"
+      >
+        Clear stuck…
+      </v-btn>
       <v-btn
         variant="text" rounded="pill" size="small" color="error"
         @click="onClearOpen"
@@ -69,6 +75,31 @@
         </v-card-actions>
       </v-card>
     </v-dialog>
+
+    <v-dialog v-model="clearStuckDialog" max-width="480">
+      <v-card>
+        <v-card-title>Clear stuck tasks</v-card-title>
+        <v-card-text>
+          <v-alert type="warning" variant="tonal" density="compact" class="mb-3">
+            Force every <strong>pending / queued / processing</strong> task to
+            <strong>failed</strong> and finalize any active batch that
+            has no remaining work. Use this when the automatic recovery
+            sweep keeps re-queueing the same row (e.g., corrupt file in
+            an autoretry loop, or worker model missing).
+          </v-alert>
+          <p class="text-body-2">
+            Tasks remain in the database with status=<code>failed</code>;
+            click <em>Retry failed</em> once the underlying cause is
+            resolved to re-queue them.
+          </p>
+        </v-card-text>
+        <v-card-actions>
+          <v-spacer />
+          <v-btn @click="clearStuckDialog = false">Cancel</v-btn>
+          <v-btn color="warning" rounded="pill" @click="onClearStuckConfirm">Clear stuck</v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
   </v-card>
 </template>
 
@@ -80,6 +111,7 @@ const store = useImportStore()
 const statusFilter = ref(null)
 const clearDialog = ref(false)
 const clearAgeDays = ref(7)
+const clearStuckDialog = ref(false)
 
 const statusOptions = [
   { title: 'All', value: null },
@@ -100,6 +132,9 @@ const headers = [
 ]
 
 const hasFailed = computed(() => store.tasks.some(t => t.status === 'failed'))
+const hasStuck = computed(() => store.tasks.some(
+  t => t.status === 'pending' || t.status === 'queued' || t.status === 'processing'
+))
 
 function statusColor(s) {
   return {
@@ -138,4 +173,9 @@ async function onClearConfirm() {
   await store.clearCompleted(clearAgeDays.value)
   clearDialog.value = false
 }
+function onClearStuckOpen() { clearStuckDialog.value = true }
+async function onClearStuckConfirm() {
+  await store.clearStuck()
+  clearStuckDialog.value = false
+}
 </script>

frontend/src/components/settings/ImportTriggerPanel.vue

@@ -2,31 +2,71 @@
   <v-card>
     <v-card-title>Trigger scan</v-card-title>
     <v-card-text>
-      <div v-if="store.activeBatch" class="d-flex align-center" style="gap: 12px;">
+      <div v-if="store.activeBatch" class="d-flex align-center mb-3" style="gap: 12px;">
         <v-progress-circular
           indeterminate color="accent" size="20"
         />
         <span>
-          Scanning {{ store.activeBatch.source_path }} —
+          {{ store.activeBatch.scan_mode === 'deep' ? 'Deep scanning' : 'Scanning' }}
+          {{ store.activeBatch.source_path || '/import' }} —
           imported {{ store.activeBatch.imported }},
+          <template v-if="store.activeBatch.scan_mode === 'deep'">
+            refreshed {{ store.activeBatch.refreshed || 0 }},
+          </template>
           skipped {{ store.activeBatch.skipped }},
           failed {{ store.activeBatch.failed }} /
           {{ store.activeBatch.total_files }} files
         </span>
+        <v-spacer />
+        <v-btn
+          variant="text" rounded="pill" size="small" color="warning"
+          :loading="clearing" @click="onClearStuck"
+        >
+          Clear stuck
+        </v-btn>
       </div>
-      <div v-else>
+
-        <p class="text-body-2 mb-3">
+      <p class="text-body-2 mb-3">
-          Run a quick scan of the import directory. Deep scan (pHash dedup,
+        <span v-if="!store.activeBatch">
-          archives) lands in FC-2d.
+          <strong>Quick scan</strong> walks <code>/import</code> and enqueues
-        </p>
+          new files only.
-        <v-btn color="primary" rounded="pill" @click="trigger" :loading="busy">
+          <strong>Deep scan</strong> additionally re-walks already-imported
+          files so updated sidecar metadata (post title/date/attribution) and
+          previously-NULL phashes / artist links get refreshed. Use after
+          bulk-downloading fresh sidecars for existing content. Both modes
+          route non-media + sidecar pairs through PostAttachment capture.
+        </span>
+        <span v-else>
+          An active batch is in progress. Wait for it to finish, or click
+          <em>Clear stuck</em> above if it has been wedged with no
+          measurable progress.
+        </span>
+      </p>
+
+      <div class="d-flex flex-wrap" style="gap: 12px;">
+        <v-btn
+          color="primary" rounded="pill"
+          :disabled="!!store.activeBatch"
+          :loading="busy === 'quick'"
+          @click="trigger('quick')"
+        >
           <v-icon start>mdi-magnify-scan</v-icon>
           Quick scan
         </v-btn>
-        <v-alert v-if="store.triggerError" type="error" variant="tonal" class="mt-3" closable>
+        <v-btn
-          {{ store.triggerError }}
+          color="secondary" rounded="pill" variant="tonal"
-        </v-alert>
+          :disabled="!!store.activeBatch"
+          :loading="busy === 'deep'"
+          @click="trigger('deep')"
+        >
+          <v-icon start>mdi-magnify-plus-outline</v-icon>
+          Deep scan
+        </v-btn>
       </div>
+
+      <v-alert v-if="store.triggerError" type="error" variant="tonal" class="mt-3" closable>
+        {{ store.triggerError }}
+      </v-alert>
     </v-card-text>
   </v-card>
 </template>
@@ -36,10 +76,22 @@ import { ref } from 'vue'
 import { useImportStore } from '../../stores/import.js'
 
 const store = useImportStore()
-const busy = ref(false)
+const busy = ref(null)
+const clearing = ref(false)
 
-async function trigger() {
+async function trigger(mode) {
-  busy.value = true
+  busy.value = mode
-  try { await store.triggerScan() } catch {} finally { busy.value = false }
+  try { await store.triggerScan(mode) } catch {} finally { busy.value = null }
+}
+
+async function onClearStuck() {
+  clearing.value = true
+  try {
+    await store.clearStuck()
+  } catch {
+    // store surfaces error via triggerError if needed
+  } finally {
+    clearing.value = false
+  }
 }
 </script>

frontend/src/components/settings/MaintenancePanel.vue

@@ -12,6 +12,8 @@
     <MLThresholdSliders class="mt-4" />
     <AllowlistTable class="mt-4" />
     <AliasTable class="mt-4" />
+    <BackupCard class="mt-6" />
+    <TagMaintenanceCard class="mt-6" />
     <LegacyMigrationCard class="mt-6" />
   </div>
 </template>
@@ -22,6 +24,8 @@ import CentroidRecomputeCard from './CentroidRecomputeCard.vue'
 import MLThresholdSliders from './MLThresholdSliders.vue'
 import AllowlistTable from './AllowlistTable.vue'
 import AliasTable from './AliasTable.vue'
+import BackupCard from './BackupCard.vue'
+import TagMaintenanceCard from './TagMaintenanceCard.vue'
 import LegacyMigrationCard from './LegacyMigrationCard.vue'
 </script>
 

frontend/src/components/settings/QueuesTable.vue

@@ -0,0 +1,109 @@
+<template>
+  <v-table density="compact" class="fc-queues-table">
+    <thead>
+      <tr>
+        <th>Queue</th>
+        <th class="text-right">Depth</th>
+        <th class="text-right">Workers</th>
+        <th v-if="!compact" class="text-right">Active</th>
+        <th class="text-right">Last min: ok / err</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr v-for="q in QUEUE_NAMES" :key="q">
+        <td>{{ q }}</td>
+        <td class="text-right fc-tabular" :class="depthClass(q)">
+          {{ formatDepth(q) }}
+        </td>
+        <td class="text-right fc-tabular">{{ workerCount(q) }}</td>
+        <td v-if="!compact" class="text-right fc-tabular">{{ activeCount(q) }}</td>
+        <td class="text-right fc-tabular">
+          <span class="fc-ok">{{ recentOk(q) }}</span>
+          <span class="fc-sep">/</span>
+          <span :class="recentErr(q) > 0 ? 'fc-err' : 'fc-muted'">
+            {{ recentErr(q) }}<span v-if="recentErr(q) > 0"> ⚠</span>
+          </span>
+        </td>
+      </tr>
+    </tbody>
+  </v-table>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+
+const props = defineProps({
+  queues: { type: Object, default: null },     // store.queues
+  workers: { type: Object, default: null },    // store.workers
+  recentMinute: { type: Array, default: () => [] }, // store.recentMinute
+  compact: { type: Boolean, default: false },
+})
+
+const QUEUE_NAMES = [
+  'default', 'import', 'thumbnail', 'ml',
+  'download', 'scan', 'maintenance',
+]
+
+function formatDepth(name) {
+  const d = props.queues?.queues?.[name]
+  if (d == null) return '—'
+  return d.toLocaleString()
+}
+
+function depthClass(name) {
+  const d = props.queues?.queues?.[name]
+  const workers = workerCount(name)
+  // Queue has depth but no workers → warning.
+  if (d != null && d > 0 && workers === 0) return 'fc-warn'
+  return ''
+}
+
+function workerCount(name) {
+  if (!props.workers?.workers) return 0
+  let count = 0
+  for (const info of Object.values(props.workers.workers)) {
+    if (info.queues?.includes(name)) count++
+  }
+  return count
+}
+
+function activeCount(name) {
+  if (!props.workers?.workers) return 0
+  // Active count is per-worker, not per-queue. Approximate: sum of
+  // active_count across workers that subscribe to this queue.
+  let count = 0
+  for (const info of Object.values(props.workers.workers)) {
+    if (info.queues?.includes(name)) count += info.active_count || 0
+  }
+  return count
+}
+
+const recentByQueue = computed(() => {
+  const out = {}
+  for (const r of props.recentMinute) {
+    if (!out[r.queue]) out[r.queue] = { ok: 0, err: 0 }
+    if (r.status === 'ok') out[r.queue].ok++
+    else if (r.status === 'error' || r.status === 'timeout') out[r.queue].err++
+  }
+  return out
+})
+
+function recentOk(name) { return recentByQueue.value[name]?.ok || 0 }
+function recentErr(name) { return recentByQueue.value[name]?.err || 0 }
+</script>
+
+<style scoped>
+.fc-queues-table { background: transparent; }
+.fc-tabular {
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: 'tnum';
+}
+.fc-ok { color: rgb(var(--v-theme-success, 76 175 80)); }
+.fc-err { color: rgb(var(--v-theme-error, 220 80 80)); }
+.fc-warn { color: rgb(var(--v-theme-warning, 255 179 0)); font-weight: 500; }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-sep {
+  margin: 0 4px;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+</style>

frontend/src/components/settings/SystemActivitySummary.vue

@@ -0,0 +1,64 @@
+<template>
+  <v-card class="fc-activity-summary">
+    <v-card-title class="d-flex align-center" style="gap: 10px;">
+      <v-icon icon="mdi-pulse" size="small" />
+      <span>System activity (last min)</span>
+      <v-spacer />
+      <v-btn
+        variant="text" size="small" rounded="pill"
+        @click="$emit('open-activity')"
+      >
+        View activity
+        <v-icon end size="small">mdi-arrow-right</v-icon>
+      </v-btn>
+    </v-card-title>
+
+    <v-card-text>
+      <v-alert
+        v-if="store.lastError"
+        type="warning" variant="tonal" density="compact" class="mb-3"
+      >
+        {{ store.lastError }}
+      </v-alert>
+
+      <QueuesTable
+        :queues="store.queues"
+        :workers="store.workers"
+        :recent-minute="store.recentMinute"
+        compact
+      />
+    </v-card-text>
+  </v-card>
+</template>
+
+<script setup>
+import { onMounted, onUnmounted } from 'vue'
+
+import { useSystemActivityStore } from '../../stores/systemActivity.js'
+import QueuesTable from './QueuesTable.vue'
+
+defineEmits(['open-activity'])
+
+const store = useSystemActivityStore()
+
+let pollId = null
+
+function pollOnce() {
+  if (document.hidden) return
+  store.loadQueues()
+  store.loadWorkers()
+  store.loadRecentMinute()
+}
+
+onMounted(() => {
+  pollOnce()
+  pollId = setInterval(pollOnce, 5000)
+})
+onUnmounted(() => {
+  if (pollId) { clearInterval(pollId); pollId = null }
+})
+</script>
+
+<style scoped>
+.fc-activity-summary { border-radius: 8px; }
+</style>

frontend/src/components/settings/SystemActivityTab.vue

@@ -0,0 +1,280 @@
+<template>
+  <div class="fc-activity">
+    <!-- Queues + workers pane -->
+    <v-card class="mb-4">
+      <v-card-title class="d-flex align-center" style="gap: 10px;">
+        <v-icon icon="mdi-pulse" size="small" />
+        <span>Queues + workers</span>
+        <v-spacer />
+        <span class="text-caption fc-muted">
+          updated {{ formatRelative(store.queues?.fetched_at) }}
+        </span>
+      </v-card-title>
+      <v-card-text>
+        <QueuesTable
+          :queues="store.queues"
+          :workers="store.workers"
+          :recent-minute="store.recentMinute"
+        />
+      </v-card-text>
+    </v-card>
+
+    <!-- Recent failures pane -->
+    <v-card class="mb-4">
+      <v-card-title class="d-flex align-center" style="gap: 10px;">
+        <v-icon icon="mdi-alert-circle-outline" size="small" />
+        <span>Recent failures (last 24h)</span>
+        <v-spacer />
+        <span class="text-caption fc-muted">
+          {{ failureCount }} failures
+        </span>
+      </v-card-title>
+      <v-card-text>
+        <div v-if="errorTypes.length" class="mb-3 fc-pills">
+          <v-chip
+            v-for="t in errorTypes" :key="t.name"
+            :color="t.name === filterErrorType ? 'accent' : undefined"
+            size="small" variant="tonal" closable
+            @click="toggleErrorTypeFilter(t.name)"
+            @click:close="toggleErrorTypeFilter(t.name)"
+          >
+            {{ t.name }} × {{ t.count }}
+          </v-chip>
+        </div>
+        <v-table density="compact">
+          <thead>
+            <tr>
+              <th>Time</th>
+              <th>Queue</th>
+              <th>Task</th>
+              <th>Target</th>
+              <th>Error</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="r in filteredFailures" :key="r.id">
+              <td class="fc-tabular" :title="r.finished_at">
+                {{ formatRelative(r.finished_at) }}
+              </td>
+              <td>{{ r.queue }}</td>
+              <td><code>{{ shortTaskName(r.task_name) }}</code></td>
+              <td class="fc-tabular">{{ r.target_id ?? '—' }}</td>
+              <td class="fc-err" :title="r.error_message">
+                {{ r.error_type }}
+              </td>
+            </tr>
+            <tr v-if="!filteredFailures.length">
+              <td colspan="5" class="text-center fc-muted py-4">
+                No failures in the last 24h.
+              </td>
+            </tr>
+          </tbody>
+        </v-table>
+      </v-card-text>
+    </v-card>
+
+    <!-- All activity pane -->
+    <v-card>
+      <v-card-title class="d-flex align-center" style="gap: 10px;">
+        <v-icon icon="mdi-format-list-bulleted" size="small" />
+        <span>All recent activity</span>
+        <v-spacer />
+        <v-select
+          v-model="filterQueue"
+          :items="queueOptions" density="compact" hide-details
+          style="max-width: 180px;"
+          @update:model-value="onFilterChange"
+        />
+        <v-select
+          v-model="filterStatus"
+          :items="statusOptions" density="compact" hide-details
+          style="max-width: 180px;"
+          @update:model-value="onFilterChange"
+        />
+        <v-btn
+          variant="text" size="small" rounded="pill"
+          @click="onRefresh"
+        >
+          <v-icon start size="small">mdi-refresh</v-icon>
+          Refresh
+        </v-btn>
+      </v-card-title>
+      <v-card-text>
+        <v-table density="compact">
+          <thead>
+            <tr>
+              <th></th>
+              <th>Time</th>
+              <th>Queue</th>
+              <th>Task</th>
+              <th>Target</th>
+              <th class="text-right">Duration</th>
+              <th>Status</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="r in store.runs" :key="r.id">
+              <td><v-icon size="small" :color="statusColor(r.status)">{{ statusIcon(r.status) }}</v-icon></td>
+              <td class="fc-tabular" :title="r.started_at">{{ formatRelative(r.started_at) }}</td>
+              <td>{{ r.queue }}</td>
+              <td><code>{{ shortTaskName(r.task_name) }}</code></td>
+              <td class="fc-tabular">{{ r.target_id ?? '—' }}</td>
+              <td class="text-right fc-tabular">{{ formatDuration(r.duration_ms) }}</td>
+              <td>{{ r.status }}</td>
+            </tr>
+            <tr v-if="!store.runs.length && !store.loading.runs">
+              <td colspan="7" class="text-center fc-muted py-4">
+                No activity yet.
+              </td>
+            </tr>
+          </tbody>
+        </v-table>
+        <div v-if="store.runsHasMore" class="d-flex justify-center py-3">
+          <v-btn
+            variant="text" size="small"
+            :loading="store.loading.runs"
+            @click="onLoadMore"
+          >Load more</v-btn>
+        </div>
+      </v-card-text>
+    </v-card>
+  </div>
+</template>
+
+<script setup>
+import { computed, onMounted, onUnmounted, ref } from 'vue'
+
+import { useSystemActivityStore } from '../../stores/systemActivity.js'
+import QueuesTable from './QueuesTable.vue'
+
+const store = useSystemActivityStore()
+
+const filterQueue = ref(null)
+const filterStatus = ref(null)
+const filterErrorType = ref(null)
+
+const queueOptions = [
+  { title: 'All queues', value: null },
+  { title: 'import', value: 'import' },
+  { title: 'thumbnail', value: 'thumbnail' },
+  { title: 'ml', value: 'ml' },
+  { title: 'download', value: 'download' },
+  { title: 'scan', value: 'scan' },
+  { title: 'maintenance', value: 'maintenance' },
+  { title: 'default', value: 'default' },
+]
+const statusOptions = [
+  { title: 'All statuses', value: null },
+  { title: 'Running', value: 'running' },
+  { title: 'OK', value: 'ok' },
+  { title: 'Error', value: 'error' },
+  { title: 'Timeout', value: 'timeout' },
+  { title: 'Retry', value: 'retry' },
+]
+
+let queuesPollId = null
+let failuresPollId = null
+
+function pollQueues() {
+  if (document.hidden) return
+  store.loadQueues()
+  store.loadWorkers()
+  store.loadRecentMinute()
+}
+function pollFailures() {
+  if (document.hidden) return
+  store.loadFailures()
+}
+
+onMounted(() => {
+  pollQueues()
+  pollFailures()
+  store.setFilter({ queue: null, status: null })
+  store.loadRuns({ reset: true })
+  queuesPollId = setInterval(pollQueues, 3000)
+  failuresPollId = setInterval(pollFailures, 15000)
+})
+onUnmounted(() => {
+  if (queuesPollId) clearInterval(queuesPollId)
+  if (failuresPollId) clearInterval(failuresPollId)
+})
+
+const errorTypes = computed(() => {
+  const counts = store.failures?.count_by_type || {}
+  return Object.entries(counts).map(([name, count]) => ({ name, count }))
+})
+
+const failureCount = computed(() => (store.failures?.recent || []).length)
+
+const filteredFailures = computed(() => {
+  const all = store.failures?.recent || []
+  if (!filterErrorType.value) return all
+  return all.filter(r => r.error_type === filterErrorType.value)
+})
+
+function toggleErrorTypeFilter(name) {
+  filterErrorType.value = filterErrorType.value === name ? null : name
+  if (filterErrorType.value) {
+    // Mirror into the All-activity table too.
+    filterStatus.value = 'error'
+    onFilterChange()
+  }
+}
+
+function onFilterChange() {
+  store.setFilter({ queue: filterQueue.value, status: filterStatus.value })
+  store.loadRuns({ reset: true })
+}
+function onLoadMore() { store.loadRuns({ reset: false }) }
+function onRefresh() { store.loadRuns({ reset: true }) }
+
+function statusIcon(status) {
+  return {
+    ok: 'mdi-check-circle',
+    error: 'mdi-close-circle',
+    timeout: 'mdi-clock-alert',
+    retry: 'mdi-refresh',
+    running: 'mdi-timer-sand',
+  }[status] || 'mdi-help-circle'
+}
+function statusColor(status) {
+  return {
+    ok: 'success', error: 'error', timeout: 'warning',
+    retry: 'info', running: 'accent',
+  }[status] || 'on-surface-variant'
+}
+function shortTaskName(name) {
+  if (!name) return ''
+  const parts = name.split('.')
+  return parts.slice(-1)[0]
+}
+function formatDuration(ms) {
+  if (ms == null) return '—'
+  if (ms < 1000) return `${ms} ms`
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)} s`
+  return `${(ms / 60_000).toFixed(1)} min`
+}
+function formatRelative(iso) {
+  if (!iso) return '—'
+  const then = new Date(iso).getTime()
+  const now = Date.now()
+  const diff = Math.max(0, (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`
+  return `${Math.floor(diff / 86400)}d ago`
+}
+</script>
+
+<style scoped>
+.fc-activity { padding: 0; }
+.fc-pills {
+  display: flex; gap: 6px; flex-wrap: wrap;
+}
+.fc-tabular {
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: 'tnum';
+}
+.fc-err { color: rgb(var(--v-theme-error, 220 80 80)); }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+</style>

frontend/src/components/settings/SystemStatsCards.vue

@@ -1,6 +1,6 @@
 <template>
   <v-row dense>
-    <v-col v-for="card in cards" :key="card.label" cols="12" sm="6" md="4" lg="2">
+    <v-col v-for="card in cards" :key="card.label" cols="12" sm="6" md="4" lg="3" xl="2">
       <v-card class="fc-stat">
         <v-card-text>
           <div class="fc-stat__label text-caption">{{ card.label }}</div>
@@ -33,15 +33,17 @@ const cards = computed(() => {
     { label: 'Total images', value: '—' },
     { label: 'Total tags', value: '—' },
     { label: 'Storage used', value: '—' },
+    { label: 'Subscriptions', value: '—' },
     { label: 'Pending tasks', value: '—' },
     { label: 'Failed tasks', value: '—' }
   ]
   return [
-    { label: 'Total images', value: s.total_images.toLocaleString() },
+    { label: 'Total images',  value: s.total_images.toLocaleString() },
-    { label: 'Total tags',   value: s.total_tags.toLocaleString() },
+    { label: 'Total tags',    value: s.total_tags.toLocaleString() },
-    { label: 'Storage used', value: formatBytes(s.storage_bytes) },
+    { label: 'Storage used',  value: formatBytes(s.storage_bytes) },
-    { label: 'Pending',      value: (s.tasks.pending + s.tasks.queued).toLocaleString() },
+    { label: 'Subscriptions', value: (s.subscription_count ?? 0).toLocaleString() },
-    { label: 'Failed',       value: s.tasks.failed.toLocaleString() }
+    { label: 'Pending',       value: (s.tasks.pending + s.tasks.queued).toLocaleString() },
+    { label: 'Failed',        value: s.tasks.failed.toLocaleString() }
   ]
 })
 </script>

frontend/src/components/settings/TagMaintenanceCard.vue

@@ -0,0 +1,95 @@
+<template>
+  <v-card class="fc-tag-maint">
+    <v-card-title class="d-flex align-center" style="gap: 10px;">
+      <v-icon icon="mdi-tag-remove" size="small" />
+      <span>Tag maintenance</span>
+    </v-card-title>
+    <v-card-text>
+      <p class="fc-muted text-body-2 mb-4">
+        Remove tags with zero image associations and zero series-page
+        references. Auto-created tag rows that never got applied get
+        swept here.
+      </p>
+
+      <v-alert
+        v-if="store.lastError"
+        type="warning" variant="tonal" density="compact" class="mb-3"
+      >{{ store.lastError }}</v-alert>
+
+      <v-btn
+        color="accent" variant="flat" rounded="pill"
+        prepend-icon="mdi-magnify"
+        :loading="loadingPreview"
+        class="mb-3"
+        @click="onPreview"
+      >Preview unused tags</v-btn>
+
+      <div v-if="preview">
+        <p class="text-body-2 mb-2">
+          <strong>{{ preview.count }}</strong> unused tag(s).
+          <span v-if="preview.count > 50" class="fc-muted">
+            Showing first 50 names.
+          </span>
+        </p>
+        <div v-if="preview.sample_names?.length" class="fc-name-grid mb-3">
+          <span v-for="n in preview.sample_names" :key="n" class="fc-name">
+            {{ n }}
+          </span>
+        </div>
+        <v-btn
+          color="error" variant="flat" rounded="pill"
+          prepend-icon="mdi-delete-sweep"
+          :disabled="!preview.count"
+          :loading="committing"
+          @click="onCommit"
+        >Delete {{ preview.count }} unused tag(s)</v-btn>
+      </div>
+    </v-card-text>
+  </v-card>
+</template>
+
+<script setup>
+import { ref } from 'vue'
+
+import { useAdminStore } from '../../stores/admin.js'
+
+const store = useAdminStore()
+const preview = ref(null)
+const loadingPreview = ref(false)
+const committing = ref(false)
+
+async function onPreview() {
+  loadingPreview.value = true
+  try {
+    preview.value = await store.pruneUnusedTags({ dryRun: true })
+  } finally {
+    loadingPreview.value = false
+  }
+}
+
+async function onCommit() {
+  committing.value = true
+  try {
+    const result = await store.pruneUnusedTags({ dryRun: false })
+    preview.value = { count: 0, sample_names: result.sample_names || [] }
+  } finally {
+    committing.value = false
+  }
+}
+</script>
+
+<style scoped>
+.fc-tag-maint { border-radius: 8px; }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-name-grid {
+  display: flex; flex-wrap: wrap; gap: 4px 8px;
+  max-height: 200px; overflow-y: auto;
+  padding: 8px; border-radius: 4px;
+  background: rgb(var(--v-theme-surface-light));
+}
+.fc-name {
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 12px;
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+</style>

frontend/src/components/subscriptions/ArtistSection.vue

@@ -1,64 +0,0 @@
-<template>
-  <section class="fc-artist-section">
-    <header class="fc-artist-section__head" @click="$emit('toggle')">
-      <v-icon :icon="open ? 'mdi-chevron-down' : 'mdi-chevron-right'" size="small" />
-      <span class="fc-artist-section__name">{{ artist.name }}</span>
-      <span class="fc-artist-section__meta">
-        {{ sources.length }} source{{ sources.length === 1 ? '' : 's' }}
-        <template v-if="latestChecked">
-          · last check {{ latestChecked }}
-        </template>
-      </span>
-    </header>
-    <div v-if="open" class="fc-artist-section__body">
-      <SourceRow
-        v-for="s in sources" :key="s.id" :source="s"
-        :checking="checkingIds.has(s.id)"
-        @edit="$emit('edit', $event)"
-        @remove="$emit('remove', $event)"
-        @toggle="$emit('toggle-source', $event)"
-        @check="$emit('check', $event)"
-      />
-      <v-btn
-        size="small" variant="text" prepend-icon="mdi-plus"
-        class="fc-artist-section__add"
-        @click="$emit('add-source', artist)"
-      >Add source to {{ artist.name }}</v-btn>
-    </div>
-  </section>
-</template>
-
-<script setup>
-import { computed } from 'vue'
-import SourceRow from './SourceRow.vue'
-
-const props = defineProps({
-  artist: { type: Object, required: true },
-  sources: { type: Array, required: true },
-  open: { type: Boolean, default: false },
-  checkingIds: { type: Set, default: () => new Set() },
-})
-defineEmits(['toggle', 'edit', 'remove', 'toggle-source', 'add-source', 'check'])
-
-const latestChecked = computed(() => {
-  const dates = props.sources.map(s => s.last_checked_at).filter(Boolean)
-  if (dates.length === 0) return null
-  const latest = dates.sort().slice(-1)[0]
-  return latest.slice(0, 10)
-})
-</script>
-
-<style scoped>
-.fc-artist-section { border-bottom: 1px solid rgb(var(--v-theme-on-surface-variant) / 0.18); }
-.fc-artist-section__head {
-  display: flex; align-items: center; gap: 0.5rem;
-  padding: 0.75rem 0; cursor: pointer; user-select: none;
-}
-.fc-artist-section__name { font-weight: 600; }
-.fc-artist-section__meta {
-  color: rgb(var(--v-theme-on-surface-variant));
-  font-size: 0.85rem;
-}
-.fc-artist-section__body { padding: 0 0 0.75rem 1.5rem; }
-.fc-artist-section__add { margin-top: 0.25rem; }
-</style>

frontend/src/components/subscriptions/SourceRow.vue

@@ -1,25 +1,63 @@
 <template>
-  <div class="fc-source-row">
+  <tr class="fc-source-row">
-    <SourceHealthDot :source="source" :warning-threshold="warningThreshold" />
+    <td class="fc-source-row__health">
-    <v-chip size="x-small" variant="tonal" class="fc-source-row__platform">
+      <SourceHealthDot :source="source" :warning-threshold="warningThreshold" />
-      {{ source.platform }}
+    </td>
-    </v-chip>
+    <td>
-    <a :href="source.url" target="_blank" rel="noopener" class="fc-source-row__url">
+      <v-chip size="x-small" variant="tonal" label>{{ source.platform }}</v-chip>
-      {{ source.url }}
+    </td>
-    </a>
+    <td class="fc-source-row__url-cell">
-    <v-switch
+      <a :href="source.url" target="_blank" rel="noopener" class="fc-source-row__url"
-      :model-value="source.enabled"
+         @click.stop>
-      density="compact" hide-details color="accent"
+        {{ source.url }}
-      @update:model-value="onToggleEnabled"
+      </a>
-    />
+    </td>
-    <v-btn
+    <td>
-      icon="mdi-play" size="x-small" variant="text"
+      <v-switch
-      :loading="checking"
+        :model-value="source.enabled"
-      @click="$emit('check', source)"
+        density="compact" hide-details color="accent"
-    />
+        @click.stop
-    <v-btn icon="mdi-pencil" size="x-small" variant="text" @click="$emit('edit', source)" />
+        @update:model-value="onToggleEnabled"
-    <v-btn icon="mdi-close" size="x-small" variant="text" @click="$emit('remove', source)" />
+      />
-  </div>
+    </td>
+    <td class="fc-source-row__when">
+      {{ formatRelative(source.last_checked_at) }}
+    </td>
+    <td class="fc-source-row__when">
+      {{ formatRelative(source.next_check_at, { future: true }) }}
+    </td>
+    <td>
+      <v-chip
+        v-if="(source.consecutive_failures || 0) > 0"
+        size="x-small" color="error" variant="tonal" label
+      >{{ source.consecutive_failures }}</v-chip>
+      <span v-else class="fc-source-row__zero">0</span>
+    </td>
+    <td class="fc-source-row__actions">
+      <v-btn
+        icon="mdi-play" size="x-small" variant="text"
+        :loading="checking"
+        @click.stop="$emit('check', source)"
+      >
+        <v-icon>mdi-play</v-icon>
+        <v-tooltip activator="parent" location="top">Check now</v-tooltip>
+      </v-btn>
+      <v-btn
+        icon="mdi-pencil" size="x-small" variant="text"
+        @click.stop="$emit('edit', source)"
+      >
+        <v-icon>mdi-pencil</v-icon>
+        <v-tooltip activator="parent" location="top">Edit</v-tooltip>
+      </v-btn>
+      <v-btn
+        icon="mdi-close" size="x-small" variant="text" color="error"
+        @click.stop="$emit('remove', source)"
+      >
+        <v-icon>mdi-close</v-icon>
+        <v-tooltip activator="parent" location="top">Remove</v-tooltip>
+      </v-btn>
+    </td>
+  </tr>
 </template>
 
 <script setup>
@@ -31,25 +69,59 @@ const props = defineProps({
   warningThreshold: { type: Number, default: 5 },
 })
 const emit = defineEmits(['edit', 'remove', 'toggle', 'check'])
+
 function onToggleEnabled(value) {
   emit('toggle', { source: props.source, enabled: value })
 }
+
+function formatRelative(iso, opts = {}) {
+  if (!iso) return opts.future ? '—' : 'Never'
+  const then = new Date(iso).getTime()
+  const now = Date.now()
+  const diff = (then - now) / 1000  // seconds; positive = future, negative = past
+  const abs = Math.abs(diff)
+
+  let body
+  if (abs < 60) body = `${Math.floor(abs)}s`
+  else if (abs < 3600) body = `${Math.floor(abs / 60)}m`
+  else if (abs < 86400) body = `${Math.floor(abs / 3600)}h`
+  else body = `${Math.floor(abs / 86400)}d`
+
+  if (opts.future) return diff <= 0 ? 'imminent' : `in ${body}`
+  return `${body} ago`
+}
 </script>
 
 <style scoped>
-.fc-source-row {
+.fc-source-row__health {
-  display: grid;
+  width: 24px;
-  grid-template-columns: auto 96px 1fr auto auto auto auto;
+  padding-right: 0 !important;
-  gap: 0.75rem;
+}
-  align-items: center;
+.fc-source-row__url-cell {
-  padding: 0.4rem 0;
+  max-width: 400px;
+  overflow: hidden;
 }
 .fc-source-row__url {
   color: rgb(var(--v-theme-on-surface-variant));
   text-decoration: none;
+  display: inline-block;
+  max-width: 100%;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 .fc-source-row__url:hover { color: rgb(var(--v-theme-accent)); }
+.fc-source-row__when {
+  color: rgb(var(--v-theme-on-surface-variant));
+  white-space: nowrap;
+  font-variant-numeric: tabular-nums;
+}
+.fc-source-row__zero {
+  color: rgb(var(--v-theme-on-surface-variant));
+  opacity: 0.6;
+}
+.fc-source-row__actions {
+  white-space: nowrap;
+  text-align: right;
+}
 </style>

frontend/src/composables/useApi.js

@@ -24,8 +24,16 @@ async function request(method, url, { body, params, signal } = {}) {
   const headers = {}
   const init = { method, headers, signal }
   if (body !== undefined) {
-    headers['Content-Type'] = 'application/json'
+    if (body instanceof FormData) {
-    init.body = JSON.stringify(body)
+      // Let the browser set Content-Type with the multipart boundary.
+      // JSON-stringifying FormData produces "{}" and the backend sees
+      // an empty multipart payload (this broke FC-5 IR/GS ingest from
+      // the UI for several releases).
+      init.body = body
+    } else {
+      headers['Content-Type'] = 'application/json'
+      init.body = JSON.stringify(body)
+    }
   }
 
   const r = await fetch(fullUrl, init)

frontend/src/composables/usePolyMasonry.js

@@ -29,10 +29,11 @@ export function distributeIntoColumns(items, columnCount) {
 }
 
 // Reactive column count from container width. Breakpoints mirror the
-// gallery grid intent: ~260px target column width, min 1 column.
+// gallery grid intent: ~390px target column width, min 1 column. Bumped
+// from 260px on 2026-05-23 per dogfood UX feedback (thumbs were too small).
 export function columnCountForWidth(width) {
   if (!width || width < 0) return 1
-  return Math.max(1, Math.floor(width / 260))
+  return Math.max(1, Math.floor(width / 390))
 }
 
 export function usePolyMasonry(containerRef) {

frontend/src/stores/admin.js

@@ -0,0 +1,153 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+
+import { useApi } from '../composables/useApi.js'
+
+export const useAdminStore = defineStore('admin', () => {
+  const api = useApi()
+  const lastError = ref(null)
+
+  // --- Tier-C: artist cascade ---------------------------------------
+
+  async function projectArtistCascade(slug) {
+    lastError.value = null
+    try {
+      return await api.post(
+        `/api/admin/artists/${encodeURIComponent(slug)}/cascade-delete`,
+        { body: { dry_run: true } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function dispatchArtistCascade(slug, confirm) {
+    lastError.value = null
+    try {
+      return await api.post(
+        `/api/admin/artists/${encodeURIComponent(slug)}/cascade-delete`,
+        { body: { dry_run: false, confirm } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  // --- Tier-C: bulk image delete ------------------------------------
+
+  async function projectBulkImageDelete(imageIds) {
+    lastError.value = null
+    try {
+      return await api.post(
+        '/api/admin/images/bulk-delete',
+        { body: { image_ids: imageIds, dry_run: true } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function dispatchBulkImageDelete(imageIds, confirm) {
+    lastError.value = null
+    try {
+      return await api.post(
+        '/api/admin/images/bulk-delete',
+        { body: { image_ids: imageIds, dry_run: false, confirm } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  // --- Tier-B: tag delete + merge -----------------------------------
+
+  async function deleteTag(tagId) {
+    lastError.value = null
+    try {
+      return await api.delete(`/api/admin/tags/${tagId}`)
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function mergeTags(destId, sourceId) {
+    lastError.value = null
+    try {
+      return await api.post(
+        `/api/admin/tags/${destId}/merge`,
+        { body: { source_id: sourceId } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function tagUsageCount(tagId) {
+    lastError.value = null
+    try {
+      const body = await api.get(`/api/admin/tags/${tagId}/usage-count`)
+      return body.count
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  // --- Tier-A: prune unused -----------------------------------------
+
+  async function pruneUnusedTags({ dryRun = true } = {}) {
+    lastError.value = null
+    try {
+      return await api.post(
+        '/api/admin/tags/prune-unused',
+        { body: { dry_run: dryRun } },
+      )
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  // --- Task progress polling (taps FC-3i activity dashboard) --------
+
+  /**
+   * Polls /api/system/activity/runs?queue=maintenance every 3s,
+   * resolves when a task_run row with the given celery task_id
+   * reaches a terminal status (ok / error / timeout). Returns the
+   * row. Times out after 30 min by default.
+   */
+  async function pollTaskUntilDone(taskId, { timeoutMs = 1_800_000 } = {}) {
+    const deadline = Date.now() + timeoutMs
+    while (Date.now() < deadline) {
+      const body = await api.get(
+        '/api/system/activity/runs',
+        { params: { queue: 'maintenance', limit: 20 } },
+      )
+      const row = (body.runs || []).find(r => r.celery_task_id === taskId)
+      if (row && ['ok', 'error', 'timeout'].includes(row.status)) {
+        return row
+      }
+      await new Promise((r) => setTimeout(r, 3000))
+    }
+    throw new Error(`task ${taskId} did not finish within ${timeoutMs}ms`)
+  }
+
+  return {
+    lastError,
+    projectArtistCascade,
+    dispatchArtistCascade,
+    projectBulkImageDelete,
+    dispatchBulkImageDelete,
+    deleteTag,
+    mergeTags,
+    tagUsageCount,
+    pruneUnusedTags,
+    pollTaskUntilDone,
+  }
+})

frontend/src/stores/backup.js

@@ -0,0 +1,109 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+
+import { useApi } from '../composables/useApi.js'
+
+export const useBackupStore = defineStore('backup', () => {
+  const api = useApi()
+
+  const dbRuns = ref([])
+  const imagesRuns = ref([])
+  const settings = ref(null)
+  const loading = ref({ dbRuns: false, imagesRuns: false, settings: false })
+  const lastError = ref(null)
+
+  async function loadRuns(kind) {
+    const targetRef = kind === 'db' ? dbRuns : imagesRuns
+    const loadingKey = kind === 'db' ? 'dbRuns' : 'imagesRuns'
+    loading.value[loadingKey] = true
+    lastError.value = null
+    try {
+      const body = await api.get('/api/system/backup/runs', {
+        params: { kind, limit: 50 },
+      })
+      targetRef.value = body.runs || []
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value[loadingKey] = false
+    }
+  }
+
+  async function triggerBackup(kind, tag = null) {
+    lastError.value = null
+    try {
+      await api.post(`/api/system/backup/${kind}`, {
+        body: tag ? { tag } : {},
+      })
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function restore(runId, confirm) {
+    lastError.value = null
+    try {
+      await api.post(`/api/system/backup/runs/${runId}/restore`, {
+        body: { confirm },
+      })
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function deleteRun(runId, confirm) {
+    lastError.value = null
+    try {
+      await api.delete(`/api/system/backup/runs/${runId}`, {
+        body: { confirm },
+      })
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function setTag(runId, tag) {
+    lastError.value = null
+    try {
+      await api.patch(`/api/system/backup/runs/${runId}`, {
+        body: { tag },
+      })
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  async function loadSettings() {
+    loading.value.settings = true
+    lastError.value = null
+    try {
+      settings.value = await api.get('/api/system/backup/settings')
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value.settings = false
+    }
+  }
+
+  async function patchSettings(patch) {
+    lastError.value = null
+    try {
+      settings.value = await api.patch('/api/system/backup/settings', {
+        body: patch,
+      })
+    } catch (e) {
+      lastError.value = e.message
+      throw e
+    }
+  }
+
+  return {
+    dbRuns, imagesRuns, settings, loading, lastError,
+    loadRuns, triggerBackup, restore, deleteRun, setTag,
+    loadSettings, patchSettings,
+  }
+})

frontend/src/stores/import.js

@@ -52,11 +52,58 @@ export const useImportStore = defineStore('import', () => {
     }
   }
 
-  async function triggerScan() {
+  async function triggerScan(mode = 'quick') {
+    if (!['quick', 'deep', 'verify'].includes(mode)) {
+      throw new Error(`unsupported scan mode: ${mode}`)
+    }
     triggerError.value = null
     try {
-      await api.post('/api/import/trigger', { body: { mode: 'quick' } })
+      await api.post('/api/import/trigger', { body: { mode } })
+      // Acknowledge immediately so the click isn't invisible. scan_directory
+      // can finalize the batch synchronously when every file in /import is
+      // already on a non-failed ImportTask (operator-flagged 2026-05-25:
+      // 233k existing tasks → all paths in skip-set → files_seen=0 →
+      // batch flashes 'running' for <100ms then 'complete' before the
+      // first refreshStatus() lands; UI never sees the active state).
+      const label = mode === 'deep'
+        ? 'Deep scan triggered (re-applying sidecar metadata + filling NULL phash/artist on existing rows)'
+        : mode === 'verify' ? 'Library verify triggered' : 'Quick scan triggered'
+      window.__fcToast?.({ text: label, type: 'success' })
       await refreshStatus()
+      // Re-poll twice over ~5s and produce an HONEST follow-up toast.
+      // Operator-flagged 2026-05-25: the prior "no new files" message was
+      // misleading because deep scan IS doing work (refresh) even when
+      // there are no new files to import. Surface the real workload count
+      // (imported + refreshed + queued) instead. For quick scan + zero
+      // queued work, fall back to "up to date" instead of the old
+      // implementation-detail-leaking message.
+      setTimeout(async () => {
+        await refreshStatus()
+        await loadTasks(true)
+        if (activeBatch.value || mode === 'verify') return
+        // Batch finalized quickly; figure out what actually happened.
+        // The task list was just refreshed; the freshest row(s) carry
+        // the batch outcome.
+        const batchId = tasks.value[0]?.batch_id
+        const sameBatch = batchId
+          ? tasks.value.filter(t => t.batch_id === batchId)
+          : []
+        const refreshedCount = sameBatch.filter(t => t.status === 'complete' && t.result_image_id).length
+        const newImported = sameBatch.filter(t => t.status === 'complete' && t.result_image_id && !t.error).length
+        if (mode === 'deep' && sameBatch.length > 0) {
+          window.__fcToast?.({
+            text: `Deep scan finished — ${sameBatch.length} file(s) processed`,
+            type: 'info',
+          })
+        } else if (mode === 'quick' && sameBatch.length > 0) {
+          window.__fcToast?.({
+            text: `Quick scan finished — ${newImported} new file(s) queued`,
+            type: 'info',
+          })
+        } else {
+          window.__fcToast?.({ text: 'Library is up to date', type: 'info' })
+        }
+      }, 2000)
     } catch (e) {
       triggerError.value = e.message
       window.__fcToast?.({ text: `Scan failed: ${e.message}`, type: 'error' })
@@ -92,6 +139,13 @@ export const useImportStore = defineStore('import', () => {
     await loadTasks(true)
   }
 
+  async function clearStuck() {
+    const body = await api.post('/api/import/clear-stuck')
+    await loadTasks(true)
+    await refreshStatus()
+    return body
+  }
+
   const hasMore = computed(() => tasksNextCursor.value !== null)
 
   return {
@@ -101,6 +155,6 @@ export const useImportStore = defineStore('import', () => {
     triggerError,
     loadSettings, patchSettings,
     refreshStatus, triggerScan,
-    loadTasks, setStatusFilter, retryFailed, clearCompleted
+    loadTasks, setStatusFilter, retryFailed, clearCompleted, clearStuck
   }
 })

frontend/src/stores/systemActivity.js

@@ -0,0 +1,103 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+
+import { useApi } from '../composables/useApi.js'
+
+export const useSystemActivityStore = defineStore('systemActivity', () => {
+  const api = useApi()
+
+  // Live polled state.
+  const queues = ref(null)       // { queues: {name: depth|null}, fetched_at }
+  const workers = ref(null)      // { workers: {hostname: {...}}, fetched_at }
+  const recentMinute = ref([])   // last-60s rows (for Overview summary)
+  const failures = ref(null)     // { recent, count_by_type, since }
+
+  // Paginated runs (Activity tab "All recent activity" pane).
+  const runs = ref([])
+  const runsCursor = ref(null)
+  const runsHasMore = ref(false)
+  const runsFilter = ref({ queue: null, status: null, limit: 50 })
+
+  const loading = ref({ queues: false, workers: false, runs: false, failures: false })
+  const lastError = ref(null)
+
+  async function loadQueues() {
+    loading.value.queues = true
+    lastError.value = null
+    try {
+      queues.value = await api.get('/api/system/activity/queues')
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value.queues = false
+    }
+  }
+
+  async function loadWorkers() {
+    loading.value.workers = true
+    lastError.value = null
+    try {
+      workers.value = await api.get('/api/system/activity/workers')
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value.workers = false
+    }
+  }
+
+  async function loadRecentMinute() {
+    // Used by the Overview summary card: pull last 60s of runs to compute
+    // per-queue ok/err counts. One call covers all queues; UI groups.
+    try {
+      const body = await api.get('/api/system/activity/runs', {
+        params: { limit: 200 },
+      })
+      recentMinute.value = body.runs || []
+    } catch (e) {
+      lastError.value = e.message
+    }
+  }
+
+  async function loadRuns({ reset = false } = {}) {
+    loading.value.runs = true
+    lastError.value = null
+    try {
+      const params = { limit: runsFilter.value.limit }
+      if (runsFilter.value.queue) params.queue = runsFilter.value.queue
+      if (runsFilter.value.status) params.status = runsFilter.value.status
+      if (!reset && runsCursor.value) params.before_id = runsCursor.value
+      const body = await api.get('/api/system/activity/runs', { params })
+      runs.value = reset ? body.runs : [...runs.value, ...body.runs]
+      runsCursor.value = body.next_cursor
+      runsHasMore.value = body.next_cursor !== null
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value.runs = false
+    }
+  }
+
+  async function loadFailures() {
+    loading.value.failures = true
+    lastError.value = null
+    try {
+      failures.value = await api.get('/api/system/activity/failures')
+    } catch (e) {
+      lastError.value = e.message
+    } finally {
+      loading.value.failures = false
+    }
+  }
+
+  function setFilter(filter) {
+    runsFilter.value = { ...runsFilter.value, ...filter }
+  }
+
+  return {
+    queues, workers, recentMinute, failures,
+    runs, runsCursor, runsHasMore, runsFilter,
+    loading, lastError,
+    loadQueues, loadWorkers, loadRecentMinute,
+    loadRuns, loadFailures, setFilter,
+  }
+})

frontend/src/views/ArtistView.vue

@@ -45,74 +45,116 @@
         >Credential health · FC-3b</v-chip>
       </div>
 
-      <section v-if="store.overview.cooccurring_tags.length" class="fc-artist__sec">
+      <!-- Tabs split (2026-05-25): Settings was previously slotted at the
-        <h2 class="fc-h2">Frequent tags</h2>
+           bottom of the page after the infinite-scroll image grid, which
-        <div class="fc-artist__tags">
+           made it effectively unreachable for any artist with more than
-          <v-chip
+           a couple of pages of content. The Settings tab now hosts
-            v-for="t in store.overview.cooccurring_tags" :key="t.id"
+           destructive admin actions (artist+content cascade-delete) and
-            size="small" @click="openTag(t.id)"
+           any future per-artist management UI. v-tabs is `position:
-          >{{ t.name }} <span class="fc-artist__tagc">{{ t.count }}</span></v-chip>
+           sticky; top: 64px` (under the 64px AppShell TopNav) so it
-        </div>
+           stays parked while the gallery scrolls. -->
-      </section>
+      <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>
 
-      <section v-if="store.overview.activity.length" class="fc-artist__sec">
+      <v-window v-model="tab">
-        <h2 class="fc-h2">Activity</h2>
+        <v-window-item value="overview">
-        <svg class="fc-artist__spark" :viewBox="`0 0 ${sparkW} ${sparkH}`"
+          <section v-if="store.overview.cooccurring_tags.length" class="fc-artist__sec">
-             preserveAspectRatio="none" role="img" aria-label="posts over time">
+            <h2 class="fc-h2">Frequent tags</h2>
-          <polyline :points="sparkPoints" fill="none"
+            <div class="fc-artist__tags">
-                    stroke="rgb(var(--v-theme-accent))" stroke-width="2" />
+              <v-chip
-        </svg>
+                v-for="t in store.overview.cooccurring_tags" :key="t.id"
-      </section>
+                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.sources.length" class="fc-artist__sec">
+          <section v-if="store.overview.activity.length" class="fc-artist__sec">
-        <div class="fc-artist__sec-head">
+            <h2 class="fc-h2">Activity</h2>
-          <h2 class="fc-h2">Sources</h2>
+            <svg class="fc-artist__spark" :viewBox="`0 0 ${sparkW} ${sparkH}`"
-          <RouterLink
+                 preserveAspectRatio="none" role="img" aria-label="posts over time">
-            :to="`/subscriptions?artist_id=${store.overview.id}`"
+              <polyline :points="sparkPoints" fill="none"
-            class="fc-artist__manage"
+                        stroke="rgb(var(--v-theme-accent))" stroke-width="2" />
-          >Manage subscriptions →</RouterLink>
+            </svg>
-        </div>
+          </section>
-        <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">
+          <section v-if="store.overview.sources.length" class="fc-artist__sec">
-        <h2 class="fc-h2">Images</h2>
+            <div class="fc-artist__sec-head">
-        <MasonryGrid
+              <h2 class="fc-h2">Sources</h2>
-          :items="store.images"
+              <RouterLink
-          :loading="store.imagesLoading"
+                :to="`/subscriptions?artist_id=${store.overview.id}`"
-          :has-more="store.hasMoreImages"
+                class="fc-artist__manage"
-          @load-more="store.loadMoreImages(slug)"
+              >Manage subscriptions →</RouterLink>
-          @open="openImage"
+            </div>
-        />
+            <v-table density="compact">
-      </section>
+              <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"
+            :artist-id="store.overview.id"
+            :artist-name="store.overview.name"
+          />
+        </v-window-item>
+      </v-window>
     </template>
   </v-container>
 </template>
 
 <script setup>
-import { computed, watch } from 'vue'
+import { computed, ref, watch } from 'vue'
 import { useRoute, useRouter, RouterLink } 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'
 
 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')
 
-watch(slug, (s) => { if (s) store.load(s) }, { immediate: true })
+watch(slug, (s) => {
+  if (s) {
+    store.load(s)
+    tab.value = 'overview'
+  }
+}, { immediate: true })
 
 const dateRange = computed(() => {
   const r = store.overview?.date_range
@@ -136,7 +178,7 @@ const sparkPoints = computed(() => {
 })
 
 function openImage(id) {
-  router.push({ name: 'gallery', query: { image: id } })
+  modal.open(id)
 }
 function openTag(tagId) {
   router.push({ name: 'gallery', query: { tag_id: tagId } })

frontend/src/views/ArtistsView.vue

@@ -84,7 +84,7 @@ onUnmounted(() => observer && observer.disconnect())
 }
 .fc-artists__grid {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(440px, 1fr));
   gap: 12px;
 }
 .fc-artists__sentinel {