feat(suggestions): heads are the suggestion source — Camie + centroid removed (#114 C)

The rail's Suggestions now come from the trained per-concept heads. SuggestionService.for_image scores the image's frozen SigLIP embedding against
every head (heads.score_image) and surfaces concepts above each head's own
suggest threshold; the typed-dropdown's min=0 "show everything" mode maps to a
flat floor so any head-scored concept can still be picked. Already-applied tags
drop; rejected tags stay flagged + reversible (unchanged).

REMOVED from the suggestion path (rule 22, no fallback): the Camie
ImagePrediction candidate/alias/merge pipeline and the per-tag centroid
augmentation, plus the now-dead SuggestionService internals (_load_predictions,
_threshold_for, _settings, self.aliases, self.centroids). Head suggestions are
always canonical tags, so raw_name/via_alias are null/false and the rail's
alias kebab is inert by data (its removal + the Camie ingest-tagger rip are the
flagged follow-up). for_selection (bulk consensus) now aggregates head
suggestions unchanged.

Tests rewritten to the head path: test_ml_suggestions (surfaces/applied/
rejected-reversible/override/no-embedding/no-heads), test_suggestions_bulk
(consensus), test_api_suggestions (get + dropped the Camie-alias roundtrip),
and test_ml_artist_retired (artist not head-eligible via _HEAD_KINDS).

DEPLOY NOTE: after this lands, the rail is empty until you run Train heads
(Settings → Tagging → Concept heads) — deploy, train, then the rail populates.

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

tests/test_api_suggestions.py

@@ -1,7 +1,8 @@
 import pytest
+from sqlalchemy import select
 
 from backend.app.celery_app import celery
-from backend.app.models import ImageRecord, TagKind
+from backend.app.models import ImageRecord, MLSettings, TagHead, TagKind
 from backend.app.services.tag_service import TagService
 
 pytestmark = pytest.mark.integration
@@ -31,13 +32,30 @@ async def _img(db, preds, sha="s" * 64):
 
 @pytest.mark.asyncio
 async def test_get_suggestions(client, db):
-    img = await _img(
-        db, {"sword": {"category": "general", "confidence": 0.97}}
+    # Suggestions come from a trained head now (Camie/centroid removed): an image
+    # whose embedding aligns with the head surfaces that concept.
+    s = (await db.execute(select(MLSettings).where(MLSettings.id == 1))).scalar_one()
+    img = ImageRecord(
+        path="/images/headsug.jpg", sha256="h" * 64, size_bytes=1,
+        mime="image/jpeg", width=1, height=1, origin="imported_filesystem",
+        integrity_status="unknown", siglip_embedding=[3.0] + [0.0] * 1151,
     )
+    db.add(img)
+    await db.flush()
+    tag = await TagService(db).find_or_create("sword", TagKind.general)
+    db.add(TagHead(
+        tag_id=tag.id, embedding_version=s.embedder_model_version,
+        weights=[1.0] + [0.0] * 1151, bias=0.0, suggest_threshold=0.5,
+        auto_apply_threshold=None, n_pos=10, n_neg=30,
+        ap=0.8, precision_cv=0.9, recall=0.6,
+    ))
+    await db.commit()
     resp = await client.get(f"/api/images/{img.id}/suggestions")
     assert resp.status_code == 200
     body = await resp.get_json()
-    assert "general" in body["by_category"]
+    general = body["by_category"].get("general", [])
+    s2 = next(x for x in general if x["canonical_tag_id"] == tag.id)
+    assert s2["source"] == "head"
 
 
 @pytest.mark.asyncio
@@ -121,67 +139,3 @@ async def test_alias_requires_fields(client, db):
         f"/api/images/{img.id}/suggestions/alias", json={"alias_string": "x"}
     )
     assert resp.status_code == 400
-
-
-async def _img_at(db, path, sha, preds):
-    from tests._prediction_helpers import seed_predictions
-
-    img = ImageRecord(
-        path=path, sha256=sha, 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, preds)
-    await db.commit()
-    return img
-
-
-@pytest.mark.asyncio
-async def test_alias_roundtrip_resolves_by_raw_key(client, db):
-    """Locks the modal-alias contract: the suggestion exposes the RAW model key,
-    an alias authored with that key resolves on a later image, and the resolved
-    suggestion is flagged via_alias. (Pre-fix the modal stored the normalized
-    display name, which never resolved.)"""
-    canonical = await TagService(db).find_or_create(
-        "Sasuke Uchiha", TagKind.character
-    )
-    await db.commit()
-    preds = {"uchiha_sasuke": {"category": "character", "confidence": 0.99}}
-    img_a = await _img_at(db, "/images/alias_a.jpg", "a" * 64, preds)
-
-    # (a) raw_name is exposed so the modal can author the alias with it; the
-    # raw prediction doesn't textually match the tag, so it'd otherwise be +new.
-    body = await (
-        await client.get(f"/api/images/{img_a.id}/suggestions")
-    ).get_json()
-    sug = body["by_category"]["character"][0]
-    assert sug["raw_name"] == "uchiha_sasuke"
-    assert sug["via_alias"] is False
-    assert sug["creates_new_tag"] is True
-
-    # Author the alias keyed by the RAW key (what the frontend now sends).
-    resp = await client.post(
-        f"/api/images/{img_a.id}/suggestions/alias",
-        json={
-            "alias_string": sug["raw_name"],
-            "alias_category": "character",
-            "canonical_tag_id": canonical.id,
-        },
-    )
-    assert resp.status_code == 200
-    assert (await resp.get_json())["allowlisted"] is True
-
-    # (b) A DIFFERENT image with the same prediction now resolves via the alias
-    # (image A's tag is applied, so it's filtered there). Had the alias been
-    # stored under the display name, this would NOT resolve.
-    img_b = await _img_at(db, "/images/alias_b.jpg", "b" * 64, preds)
-    body_b = await (
-        await client.get(f"/api/images/{img_b.id}/suggestions")
-    ).get_json()
-    sug_b = body_b["by_category"]["character"][0]
-    assert sug_b["canonical_tag_id"] == canonical.id
-    assert sug_b["via_alias"] is True
-    assert sug_b["creates_new_tag"] is False
-    assert sug_b["raw_name"] == "uchiha_sasuke"

tests/test_ml_artist_retired.py

@@ -14,14 +14,12 @@ def test_artist_not_centroid_eligible():
     assert TagKind.artist not in ELIGIBLE_KINDS
 
 
-def test_threshold_for_artist_is_unsurfaced():
-    from backend.app.services.ml.suggestions import SuggestionService
+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.
+    from backend.app.models import TagKind
+    from backend.app.services.ml.heads import _HEAD_KINDS
 
-    class _S:
-        suggestion_threshold_character = 0.5
-        suggestion_threshold_general = 0.5
-
-    svc = SuggestionService.__new__(SuggestionService)
-    # 'artist' and 'copyright' both retired — fall through to 1.01
-    assert svc._threshold_for(_S(), "artist") == 1.01
-    assert svc._threshold_for(_S(), "copyright") == 1.01
+    assert TagKind.general in _HEAD_KINDS
+    assert TagKind.character in _HEAD_KINDS
+    assert TagKind.artist not in _HEAD_KINDS

tests/test_ml_suggestions.py

@@ -1,8 +1,11 @@
+"""Suggestion read-path (tagging-v2): suggestions come from trained HEADS, not
+Camie predictions or centroids. Heads are inserted directly (training needs
+scikit-learn, ml image only); scoring is numpy-only (available via pgvector)."""
 import pytest
+from sqlalchemy import select
 
-from backend.app.models import ImageRecord, TagKind
+from backend.app.models import ImageRecord, MLSettings, TagHead, TagKind
 from backend.app.models.tag import image_tag
-from backend.app.services.ml.aliases import AliasService
 from backend.app.services.ml.allowlist import AllowlistService
 from backend.app.services.ml.suggestions import SuggestionService
 from backend.app.services.tag_service import TagService
@@ -10,179 +13,121 @@ from backend.app.services.tag_service import TagService
 pytestmark = pytest.mark.integration
 
 
-def _img(sha: str) -> ImageRecord:
-    return ImageRecord(
-        path=f"/images/{sha}.jpg",
-        sha256=sha,
-        size_bytes=1,
-        mime="image/jpeg",
-        width=1,
-        height=1,
-        origin="imported_filesystem",
-        integrity_status="unknown",
+def _emb(slot: int, val: float = 3.0) -> list[float]:
+    """An embedding pointing along axis `slot` (so its L2-normalized form is the
+    unit vector e_slot — a head with weights e_slot scores it sigmoid(1)≈0.73)."""
+    v = [0.0] * 1152
+    v[slot] = val
+    return v
+
+
+async def _img(db, sha: str, emb=None) -> ImageRecord:
+    img = ImageRecord(
+        path=f"/images/{sha}.jpg", sha256=sha, size_bytes=1, mime="image/jpeg",
+        width=1, height=1, origin="imported_filesystem",
+        integrity_status="unknown", siglip_embedding=emb,
     )
-
-
-async def _seed_img(db, sha: str, predictions: dict) -> ImageRecord:
-    """#768: create an image + seed its predictions into image_prediction
-    (the read path's source), returning the flushed record."""
-    from tests._prediction_helpers import seed_predictions
-
-    img = _img(sha)
     db.add(img)
     await db.flush()
-    await seed_predictions(db, img.id, predictions)
     return img
 
 
+async def _embver(db) -> str:
+    s = (await db.execute(select(MLSettings).where(MLSettings.id == 1))).scalar_one()
+    return s.embedder_model_version
+
+
+async def _head(db, tag_id: int, slot: int, suggest_threshold: float = 0.5):
+    weights = [0.0] * 1152
+    weights[slot] = 1.0
+    db.add(TagHead(
+        tag_id=tag_id, embedding_version=await _embver(db),
+        weights=weights, bias=0.0, suggest_threshold=suggest_threshold,
+        auto_apply_threshold=None, n_pos=10, n_neg=30,
+        ap=0.8, precision_cv=0.9, recall=0.6,
+    ))
+
+
 @pytest.mark.asyncio
-async def test_threshold_filters_low_confidence_general(db):
-    # Default general threshold is 0.50 (alembic 0029 lowered it from
-    # 0.95). Use 0.30/0.60 to keep the test asserting threshold behavior
-    # rather than the exact cutoff number.
-    img = await _seed_img(
-        db,
-        "a" * 64,
-        {
-            "lowconf": {"category": "general", "confidence": 0.30},
-            "sword": {"category": "general", "confidence": 0.97},
-        },
-    )
+async def test_head_suggestion_surfaces_for_matching_image(db):
+    tag = await TagService(db).find_or_create("glasses", TagKind.general)
+    img = await _img(db, "a" * 64, _emb(0))
+    await _head(db, tag.id, slot=0)
+    await db.commit()
+
     sl = await SuggestionService(db).for_image(img.id)
-    names = [s.display_name for s in sl.by_category.get("general", [])]
-    # display_name is normalized (tag_name.normalize) before surfacing.
-    assert "Sword" in names
-    assert "Lowconf" not in names
+    general = sl.by_category["general"]
+    assert len(general) == 1
+    s = general[0]
+    assert s.canonical_tag_id == tag.id
+    assert s.source == "head"
+    assert s.creates_new_tag is False
+    assert s.via_alias is False and s.raw_name is None
+    assert s.score > 0.5
 
 
 @pytest.mark.asyncio
-async def test_threshold_override_surfaces_low_confidence(db):
-    # The typed-dropdown "show everything the model saw" mode: threshold_override
-    # surfaces stored predictions below the configured threshold (in canonical
-    # formatting) so they can be picked instead of hand-typed (2026-06-09).
-    img = await _seed_img(
-        db,
-        "d" * 64,
-        {
-            "lowconf": {"category": "general", "confidence": 0.30},
-            "sword": {"category": "general", "confidence": 0.97},
-        },
-    )
-    sl = await SuggestionService(db).for_image(img.id, threshold_override=0.0)
-    names = [s.display_name for s in sl.by_category.get("general", [])]
-    assert "Sword" in names
-    assert "Lowconf" in names  # below the configured threshold, surfaced anyway
-
-    # Unsurfaced categories are still excluded even with the override.
-    img2 = await _seed_img(
-        db, "e" * 64, {"safe": {"category": "rating", "confidence": 0.99}}
-    )
-    sl2 = await SuggestionService(db).for_image(img2.id, threshold_override=0.0)
-    assert "rating" not in sl2.by_category
+async def test_no_embedding_means_no_suggestions(db):
+    img = await _img(db, "b" * 64, None)
+    tag = await TagService(db).find_or_create("cat", TagKind.general)
+    await _head(db, tag.id, slot=0)
+    await db.commit()
+    assert (await SuggestionService(db).for_image(img.id)).by_category == {}
 
 
 @pytest.mark.asyncio
-async def test_unsurfaced_category_dropped(db):
-    img = await _seed_img(
-        db,
-        "b" * 64,
-        {"safe": {"category": "rating", "confidence": 0.99}},
-    )
-    sl = await SuggestionService(db).for_image(img.id)
-    assert "rating" not in sl.by_category
-
-
-@pytest.mark.asyncio
-async def test_alias_resolution(db):
-    tags = TagService(db)
-    canonical = await tags.find_or_create("Sasuke Uchiha", TagKind.character)
-    await AliasService(db).create("uchiha_sasuke", "character", canonical.id)
-    img = await _seed_img(
-        db,
-        "c" * 64,
-        {"uchiha_sasuke": {"category": "character", "confidence": 0.96}},
-    )
-    sl = await SuggestionService(db).for_image(img.id)
-    chars = sl.by_category["character"]
-    assert len(chars) == 1
-    assert chars[0].display_name == "Sasuke Uchiha"
-    assert chars[0].canonical_tag_id == canonical.id
-    assert chars[0].creates_new_tag is False
-    # Surfaced via an alias on the raw model key — the UI marks it + offers undo.
-    assert chars[0].via_alias is True
-    assert chars[0].raw_name == "uchiha_sasuke"
-
-
-@pytest.mark.asyncio
-async def test_raw_tag_creates_new(db):
-    img = await _seed_img(
-        db,
-        "d" * 64,
-        {"brand_new_tag": {"category": "character", "confidence": 0.96}},
-    )
-    sl = await SuggestionService(db).for_image(img.id)
-    chars = sl.by_category["character"]
-    # display_name is the normalized Camie name (underscores -> spaces,
-    # title-cased), not the raw vocab key.
-    assert chars[0].display_name == "Brand New Tag"
-    assert chars[0].creates_new_tag is True
-    # Not aliased, but the raw key is carried so the modal can author one.
-    assert chars[0].via_alias is False
-    assert chars[0].raw_name == "brand_new_tag"
-    assert chars[0].canonical_tag_id is None
+async def test_no_heads_means_no_suggestions(db):
+    img = await _img(db, "c" * 64, _emb(0))
+    await db.commit()  # no heads trained yet
+    assert (await SuggestionService(db).for_image(img.id)).by_category == {}
 
 
 @pytest.mark.asyncio
 async def test_applied_tag_not_suggested(db):
-    tags = TagService(db)
-    tag = await tags.find_or_create("alreadyhere", TagKind.character)
-    img = await _seed_img(
-        db,
-        "e" * 64,
-        {"alreadyhere": {"category": "character", "confidence": 0.96}},
-    )
+    tag = await TagService(db).find_or_create("dog", TagKind.general)
+    img = await _img(db, "d" * 64, _emb(0))
+    await _head(db, tag.id, slot=0)
     await db.execute(
         image_tag.insert().values(
             image_record_id=img.id, tag_id=tag.id, source="manual"
         )
     )
+    await db.commit()
     sl = await SuggestionService(db).for_image(img.id)
-    assert "character" not in sl.by_category or not sl.by_category["character"]
+    assert "general" not in sl.by_category or not sl.by_category["general"]
+
+
+@pytest.mark.asyncio
+async def test_threshold_override_surfaces_below_cut(db):
+    # A head with a high suggest_threshold won't surface on a so-so score, but
+    # the dropdown's override=0 floor surfaces every head regardless.
+    tag = await TagService(db).find_or_create("horse", TagKind.general)
+    img = await _img(db, "e" * 64, _emb(1))   # orthogonal to the head → score 0.5
+    await _head(db, tag.id, slot=0, suggest_threshold=0.6)
+    await db.commit()
+    svc = SuggestionService(db)
+    assert svc and not (await svc.for_image(img.id)).by_category.get("general")
+    flooded = await svc.for_image(img.id, threshold_override=0.0)
+    assert any(s.canonical_tag_id == tag.id for s in flooded.by_category["general"])
 
 
 @pytest.mark.asyncio
 async def test_rejected_tag_surfaced_flagged_then_reversible(db):
-    # A dismissed suggestion is NOT dropped: it stays in the list flagged
-    # rejected=True so the rail can show it + offer one-click un-reject
-    # (visible, reversible rejection — operator-asked 2026-06-27). A live
-    # suggestion sorts ahead of the rejected one.
-    tags = TagService(db)
-    rejected_tag = await tags.find_or_create("rejectme", TagKind.general)
-    img = await _seed_img(
-        db,
-        "f" * 64,
-        {
-            "rejectme": {"category": "general", "confidence": 0.96},
-            "keepme": {"category": "general", "confidence": 0.90},
-        },
-    )
-    await AllowlistService(db).dismiss(img.id, rejected_tag.id)
+    # A dismissed suggestion is NOT dropped: it stays flagged rejected so the
+    # rail can show it + offer one-click un-reject (operator-asked 2026-06-27).
+    tag = await TagService(db).find_or_create("goblin", TagKind.general)
+    img = await _img(db, "f" * 64, _emb(0))
+    await _head(db, tag.id, slot=0)
+    await db.commit()
+    await AllowlistService(db).dismiss(img.id, tag.id)
+    await db.commit()
 
     sl = await SuggestionService(db).for_image(img.id)
-    general = sl.by_category["general"]
-    # Match by id, not display casing (an existing tag keeps its stored name).
-    rej = next(s for s in general if s.canonical_tag_id == rejected_tag.id)
-    assert rej.rejected is True
-    live = [s for s in general if not s.rejected]
-    assert live, "the un-rejected 'keepme' suggestion should still surface"
-    # Live suggestions sort ahead of rejected ones regardless of score.
-    assert general[-1].canonical_tag_id == rejected_tag.id
+    s = next(x for x in sl.by_category["general"] if x.canonical_tag_id == tag.id)
+    assert s.rejected is True
 
-    # Un-reject reverts it to a live suggestion.
-    await AllowlistService(db).undismiss(img.id, rejected_tag.id)
+    await AllowlistService(db).undismiss(img.id, tag.id)
+    await db.commit()
     sl2 = await SuggestionService(db).for_image(img.id)
-    rej2 = next(
-        s for s in sl2.by_category["general"]
-        if s.canonical_tag_id == rejected_tag.id
-    )
-    assert rej2.rejected is False
+    s2 = next(x for x in sl2.by_category["general"] if x.canonical_tag_id == tag.id)
+    assert s2.rejected is False

tests/test_suggestions_bulk.py

@@ -1,88 +1,84 @@
+"""Consensus (for_selection) over the tagging-v2 HEAD suggestion source."""
 import pytest
+from sqlalchemy import select
 
 from backend.app import create_app
-from backend.app.models import ImageRecord, TagKind
+from backend.app.models import ImageRecord, MLSettings, TagHead, TagKind
 from backend.app.models.tag import image_tag
 from backend.app.services.ml.suggestions import SuggestionService
 from backend.app.services.tag_service import TagService
-from tests._prediction_helpers import seed_predictions
 
 pytestmark = pytest.mark.integration
 
 
-def _img(sha: str) -> ImageRecord:
-    return ImageRecord(
-        path=f"/images/{sha}.jpg", sha256=sha, size_bytes=1,
-        mime="image/jpeg", width=1, height=1,
-        origin="imported_filesystem", integrity_status="unknown",
+def _emb(slot: int) -> list[float]:
+    v = [0.0] * 1152
+    v[slot] = 3.0
+    return v
+
+
+async def _img(db, sha: str, emb=None) -> ImageRecord:
+    img = ImageRecord(
+        path=f"/images/{sha}.jpg", sha256=sha, size_bytes=1, mime="image/jpeg",
+        width=1, height=1, origin="imported_filesystem",
+        integrity_status="unknown", siglip_embedding=emb,
     )
+    db.add(img)
+    await db.flush()
+    return img
+
+
+async def _head(db, tag_id: int, slot: int = 0):
+    s = (await db.execute(select(MLSettings).where(MLSettings.id == 1))).scalar_one()
+    weights = [0.0] * 1152
+    weights[slot] = 1.0
+    db.add(TagHead(
+        tag_id=tag_id, embedding_version=s.embedder_model_version,
+        weights=weights, bias=0.0, suggest_threshold=0.5,
+        auto_apply_threshold=None, n_pos=10, n_neg=30,
+        ap=0.8, precision_cv=0.9, recall=0.6,
+    ))
 
 
 @pytest.mark.asyncio
 async def test_consensus_includes_tag_over_threshold(db):
-    tags = TagService(db)
-    t = await tags.find_or_create("sword", TagKind.general)
-    a = _img("a" * 64)
-    b = _img("b" * 64)
-    db.add_all([a, b])
-    await db.flush()
-    await seed_predictions(db, a.id, {"sword": {"category": "general", "confidence": 0.97}})
-    await seed_predictions(db, b.id, {"sword": {"category": "general", "confidence": 0.95}})
+    t = await TagService(db).find_or_create("sword", TagKind.general)
+    a = await _img(db, "a" * 64, _emb(0))
+    b = await _img(db, "b" * 64, _emb(0))
+    await _head(db, t.id, slot=0)
+    await db.commit()
     res = await SuggestionService(db).for_selection([a.id, b.id], threshold=0.8)
-    gen = res["general"]
-    assert any(s["canonical_tag_id"] == t.id for s in gen)
-    s = next(s for s in gen if s["canonical_tag_id"] == t.id)
-    assert s["coverage"] == 1.0
-    assert 0.95 <= s["confidence"] <= 0.97
+    s = next(s for s in res["general"] if s["canonical_tag_id"] == t.id)
+    assert s["coverage"] == 1.0          # suggested on both
+    assert s["confidence"] > 0.5
 
 
 @pytest.mark.asyncio
 async def test_consensus_counts_already_applied_for_coverage(db):
-    tags = TagService(db)
-    t = await tags.find_or_create("sky", TagKind.general)
-    a = _img("c" * 64)
-    b = _img("d" * 64)  # no prediction
-    db.add_all([a, b])
-    await db.flush()
-    await seed_predictions(db, a.id, {"sky": {"category": "general", "confidence": 0.96}})
-    # b already has the tag applied -> counts toward coverage, not confidence
+    t = await TagService(db).find_or_create("sky", TagKind.general)
+    a = await _img(db, "c" * 64, _emb(0))   # head suggests it
+    b = await _img(db, "d" * 64, None)       # no embedding; tag applied instead
+    await _head(db, t.id, slot=0)
     await db.execute(
         image_tag.insert().values(
             image_record_id=b.id, tag_id=t.id, source="manual"
         )
     )
+    await db.commit()
     res = await SuggestionService(db).for_selection([a.id, b.id], threshold=0.8)
     s = next(s for s in res["general"] if s["canonical_tag_id"] == t.id)
     assert s["coverage"] == 1.0          # 1 suggested + 1 applied / 2
-    assert s["confidence"] == pytest.approx(0.96, abs=1e-4)
 
 
 @pytest.mark.asyncio
 async def test_consensus_excludes_below_threshold(db):
-    tags = TagService(db)
-    await tags.find_or_create("rare", TagKind.general)
-    a = _img("e" * 64)
-    b = _img("f" * 64)
-    db.add_all([a, b])
-    await db.flush()
-    await seed_predictions(db, a.id, {"rare": {"category": "general", "confidence": 0.96}})
+    t = await TagService(db).find_or_create("rare", TagKind.general)
+    a = await _img(db, "e" * 64, _emb(0))   # suggested here
+    b = await _img(db, "f" * 64, None)       # not here → coverage 0.5 < 0.8
+    await _head(db, t.id, slot=0)
+    await db.commit()
     res = await SuggestionService(db).for_selection([a.id, b.id], threshold=0.8)
-    assert all(
-        s["name"] != "rare" for s in res.get("general", [])
-    )  # coverage 0.5 < 0.8
-
-
-@pytest.mark.asyncio
-async def test_consensus_skips_creates_new_tag(db):
-    a = _img("g" * 64)
-    b = _img("h" * 64)
-    db.add_all([a, b])
-    await db.flush()
-    await seed_predictions(db, a.id, {"neverseen": {"category": "general", "confidence": 0.99}})
-    await seed_predictions(db, b.id, {"neverseen": {"category": "general", "confidence": 0.99}})
-    res = await SuggestionService(db).for_selection([a.id, b.id], threshold=0.8)
-    # 'neverseen' has no Tag row -> creates_new_tag -> excluded from consensus
-    assert all(s["name"] != "neverseen" for s in res.get("general", []))
+    assert all(s["name"] != "rare" for s in res.get("general", []))
 
 
 @pytest.mark.asyncio
@@ -93,13 +89,9 @@ async def test_consensus_threshold_clamped_and_empty_for_no_ids(db):
 
 @pytest.mark.asyncio
 async def test_bulk_suggestions_route(db):
-
-    tags = TagService(db)
-    await tags.find_or_create("sword", TagKind.general)
-    a = _img("i" * 64)
-    db.add(a)
-    await db.commit()
-    await seed_predictions(db, a.id, {"sword": {"category": "general", "confidence": 0.97}})
+    t = await TagService(db).find_or_create("sword", TagKind.general)
+    a = await _img(db, "i" * 64, _emb(0))
+    await _head(db, t.id, slot=0)
     await db.commit()
     app = create_app()
     async with app.test_client() as c:
@@ -115,7 +107,6 @@ async def test_bulk_suggestions_route(db):
 
 @pytest.mark.asyncio
 async def test_bulk_suggestions_requires_ids(db):
-
     app = create_app()
     async with app.test_client() as c:
         resp = await c.post("/api/suggestions/bulk", json={})