feat(wip): soft title tier — sketch/doodle vocab + ring-loud audit (#1474)

Extends WIP title-tagging to lower-precision cues (sketch/doodle/scribble) safely.

- wip_title.py: soft matcher (word-anchored; sketchbook/kadoodle don't trip it);
  WIP_TITLE_SOFT_SOURCE + soft SQL prefilter; apply_wip_image_tags takes a source arg.
- training_data._AUTO_SOURCES += 'wip_title_soft' → the soft tier is PROVISIONAL and
  never trains the wip head (a finished "sketch" can't pollute it). Only the hard
  tier (wip_title) + manual train.
- ImportSettings.wip_soft_title_tagging_enabled (OFF by default, opt-in). Migration 0087.
- importer: hard tier wins, soft is the fallback (source wip_title_soft).
- backfill: refactored into a shared _backfill_wip_tier; hard always, soft when enabled.
- heads.soft_wip_conflict_audit + daily beat: score soft-tagged images against content
  heads, flag ring-loud ones (PresentationReview mode=process) for the review strip —
  the operator's "measure if they got falsely tagged" safety.
- api settings toggle; ImportFiltersForm soft toggle.
- tests: soft matcher pos/neg; soft source not a training positive; audit flags
  ring-loud + spares quiet.

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

tests/test_process_auto_apply.py

@@ -136,17 +136,53 @@ def test_process_sweep_flags_conflict_with_process_mode(db_sync):
 
 
 def test_process_auto_source_never_trains_head(db_sync):
-    # The runaway break: a wip tag the process sweep applied (source='process_auto')
-    # is NOT a training positive; a title-heuristic / manual one IS. So the head
-    # learns only from trusted labels, never its own output.
+    # The runaway break: provisional wip tags (process sweep 'process_auto', soft
+    # title 'wip_title_soft') are NOT training positives; a HARD title-heuristic /
+    # manual one IS. So the head learns only from trusted labels, never its own
+    # output or the low-precision sketch/doodle tier (#1464 + #1474).
     wip = _system_tag(db_sync, "wip")
     auto_img = _img(db_sync, "f" * 64, _emb(0))
+    soft_img = _img(db_sync, "9" * 64, _emb(2))
     title_img = _img(db_sync, "0" * 64, _emb(1))
     db_sync.execute(image_tag.insert().values(
         image_record_id=auto_img.id, tag_id=wip.id, source="process_auto"))
+    db_sync.execute(image_tag.insert().values(
+        image_record_id=soft_img.id, tag_id=wip.id, source="wip_title_soft"))
     db_sync.execute(image_tag.insert().values(
         image_record_id=title_img.id, tag_id=wip.id, source="wip_title"))
     db_sync.commit()
     positives = set(_ids_with_tag(db_sync, wip.id))
-    assert title_img.id in positives       # trusted label trains the head
+    assert title_img.id in positives       # trusted HARD label trains the head
     assert auto_img.id not in positives    # its own auto-applied output does NOT
+    assert soft_img.id not in positives    # low-precision soft tier does NOT
+
+
+def test_soft_wip_conflict_audit_flags_ring_loud(db_sync):
+    # A soft-tagged image (sketch/doodle title) that ALSO scores high on a content
+    # head is probably finished art mis-tagged — flagged for review; a quiet one is not.
+    from backend.app.services.ml.heads import soft_wip_conflict_audit
+
+    s = db_sync.execute(select(MLSettings).where(MLSettings.id == 1)).scalar_one()
+    s.process_conflict_threshold = 0.6
+    wip = _system_tag(db_sync, "wip")
+    content = Tag(name="looksreal", kind=TagKind.general)
+    db_sync.add(content)
+    db_sync.flush()
+    _head(db_sync, content.id, 0, weight=1.0)   # sigmoid(1)=0.73 > 0.6 conflict
+    ring = _img(db_sync, "1" * 64, _emb(0))      # scores on the content head
+    quiet = _img(db_sync, "2" * 64, _emb(5))     # orthogonal → 0.5 < 0.6
+    for img in (ring, quiet):
+        db_sync.execute(image_tag.insert().values(
+            image_record_id=img.id, tag_id=wip.id, source="wip_title_soft"))
+    db_sync.commit()
+
+    res = soft_wip_conflict_audit(db_sync)
+    assert res["n_flagged"] == 1
+    flag = db_sync.execute(
+        select(PresentationReview).where(PresentationReview.image_record_id == ring.id)
+    ).scalar_one()
+    assert flag.mode == "process"
+    assert flag.conflict_tag_id == content.id
+    assert db_sync.execute(
+        select(PresentationReview).where(PresentationReview.image_record_id == quiet.id)
+    ).scalar_one_or_none() is None

tests/test_wip_title.py

@@ -8,7 +8,7 @@ negative cases (substrings like ``swipe`` / ``wiped``) are the load-bearing ones
 """
 import pytest
 
-from backend.app.services.wip_title import matches_wip_title
+from backend.app.services.wip_title import matches_soft_wip_title, matches_wip_title
 
 
 @pytest.mark.parametrize("title", [
@@ -44,6 +44,33 @@ def test_matches_positive(title):
     "finished at last",
     "Kawips diner",                 # 'wip' mid-word
     "swipright",
+    "quick sketch of Nami",         # soft cue — NOT a HARD WIP match
 ])
 def test_matches_negative(title):
     assert matches_wip_title(title) is False
+
+
+@pytest.mark.parametrize("title", [
+    "quick sketch",
+    "Nami sketch",
+    "morning doodle",
+    "some doodles",
+    "sketches from today",
+    "a little scribble",
+    "SKETCH",
+])
+def test_soft_matches_positive(title):
+    assert matches_soft_wip_title(title) is True
+
+
+@pytest.mark.parametrize("title", [
+    None,
+    "",
+    "sketchbook tour",              # 'sketch' inside sketchbook — must NOT match
+    "kadoodle mascot",              # 'doodle' mid-word
+    "the final piece",
+    "WIP",                          # a HARD cue is not a SOFT cue
+    "prescribed colours",           # 'scrib' inside prescribed — must NOT match
+])
+def test_soft_matches_negative(title):
+    assert matches_soft_wip_title(title) is False

tests/test_wip_title_tagging.py

@@ -9,7 +9,11 @@ from sqlalchemy import select
 from backend.app.celery_app import celery
 from backend.app.models import Artist, ImageProvenance, ImageRecord, Post, Source
 from backend.app.models.tag import image_tag
-from backend.app.services.wip_title import apply_wip_image_tags, resolve_wip_tag_id
+from backend.app.services.wip_title import (
+    WIP_TITLE_SOFT_SOURCE,
+    apply_wip_image_tags,
+    resolve_wip_tag_id,
+)
 
 pytestmark = pytest.mark.integration
 
@@ -104,3 +108,14 @@ def test_backfill_tags_only_wip_titled_posts(db_sync):
 
     # Idempotent: a second sweep finds the tag already present and applies nothing.
     assert backfill_wip_title_tags.apply().get() == 0
+
+
+def test_apply_soft_source_stamps_wip_title_soft(db_sync):
+    # The soft tier (#1474) stamps a distinct provisional source.
+    tag_id = resolve_wip_tag_id(db_sync)
+    rec = _img(db_sync)
+    db_sync.commit()
+    assert apply_wip_image_tags(
+        db_sync, [rec.id], tag_id, source=WIP_TITLE_SOFT_SOURCE
+    ) == 1
+    assert _wip_source(db_sync, rec.id, tag_id) == "wip_title_soft"