Merge pull request 'fix(ui): tag-chip left-edge clipping + kind-coloured border' (#206) from dev into main

The tonal fill (esp. character = info) is intentionally faint and blends into
the dark tag rail. Add a thin border in each chip's own kind colour via
color-mix on currentColor (the tonal chip's themed foreground), defining the
edge without changing the fill. Theme-aware in both light and dark.

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

backend/app/api/settings.py

@@ -16,6 +16,7 @@ from ..models import (
     ImportTask,
     Post,
     Tag,
+    TaskRun,
 )
 from ..services import interpreter_client as ic
 
@@ -306,6 +307,10 @@ async def translation_status():
     """For the Settings card: is it on, is a URL set, is the service reachable,
     and how many posts still await translation. Health runs the sync client in a
     thread so the event loop isn't blocked."""
+    translation_tasks = (
+        "backend.app.tasks.translation.translate_posts",
+        "backend.app.tasks.translation.retranslate_posts",
+    )
     async with get_session() as session:
         cfg = await ImportSettings.load(session)
         untranslated = (await session.execute(
@@ -315,6 +320,21 @@ async def translation_status():
                 Post.post_title.is_not(None), Post.description.is_not(None),
             ))
         )).scalar_one()
+        # Live progress: is a sweep running now, and what did the last one do?
+        # (run-until-done re-enqueues itself, so `active` stays true across a
+        # bulk re-translate; `last_run` surfaces a completed run's outcome.)
+        active = (await session.execute(
+            select(func.count(TaskRun.id))
+            .where(TaskRun.task_name.in_(translation_tasks))
+            .where(TaskRun.status == "running")
+        )).scalar_one()
+        last = (await session.execute(
+            select(TaskRun.task_name, TaskRun.status, TaskRun.finished_at)
+            .where(TaskRun.task_name.in_(translation_tasks))
+            .where(TaskRun.finished_at.is_not(None))
+            .order_by(TaskRun.finished_at.desc())
+            .limit(1)
+        )).first()
     base_url = (cfg.interpreter_base_url or "").strip()
     healthy = await asyncio.to_thread(ic.health, base_url) if base_url else False
     return jsonify({
@@ -322,6 +342,12 @@ async def translation_status():
         "base_url_set": bool(base_url),
         "healthy": healthy,
         "untranslated_count": int(untranslated),
+        "active": int(active) > 0,
+        "last_run": {
+            "task": last[0].rsplit(".", 1)[-1],
+            "status": last[1],
+            "finished_at": last[2].isoformat() if last[2] else None,
+        } if last else None,
     })
 
 

backend/app/celery_app.py

@@ -115,6 +115,11 @@ def make_celery() -> Celery:
                 "task": "backend.app.tasks.maintenance.cleanup_old_tasks",
                 "schedule": 86400.0,  # daily
             },
+            "cleanup-orphaned-temp-files": {
+                "task": "backend.app.tasks.maintenance.cleanup_orphaned_temp_files",
+                "schedule": 86400.0,  # daily — sweep .part/.partial left by a
+                # download/import killed mid-write (graceful-shutdown fallout)
+            },
             "train-heads-nightly": {
                 "task": "backend.app.tasks.ml.scheduled_train_heads",
                 "schedule": 86400.0,  # passive cadence; manual retrain stays available

backend/app/tasks/maintenance.py

@@ -79,6 +79,14 @@ 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
+# Orphaned staging files: downloads/imports stage into <name>.part / <name>.partial
+# then os.replace() into place (importer / external_fetch / native_ingest_common /
+# attachment_store), so a kill mid-write leaves a discardable temp, never a corrupt
+# final. cleanup_orphaned_temp_files sweeps ones left behind; the min-age guard
+# keeps it from deleting an in-flight download's staging file mid-write.
+IMAGES_ROOT = Path("/images")
+TEMP_STAGING_SUFFIXES = (".part", ".partial")
+ORPHAN_TEMP_MIN_AGE_HOURS = 6
 
 # Audit 2026-06-02: per-entity recovery sweep thresholds. Each must be
 # > the entity's longest legitimate runtime (its task's time_limit + a
@@ -339,6 +347,34 @@ def cleanup_old_tasks() -> int:
         return result.rowcount or 0
 
 
+@celery.task(name="backend.app.tasks.maintenance.cleanup_orphaned_temp_files")
+def cleanup_orphaned_temp_files() -> int:
+    """Delete orphaned .part/.partial staging files under the images root, left by
+    a download/import killed mid-write. Only removes files older than
+    ORPHAN_TEMP_MIN_AGE_HOURS so an in-flight download's staging file is never
+    pulled out from under it. Returns the count removed."""
+    if not IMAGES_ROOT.is_dir():
+        return 0
+    cutoff = datetime.now(UTC).timestamp() - ORPHAN_TEMP_MIN_AGE_HOURS * 3600
+    removed = 0
+    for path in IMAGES_ROOT.rglob("*"):
+        if path.suffix not in TEMP_STAGING_SUFFIXES or not path.is_file():
+            continue
+        try:
+            if path.stat().st_mtime >= cutoff:
+                continue          # too fresh — may be an active download
+            path.unlink()
+            removed += 1
+        except OSError as exc:
+            log.warning("cleanup_orphaned_temp_files: %s: %s", path, exc)
+    if removed:
+        log.info(
+            "cleanup_orphaned_temp_files: removed %d orphaned staging file(s)",
+            removed,
+        )
+    return removed
+
+
 @celery.task(name="backend.app.tasks.maintenance.recover_stalled_task_runs")
 def recover_stalled_task_runs() -> int:
     """Flip task_run rows stuck in 'running' past their queue-specific

backend/app/tasks/translation.py

@@ -250,29 +250,39 @@ def _summary(status: str, translated: int, scanned: int) -> str:
     return f"translated={translated} scanned={scanned}"
 
 
+def _translate_field(text: str, base_url: str, target: str):
+    """Translate ONE field independently. Returns (translated, source_lang,
+    engine_version), or (None, None, None) when there's nothing to store — empty
+    text, already the target language, or a passthrough (engine "none"). Per-field
+    (not aggregate first-item) detection so a non-English description still gets
+    translated when the title is already English (mixed-language posts)."""
+    if not text:
+        return None, None, None
+    res = ic.translate([text], base_url=base_url, target=target)
+    detected = res["detected_lang"] or target
+    if detected == target or res["engine"] == "none":
+        return None, None, None
+    return res["translations"][0], detected, res["engine_version"]
+
+
 def _translate_one(session, post, base_url: str, target: str) -> int:
-    """Translate one post's title/description in place. Returns 1 if it stored a
-    translation, 0 for passthrough/empty (which still marks the post handled)."""
+    """Translate a post's title/description in place, each field independently.
+    Returns 1 if it stored at least one translation, 0 when the post is all
+    passthrough/empty (still marks it handled so the sweep won't revisit it)."""
     title = (post.post_title or "").strip()
     desc = (html_to_plain(post.description) if post.description else "") or ""
     desc = desc.strip()
-    fields: list[tuple[str, str]] = []
-    if title:
-        fields.append(("title", title))
-    if desc:
-        fields.append(("desc", desc))
-    if not fields:
-        post.translated_source_lang = target   # nothing to translate → handled
+    title_tr, title_lang, title_ev = _translate_field(title, base_url, target)
+    desc_tr, desc_lang, desc_ev = _translate_field(desc, base_url, target)
+    if title_tr is None and desc_tr is None:
+        # Nothing non-target (or nothing to translate) → handled, store nothing.
+        post.translated_source_lang = target
         return 0
-    res = ic.translate([t for _, t in fields], base_url=base_url, target=target)
-    detected = res["detected_lang"] or target
-    if detected == target or res["engine"] == "none":
-        post.translated_source_lang = target   # already target language → handled
-        return 0
-    by_field = {f: res["translations"][i] for i, (f, _) in enumerate(fields)}
-    post.post_title_translated = by_field.get("title")
-    post.description_translated = by_field.get("desc")
-    post.translated_source_lang = detected
-    post.translation_engine_version = res["engine_version"]
+    post.post_title_translated = title_tr
+    post.description_translated = desc_tr
+    # Source lang = whichever field was actually non-target (for a mixed post,
+    # the translated field's language, not the already-English one).
+    post.translated_source_lang = title_lang or desc_lang
+    post.translation_engine_version = title_ev or desc_ev
     post.translated_at = datetime.now(UTC)
     return 1

docker-compose.yml

@@ -8,6 +8,35 @@
 # run `docker compose up` from this directory and switches images to
 # local builds + DEBUG logging.
 
+# Rolling-deploy safety (Swarm / `docker stack deploy`): update one task at a
+# time, START the new task before stopping the old (zero-downtime via the ingress
+# mesh), and if the new task doesn't reach a healthy state within `monitor`, roll
+# back to the previous image automatically. `monitor` is sized above web's
+# healthcheck start_period so a broken image that never goes healthy is caught.
+# Plain `docker compose up` ignores `deploy:` (it warns + skips), so the dev
+# override is unaffected. Referenced by each long-lived service below.
+x-deploy-policy: &deploy_policy
+  update_config:
+    order: start-first
+    failure_action: rollback
+    monitor: 90s
+  rollback_config:
+    order: start-first
+  restart_policy:
+    condition: any
+    delay: 10s
+
+# Worker liveness: ping THIS container's celery node over the broker. Lenient
+# (60s interval, 3 retries, 60s start_period) so a transient broker blip never
+# false-flags a worker into a rollback. `$$HOSTNAME` → `$HOSTNAME` for the shell;
+# celery's default node name is celery@<hostname> (the container id).
+x-celery-healthcheck: &celery_healthcheck
+  test: ["CMD-SHELL", "celery -A backend.app.celery_app:celery inspect ping -d celery@$$HOSTNAME --timeout 10 >/dev/null 2>&1"]
+  interval: 60s
+  timeout: 15s
+  retries: 3
+  start_period: 60s
+
 services:
   redis:
     image: redis:7-alpine
@@ -55,6 +84,16 @@ services:
     # by the 5-min recovery sweeps, so a kill never corrupts. web = short HTTP
     # requests + the occasional file download.
     stop_grace_period: 30s
+    # Liveness for rolling deploys: /api/health is a no-DB 200 (just proves the
+    # app booted + serves HTTP after `alembic upgrade head`). start_period covers
+    # the migration + boot so a slow start isn't mis-flagged.
+    healthcheck:
+      test: ["CMD-SHELL", "python -c \"import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://localhost:8080/api/health', timeout=5).status==200 else 1)\""]
+      interval: 15s
+      timeout: 6s
+      retries: 3
+      start_period: 40s
+    deploy: *deploy_policy
     ports:
       - "${PORT:-8080}:8080"
     environment: &app_env
@@ -87,6 +126,8 @@ services:
     command: ["worker"]
     # Drain in-flight import/thumbnail/download tasks before SIGKILL on deploy.
     stop_grace_period: 90s
+    healthcheck: *celery_healthcheck
+    deploy: *deploy_policy
     environment:
       <<: *app_env
       CELERY_QUEUES: default,import,thumbnail,download
@@ -105,6 +146,8 @@ services:
     command: ["scheduler"]
     # Quick maintenance/scan lane + beat — short tasks, modest drain window.
     stop_grace_period: 60s
+    healthcheck: *celery_healthcheck
+    deploy: *deploy_policy
     environment:
       <<: *app_env
       CELERY_QUEUES: maintenance,scan
@@ -126,6 +169,8 @@ services:
     # the most room to finish a chunk gracefully. Chunked + idempotent, so a job
     # that still outruns this resumes cleanly next run rather than corrupting.
     stop_grace_period: 180s
+    healthcheck: *celery_healthcheck
+    deploy: *deploy_policy
     environment:
       <<: *app_env
       CELERY_QUEUES: maintenance_long
@@ -143,6 +188,8 @@ services:
     command: ["ml-worker"]
     # A single GPU inference pass can run tens of seconds — let it finish.
     stop_grace_period: 120s
+    healthcheck: *celery_healthcheck
+    deploy: *deploy_policy
     environment:
       <<: *app_env
     volumes:

frontend/src/components/modal/TagChip.vue

@@ -1,7 +1,7 @@
 <template>
   <span class="fc-tag-chip" @mouseenter="onEnter" @mouseleave="onLeave">
     <v-chip
-      size="small" :closable="!unconfirmedAuto"
+      size="default" :closable="!unconfirmedAuto"
       :color="store.colorFor(tag.kind)" variant="tonal"
       class="fc-tag-chip__nav"
       role="link"
@@ -9,7 +9,7 @@
       @click="$emit('navigate', tag)"
       @click:close="$emit('remove', tag.id)"
     >
-      <v-icon start size="x-small">{{ iconFor(tag.kind) }}</v-icon>
+      <v-icon start size="small">{{ iconFor(tag.kind) }}</v-icon>
       <span class="fc-tag-chip__name">{{ tag.name }}</span><v-icon
         v-if="tag.is_system" end size="x-small" class="fc-tag-chip__system"
         title="System tag — tagged items are excluded from training other concepts"
@@ -27,13 +27,13 @@
           :title="`Yes — keep “${tag.name}” (trains the model, won't be retracted)`"
           :aria-label="`Confirm ${tag.name}`"
           @click.stop="$emit('confirm', tag)"
-        ><v-icon size="13">mdi-check</v-icon></button>
+        ><v-icon size="15">mdi-check</v-icon></button>
         <button
           type="button" class="fc-tag-chip__no"
           :title="`No — remove “${tag.name}”`"
           :aria-label="`Reject ${tag.name}`"
           @click.stop="$emit('remove', tag.id)"
-        ><v-icon size="13">mdi-close</v-icon></button>
+        ><v-icon size="15">mdi-close</v-icon></button>
       </span>
     </v-chip>
     <!-- Modal-safe kebab is baked into KebabMenu (this chip lives in the
@@ -143,7 +143,19 @@ function iconFor (k) { return KIND_ICONS[k] || 'mdi-tag' }
    chip's hover title. */
 .fc-tag-chip { display: inline-flex; align-items: center; gap: 1px; max-width: 100%; min-width: 0; }
 .fc-tag-chip__nav { max-width: 100%; min-width: 0; }
+/* Tonal chips (esp. character = info) wash out against the dark rail — the fill
+   is intentionally faint. Give every tag chip a thin border in its OWN kind
+   colour (currentColor = the tonal chip's themed foreground) so the edge reads
+   clearly without touching the fill (operator-asked 2026-07-08). Theme-aware:
+   currentColor tracks the kind colour in either light or dark. */
+.fc-tag-chip__nav { border: thin solid color-mix(in srgb, currentColor 55%, transparent); }
 .fc-tag-chip__nav :deep(.v-chip__content) { min-width: 0; overflow: hidden; }
+/* The bigger size=default chip widens Vuetify's negative start-margin on the
+   leading kind-icon, pulling it LEFT of the content box above — where that
+   overflow:hidden then clips the icon's left edge as a vertical slice
+   (operator-flagged 2026-07-08). Zero the pull so the icon sits inside the clip
+   box; the chip's own 12px padding keeps a comfortable left inset. */
+.fc-tag-chip__nav :deep(.v-icon--start) { margin-inline-start: 0; }
 .fc-tag-chip__name {
   overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
   min-width: 0; flex: 0 1 auto;
@@ -159,23 +171,27 @@ function iconFor (k) { return KIND_ICONS[k] || 'mdi-tag' }
 .fc-tag-chip__kebab { opacity: 0.7; }
 .fc-tag-chip:hover .fc-tag-chip__kebab { opacity: 1; }
 .fc-tag-chip__fandom { opacity: 0.7; font-size: 0.85em; }
-/* Provisional auto-tag: a compact green ✓ / red ✗ pair in place of the ✕. The
-   yes/no is obvious enough on its own, so there's no "auto" label (operator-asked
+/* Provisional auto-tag: a green ✓ / red ✗ pair in place of the ✕. The yes/no is
+   obvious enough on its own, so there's no "auto" label (operator-asked
    2026-07-07). flex:0 0 auto keeps it visible while the name ellipsis-truncates. */
 .fc-tag-chip__verdict {
-  flex: 0 0 auto; display: inline-flex; align-items: center; gap: 1px;
-  margin-left: 3px;
+  flex: 0 0 auto; display: inline-flex; align-items: center; gap: 3px;
+  margin-left: 5px;
 }
+/* Solid-filled (white glyph on a full success/error circle) so accept/reject
+   stay well-defined even on a muted tonal chip — e.g. character (info) — instead
+   of a faint icon that only lit up on hover. Mirrors the Suggestions rail's
+   verdict buttons so the affordance reads identically (operator-asked 2026-07-08). */
 .fc-tag-chip__yes, .fc-tag-chip__no {
   display: inline-flex; align-items: center; justify-content: center;
-  width: 18px; height: 18px; padding: 0; border: none; border-radius: 50%;
-  background: transparent; cursor: pointer; transition: background 0.1s;
+  width: 22px; height: 22px; padding: 0; border: none; border-radius: 50%;
+  color: #fff; cursor: pointer; opacity: 0.92;
+  transition: transform 0.1s, opacity 0.1s;
 }
-.fc-tag-chip__yes { color: rgb(var(--v-theme-success)); }
-.fc-tag-chip__no { color: rgb(var(--v-theme-error)); }
-.fc-tag-chip__yes:hover { background: rgb(var(--v-theme-success), 0.16); }
-.fc-tag-chip__no:hover { background: rgb(var(--v-theme-error), 0.16); }
+.fc-tag-chip__yes { background: rgb(var(--v-theme-success)); }
+.fc-tag-chip__no { background: rgb(var(--v-theme-error)); }
+.fc-tag-chip__yes:hover, .fc-tag-chip__no:hover { opacity: 1; transform: scale(1.1); }
 .fc-tag-chip__yes:focus-visible, .fc-tag-chip__no:focus-visible {
-  outline: 2px solid rgb(var(--v-theme-accent)); outline-offset: 1px;
+  outline: 2px solid rgb(var(--v-theme-accent)); outline-offset: 2px;
 }
 </style>

frontend/src/components/settings/TranslationCard.vue

@@ -52,11 +52,25 @@
         prepend-icon="mdi-refresh" :loading="retranslating"
         :disabled="!enabled || !baseUrl" @click="confirmAll = true"
       >Re-translate all</v-btn>
-      <span v-if="status" class="fc-muted text-caption">
+      <span
+        v-if="status && status.active"
+        class="fc-muted text-caption d-inline-flex align-center" style="gap: 6px;"
+      >
+        <v-progress-circular indeterminate size="12" width="2" color="accent" />
+        Translating… {{ status.untranslated_count }} remaining
+      </span>
+      <span v-else-if="status" class="fc-muted text-caption">
         {{ status.untranslated_count }}
         post{{ status.untranslated_count === 1 ? '' : 's' }} awaiting translation
       </span>
     </div>
+    <p
+      v-if="status && status.last_run && ['error', 'timeout'].includes(status.last_run.status)"
+      class="text-caption text-error mt-1 mb-0"
+    >
+      Last translation run ended with “{{ status.last_run.status }}”. It resumes on
+      the next sweep; check the Interpreter connection if it persists.
+    </p>
     <p class="fc-muted text-caption mt-2 mb-0">
       Use <strong>Re-translate all</strong> after switching the Interpreter model —
       it clears every stored translation and re-runs it through the new model
@@ -94,7 +108,7 @@
 </template>
 
 <script setup>
-import { computed, onMounted, ref } from 'vue'
+import { computed, onMounted, onUnmounted, ref } from 'vue'
 import { toast } from '../../utils/toast.js'
 import { useApi } from '../../composables/useApi.js'
 import { useImportStore } from '../../stores/import.js'
@@ -126,10 +140,16 @@ const statusText = computed(() => {
   return status.value.healthy ? 'Interpreter reachable' : 'Interpreter unreachable'
 })
 
+let pollTimer = null
 async function loadStatus() {
   try { status.value = await api.get('/api/settings/translation/status') }
   catch { status.value = null }
+  // Poll live while a sweep is running so the remaining count ticks down; stop
+  // when idle (a fresh trigger restarts it via its own setTimeout(loadStatus)).
+  clearTimeout(pollTimer)
+  if (status.value?.active) pollTimer = setTimeout(loadStatus, 3000)
 }
+onUnmounted(() => clearTimeout(pollTimer))
 
 async function onTest() {
   // Ping /v1/health for the CURRENTLY-typed URL (not the saved one), so a new

tests/test_api_settings.py

@@ -61,6 +61,34 @@ async def test_translation_status_defaults(client):
     assert body["base_url_set"] is False
     assert body["healthy"] is False
     assert "untranslated_count" in body
+    assert body["active"] is False      # no sweep running
+    assert body["last_run"] is None
+
+
+@pytest.mark.asyncio
+async def test_translation_status_reports_active_and_last_run(client, db):
+    # A running translate/retranslate TaskRun → active True; the most recent
+    # finished one → last_run (task basename + status).
+    from datetime import UTC, datetime
+
+    from backend.app.models import TaskRun
+
+    db.add(TaskRun(
+        celery_task_id="r-run", queue="maintenance_long",
+        task_name="backend.app.tasks.translation.retranslate_posts",
+        started_at=datetime.now(UTC), status="running",
+    ))
+    db.add(TaskRun(
+        celery_task_id="r-done", queue="maintenance_long",
+        task_name="backend.app.tasks.translation.translate_posts",
+        started_at=datetime.now(UTC), finished_at=datetime.now(UTC),
+        status="success",
+    ))
+    await db.commit()
+    body = await (await client.get("/api/settings/translation/status")).get_json()
+    assert body["active"] is True
+    assert body["last_run"]["task"] == "translate_posts"
+    assert body["last_run"]["status"] == "success"
 
 
 @pytest.mark.asyncio

tests/test_maintenance.py

@@ -26,6 +26,28 @@ def _make_batch(session) -> int:
     return batch.id
 
 
+def test_cleanup_orphaned_temp_files_removes_stale_only(tmp_path, monkeypatch):
+    import os
+
+    from backend.app.tasks import maintenance as m
+
+    monkeypatch.setattr(m, "IMAGES_ROOT", tmp_path)
+    stale = tmp_path / "artist" / "img.jpg.part"      # killed download → orphan
+    stale.parent.mkdir(parents=True)
+    stale.write_bytes(b"x")
+    old = datetime.now(UTC).timestamp() - 8 * 3600     # older than the 6h guard
+    os.utime(stale, (old, old))
+    fresh = tmp_path / "in_progress.jpg.partial"       # active download → keep
+    fresh.write_bytes(b"x")
+    keep = tmp_path / "real.jpg"                        # a real image → keep
+    keep.write_bytes(b"x")
+
+    assert m.cleanup_orphaned_temp_files() == 1
+    assert not stale.exists()
+    assert fresh.exists()
+    assert keep.exists()
+
+
 def test_recover_interrupted_only_old(db_sync, monkeypatch):
     batch_id = _make_batch(db_sync)
     now = datetime.now(UTC)

tests/test_translate_posts.py

@@ -115,6 +115,35 @@ def test_translate_posts_passthrough_english_marks_handled(db_sync, monkeypatch)
     assert p.post_title_translated is None       # ...but nothing to show
 
 
+def test_translate_posts_mixed_language_translates_nonenglish_field(db_sync, monkeypatch):
+    # English title + Japanese description: the description is still translated
+    # even though the title is already English (per-field detection, not the old
+    # aggregate first-item bail). Source lang comes from the translated field.
+    _patch(monkeypatch, db_sync)
+    monkeypatch.setattr("backend.app.tasks.translation.ic.health", lambda *a, **k: True)
+
+    def fake_translate(texts, **k):
+        t = texts[0]
+        if t.isascii():   # already English → passthrough
+            return {"translations": [t], "detected_lang": "en",
+                    "engine": "none", "engine_version": None}
+        return {"translations": [f"EN:{t}"], "detected_lang": "ja",
+                "engine": "llm", "engine_version": "v9"}
+
+    monkeypatch.setattr("backend.app.tasks.translation.ic.translate", fake_translate)
+    a = _artist(db_sync)
+    p = _post(db_sync, a.id, title="hello", desc="ねこ")
+    _enable(db_sync)
+    db_sync.commit()
+
+    assert "translated=1" in translate_posts()
+    db_sync.refresh(p)
+    assert p.post_title_translated is None          # English title untouched
+    assert p.description_translated == "EN:ねこ"      # Japanese desc translated
+    assert p.translated_source_lang == "ja"          # from the translated field
+    assert p.translation_engine_version == "v9"
+
+
 def test_translate_posts_disabled_is_noop(db_sync, monkeypatch):
     _patch(monkeypatch, db_sync)
     a = _artist(db_sync)