refactor(ml): retire the Camie tagger + allowlist bulk-apply (#1189)

Heads + CCIP are the tag source and head auto-apply is the earned propagation.
The Camie tagger ran only to feed the allowlist bulk-apply (its ImagePrediction
rows had no other consumer), and the allowlist was a SECOND, un-earned auto-apply
path firing in parallel with heads on every accept — exactly the un-earned spray
the v2 pivot replaced. Retire both.

Behavior change: accepting a suggestion now applies the tag to THAT image only
(source='ml_accepted', a head-training positive) — it no longer allowlists +
fans the tag across the library via Camie. Propagation is heads' earned
auto-apply. (Loses instant cold-start propagation for booru-vocab tags; that was
un-earned and bypassed the precision gate.)

- tag_and_embed is now EMBED-ONLY (no Camie load/infer, no ImagePrediction
  writes); backfill enqueues it for images with no embedding.
- Removed: services/ml/tagger.py, apply_allowlist_tags + helpers + daily beat +
  every enqueue caller (accept/alias/merge/per-image), api/allowlist.py +
  blueprint, ImagePrediction + TagAllowlist models/tables (migration 0067),
  AllowlistTable.vue + allowlist store, the accept coverage-projection payload.
- AllowlistService gutted to accept/dismiss/undismiss/reject (the rejection store
  the rail still needs); accept returns nothing, API returns {accepted, tag_id}.
- tag merge no longer repoints/triggers the allowlist; _keep_as_alias now keys on
  ML-applied image_tag sources (incl. head_auto) instead of the allowlist.
- UI: MLBackfillCard relabelled to embedding-only; accept toast simplified;
  MaintenancePanel drops the allowlist tile.

Left for a follow-up hygiene pass (now-inert, harmless): the dead settings
columns (tagger_store_floor, tagger_model_version, suggestion_threshold_*,
video_min_tag_frames), image_record.tagger_model_version, MLThresholdSliders
trim, and the Camie model download in download_models.py.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ttrj5P7upUTueSfoJcxEqa

tests/_prediction_helpers.py

@@ -1,21 +0,0 @@
-"""#768 test helper: seed image_prediction rows.
-
-Read-path tests used to seed ImageRecord(tagger_predictions={...}); predictions
-now live in the normalized image_prediction table, so seed there instead.
-"""
-from backend.app.models import ImagePrediction
-
-
-async def seed_predictions(session, image_id: int, predictions: dict) -> None:
-    """Insert image_prediction rows from a {raw_name: {category, confidence}}
-    dict (the old JSON shape). Caller commits/flushes as needed; this flushes."""
-    session.add_all([
-        ImagePrediction(
-            image_record_id=image_id,
-            raw_name=name,
-            category=p.get("category", "general"),
-            score=float(p.get("confidence", 0.0)),
-        )
-        for name, p in predictions.items()
-    ])
-    await session.flush()

tests/test_api_allowlist.py

@@ -1,88 +0,0 @@
-import pytest
-
-from backend.app.models import ImagePrediction, ImageRecord, TagAllowlist, TagKind
-from backend.app.services.tag_service import TagService
-
-pytestmark = pytest.mark.integration
-
-
-@pytest.mark.asyncio
-async def test_list_and_patch_and_delete(client, db):
-    tag = await TagService(db).find_or_create("AL", TagKind.character)
-    db.add(TagAllowlist(tag_id=tag.id, min_confidence=0.95))
-    await db.commit()
-
-    resp = await client.get("/api/allowlist")
-    assert resp.status_code == 200
-    assert any(r["tag_id"] == tag.id for r in await resp.get_json())
-
-    resp = await client.patch(
-        f"/api/tags/{tag.id}/allowlist", json={"min_confidence": 0.80}
-    )
-    assert resp.status_code == 204
-
-    resp = await client.get(f"/api/tags/{tag.id}/allowlist")
-    assert (await resp.get_json())["min_confidence"] == pytest.approx(0.80)
-
-    resp = await client.delete(f"/api/tags/{tag.id}/allowlist")
-    assert resp.status_code == 204
-    resp = await client.get(f"/api/tags/{tag.id}/allowlist")
-    assert resp.status_code == 404
-
-
-@pytest.mark.asyncio
-async def test_patch_rejects_out_of_range(client, db):
-    tag = await TagService(db).find_or_create("AL2", TagKind.character)
-    db.add(TagAllowlist(tag_id=tag.id))
-    await db.commit()
-    resp = await client.patch(
-        f"/api/tags/{tag.id}/allowlist", json={"min_confidence": 1.5}
-    )
-    assert resp.status_code == 400
-
-
-@pytest.mark.asyncio
-async def test_coverage_endpoint(client, db):
-    tag = await TagService(db).find_or_create("Cover", TagKind.general)
-    db.add(TagAllowlist(tag_id=tag.id, min_confidence=0.90))
-    for i, score in enumerate((0.95, 0.60)):
-        img = ImageRecord(
-            path=f"/images/cov{i}.jpg", sha256=f"cv{i:062d}", size_bytes=1,
-            mime="image/jpeg", width=1, height=1,
-            origin="imported_filesystem", integrity_status="unknown",
-        )
-        db.add(img)
-        await db.flush()
-        db.add(ImagePrediction(
-            image_record_id=img.id, raw_name="Cover",
-            category="general", score=score,
-        ))
-    await db.commit()
-
-    # Explicit threshold.
-    resp = await client.get(
-        f"/api/tags/{tag.id}/allowlist/coverage?threshold=0.90"
-    )
-    assert resp.status_code == 200
-    assert (await resp.get_json())["count"] == 1
-    # Lower what-if threshold widens coverage.
-    resp = await client.get(
-        f"/api/tags/{tag.id}/allowlist/coverage?threshold=0.50"
-    )
-    assert (await resp.get_json())["count"] == 2
-    # No threshold → uses the stored min_confidence (0.90).
-    resp = await client.get(f"/api/tags/{tag.id}/allowlist/coverage")
-    body = await resp.get_json()
-    assert body["count"] == 1
-    assert body["threshold"] == pytest.approx(0.90)
-
-
-@pytest.mark.asyncio
-async def test_coverage_rejects_bad_threshold(client, db):
-    tag = await TagService(db).find_or_create("Cover2", TagKind.general)
-    db.add(TagAllowlist(tag_id=tag.id))
-    await db.commit()
-    resp = await client.get(
-        f"/api/tags/{tag.id}/allowlist/coverage?threshold=2.0"
-    )
-    assert resp.status_code == 400

tests/test_api_suggestions.py

@@ -15,9 +15,7 @@ def eager():
     celery.conf.task_always_eager = False
 
 
-async def _img(db, preds, sha="s" * 64):
-    from tests._prediction_helpers import seed_predictions
-
+async def _img(db, sha="s" * 64):
     img = ImageRecord(
         path=f"/images/{sha}.jpg", sha256=sha, size_bytes=1,
         mime="image/jpeg", width=1, height=1,
@@ -25,8 +23,6 @@ async def _img(db, preds, sha="s" * 64):
     )
     db.add(img)
     await db.commit()
-    await seed_predictions(db, img.id, preds)
-    await db.commit()
     return img
 
 
@@ -60,7 +56,7 @@ async def test_get_suggestions(client, db):
 
 @pytest.mark.asyncio
 async def test_accept_requires_tag_id(client, db):
-    img = await _img(db, {})
+    img = await _img(db)
     resp = await client.post(
         f"/api/images/{img.id}/suggestions/accept", json={}
     )
@@ -68,43 +64,31 @@ async def test_accept_requires_tag_id(client, db):
 
 
 @pytest.mark.asyncio
-async def test_accept_then_applied(client, db):
-    img = await _img(db, {})
+async def test_accept_applies_tag_to_image(client, db):
+    # Camie/allowlist retired (#1189): accept applies the tag to THIS image
+    # (source='ml_accepted', a head-training positive) — no bulk allowlist
+    # fan-out anymore.
+    from backend.app.models.tag import image_tag
+
+    img = await _img(db)
     tag = await TagService(db).find_or_create("AcceptMe", TagKind.character)
     await db.commit()
     resp = await client.post(
         f"/api/images/{img.id}/suggestions/accept", json={"tag_id": tag.id}
     )
     assert resp.status_code == 200
-    body = await resp.get_json()
-    # #7b: a fresh accept newly-allowlists → projection payload for the toast.
-    assert body["allowlisted"] is True
-    assert body["tag_id"] == tag.id
-    assert body["tag_name"] == "AcceptMe"
-    assert "projected_count" in body
-
-
-@pytest.mark.asyncio
-async def test_accept_already_allowlisted_reports_not_new(client, db):
-    img1 = await _img(db, {}, sha="c" * 64)
-    img2 = await _img(db, {}, sha="d" * 64)
-    tag = await TagService(db).find_or_create("Twice", TagKind.character)
-    await db.commit()
-    first = await client.post(
-        f"/api/images/{img1.id}/suggestions/accept", json={"tag_id": tag.id}
-    )
-    assert (await first.get_json())["allowlisted"] is True
-    second = await client.post(
-        f"/api/images/{img2.id}/suggestions/accept", json={"tag_id": tag.id}
-    )
-    body = await second.get_json()
-    assert body["allowlisted"] is False   # already on the allowlist
-    assert "projected_count" not in body
+    assert (await resp.get_json())["accepted"] is True
+    src = (await db.execute(
+        select(image_tag.c.source)
+        .where(image_tag.c.image_record_id == img.id)
+        .where(image_tag.c.tag_id == tag.id)
+    )).scalar_one()
+    assert src == "ml_accepted"
 
 
 @pytest.mark.asyncio
 async def test_dismiss(client, db):
-    img = await _img(db, {})
+    img = await _img(db)
     tag = await TagService(db).find_or_create("DismissMe", TagKind.general)
     await db.commit()
     resp = await client.post(
@@ -115,7 +99,7 @@ async def test_dismiss(client, db):
 
 @pytest.mark.asyncio
 async def test_undismiss_reverses_rejection(client, db):
-    img = await _img(db, {})
+    img = await _img(db)
     tag = await TagService(db).find_or_create("UndismissMe", TagKind.general)
     await db.commit()
     await client.post(
@@ -134,7 +118,7 @@ async def test_undismiss_reverses_rejection(client, db):
 
 @pytest.mark.asyncio
 async def test_alias_requires_fields(client, db):
-    img = await _img(db, {})
+    img = await _img(db)
     resp = await client.post(
         f"/api/images/{img.id}/suggestions/alias", json={"alias_string": "x"}
     )

tests/test_api_tag_merge.py

@@ -68,15 +68,7 @@ async def test_rename_collision_returns_rich_409(client):
 
 
 @pytest.mark.asyncio
-async def test_merge_endpoint_moves_and_deletes(client, monkeypatch):
-    calls = []
-    from backend.app.tasks import ml as ml_tasks
-
-    monkeypatch.setattr(
-        ml_tasks.apply_allowlist_tags,
-        "delay",
-        lambda **kw: calls.append(kw),
-    )
+async def test_merge_endpoint_moves_and_deletes(client):
     tgt = await _mk(client, "Keep", "general")
     src = await _mk(client, "Gone", "general")
     resp = await client.post(
@@ -92,36 +84,6 @@ async def test_merge_endpoint_moves_and_deletes(client, monkeypatch):
     assert r2.status_code == 200
 
 
-@pytest.mark.asyncio
-async def test_merge_enqueues_backfill_when_target_allowlisted(
-    client, monkeypatch
-):
-    calls = []
-    from backend.app.tasks import ml as ml_tasks
-
-    monkeypatch.setattr(
-        ml_tasks.apply_allowlist_tags,
-        "delay",
-        lambda **kw: calls.append(kw),
-    )
-    tgt = await _mk(client, "AllowTgt", "general")
-    src = await _mk(client, "AllowSrc", "general")
-    # No public route adds a tag to the allowlist (it happens via
-    # accept-suggestion); set the row directly through the app session.
-    from backend.app.extensions import get_session
-    from backend.app.models.tag_allowlist import TagAllowlist
-
-    async with get_session() as s:
-        s.add(TagAllowlist(tag_id=tgt))
-        await s.commit()
-
-    resp = await client.post(
-        f"/api/tags/{src}/merge", json={"target_id": tgt}
-    )
-    assert resp.status_code == 200
-    assert calls == [{"tag_id": tgt}]
-
-
 @pytest.mark.asyncio
 async def test_merge_self_is_400(client):
     t = await _mk(client, "Selfie", "general")

tests/test_image_prediction.py

@@ -1,57 +0,0 @@
-"""#768: image_prediction table — model + constraints round-trip."""
-import pytest
-from sqlalchemy import select
-from sqlalchemy.exc import IntegrityError
-
-from backend.app.models import ImagePrediction, ImageRecord
-
-pytestmark = pytest.mark.integration
-
-
-async def _make_image(db, path="/img/p0.jpg", sha="0"):
-    rec = ImageRecord(
-        path=path, sha256=sha.ljust(64, "0")[:64], size_bytes=10,
-        mime="image/jpeg", origin="imported_filesystem",
-    )
-    db.add(rec)
-    await db.flush()
-    return rec
-
-
-@pytest.mark.asyncio
-async def test_image_prediction_round_trip(db):
-    rec = await _make_image(db)
-    db.add_all([
-        ImagePrediction(
-            image_record_id=rec.id, raw_name="blue_eyes",
-            category="general", score=0.92,
-        ),
-        ImagePrediction(
-            image_record_id=rec.id, raw_name="hatsune_miku",
-            category="character", score=0.88,
-        ),
-    ])
-    await db.commit()
-
-    rows = (await db.execute(
-        select(ImagePrediction.raw_name, ImagePrediction.score)
-        .where(ImagePrediction.image_record_id == rec.id)
-        .order_by(ImagePrediction.score.desc())
-    )).all()
-    assert [r.raw_name for r in rows] == ["blue_eyes", "hatsune_miku"]
-
-
-@pytest.mark.asyncio
-async def test_image_prediction_unique_per_image_name(db):
-    rec = await _make_image(db, path="/img/p1.jpg", sha="1")
-    db.add(ImagePrediction(
-        image_record_id=rec.id, raw_name="dup",
-        category="general", score=0.9,
-    ))
-    await db.commit()
-    db.add(ImagePrediction(
-        image_record_id=rec.id, raw_name="dup",
-        category="general", score=0.7,
-    ))
-    with pytest.raises(IntegrityError):
-        await db.commit()

tests/test_migration_0003.py

@@ -5,14 +5,12 @@ from backend.app.models import (
     ImageRecord,
     MLSettings,
     TagAlias,
-    TagAllowlist,
     TagSuggestionRejection,
 )
 
 
 def test_new_tables_registered():
     expected = {
-        "tag_allowlist",
         "tag_suggestion_rejection",
         "tag_alias",
         "ml_settings",
@@ -40,11 +38,6 @@ def test_ml_settings_singleton_constraint():
     assert "ck_ml_settings_singleton" in names
 
 
-def test_tag_allowlist_confidence_check():
-    names = {c.name for c in TagAllowlist.__table__.constraints}
-    assert "ck_tag_allowlist_confidence_range" in names
-
-
 def test_tag_suggestion_rejection_pk():
     pk_cols = {c.name for c in TagSuggestionRejection.__table__.primary_key.columns}
     assert pk_cols == {"image_record_id", "tag_id"}

tests/test_ml_allowlist.py

@@ -1,182 +0,0 @@
-import pytest
-from sqlalchemy import select
-
-from backend.app.models import (
-    ImagePrediction,
-    TagAlias,
-    TagAllowlist,
-    TagKind,
-    TagSuggestionRejection,
-)
-from backend.app.models.tag import image_tag
-from backend.app.services.ml.allowlist import AllowlistService
-from backend.app.services.tag_service import TagService
-
-pytestmark = pytest.mark.integration
-
-
-async def _make_image(db, sha: str = "x" * 64):
-    from backend.app.models import ImageRecord
-    img = ImageRecord(
-        # Full sha in the path — the first 8 chars collide for sequential
-        # shas like c{i:063d}, and path is UNIQUE (uq_image_record_path).
-        path=f"/images/{sha}.jpg", sha256=sha, size_bytes=1,
-        mime="image/jpeg", width=1, height=1,
-        origin="imported_filesystem", integrity_status="unknown",
-    )
-    db.add(img)
-    await db.flush()
-    return img
-
-
-async def _add_pred(db, image_id, raw_name, score, category="general"):
-    db.add(ImagePrediction(
-        image_record_id=image_id, raw_name=raw_name,
-        category=category, score=score,
-    ))
-    await db.flush()
-
-
-@pytest.mark.asyncio
-async def test_accept_applies_and_allowlists(db):
-    img = await _make_image(db)
-    tag = await TagService(db).find_or_create("Hero", TagKind.character)
-    svc = AllowlistService(db)
-    newly_added = await svc.accept(img.id, tag.id)
-    assert newly_added is True
-
-    applied = (
-        await db.execute(
-            select(image_tag.c.source)
-            .where(image_tag.c.image_record_id == img.id)
-            .where(image_tag.c.tag_id == tag.id)
-        )
-    ).scalar_one()
-    assert applied == "ml_accepted"
-    assert await db.get(TagAllowlist, tag.id) is not None
-
-
-@pytest.mark.asyncio
-async def test_accept_idempotent_allowlist(db):
-    img = await _make_image(db)
-    tag = await TagService(db).find_or_create("Hero2", TagKind.character)
-    svc = AllowlistService(db)
-    assert await svc.accept(img.id, tag.id) is True
-    assert await svc.accept(img.id, tag.id) is False
-
-
-@pytest.mark.asyncio
-async def test_reject_applied_tag_records_rejection(db):
-    img = await _make_image(db)
-    tag = await TagService(db).find_or_create("Removeme", TagKind.general)
-    svc = AllowlistService(db)
-    await svc.accept(img.id, tag.id)
-    await svc.reject_applied_tag(img.id, tag.id)
-
-    still_applied = (
-        await db.execute(
-            select(image_tag.c.tag_id)
-            .where(image_tag.c.image_record_id == img.id)
-            .where(image_tag.c.tag_id == tag.id)
-        )
-    ).scalar_one_or_none()
-    assert still_applied is None
-    rej = await db.get(TagSuggestionRejection, (img.id, tag.id))
-    assert rej is not None
-
-
-@pytest.mark.asyncio
-async def test_dismiss_records_rejection(db):
-    img = await _make_image(db)
-    tag = await TagService(db).find_or_create("Dismissme", TagKind.general)
-    await AllowlistService(db).dismiss(img.id, tag.id)
-    assert await db.get(TagSuggestionRejection, (img.id, tag.id)) is not None
-
-
-@pytest.mark.asyncio
-async def test_add_alias_and_accept(db):
-    img = await _make_image(db)
-    canonical = await TagService(db).find_or_create(
-        "Canonical Char", TagKind.character
-    )
-    svc = AllowlistService(db)
-    await svc.add_alias_and_accept(
-        img.id, "model_char_name", "character", canonical.id
-    )
-    from backend.app.services.ml.aliases import AliasService
-    resolved = await AliasService(db).resolve("model_char_name", "character")
-    assert resolved.id == canonical.id
-    assert await db.get(TagAllowlist, canonical.id) is not None
-
-
-@pytest.mark.asyncio
-async def test_update_threshold_and_remove(db):
-    tag = await TagService(db).find_or_create("Thr", TagKind.general)
-    svc = AllowlistService(db)
-    img = await _make_image(db)
-    await svc.accept(img.id, tag.id)
-    await svc.update_threshold(tag.id, 0.80)
-    row = await db.get(TagAllowlist, tag.id)
-    assert abs(row.min_confidence - 0.80) < 1e-6
-    await svc.remove(tag.id)
-    assert await db.get(TagAllowlist, tag.id) is None
-
-
-@pytest.mark.asyncio
-async def test_coverage_by_threshold_direct_name(db):
-    tag = await TagService(db).find_or_create("Cov", TagKind.general)
-    svc = AllowlistService(db)
-    for i, score in enumerate((0.95, 0.80, 0.60)):
-        img = await _make_image(db, sha=f"c{i:063d}")
-        await _add_pred(db, img.id, "Cov", score)
-    assert await svc.coverage(tag.id, 0.90) == 1
-    assert await svc.coverage(tag.id, 0.70) == 2
-    assert await svc.coverage(tag.id, 0.50) == 3
-
-
-@pytest.mark.asyncio
-async def test_coverage_via_alias_respects_category(db):
-    tag = await TagService(db).find_or_create("Aliased", TagKind.character)
-    db.add(TagAlias(
-        alias_string="model_key", alias_category="character",
-        canonical_tag_id=tag.id,
-    ))
-    await db.flush()
-    svc = AllowlistService(db)
-    hit = await _make_image(db, sha=f"a{0:063d}")
-    await _add_pred(db, hit.id, "model_key", 0.92, category="character")
-    # Same alias string but wrong category must NOT resolve to the tag.
-    miss = await _make_image(db, sha=f"a{1:063d}")
-    await _add_pred(db, miss.id, "model_key", 0.99, category="general")
-    assert await svc.coverage(tag.id, 0.90) == 1
-
-
-@pytest.mark.asyncio
-async def test_list_all_reports_applied_and_coverage(db):
-    tag = await TagService(db).find_or_create("Both", TagKind.general)
-    svc = AllowlistService(db)
-    applied_img = await _make_image(db, sha=f"b{0:063d}")
-    await svc.accept(applied_img.id, tag.id)  # applies + allowlists
-    await _add_pred(db, applied_img.id, "Both", 0.95)
-    # A second image only has a qualifying prediction (covered, not applied).
-    cov_img = await _make_image(db, sha=f"b{1:063d}")
-    await _add_pred(db, cov_img.id, "Both", 0.95)
-
-    rows = await svc.list_all()
-    row = next(r for r in rows if r.tag_id == tag.id)
-    assert row.applied_count == 1                 # only the accepted image
-    assert row.coverage_count == 2                # both have a ≥threshold pred
-
-
-@pytest.mark.asyncio
-async def test_update_threshold_clamped_to_store_floor(db):
-    # A min_confidence below the store floor (default 0.70) is clamped up —
-    # predictions below the floor aren't stored, so a lower threshold can't
-    # apply more permissively than the floor (#764).
-    tag = await TagService(db).find_or_create("Lowthr", TagKind.general)
-    svc = AllowlistService(db)
-    img = await _make_image(db)
-    await svc.accept(img.id, tag.id)
-    await svc.update_threshold(tag.id, 0.30)
-    row = await db.get(TagAllowlist, tag.id)
-    assert abs(row.min_confidence - 0.70) < 1e-6

tests/test_ml_artist_retired.py

@@ -3,11 +3,6 @@ import pytest
 pytestmark = pytest.mark.integration
 
 
-def test_artist_not_surfaced():
-    from backend.app.services.ml.tagger import SURFACED_CATEGORIES
-    assert "artist" not in SURFACED_CATEGORIES
-
-
 def test_artist_not_head_eligible():
     # Tagging-v2: suggestions come from heads, and heads are only trained for
     # general/character concepts — so 'artist' (and any other kind) can't surface.

tests/test_ml_tagger.py

@@ -1,54 +0,0 @@
-"""Tagger unit tests. The ONNX model isn't available in CI (it's a 1GB
-download into /models), so these test the pure-logic surface:
-DEFAULT_STORE_FLOOR constant, SURFACED_CATEGORIES set, TagPrediction
-dataclass, and the load()-missing-file error path. Full inference is
-exercised by the local integration suite against a real /models volume.
-"""
-
-import pytest
-
-from backend.app.services.ml.tagger import (
-    DEFAULT_STORE_FLOOR,
-    SURFACED_CATEGORIES,
-    Tagger,
-    TagPrediction,
-    get_tagger,
-)
-
-
-def test_surfaced_categories():
-    # FC-2d-vii-c: 'artist' retired — artist identity is acquisition-
-    # derived (image_record.artist_id), never ML-inferred.
-    # 2026-06-01: 'copyright' retired — fandom serves as the franchise/
-    # copyright concept; operator doesn't use a separate copyright kind.
-    assert SURFACED_CATEGORIES == {"character", "general"}
-    assert "artist" not in SURFACED_CATEGORIES
-    assert "copyright" not in SURFACED_CATEGORIES
-
-
-def test_default_store_floor():
-    # Raised 0.05 → 0.70 (plan-task #764): the suggestion path filters at
-    # 0.70 and the centroid path covers lower-confidence preferred tags, so
-    # storing the sub-0.70 tail was redundant (100 GB of TOAST). The live
-    # value is DB-backed (ml_settings.tagger_store_floor); this is the default.
-    assert DEFAULT_STORE_FLOOR == 0.70
-
-
-def test_tag_prediction_dataclass():
-    p = TagPrediction(name="x", category="general", confidence=0.9)
-    assert p.name == "x"
-    assert p.category == "general"
-    assert p.confidence == 0.9
-
-
-def test_get_tagger_singleton():
-    assert get_tagger() is get_tagger()
-
-
-def test_load_raises_when_model_missing(tmp_path):
-    t = Tagger(model_dir=tmp_path / "nonexistent")
-    # Match the trailing "missing at <path>" rather than the specific
-    # filename, so a future model-version bump (camie-tagger-v3.onnx, etc.)
-    # doesn't bounce this test.
-    with pytest.raises(RuntimeError, match=r"\.onnx missing at "):
-        t.load()

tests/test_phash_dedup.py

@@ -11,7 +11,6 @@ from PIL import Image
 from sqlalchemy import func, select
 
 from backend.app.models import (
-    ImagePrediction,
     ImageProvenance,
     ImageRecord,
     ImportSettings,
@@ -119,11 +118,6 @@ def test_smaller_existing_is_superseded(importer, import_layout):
             image_record_id=eid, tag_id=tag.id, source="manual"
         )
     )
-    importer.session.add(
-        ImagePrediction(
-            image_record_id=eid, raw_name="x", category="general", score=0.9
-        )
-    )
     old.siglip_embedding = [0.0] * 1152
     old.integrity_status = "ok"
     importer.session.commit()
@@ -141,11 +135,6 @@ def test_smaller_existing_is_superseded(importer, import_layout):
     assert row.path != old_path
     assert row.phash is not None
     assert row.integrity_status == "unknown"
-    # #768: re-import clears the normalized predictions too
-    assert importer.session.execute(
-        select(func.count()).select_from(ImagePrediction)
-        .where(ImagePrediction.image_record_id == eid)
-    ).scalar_one() == 0
     assert row.siglip_embedding is None
     linked = importer.session.execute(
         select(image_tag.c.tag_id).where(

tests/test_tag_merge.py

@@ -2,7 +2,6 @@ import pytest
 from sqlalchemy import func, select
 
 from backend.app.models import Tag, TagKind, image_tag
-from backend.app.models.tag_allowlist import TagAllowlist
 from backend.app.services.tag_service import (
     MergeResult,
     TagMergeConflict,
@@ -110,18 +109,6 @@ async def test_will_alias_true_when_machine_sourced(db):
     assert ei.value.will_alias is True
 
 
-@pytest.mark.asyncio
-async def test_will_alias_true_when_allowlisted(db):
-    svc = TagService(db)
-    await svc.find_or_create("Canon2", TagKind.general)
-    source = await svc.find_or_create("Allowed", TagKind.general)
-    db.add(TagAllowlist(tag_id=source.id))
-    await db.flush()
-    with pytest.raises(TagMergeConflict) as ei:
-        await svc.rename(source.id, "Canon2")
-    assert ei.value.will_alias is True
-
-
 @pytest.mark.asyncio
 async def test_merge_rejects_self_merge(db):
     svc = TagService(db)
@@ -250,35 +237,6 @@ async def test_merge_dedups_suggestion_rejections(db):
     ).first() is None
 
 
-@pytest.mark.asyncio
-async def test_merge_allowlist_target_has_keeps_target_threshold(db):
-    svc = TagService(db)
-    a = await svc.find_or_create("SrcAL", TagKind.general)
-    b = await svc.find_or_create("TgtAL", TagKind.general)
-    db.add(TagAllowlist(tag_id=a.id, min_confidence=0.5))
-    db.add(TagAllowlist(tag_id=b.id, min_confidence=0.9))
-    await db.flush()
-    await svc.merge(a.id, b.id)
-    rows = (await db.execute(select(TagAllowlist))).scalars().all()
-    assert len(rows) == 1
-    assert rows[0].tag_id == b.id
-    assert rows[0].min_confidence == 0.9
-
-
-@pytest.mark.asyncio
-async def test_merge_allowlist_source_only_moves_to_target(db):
-    svc = TagService(db)
-    a = await svc.find_or_create("SrcAL2", TagKind.general)
-    b = await svc.find_or_create("TgtAL2", TagKind.general)
-    db.add(TagAllowlist(tag_id=a.id, min_confidence=0.42))
-    await db.flush()
-    await svc.merge(a.id, b.id)
-    rows = (await db.execute(select(TagAllowlist))).scalars().all()
-    assert len(rows) == 1
-    assert rows[0].tag_id == b.id
-    assert rows[0].min_confidence == 0.42
-
-
 @pytest.mark.asyncio
 async def test_merge_repoints_existing_aliases(db):
     from backend.app.models.tag_alias import TagAlias
@@ -372,7 +330,9 @@ async def test_alias_fallback_to_kind_when_no_predictions(db):
     svc = TagService(db)
     a = await svc.find_or_create("AllowNoPred", TagKind.character)
     b = await svc.find_or_create("CanonF", TagKind.character)
-    db.add(TagAllowlist(tag_id=a.id))
+    # Machine-known via a prior accept (source='ml_accepted') → kept as alias.
+    img = await _img(db)
+    await svc.add_to_image(img, a.id, source="ml_accepted")
     await db.flush()
     result = await svc.merge(a.id, b.id)
     assert result.alias_created is True

tests/test_tasks_ml.py

@@ -1,15 +1,12 @@
-"""tag_and_embed / backfill task tests. Models aren't in CI, so we test
-the pure helpers (_aggregate_video_predictions, _is_video) as unit tests, and
-the DB-touching backfill query as an integration test with monkeypatched
-inference.
-"""
+"""tag_and_embed (embed-only) / backfill task tests. The pure _is_video helper
+is a unit test; the DB-touching backfill query is an integration test with
+monkeypatched dispatch."""
 
 from pathlib import Path
 
 import pytest
 
-from backend.app.services.ml.tagger import TagPrediction
-from backend.app.tasks.ml import _aggregate_video_predictions, _is_video
+from backend.app.tasks.ml import _is_video
 
 
 def test_is_video():
@@ -18,34 +15,6 @@ def test_is_video():
     assert _is_video(Path("a.jpg")) is False
 
 
-def _pred(name, conf, cat="general"):
-    return {name: TagPrediction(name, cat, conf)}
-
-
-def test_aggregate_video_keeps_corroborated_and_means():
-    # #747: 4 frames; "smile" in 3, "sword" in 1 (noise). min_frames=2.
-    per_frame = [
-        {"smile": TagPrediction("smile", "general", 0.6),
-         "sword": TagPrediction("sword", "general", 0.9)},
-        _pred("smile", 0.8),
-        _pred("smile", 0.7),
-        {},
-    ]
-    out = _aggregate_video_predictions(per_frame, min_frames=2)
-    assert "sword" not in out  # one-frame flicker dropped
-    assert abs(out["smile"]["confidence"] - (0.6 + 0.8 + 0.7) / 3) < 1e-9  # mean, not max
-
-
-def test_aggregate_video_clamps_min_frames_to_sample_count():
-    # Short video: 1 frame but min_frames=3 — clamp so it still tags.
-    out = _aggregate_video_predictions([_pred("solo", 0.8)], min_frames=3)
-    assert out["solo"]["confidence"] == 0.8
-
-
-def test_aggregate_video_empty():
-    assert _aggregate_video_predictions([], min_frames=3) == {}
-
-
 @pytest.mark.integration
 @pytest.mark.asyncio
 async def test_backfill_enqueues_missing(db, monkeypatch):
@@ -69,75 +38,3 @@ async def test_backfill_enqueues_missing(db, monkeypatch):
     count = ml_tasks.backfill()
     assert count >= 1
     assert img.id in calls
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_apply_allowlist_applies_above_threshold(db):
-    from sqlalchemy import select
-
-    from backend.app.models import ImageRecord, TagAllowlist, TagKind
-    from backend.app.models.tag import image_tag
-    from backend.app.services.tag_service import TagService
-    from backend.app.tasks import ml as ml_tasks
-    from tests._prediction_helpers import seed_predictions
-
-    tag = await TagService(db).find_or_create("autohero", TagKind.character)
-    db.add(TagAllowlist(tag_id=tag.id, min_confidence=0.95))
-    img = ImageRecord(
-        path="/images/al.jpg", sha256="al" + "0" * 62, size_bytes=1,
-        mime="image/jpeg", width=1, height=1,
-        origin="imported_filesystem", integrity_status="unknown",
-    )
-    db.add(img)
-    await db.commit()
-    await seed_predictions(
-        db, img.id, {"autohero": {"category": "character", "confidence": 0.97}}
-    )
-    await db.commit()
-
-    n = ml_tasks.apply_allowlist_tags(tag_id=tag.id)
-    assert n >= 1
-    src = (
-        await db.execute(
-            select(image_tag.c.source)
-            .where(image_tag.c.image_record_id == img.id)
-            .where(image_tag.c.tag_id == tag.id)
-        )
-    ).scalar_one()
-    assert src == "ml_auto"
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_apply_allowlist_skips_below_threshold(db):
-    from sqlalchemy import select
-
-    from backend.app.models import ImageRecord, TagAllowlist, TagKind
-    from backend.app.models.tag import image_tag
-    from backend.app.services.tag_service import TagService
-    from backend.app.tasks import ml as ml_tasks
-    from tests._prediction_helpers import seed_predictions
-
-    tag = await TagService(db).find_or_create("lowconf", TagKind.character)
-    db.add(TagAllowlist(tag_id=tag.id, min_confidence=0.95))
-    img = ImageRecord(
-        path="/images/lc.jpg", sha256="lc" + "0" * 62, size_bytes=1,
-        mime="image/jpeg", width=1, height=1,
-        origin="imported_filesystem", integrity_status="unknown",
-    )
-    db.add(img)
-    await db.commit()
-    await seed_predictions(
-        db, img.id, {"lowconf": {"category": "character", "confidence": 0.40}}
-    )
-    await db.commit()
-    ml_tasks.apply_allowlist_tags(tag_id=tag.id)
-    applied = (
-        await db.execute(
-            select(image_tag.c.tag_id)
-            .where(image_tag.c.image_record_id == img.id)
-            .where(image_tag.c.tag_id == tag.id)
-        )
-    ).scalar_one_or_none()
-    assert applied is None