Merge pull request 'feat(extension): in-app update prompt + v1.0.9 (#1489 )' (#231 ) from dev into main

Merge pull request 'fix(extension): Add-to-FC button on subscribed Patreon creators + v1.0.8 (#1485 )' (#230 ) from dev into main
Merge pull request 'chore(deps): web-ext 8→10 (Renovate batch 5) (#1450 )' (#229 ) from dev into main
2026-07-13 18:32:31 -04:00 · 2026-07-13 17:56:32 -04:00 · 2026-07-13 16:36:26 -04:00 · 2026-07-13 15:55:02 -04:00 · 2026-07-13 15:32:25 -04:00 · 2026-07-13 14:47:59 -04:00
37 changed files with 547 additions and 742 deletions
@@ -21,7 +21,7 @@ log = logging.getLogger("fc_agent.app")
 # Bump on every agent change. The page embeds this and /status reports it; the UI
 # warns to reload when they differ — so a stale browser-cached page can't be
 # mistaken for "the new image didn't deploy". (Belt-and-braces with no-store.)
-VERSION = "2026-07-17.1 · idle model-unload: after ~5 min idle the GPU models release their VRAM and reload on the next job (env IDLE_UNLOAD_SECONDS, 0=off) · sleep mode sheds to one downloader"
+VERSION = "2026-07-02.6 · sleep mode: an empty queue sheds to one downloader and backs the lease poll off to 15 min"

 logbuf.install()
 cfg = Config.from_env()
@@ -334,12 +334,9 @@ _PAGE = """<!doctype html><html><head><meta charset=utf-8>
  waited.textContent=s.transient||0
  // Instantaneous pool state → demoted to the sub-line, where its jumpiness reads
  // as live churn rather than a "broken" headline metric.
-  // '=== false' (not falsy) so a stale page that doesn't send models_loaded shows
-  // nothing; when the idle monitor unloads, the VRAM meter drops alongside this.
  pipe.textContent='downloaders '+(s.downloaders!=null?s.downloaders:'—')+' · consumers '+(s.consumers!=null?s.consumers:'—')+' · on GPU '+(s.active||0)
   +' · net '+(s.net_mb_s!=null?s.net_mb_s.toFixed(1):'—')+' MB/s'
   +(s.bandwidth_limit_mb_s>0?(' / cap '+s.bandwidth_limit_mb_s):'')
-   +(s.models_loaded===false?' · GPU models unloaded (idle — reload on next job)':'')
  if(document.activeElement!==bw && s.bandwidth_limit_mb_s!=null) bw.value=s.bandwidth_limit_mb_s
  // Buffer occupancy bar (also driven here so it tracks the /status cadence).
  if(s.buffer!=null && s.buffer_max){ const p=Math.round(100*s.buffer/s.buffer_max)
@@ -51,12 +51,6 @@ class Config:
    bandwidth_limit_mb_s: float  # aggregate download cap in MEGABYTES/s across
    #                              all downloaders + video streams (0 = unlimited);
    #                              tunable live from the agent UI
-    idle_unload_seconds: float   # after this long with the GPU idle (nothing in
-    #                              flight, queue empty or Stopped), unload the
-    #                              SigLIP embedder + YOLO proposers to free their
-    #                              VRAM; they reload lazily on the next job. A
-    #                              24/7 agent otherwise squats on ~5GB doing
-    #                              nothing. 0 disables (keep models warm forever).

    @classmethod
    def from_env(cls) -> Config:
@@ -93,8 +87,4 @@ class Config:
            # link to ~1-1.5 MB/s per stream, browser included). Raise it (or 0)
            # from the agent UI on wired/faster networks.
            bandwidth_limit_mb_s=float(os.environ.get("BANDWIDTH_LIMIT_MB_S", "8")),
-            # 5 min: long enough that a lull between job bursts doesn't thrash the
-            # (few-second) reload, short enough that an agent left running with an
-            # empty queue hands its VRAM back promptly.
-            idle_unload_seconds=float(os.environ.get("IDLE_UNLOAD_SECONDS", "300")),
        )
@@ -170,13 +170,6 @@ class YoloProposer:
            ))
        return out

-    def unload(self) -> None:
-        """Drop the loaded YOLO so its VRAM can be reclaimed; detect() reloads it
-        lazily on the next job. Leaves _ok untouched — a healthy proposer comes
-        back, but one that self-disabled on a fault stays off."""
-        with self._lock:
-            self._model = None
-

 class Proposers:
    """The agent's proposer set, built from config. Each detector is optional —
@@ -223,11 +216,3 @@ class Proposers:

    def panels(self, image):
        return self._top(self._panel, image, self.cfg.max_panels)
-
-    def unload(self) -> None:
-        """Release every loaded proposer's YOLO (idle VRAM reclaim). The worker
-        also drops its reference to this Proposers and rebuilds a fresh one via
-        _proposers_for on the next job, so this is belt-and-braces."""
-        for p in (self._person, self._anatomy, self._panel):
-            if p is not None:
-                p.unload()
@@ -75,18 +75,3 @@ class CropEmbedder:
        pooled = out.pooler_output if hasattr(out, "pooler_output") else out
        arr = pooled.float().cpu().numpy().astype(np.float32)
        return [row.reshape(-1).tolist() for row in arr]
-
-    def unload(self) -> bool:
-        """Drop the loaded model so its VRAM can be reclaimed — the idle monitor
-        calls this after a spell with no work so an idle agent doesn't squat on
-        the card; the next embed() reloads it lazily (a few seconds). Held under
-        BOTH the load and inference locks so it can never race a concurrent load
-        or an in-flight forward pass. Returns True if a model was actually
-        released (the caller then runs one empty_cache() to hand the freed blocks
-        back to the driver)."""
-        with self._load_lock, self._infer_lock:
-            if self._model is None:
-                return False
-            self._model = None
-            self._processor = None
-            return True
@@ -57,15 +57,6 @@ MAX_BACKOFF_SECONDS = 60.0
 # up on their own.
 IDLE_POLL_MAX_SECONDS = 900.0

-# Idle VRAM reclaim (operator 2026-07-17): the SigLIP embedder + YOLO proposers
-# load lazily and then stay warm for fast job bursts — but a 24/7 agent with an
-# empty queue would otherwise squat on that VRAM (~5GB on the operator's card)
-# indefinitely while doing nothing. So a monitor unloads them after
-# cfg.idle_unload_seconds with the GPU genuinely idle (nothing in flight, buffer
-# drained); they reload lazily on the next job. This is just how often the
-# monitor wakes to check — it bounds how soon past the threshold the unload fires.
-IDLE_UNLOAD_CHECK_INTERVAL = 30.0
-
 # A job whose fetch dies transiently this many times IN ONE SESSION stops being
 # handed back and is failed instead. Transient handbacks (release) burn no
 # attempts on the server, so a poisoned transfer — an original that stalls the
@@ -277,11 +268,6 @@ class Worker:
        self._proposers_sig = None    # detector-config signature the current
        #                               proposers were built for (#134)
        self._proposers_lock = threading.Lock()
-        # Monotonic time of the last GPU activity (a consumer finishing a job).
-        # The idle monitor unloads the warm models once this goes stale by
-        # cfg.idle_unload_seconds — see _idle_unload_loop.
-        self._last_gpu_activity = time.monotonic()
-        threading.Thread(target=self._idle_unload_loop, daemon=True).start()

    # --- held-lease bookkeeping --------------------------------------------
    def _hold(self, job_ids) -> None:
@@ -622,9 +608,6 @@ class Worker:
            "net_mb_s": round(self._net_mb_s, 1),       # observed aggregate rate
            "bw_capped": self._bw_capped,   # autoscaler holding at the cap (UI hint)
            "idle": self._idle,             # queue empty → poll backed off (UI hint)
-            # Whether the GPU models are currently resident (False after an idle
-            # unload freed their VRAM) — a plain bool read, UI hint only.
-            "models_loaded": self._embedder is not None or self._proposers is not None,
        }

    def _bump(self, *, processed=0, downloaded=0, errors=0, active=0, transient=0):
@@ -805,9 +788,6 @@ class Worker:
                    self._bump(processed=1)
            finally:
                self._bump(active=-1)
-                # Mark the GPU busy-until-now so the idle monitor starts its
-                # unload countdown from when work actually stopped, not before.
-                self._last_gpu_activity = time.monotonic()

    def _ensure_embedder(self, model_name: str):
        if self._embedder is not None:
@@ -865,61 +845,6 @@ class Worker:
                self._proposers_sig = sig
            return self._proposers

-    def _unload_models(self) -> bool:
-        """Release the GPU-resident models (SigLIP embedder + YOLO proposers) so an
-        idle agent hands their VRAM back instead of squatting on the card. They
-        reload lazily on the next job (_ensure_embedder / _proposers_for) — a
-        few seconds' cost paid only when work actually resumes. Dropping the
-        shared instances under their build locks means a concurrent job either
-        sees the old instance (before) or rebuilds a fresh one (after); the idle
-        monitor only calls this with nothing in flight, so no inference is using
-        them. Returns True if anything was released."""
-        released = False
-        with self._embedder_lock:
-            if self._embedder is not None:
-                self._embedder.unload()
-                self._embedder = None
-                released = True
-        with self._proposers_lock:
-            if self._proposers is not None:
-                self._proposers.unload()
-                self._proposers = None
-                self._proposers_sig = None
-                released = True
-        if released:
-            try:
-                import torch
-                if torch.cuda.is_available():
-                    # torch's caching allocator holds freed blocks; hand them back
-                    # to the driver so nvidia-smi actually reflects the drop.
-                    torch.cuda.empty_cache()
-            except Exception:   # noqa: BLE001 — torch absent / CPU-only → nothing to free
-                pass
-        return released
-
-    def _idle_unload_loop(self) -> None:
-        """Unload the warm GPU models after a stretch of inactivity so a 24/7
-        agent with an empty queue doesn't hold ~5GB of VRAM doing nothing. Fires
-        only when nothing is in flight (active == 0 AND the buffer is drained) and
-        no job has completed for cfg.idle_unload_seconds — a window long enough
-        that a brief lull between bursts doesn't thrash reload/unload. Covers BOTH
-        sleep mode (queue empty, pipeline still running) and a full Stop; the
-        models reload lazily on the next job. idle_unload_seconds <= 0 disables it."""
-        idle_after = self.cfg.idle_unload_seconds
-        if idle_after <= 0:
-            return
-        while True:
-            time.sleep(IDLE_UNLOAD_CHECK_INTERVAL)
-            if self._embedder is None and self._proposers is None:
-                continue                       # nothing loaded → nothing to free
-            if self._active != 0 or not self._buffer.empty():
-                continue                       # work in flight → keep them warm
-            if time.monotonic() - self._last_gpu_activity < idle_after:
-                continue                       # not idle long enough yet
-            if self._unload_models():
-                log.info("idle %.0fs — unloaded GPU models, freed VRAM "
-                         "(reload on next job)", idle_after)
-
    def _consume(self, job: dict, frames: list, stop_evt: threading.Event) -> bool:
        """Detect + embed the decoded frames and submit the result. Returns True
        when the job was completed (→ count it processed), False otherwise: a
@@ -256,7 +256,9 @@ async def lease():
        if not await _agent_authed(session):
            return jsonify({"error": "unauthorized"}), 401
        jobs = await GpuJobService(session).lease(agent_id, batch_size=batch)
-        ml = await MLSettings.load(session)
+        ml = (
+            await session.execute(select(MLSettings).where(MLSettings.id == 1))
+        ).scalar_one()
        # image rows for url/mime in one shot
        ids = [j.image_record_id for j in jobs]
        imgs = {
@@ -4,7 +4,6 @@ from quart import Blueprint, jsonify, request

 from ..extensions import get_session
 from ..models import MLSettings
-from ..services.ml.heads import AUTO_APPLY_THRESHOLD_MAX, AUTO_APPLY_THRESHOLD_MIN

 ml_admin_bp = Blueprint("ml_admin", __name__, url_prefix="/api/ml")

@@ -84,21 +83,48 @@ async def embedder_models():

@ml_admin_bp.route("/settings", methods=["GET"])
 async def get_settings():
+    from sqlalchemy import select
+
    async with get_session() as session:
-        s = await MLSettings.load(session)
-    # Table-driven off _EDITABLE (which PATCH also writes) so a new settings field
-    # can never be silently absent from GET — the split that historically dropped
-    # fields. _EDITABLE already includes *_DETECTOR_FIELDS.
-    return jsonify({f: getattr(s, f) for f in _EDITABLE})
+        s = (
+            await session.execute(select(MLSettings).where(MLSettings.id == 1))
+        ).scalar_one()
+    return jsonify(
+        {
+            "cpu_embed_enabled": s.cpu_embed_enabled,
+            "video_frame_interval_seconds": s.video_frame_interval_seconds,
+            "video_max_frames": s.video_max_frames,
+            "embedder_model_version": s.embedder_model_version,
+            "head_min_positives": s.head_min_positives,
+            "head_auto_apply_precision": s.head_auto_apply_precision,
+            "head_auto_apply_enabled": s.head_auto_apply_enabled,
+            "head_auto_apply_min_positives": s.head_auto_apply_min_positives,
+            "ccip_match_threshold": s.ccip_match_threshold,
+            "ccip_auto_apply_enabled": s.ccip_auto_apply_enabled,
+            "ccip_auto_apply_threshold": s.ccip_auto_apply_threshold,
+            "presentation_auto_apply_enabled": s.presentation_auto_apply_enabled,
+            "presentation_auto_apply_threshold": s.presentation_auto_apply_threshold,
+            "presentation_conflict_threshold": s.presentation_conflict_threshold,
+            "process_auto_apply_enabled": s.process_auto_apply_enabled,
+            "process_auto_apply_threshold": s.process_auto_apply_threshold,
+            "process_conflict_threshold": s.process_conflict_threshold,
+            "embedder_model_name": s.embedder_model_name,
+            **{f: getattr(s, f) for f in _DETECTOR_FIELDS},
+        }
+    )


@ml_admin_bp.route("/settings", methods=["PATCH"])
 async def patch_settings():
+    from sqlalchemy import select
+
    body = await request.get_json()
    if not isinstance(body, dict):
        return jsonify({"error": "body must be an object"}), 400
    async with get_session() as session:
-        s = await MLSettings.load(session)
+        s = (
+            await session.execute(select(MLSettings).where(MLSettings.id == 1))
+        ).scalar_one()

        # Merge the patch over current values, then validate the result as a
        # whole — the store-floor invariant couples three fields, so they
@@ -128,24 +154,24 @@ def _validate(p: dict) -> str | None:
    # Head training (#114).
    if int(p["head_min_positives"]) < 1:
        return "head_min_positives must be >= 1"
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["head_auto_apply_precision"]) <= AUTO_APPLY_THRESHOLD_MAX):
-        return f"head_auto_apply_precision must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+    if not (0.5 <= float(p["head_auto_apply_precision"]) <= 0.999):
+        return "head_auto_apply_precision must be between 0.5 and 0.999"
    if int(p["head_auto_apply_min_positives"]) < 1:
        return "head_auto_apply_min_positives must be >= 1"
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["ccip_match_threshold"]) <= AUTO_APPLY_THRESHOLD_MAX):
-        return f"ccip_match_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["ccip_auto_apply_threshold"]) <= AUTO_APPLY_THRESHOLD_MAX):
-        return f"ccip_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+    if not (0.5 <= float(p["ccip_match_threshold"]) <= 0.999):
+        return "ccip_match_threshold must be between 0.5 and 0.999"
+    if not (0.5 <= float(p["ccip_auto_apply_threshold"]) <= 0.999):
+        return "ccip_auto_apply_threshold must be between 0.5 and 0.999"
    # Presentation chrome auto-hide (#141). Auto-apply runs high (hiding is
    # consequential); the conflict cut is a plain probability [0,1].
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["presentation_auto_apply_threshold"]) <= AUTO_APPLY_THRESHOLD_MAX):
-        return f"presentation_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+    if not (0.5 <= float(p["presentation_auto_apply_threshold"]) <= 0.999):
+        return "presentation_auto_apply_threshold must be between 0.5 and 0.999"
    if not (0.0 <= float(p["presentation_conflict_threshold"]) <= 1.0):
        return "presentation_conflict_threshold must be between 0 and 1"
    # Process auto-apply (#1464). wip/editor stay VISIBLE so a false apply is
    # low-harm (excludes-from-training + a review flag), but keep the same bar.
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["process_auto_apply_threshold"]) <= AUTO_APPLY_THRESHOLD_MAX):
-        return f"process_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+    if not (0.5 <= float(p["process_auto_apply_threshold"]) <= 0.999):
+        return "process_auto_apply_threshold must be between 0.5 and 0.999"
    if not (0.0 <= float(p["process_conflict_threshold"]) <= 1.0):
        return "process_conflict_threshold must be between 0 and 1"
    # Embedder model swap (#1190): both must be non-empty. Changing them means a
@@ -66,9 +66,34 @@ _EXTDL_TOGGLE_FIELDS = (
 async def get_import_settings():
    async with get_session() as session:
        row = await ImportSettings.load(session)
-    # Table-driven off _EDITABLE_FIELDS (which PATCH also writes) so a new field
-    # can't be silently absent from GET.
-    return jsonify({f: getattr(row, f) for f in _EDITABLE_FIELDS})
+    return jsonify({
+        "min_width": row.min_width,
+        "min_height": row.min_height,
+        "skip_transparent": row.skip_transparent,
+        "transparency_threshold": row.transparency_threshold,
+        "skip_single_color": row.skip_single_color,
+        "single_color_threshold": row.single_color_threshold,
+        "single_color_tolerance": row.single_color_tolerance,
+        "phash_threshold": row.phash_threshold,
+        "download_rate_limit_seconds": row.download_rate_limit_seconds,
+        "download_validate_files": row.download_validate_files,
+        "download_schedule_default_seconds": row.download_schedule_default_seconds,
+        "download_event_retention_days": row.download_event_retention_days,
+        "download_failure_warning_threshold": row.download_failure_warning_threshold,
+        "series_suggest_enabled": row.series_suggest_enabled,
+        "series_suggest_threshold": row.series_suggest_threshold,
+        "extdl_mega_enabled": row.extdl_mega_enabled,
+        "extdl_gdrive_enabled": row.extdl_gdrive_enabled,
+        "extdl_mediafire_enabled": row.extdl_mediafire_enabled,
+        "extdl_dropbox_enabled": row.extdl_dropbox_enabled,
+        "extdl_pixeldrain_enabled": row.extdl_pixeldrain_enabled,
+        "translation_enabled": row.translation_enabled,
+        "interpreter_base_url": row.interpreter_base_url,
+        "translation_target_lang": row.translation_target_lang,
+        "translation_min_confidence": row.translation_min_confidence,
+        "wip_title_tagging_enabled": row.wip_title_tagging_enabled,
+        "wip_soft_title_tagging_enabled": row.wip_soft_title_tagging_enabled,
+    })


@settings_bp.route("/settings/import", methods=["PATCH"])
@@ -10,7 +10,6 @@ from sqlalchemy import (
    Integer,
    String,
    func,
-    select,
 )
 from sqlalchemy.orm import Mapped, mapped_column

@@ -213,14 +212,3 @@ class MLSettings(Base):
    updated_at: Mapped[datetime] = mapped_column(
        DateTime(timezone=True), nullable=False, server_default=func.now()
    )
-
-    @classmethod
-    async def load(cls, session) -> MLSettings:
-        """The singleton settings row (id=1), via an async session. Mirrors
-        ImportSettings.load — the shared singleton-loader pattern."""
-        return (await session.execute(select(cls).where(cls.id == 1))).scalar_one()
-
-    @classmethod
-    def load_sync(cls, session) -> MLSettings:
-        """The singleton settings row (id=1), via a sync session."""
-        return session.execute(select(cls).where(cls.id == 1)).scalar_one()
@@ -150,7 +150,9 @@ def refresh_character_prototypes(
    """Incrementally refresh the prototype store. `full=True` rebuilds every
    character regardless of the gate/fingerprints (nightly reconcile). Returns
    {skipped, rebuilt, removed}; commits."""
-    settings = MLSettings.load_sync(session)
+    settings = session.execute(
+        select(MLSettings).where(MLSettings.id == 1)
+    ).scalar_one()
    sig = _global_signature(session)
    if not full and settings.ccip_ref_signature == sig:
        return {"skipped": True, "rebuilt": 0, "removed": 0}
@@ -202,7 +204,9 @@ def retract_auto_applied_ccip(session: Session) -> int:
    n_retracted."""
    import numpy as np

-    settings = MLSettings.load_sync(session)
+    settings = session.execute(
+        select(MLSettings).where(MLSettings.id == 1)
+    ).scalar_one()
    if not settings.ccip_auto_apply_enabled:
        return 0
    thr = float(settings.ccip_auto_apply_threshold)
@@ -23,7 +23,6 @@ from datetime import UTC, datetime
 from typing import Any

 from sqlalchemy import delete, exists, func, select
-from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

@@ -43,7 +42,6 @@ from ...models import (
 from ...models.tag import CHROME_SYSTEM_TAGS, PROCESS_SYSTEM_TAGS, image_tag
 from .training_data import (
    _AUTO_SOURCES,
-    _applied_or_rejected,
    _auto_apply_point,
    _hygiene_excluded_ids,
    _ids_with_tag,
@@ -63,14 +61,6 @@ MIN_POSITIVES_FLOOR = 8     # hard floor; settings.head_min_positives can raise
 _UNLABELED_POOL = 4000
 _EXAMPLES_MIN = 8           # need at least this many embedded +/- to fit a head

-# Auto-apply / match confidence operating range. Every graduated auto-apply or
-# CCIP-match threshold the operator can set lives in this band, and the head
-# precision target is clamped to it: below 0.5 "auto-apply" is meaningless, and
-# 1.0 is unachievable so 0.999 is the ceiling. One source shared by the service
-# clamp (_normalize_params) and the API validator (ml_admin._validate).
-AUTO_APPLY_THRESHOLD_MIN = 0.5
-AUTO_APPLY_THRESHOLD_MAX = 0.999
-
 # Only these tag kinds get heads (the surfaced suggestion categories).
 _HEAD_KINDS = (TagKind.general, TagKind.character)
 # tag.kind -> the suggestion category the rail groups under.
@@ -88,38 +78,6 @@ _CATEGORY = {TagKind.general: "general", TagKind.character: "character"}
 _SYSTEM_TAG_SUGGEST_FLOOR = 0.65


-def _sigmoid(z, np):
-    """Logistic sigmoid 1/(1+e^-z): the head score→probability transform. One home
-    for what was inlined at every scoring site (suggest, both sweeps, retract)."""
-    return 1.0 / (1.0 + np.exp(-z))
-
-
-def _conflict_scores(Xn, Wc, bc, np):
-    """The presentation conflict signal (#141): per row, the MAX content-head
-    probability and WHICH head produced it. Shared by the system-tag sweep's guard-2
-    and the soft-wip audit — both ask "does this ALSO look like real content?"."""
-    cprobs = _sigmoid(Xn @ Wc.T + bc, np)
-    return cprobs.max(axis=1), cprobs.argmax(axis=1)
-
-
-def _insert_presentation_review(
-    session, *, image_record_id, tag_id, conflict_tag_id, conflict_score, mode,
-):
-    """Single-source the ring-loud PresentationReview row shape so the two writers
-    (system-tag sweep guard-2 + soft-wip audit) can't drift on columns or `mode` —
-    they share the (image_record_id, tag_id) composite PK, so a divergent `mode`
-    would be a silent first-writer-wins bug."""
-    session.execute(
-        pg_insert(PresentationReview)
-        .values(
-            image_record_id=image_record_id, tag_id=tag_id,
-            conflict_tag_id=conflict_tag_id, conflict_score=conflict_score,
-            mode=mode,
-        )
-        .on_conflict_do_nothing()
-    )
-
-
 class HeadTrainingAlreadyRunning(Exception):
    """Raised by start_head_training_run when a run is already in flight."""

@@ -145,7 +103,9 @@ def start_head_training_run(session: Session, params: dict[str, Any]) -> int:


 def _settings(session: Session) -> MLSettings:
-    return MLSettings.load_sync(session)
+    return session.execute(
+        select(MLSettings).where(MLSettings.id == 1)
+    ).scalar_one()


 def _normalize_params(session: Session, params: dict[str, Any] | None) -> dict[str, Any]:
@@ -164,7 +124,7 @@ def _normalize_params(session: Session, params: dict[str, Any] | None) -> dict[s
    except (TypeError, ValueError):
        cv_folds = DEFAULT_CV_FOLDS
    try:
-        precision_target = min(max(float(params.get("precision_target", s.head_auto_apply_precision)), AUTO_APPLY_THRESHOLD_MIN), AUTO_APPLY_THRESHOLD_MAX)
+        precision_target = min(max(float(params.get("precision_target", s.head_auto_apply_precision)), 0.5), 0.999)
    except (TypeError, ValueError):
        precision_target = s.head_auto_apply_precision
    return {
@@ -576,7 +536,7 @@ async def score_image(
    norms[norms == 0] = 1.0
    Xn = X / norms
    Z = Xn @ heads["W"].T + heads["b"]                  # (B, H)
-    probs_bag = _sigmoid(Z, np)                         # (B, H)
+    probs_bag = 1.0 / (1.0 + np.exp(-Z))                # (B, H)
    probs = probs_bag.max(axis=0)                       # (H,) best over the bag
    # ARGMAX beside the max: WHICH bag row won each head → the region that grounds
    # the tag (bag_meta[win]); None when the whole-image vector won (#1206).
@@ -654,7 +614,9 @@ async def ground_applied_tag(


 async def _settings_async(session: AsyncSession) -> MLSettings:
-    return await MLSettings.load(session)
+    return (
+        await session.execute(select(MLSettings).where(MLSettings.id == 1))
+    ).scalar_one()


 # --- Earned auto-apply (sync, ml worker) ---------------------------------
@@ -725,6 +687,7 @@ def auto_apply_sweep(
    embeddings in chunks; commits per chunk on a real run. Returns
    {n_applied, concepts:[{tag_id,name,applied,scanned,threshold}]}."""
    import numpy as np
+    from sqlalchemy.dialects.postgresql import insert as pg_insert

    settings = _settings(session)
    rows = _auto_apply_heads(
@@ -741,7 +704,18 @@ def auto_apply_sweep(
    names = [r.name for r in rows]

    # Skip images that already carry, or have rejected, each tag.
-    skip = _applied_or_rejected(session, tag_ids)
+    skip = {tid: set() for tid in tag_ids}
+    for tid in tag_ids:
+        for (iid,) in session.execute(
+            select(image_tag.c.image_record_id).where(image_tag.c.tag_id == tid)
+        ):
+            skip[tid].add(iid)
+        for (iid,) in session.execute(
+            select(TagSuggestionRejection.image_record_id).where(
+                TagSuggestionRejection.tag_id == tid
+            )
+        ):
+            skip[tid].add(iid)

    applied = [0] * len(rows)
    scanned = 0
@@ -755,7 +729,7 @@ def auto_apply_sweep(
        if not cids:
            continue
        Xn = _l2norm(np.vstack([emb[i] for i in cids]).astype(np.float32), np)
-        probs = _sigmoid(Xn @ W.T + b, np)              # (N, H)
+        probs = 1.0 / (1.0 + np.exp(-(Xn @ W.T + b)))   # (N, H)
        scanned += len(cids)
        for h in range(len(rows)):
            tid = tag_ids[h]
@@ -866,6 +840,7 @@ def system_tag_auto_apply_sweep(
    enabled flag is set. numpy-only (no sklearn). Returns {n_applied, n_flagged,
    concepts}."""
    import numpy as np
+    from sqlalchemy.dialects.postgresql import insert as pg_insert

    cfg = _SWEEP_MODES[mode]
    settings = _settings(session)
@@ -894,7 +869,18 @@ def system_tag_auto_apply_sweep(
    valued = _valued_image_ids(session)

    # Skip images that already carry, or have rejected, each presentation tag.
-    skip = _applied_or_rejected(session, pres_tag_ids)
+    skip = {tid: set() for tid in pres_tag_ids}
+    for tid in pres_tag_ids:
+        for (iid,) in session.execute(
+            select(image_tag.c.image_record_id).where(image_tag.c.tag_id == tid)
+        ):
+            skip[tid].add(iid)
+        for (iid,) in session.execute(
+            select(TagSuggestionRejection.image_record_id).where(
+                TagSuggestionRejection.tag_id == tid
+            )
+        ):
+            skip[tid].add(iid)

    applied = [0] * len(pres)
    n_flagged = 0
@@ -909,9 +895,11 @@ def system_tag_auto_apply_sweep(
        if not cids:
            continue
        Xn = _l2norm(np.vstack([emb[i] for i in cids]).astype(np.float32), np)
-        probs = _sigmoid(Xn @ Wp.T + bp, np)                  # (N, P)
+        probs = 1.0 / (1.0 + np.exp(-(Xn @ Wp.T + bp)))       # (N, P)
        if Wc is not None:
-            max_c, arg_c = _conflict_scores(Xn, Wc, bc, np)   # (N,), (N,)
+            cprobs = 1.0 / (1.0 + np.exp(-(Xn @ Wc.T + bc)))  # (N, C)
+            max_c = cprobs.max(axis=1)
+            arg_c = cprobs.argmax(axis=1)
        scanned += len(cids)
        for p in range(len(pres)):
            tid = pres_tag_ids[p]
@@ -936,12 +924,15 @@ def system_tag_auto_apply_sweep(
                if Wc is not None and float(max_c[idx]) >= conflict_thr:
                    n_flagged += 1
                    if not dry_run:
-                        _insert_presentation_review(
-                            session,
-                            image_record_id=iid, tag_id=tid,
-                            conflict_tag_id=conf_tag_ids[int(arg_c[idx])],
-                            conflict_score=float(max_c[idx]),
-                            mode=mode,
+                        session.execute(
+                            pg_insert(PresentationReview)
+                            .values(
+                                image_record_id=iid, tag_id=tid,
+                                conflict_tag_id=conf_tag_ids[int(arg_c[idx])],
+                                conflict_score=float(max_c[idx]),
+                                mode=mode,
+                            )
+                            .on_conflict_do_nothing()
                        )
        if not dry_run:
            session.commit()
@@ -965,6 +956,7 @@ def soft_wip_conflict_audit(session: Session, dry_run: bool = False) -> dict:
    NOT remove the tag; the operator decides. No-op when there are no content heads.
    numpy-only. Returns {n_scanned, n_flagged}."""
    import numpy as np
+    from sqlalchemy.dialects.postgresql import insert as pg_insert

    from ..wip_title import WIP_TITLE_SOFT_SOURCE, resolve_wip_tag_id

@@ -1001,17 +993,22 @@ def soft_wip_conflict_audit(session: Session, dry_run: bool = False) -> dict:
            continue
        scanned += len(cids)
        Xn = _l2norm(np.vstack([emb[i] for i in cids]).astype(np.float32), np)
-        max_c, arg_c = _conflict_scores(Xn, Wc, bc, np)
+        cprobs = 1.0 / (1.0 + np.exp(-(Xn @ Wc.T + bc)))
+        max_c = cprobs.max(axis=1)
+        arg_c = cprobs.argmax(axis=1)
        for k in range(len(cids)):
            if float(max_c[k]) >= conflict_thr:
                n_flagged += 1
                if not dry_run:
-                    _insert_presentation_review(
-                        session,
-                        image_record_id=cids[k], tag_id=wip_id,
-                        conflict_tag_id=conf_tag_ids[int(arg_c[k])],
-                        conflict_score=float(max_c[k]),
-                        mode="process",
+                    session.execute(
+                        pg_insert(PresentationReview)
+                        .values(
+                            image_record_id=cids[k], tag_id=wip_id,
+                            conflict_tag_id=conf_tag_ids[int(arg_c[k])],
+                            conflict_score=float(max_c[k]),
+                            mode="process",
+                        )
+                        .on_conflict_do_nothing()
                    )
        if not dry_run:
            session.commit()
@@ -1065,7 +1062,7 @@ def retract_auto_applied_heads(session: Session) -> int:
            continue
        Xn = _l2norm(np.vstack([emb[i] for i in cids]).astype(np.float32), np)
        w = np.asarray(weights, dtype=np.float32)
-        probs = _sigmoid(Xn @ w + float(bias), np)
+        probs = 1.0 / (1.0 + np.exp(-(Xn @ w + float(bias))))
        below = [cids[k] for k in np.where(probs < float(thr))[0]]
        for iid in below:
            session.execute(
@@ -94,24 +94,6 @@ def _rejected_ids(session: Session, tag_id: int) -> list[int]:
    ]


-def _applied_or_rejected(session: Session, tag_ids) -> dict[int, set[int]]:
-    """Per-tag skip set for the auto-apply sweeps: every image that ALREADY carries
-    the tag (ANY source — not just training positives) OR has rejected it. A sweep
-    never re-applies to these. Shared by auto_apply_sweep + system_tag_auto_apply_sweep
-    (heads.py) and scheduled_ccip_auto_apply (tasks/ml.py). Callers mutate the returned
-    sets in-place to also dedupe within a single run."""
-    skip: dict[int, set[int]] = {}
-    for tid in tag_ids:
-        ids = {
-            r[0] for r in session.execute(
-                select(image_tag.c.image_record_id).where(image_tag.c.tag_id == tid)
-            ).all()
-        }
-        ids.update(_rejected_ids(session, tid))
-        skip[tid] = ids
-    return skip
-
-
 def _sample_unlabeled(session: Session, exclude: set[int], limit: int) -> list[int]:
    """Random image ids (with an embedding) NOT carrying the tag. Concepts are
    sparse, so an untagged image is almost always a true negative."""
@@ -91,46 +91,48 @@ def _sync_lookup(vanity: str, cookies_path: str | None) -> str | None:
    )


-def _campaigns_api_first(vanity: str, cookies_path: str | None) -> dict | None:
-    """The first `data` object from Patreon's campaigns API filtered by vanity
-    (`?filter[vanity]=<vanity>&fields[campaign]=name`), or None on any failure
-    (network / non-200 / non-JSON / empty). The single request shape shared by
-    _lookup_via_api (plucks the campaign id) and resolve_display_name (plucks the
-    display name)."""
+def _lookup_via_api(vanity: str, cookies_path: str | None) -> str | None:
    jar = _load_cookie_jar(cookies_path)
+    headers = {
+        "User-Agent": _USER_AGENT,
+        "Accept": "application/vnd.api+json",
+    }
+    params = {
+        "filter[vanity]": vanity,
+        "fields[campaign]": "name",
+    }
    try:
        resp = requests.get(
            _CAMPAIGNS_URL,
-            params={"filter[vanity]": vanity, "fields[campaign]": "name"},
-            headers={"User-Agent": _USER_AGENT, "Accept": "application/vnd.api+json"},
+            params=params,
+            headers=headers,
            cookies=jar,
            timeout=_TIMEOUT_SECONDS,
        )
    except requests.RequestException as exc:
        log.warning("Patreon campaigns API request failed for vanity=%s: %s", vanity, exc)
        return None
+
    if resp.status_code != 200:
        log.warning(
            "Patreon campaigns API returned HTTP %d for vanity=%s",
            resp.status_code, vanity,
        )
        return None
+
    try:
        payload = resp.json()
    except ValueError as exc:
        log.warning("Patreon campaigns API returned non-JSON for vanity=%s: %s", vanity, exc)
        return None
-    data = payload.get("data") if isinstance(payload, dict) else None
-    if not isinstance(data, list) or not data or not isinstance(data[0], dict):
-        return None
-    return data[0]

-
-def _lookup_via_api(vanity: str, cookies_path: str | None) -> str | None:
-    first = _campaigns_api_first(vanity, cookies_path)
-    if first is None:
+    if not isinstance(payload, dict):
        return None
-    campaign_id = first.get("id")
+    data = payload.get("data")
+    if not isinstance(data, list) or not data:
+        return None
+    first = data[0] if isinstance(data[0], dict) else None
+    campaign_id = first.get("id") if first else None
    if not isinstance(campaign_id, str) or not campaign_id:
        return None
    log.info("Resolved Patreon vanity=%s → campaign_id=%s", vanity, campaign_id)
@@ -142,10 +144,24 @@ def resolve_display_name(vanity: str, cookies_path: str | None) -> str | None:
    (`fields[campaign]=name`), used to name the Artist at add-time (#130). None
    on any failure — the caller falls back to the vanity handle. Sync: call from
    an executor."""
-    first = _campaigns_api_first(vanity, cookies_path)
-    if first is None:
+    jar = _load_cookie_jar(cookies_path)
+    try:
+        resp = requests.get(
+            _CAMPAIGNS_URL,
+            params={"filter[vanity]": vanity, "fields[campaign]": "name"},
+            headers={"User-Agent": _USER_AGENT, "Accept": "application/vnd.api+json"},
+            cookies=jar,
+            timeout=_TIMEOUT_SECONDS,
+        )
+        if resp.status_code != 200:
+            return None
+        data = resp.json().get("data")
+    except (requests.RequestException, ValueError) as exc:
+        log.warning("Patreon name lookup failed for vanity=%s: %s", vanity, exc)
        return None
-    name = (first.get("attributes") or {}).get("name")
+    if not isinstance(data, list) or not data or not isinstance(data[0], dict):
+        return None
+    name = (data[0].get("attributes") or {}).get("name")
    return name.strip() if isinstance(name, str) and name.strip() else None


@@ -776,62 +776,89 @@ def recover_stalled_library_audit_runs() -> int:
        return recovered


-def _recover_stalled_runs(model, *, stall_minutes: int, keep_runs: int, label: str) -> int:
-    """Shared recovery + retention sweep for the head run-tracking tables
-    (HeadTrainingRun / HeadAutoApplyRun, which share the
-    status/last_progress_at/started_at/finished_at/error/id columns): flip 'running'
-    rows with no progress past `stall_minutes` to 'error', then prune to the last
-    `keep_runs` (rule 89). Returns the number recovered. NOTE the two other recover
-    tasks are deliberately NOT folded in — library-audit has no prune tail and
-    backup uses a single started_at cutoff."""
-    SessionLocal = _sync_session_factory()
-    now = datetime.now(UTC)
-    cutoff = now - timedelta(minutes=stall_minutes)
-    with SessionLocal() as session:
-        result = session.execute(
-            update(model)
-            .where(model.status == "running")
-            .where(func.coalesce(model.last_progress_at, model.started_at) < cutoff)
-            .values(
-                status="error", finished_at=now,
-                error=f"stranded by recovery sweep (no progress for {stall_minutes} min)",
-            )
-        )
-        keep = session.execute(
-            select(model.id).order_by(model.id.desc()).limit(keep_runs)
-        ).scalars().all()
-        if keep:
-            session.execute(delete(model).where(model.id.not_in(keep)))
-        session.commit()
-        recovered = result.rowcount or 0
-        if recovered:
-            log.info("%s: recovered %d rows", label, recovered)
-        return recovered
-
-
@celery.task(name="backend.app.tasks.maintenance.recover_stalled_head_training_runs")
 def recover_stalled_head_training_runs() -> int:
    """Flip HeadTrainingRun rows stuck in 'running' past the stall threshold to
    'error', and prune old runs to the last HEAD_TRAINING_KEEP_RUNS (retention,
    rule 89). Runs every 5 min on the maintenance lane; no-op when idle."""
-    return _recover_stalled_runs(
-        HeadTrainingRun,
-        stall_minutes=HEAD_TRAINING_STALL_THRESHOLD_MINUTES,
-        keep_runs=HEAD_TRAINING_KEEP_RUNS,
-        label="recover_stalled_head_training_runs",
-    )
+    SessionLocal = _sync_session_factory()
+    now = datetime.now(UTC)
+    cutoff = now - timedelta(minutes=HEAD_TRAINING_STALL_THRESHOLD_MINUTES)
+    with SessionLocal() as session:
+        result = session.execute(
+            update(HeadTrainingRun)
+            .where(HeadTrainingRun.status == "running")
+            .where(
+                func.coalesce(
+                    HeadTrainingRun.last_progress_at, HeadTrainingRun.started_at
+                )
+                < cutoff
+            )
+            .values(
+                status="error", finished_at=now,
+                error=(
+                    f"stranded by recovery sweep (no progress for "
+                    f"{HEAD_TRAINING_STALL_THRESHOLD_MINUTES} min)"
+                ),
+            )
+        )
+        keep = session.execute(
+            select(HeadTrainingRun.id).order_by(HeadTrainingRun.id.desc())
+            .limit(HEAD_TRAINING_KEEP_RUNS)
+        ).scalars().all()
+        if keep:
+            session.execute(
+                delete(HeadTrainingRun).where(HeadTrainingRun.id.not_in(keep))
+            )
+        session.commit()
+        recovered = result.rowcount or 0
+        if recovered:
+            log.info(
+                "recover_stalled_head_training_runs: recovered %d rows", recovered
+            )
+        return recovered


@celery.task(name="backend.app.tasks.maintenance.recover_stalled_head_auto_apply_runs")
 def recover_stalled_head_auto_apply_runs() -> int:
    """Flip stalled HeadAutoApplyRun 'running' rows to 'error' + prune to the
    last HEAD_AUTO_APPLY_KEEP_RUNS (retention, rule 89). 5-min maintenance lane."""
-    return _recover_stalled_runs(
-        HeadAutoApplyRun,
-        stall_minutes=HEAD_AUTO_APPLY_STALL_THRESHOLD_MINUTES,
-        keep_runs=HEAD_AUTO_APPLY_KEEP_RUNS,
-        label="recover_stalled_head_auto_apply_runs",
-    )
+    SessionLocal = _sync_session_factory()
+    now = datetime.now(UTC)
+    cutoff = now - timedelta(minutes=HEAD_AUTO_APPLY_STALL_THRESHOLD_MINUTES)
+    with SessionLocal() as session:
+        result = session.execute(
+            update(HeadAutoApplyRun)
+            .where(HeadAutoApplyRun.status == "running")
+            .where(
+                func.coalesce(
+                    HeadAutoApplyRun.last_progress_at, HeadAutoApplyRun.started_at
+                )
+                < cutoff
+            )
+            .values(
+                status="error", finished_at=now,
+                error=(
+                    f"stranded by recovery sweep (no progress for "
+                    f"{HEAD_AUTO_APPLY_STALL_THRESHOLD_MINUTES} min)"
+                ),
+            )
+        )
+        keep = session.execute(
+            select(HeadAutoApplyRun.id).order_by(HeadAutoApplyRun.id.desc())
+            .limit(HEAD_AUTO_APPLY_KEEP_RUNS)
+        ).scalars().all()
+        if keep:
+            session.execute(
+                delete(HeadAutoApplyRun).where(HeadAutoApplyRun.id.not_in(keep))
+            )
+        session.commit()
+        recovered = result.rowcount or 0
+        if recovered:
+            log.info(
+                "recover_stalled_head_auto_apply_runs: recovered %d rows", recovered
+            )
+        return recovered


 # Keep ~6 months of daily head-metric snapshots (enough to see tuning trends).
@@ -105,7 +105,9 @@ def embed_image(self, image_id: int) -> dict:
            record = session.get(ImageRecord, image_id)
            if record is None:
                return {"status": "missing", "image_id": image_id}
-            settings = MLSettings.load_sync(session)
+            settings = session.execute(
+                select(MLSettings).where(MLSettings.id == 1)
+            ).scalar_one()

            src = Path(record.path)
            is_vid = _is_video(src)
@@ -486,10 +488,15 @@ def scheduled_ccip_auto_apply() -> str:
    from sqlalchemy import select as sa_select
    from sqlalchemy.dialects.postgresql import insert as pg_insert

-    from ..models import ImageRegion, MLSettings, Tag, TagKind
+    from ..models import ImageRegion, MLSettings, Tag, TagKind, TagSuggestionRejection
    from ..models.tag import image_tag
-    from ..services.ml.ccip import _FIGURE_KINDS
-    from ..services.ml.training_data import _applied_or_rejected, _l2norm
+
+    fig = ("face", "figure")
+
+    def _l2(m):
+        n = np.linalg.norm(m, axis=1, keepdims=True)
+        n[n == 0] = 1.0
+        return m / n

    SessionLocal = _sync_session_factory()
    with SessionLocal() as session:
@@ -514,7 +521,7 @@ def scheduled_ccip_auto_apply() -> str:
            )
            .join(Tag, Tag.id == image_tag.c.tag_id)
            .where(Tag.kind == TagKind.character)
-            .where(ImageRegion.kind.in_(_FIGURE_KINDS))
+            .where(ImageRegion.kind.in_(fig))
            .where(ImageRegion.ccip_embedding.is_not(None))
            .where(ImageRegion.image_record_id.in_(single))
        ).all()
@@ -525,16 +532,29 @@ def scheduled_ccip_auto_apply() -> str:
        for tid, vec in ref_rows:
            by_char.setdefault(tid, []).append(vec)
        ref_tags = list(by_char)
-        mats = [_l2norm(np.asarray(by_char[t], dtype=np.float32), np) for t in ref_tags]
+        mats = [_l2(np.asarray(by_char[t], dtype=np.float32)) for t in ref_tags]
        allref = np.vstack(mats)                                  # (total, 768)
        seg = np.cumsum([0] + [len(m) for m in mats])[:-1]        # per-char start

        # Per character: images that already carry OR rejected the tag — skip.
-        skip = _applied_or_rejected(session, ref_tags)
+        skip = {t: set() for t in ref_tags}
+        for t in ref_tags:
+            for (iid,) in session.execute(
+                sa_select(image_tag.c.image_record_id).where(
+                    image_tag.c.tag_id == t
+                )
+            ):
+                skip[t].add(iid)
+            for (iid,) in session.execute(
+                sa_select(TagSuggestionRejection.image_record_id).where(
+                    TagSuggestionRejection.tag_id == t
+                )
+            ):
+                skip[t].add(iid)

        img_ids = list(session.execute(
            sa_select(ImageRegion.image_record_id)
-            .where(ImageRegion.kind.in_(_FIGURE_KINDS), ImageRegion.ccip_embedding.is_not(None))
+            .where(ImageRegion.kind.in_(fig), ImageRegion.ccip_embedding.is_not(None))
            .distinct()
        ).scalars())

@@ -546,7 +566,7 @@ def scheduled_ccip_auto_apply() -> str:
                sa_select(ImageRegion.image_record_id, ImageRegion.ccip_embedding)
                .where(
                    ImageRegion.image_record_id.in_(chunk),
-                    ImageRegion.kind.in_(_FIGURE_KINDS),
+                    ImageRegion.kind.in_(fig),
                    ImageRegion.ccip_embedding.is_not(None),
                )
            ).all()
@@ -554,7 +574,7 @@ def scheduled_ccip_auto_apply() -> str:
            for iid, vec in rows:
                by_img.setdefault(iid, []).append(vec)
            for iid, vecs in by_img.items():
-                q = _l2norm(np.asarray(vecs, dtype=np.float32), np)  # (nq, 768)
+                q = _l2(np.asarray(vecs, dtype=np.float32))      # (nq, 768)
                colmax = (q @ allref.T).max(axis=0)              # (total,)
                charmax = np.maximum.reduceat(colmax, seg)       # (n_chars,)
                for ci in np.where(charmax >= thr)[0]:
@@ -60,8 +60,9 @@ async function checkForUpdateInfo() {
  }
  const currentVersion = browser.runtime.getManifest().version;
  const latestVersion = info && info.version ? info.version : null;
-  // latest_url is served from the web root, not the JSON API.
-  const base = api.webRoot();
+  // latest_url is served from the web root; strip the /api suffix off baseUrl
+  // (same transform as OPEN_ARTIST_PAGE).
+  const base = (api.baseUrl || '').replace(/\/+$/, '').replace(/\/api$/, '');
  return {
    updateAvailable: !!latestVersion && versionIsNewer(latestVersion, currentVersion),
    currentVersion,
@@ -210,21 +211,6 @@ browser.webRequest.onBeforeRedirect.addListener(
  { urls: ['https://app-api.pixiv.net/web/v1/users/auth/pixiv/callback*'] },
 );

-// Extract → verify → upload one cookie-auth platform. Returns a structured
-// outcome so the two callers (EXPORT_COOKIES single, EXPORT_ALL_COOKIES) shape
-// their own response + skip semantics. Verifies the captured cookies are
-// actually live BEFORE uploading, so a confirmed-stale session doesn't overwrite
-// good FC-side credentials; platforms with no verify config (v.ok === null) fall
-// through to upload.
-async function exportPlatformCookies(key) {
-  const cookies = await extractCookiesForPlatform(key);
-  if (cookies.length === 0) return { status: 'empty' };
-  const v = await verifyCookiesForPlatform(key);
-  if (v.ok === false) return { status: 'stale', reason: v.reason, cookieCount: cookies.length };
-  await api.uploadCredentials(key, 'cookies', toNetscapeFormat(cookies));
-  return { status: 'ok', cookieCount: cookies.length, verified: v.ok === true };
-}
-
 // ---- Message router ----

 browser.runtime.onMessage.addListener(async (msg) => {
@@ -269,14 +255,22 @@ browser.runtime.onMessage.addListener(async (msg) => {
      if (!platform) return { error: `Unknown platform: ${key}` };
      try {
        if (platform.authType === 'cookies') {
-          const r = await exportPlatformCookies(key);
-          if (r.status === 'empty') return { error: 'No cookies found — log in first.' };
-          if (r.status === 'stale') {
+          const cookies = await extractCookiesForPlatform(key);
+          if (cookies.length === 0) return { error: 'No cookies found — log in first.' };
+          // Verify the captured cookies are actually live BEFORE
+          // uploading. Skips upload on confirmed-stale sessions so we
+          // don't overwrite FC-side credentials with garbage. Platforms
+          // without a verify config (verify.ok === null) fall through
+          // to upload as before.
+          const v = await verifyCookiesForPlatform(key);
+          if (v.ok === false) {
            return {
-              error: `Captured ${r.cookieCount} ${platform.name} cookies but they don't appear authenticated (${r.reason}). Log in again in this browser, then retry.`,
+              error: `Captured ${cookies.length} ${platform.name} cookies but they don't appear authenticated (${v.reason}). Log in again in this browser, then retry.`,
            };
          }
-          return { success: true, cookieCount: r.cookieCount, verified: r.verified };
+          const data = toNetscapeFormat(cookies);
+          await api.uploadCredentials(key, 'cookies', data);
+          return { success: true, cookieCount: cookies.length, verified: v.ok === true };
        }
        if (key === 'discord') {
          if (!discordToken) return { error: 'Open discord.com to capture a token first.' };
@@ -304,10 +298,18 @@ browser.runtime.onMessage.addListener(async (msg) => {
          continue;
        }
        try {
-          const r = await exportPlatformCookies(key);
-          if (r.status === 'empty') results[key] = { skipped: true, reason: 'no cookies' };
-          else if (r.status === 'stale') results[key] = { error: `verify failed: ${r.reason}` };
-          else results[key] = { success: true, cookieCount: r.cookieCount, verified: r.verified };
+          const cookies = await extractCookiesForPlatform(key);
+          if (cookies.length === 0) {
+            results[key] = { skipped: true, reason: 'no cookies' };
+            continue;
+          }
+          const v = await verifyCookiesForPlatform(key);
+          if (v.ok === false) {
+            results[key] = { error: `verify failed: ${v.reason}` };
+            continue;
+          }
+          await api.uploadCredentials(key, 'cookies', toNetscapeFormat(cookies));
+          results[key] = { success: true, cookieCount: cookies.length, verified: v.ok === true };
        } catch (e) {
          results[key] = { error: e.message };
        }
@@ -344,9 +346,11 @@ browser.runtime.onMessage.addListener(async (msg) => {
      }

    case 'OPEN_ARTIST_PAGE': {
-      // The SPA artist route (/artist/:slug) is served from the web root, not
-      // the JSON API — see api.webRoot().
-      const base = api.webRoot();
+      // apiUrl is configured with the /api suffix (see
+      // options/options.html placeholder); the SPA artist route is
+      // /artist/:slug, served from the same origin. Strip /api so the
+      // browser-level URL hits the Vue router, not the JSON API.
+      const base = (api.baseUrl || '').replace(/\/+$/, '').replace(/\/api$/, '');
      const slug = encodeURIComponent(msg.slug || '');
      if (!base || !slug) return { error: 'apiUrl or slug missing' };
      try {
@@ -96,13 +96,6 @@ class FabledCuratorAPI {
    return this.request('GET', '/extension/manifest');
  }

-  // The web/SPA root: baseUrl with the trailing slash + `/api` suffix stripped.
-  // Where the Vue router (artist pages) and the served XPI live, NOT the JSON
-  // API. Used by OPEN_ARTIST_PAGE + the self-update check.
-  webRoot() {
-    return (this.baseUrl || '').replace(/\/+$/, '').replace(/\/api$/, '');
-  }
-
  // Connection test = the cheapest read with auth.
  testConnection() {
    return this.request('GET', '/credentials');
@@ -2,15 +2,6 @@ document.addEventListener('DOMContentLoaded', init);

 const CONNECTION_TEST_INTERVAL = 2 * 60 * 1000;

-// A centered muted note div — the loading / empty state shared by the platform
-// and sources lists.
-function mutedNote(text) {
-  const d = document.createElement('div');
-  d.style.cssText = 'text-align:center;padding:18px;color:var(--on-surface-variant);';
-  d.textContent = text;
-  return d;
-}
-
 async function init() {
  try {
    const cfg = await browser.runtime.sendMessage({ type: 'GET_CONFIG' });
@@ -47,7 +38,10 @@ function showSetupRequired() {
 function showPlatformsLoading() {
  const c = document.getElementById('platforms-list');
  c.textContent = '';
-  c.appendChild(mutedNote('Loading platforms…'));
+  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() {
@@ -189,7 +183,10 @@ async function exportAllCookies() {
 async function loadSources() {
  const c = document.getElementById('sources-list');
  c.textContent = '';
-  c.appendChild(mutedNote('Loading sources…'));
+  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) {
@@ -200,7 +197,10 @@ async function loadSources() {
    return;
  }
  if (!r.sources || r.sources.length === 0) {
-    c.appendChild(mutedNote('No sources yet.'));
+    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));
@@ -1,56 +0,0 @@
-<!--
-  Canonical settings number field (DRY pass #161): a compact numeric v-text-field
-  with a built-in clamp to [min,max] on commit. Hand-rolled identically across the
-  ML settings cards (HeadsCard x6, CropProposersCard, VideoEmbeddingCard).
-
-  The clamp is the point: the cards previously sent Number(raw) straight to the
-  API, so an out-of-range value bounced off the API's 400 validator (only
-  TranslationCard clamped). This is now the single home for that clamp.
-
-  Binds `modelValue` (v-model) and emits `change` on blur/enter AFTER clamping, so
-  the parent's save reads the already-clamped value — same as the prior
-  `v-model.number` + `@change=save` pattern.
-->
-<template>
-  <v-text-field
-    :model-value="modelValue"
-    :label="label"
-    type="number"
-    :min="min"
-    :max="max"
-    :step="step"
-    :disabled="disabled"
-    :density="density" hide-details
-    :style="{ maxWidth }"
-    @update:model-value="v => emit('update:modelValue', v)"
-    @change="onCommit"
-  />
-</template>
-
-<script setup>
-const props = defineProps({
-  modelValue: { type: [Number, String], default: null },
-  label: { type: String, default: '' },
-  min: { type: [Number, String], default: null },
-  max: { type: [Number, String], default: null },
-  step: { type: [Number, String], default: 1 },
-  maxWidth: { type: String, default: '200px' },
-  density: { type: String, default: 'compact' },
-  disabled: { type: Boolean, default: false },
-})
-const emit = defineEmits(['update:modelValue', 'change'])
-
-function onCommit() {
-  // On blur/enter: coerce to a number and clamp to [min,max] so an out-of-range
-  // value never reaches the API. props.modelValue reflects the latest keystroke
-  // (kept in sync by the passthrough above); re-emit the clamped number, then let
-  // the parent persist.
-  let n = Number(props.modelValue)
-  if (!Number.isNaN(n)) {
-    if (props.min !== null && props.min !== '') n = Math.max(Number(props.min), n)
-    if (props.max !== null && props.max !== '') n = Math.min(Number(props.max), n)
-    if (n !== Number(props.modelValue)) emit('update:modelValue', n)
-  }
-  emit('change')
-}
-</script>
@@ -1,42 +0,0 @@
-<!--
-  Canonical settings toggle row (DRY pass #161): an accent icon + an uppercase
-  .fc-section-h label + a right-aligned switch. Hand-rolled identically in the
-  ML settings cards (HeadsCard x3, CropProposersCard, MLBackfillCard).
-
-  Two-way binds `modelValue` (so the parent switch state stays optimistic) AND
-  emits `change` with the new boolean, so the parent can persist + revert on
-  failure — matching the prior `v-model` + `@update:model-value=handler` pattern.
-->
-<template>
-  <div class="d-flex align-center mb-1" style="gap: 10px;">
-    <v-icon v-if="icon" size="18" :color="iconColor">{{ icon }}</v-icon>
-    <span class="fc-section-h">{{ label }}</span>
-    <v-switch
-      :model-value="modelValue"
-      :loading="loading"
-      :disabled="disabled"
-      hide-details density="compact" color="success" class="ml-auto"
-      @update:model-value="onSwitch"
-    />
-  </div>
-</template>
-
-<script setup>
-defineProps({
-  modelValue: { type: Boolean, default: false },
-  label: { type: String, default: '' },
-  icon: { type: String, default: '' },
-  // Icon tint. Default accent; pass null for the theme default (e.g. when a row
-  // is off). null (not undefined) so the default doesn't override it.
-  iconColor: { type: String, default: 'accent' },
-  loading: { type: Boolean, default: false },
-  disabled: { type: Boolean, default: false },
-})
-const emit = defineEmits(['update:modelValue', 'change'])
-
-function onSwitch(v) {
-  const b = !!v
-  emit('update:modelValue', b)
-  emit('change', b)
-}
-</script>
@@ -15,23 +15,28 @@
    </p>

    <div v-for="p in proposers" :key="p.key" class="fc-proposer">
-      <SettingToggleRow
-        v-model="p.on" :loading="busy" :icon="p.icon"
-        :icon-color="p.on ? 'accent' : null" :label="p.label"
-        @change="v => saveToggle(p, v)"
-      />
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
+        <v-icon size="18" :color="p.on ? 'accent' : undefined">{{ p.icon }}</v-icon>
+        <span class="fc-section-h">{{ p.label }}</span>
+        <v-switch
+          v-model="p.on" :loading="busy" hide-details density="compact"
+          color="success" class="ml-auto"
+          @update:model-value="v => saveToggle(p, v)"
+        />
+      </div>
      <p class="fc-muted text-body-2 mb-2">{{ p.help }}</p>
      <div class="d-flex flex-wrap mb-4" style="gap: 12px;">
        <v-text-field
          v-model="p.weights" label="Weights" density="compact" hide-details
          style="min-width: 300px; flex: 1;" :disabled="busy || !p.on"
          placeholder="name | URL | hf_repo::file"
-          @change="saveField({ [`detector_${p.key}_weights`]: p.weights })"
+          @change="save({ [`detector_${p.key}_weights`]: p.weights })"
        />
-        <SettingNumberField
-          v-model="p.conf" label="Confidence" :min="0" :max="1" :step="0.05"
-          max-width="140px" :disabled="busy || !p.on"
-          @change="saveField({ [`detector_${p.key}_conf`]: Number(p.conf) })"
+        <v-text-field
+          v-model.number="p.conf" label="Confidence" type="number"
+          min="0" max="1" step="0.05" density="compact" hide-details
+          style="max-width: 140px;" :disabled="busy || !p.on"
+          @change="save({ [`detector_${p.key}_conf`]: Number(p.conf) })"
        />
      </div>
    </div>
@@ -43,12 +48,12 @@
        storage. Dedupe IoU drops near-duplicate crops before embedding.
      </p>
      <div class="d-flex flex-wrap" style="gap: 12px;">
-        <SettingNumberField
+        <v-text-field
          v-for="c in caps" :key="c.key"
-          v-model="c.val" :label="c.label"
-          :min="c.min" :max="c.max" :step="c.step || 1"
-          max-width="165px" :disabled="busy"
-          @change="saveField({ [c.key]: Number(c.val) })"
+          v-model.number="c.val" :label="c.label" type="number"
+          :min="c.min" :max="c.max" :step="c.step || 1" density="compact"
+          hide-details style="max-width: 165px;" :disabled="busy"
+          @change="save({ [c.key]: Number(c.val) })"
        />
      </div>
    </div>
@@ -56,16 +61,14 @@
 </template>

 <script setup>
+import { toast } from '../../utils/toast.js'
 import { onMounted, ref } from 'vue'

 import MaintenanceTile from '../common/MaintenanceTile.vue'
-import SettingNumberField from '../common/SettingNumberField.vue'
-import SettingToggleRow from '../common/SettingToggleRow.vue'
-import { useSettingSave } from '../../composables/useSettingSave.js'
 import { useMLStore } from '../../stores/ml.js'

 const mlSettings = useMLStore()
-const { busy, save } = useSettingSave(mlSettings.patchSettings)
+const busy = ref(false)
 const proposers = ref([])
 const caps = ref([])

@@ -108,20 +111,31 @@ onMounted(async () => {
  caps.value = CAP_DEFS.map(c => ({ ...c, val: s[c.key] ?? 0 }))
 })

-// Field @change → persist with a "Saved" confirmation. SettingNumberField has
-// already clamped numeric values to their [min,max] before this fires.
-function saveField(patch) {
-  save(patch, { successMessage: 'Saved' })
+async function save(patch, revert) {
+  busy.value = true
+  try {
+    await mlSettings.patchSettings(patch)
+    toast({ text: 'Saved', type: 'success' })
+  } catch (e) {
+    if (revert) revert()
+    toast({ text: `Could not save: ${e.message}`, type: 'error' })
+  } finally {
+    busy.value = false
+  }
 }

-async function saveToggle(p, v) {
+function saveToggle (p, v) {
  // Revert the switch on failure so it never lies about the persisted state.
-  const ok = await save({ [`detector_${p.key}_enabled`]: !!v }, { successMessage: 'Saved' })
-  if (!ok) p.on = !v
+  save({ [`detector_${p.key}_enabled`]: !!v }, () => { p.on = !v })
 }
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-section-h {
+  font-size: 13px; font-weight: 700; letter-spacing: 0.03em;
+  text-transform: uppercase; color: rgb(var(--v-theme-on-surface));
+}
 .fc-proposer {
  border-top: 1px solid rgb(var(--v-theme-surface-light)); padding-top: 14px;
 }
@@ -112,6 +112,7 @@ async function onCommit() {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
 .fc-code {
  background: rgb(var(--v-theme-surface-light));
  border-radius: 4px; padding: 2px 8px;
@@ -42,7 +42,7 @@
          </tr>
        </tbody>
      </v-table>
-      <p v-else class="text-caption mt-3 fc-muted">
+      <p v-else class="text-caption mt-3" style="opacity: 0.6;">
        No table statistics yet.
      </p>
  </MaintenanceTile>
@@ -72,5 +72,6 @@ onUnmounted(() => { if (pollId) clearInterval(pollId) })
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
 .fc-bad { color: rgb(var(--v-theme-error)); }
 </style>
@@ -95,6 +95,7 @@ onUnmounted(() => { if (pollId) clearInterval(pollId) })
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
 .fc-cells { display: flex; gap: 28px; }
 .fc-cell__n {
  font-size: 20px; font-weight: 700; line-height: 1.1;
@@ -104,5 +105,6 @@ onUnmounted(() => { if (pollId) clearInterval(pollId) })
  font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em;
  color: rgb(var(--v-theme-on-surface-variant));
 }
+.fc-good { color: rgb(var(--v-theme-success)); }
 .fc-bad { color: rgb(var(--v-theme-error)); }
 </style>
@@ -367,6 +367,11 @@ async function onReprocess() {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-section-h {
+  font-size: 13px; font-weight: 700; letter-spacing: 0.03em;
+  text-transform: uppercase; color: rgb(var(--v-theme-on-surface));
+}
 .fc-token {
  display: flex; align-items: center; gap: 4px;
  background: rgb(var(--v-theme-surface-light)); border-radius: 6px;
@@ -385,4 +390,6 @@ async function onReprocess() {
  font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em;
  color: rgb(var(--v-theme-on-surface-variant));
 }
+.fc-good { color: rgb(var(--v-theme-success)); }
+.fc-weak { color: rgb(var(--v-theme-error)); }
 </style>
@@ -155,6 +155,11 @@ async function onRecover(it) {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+.fc-section-h {
+  font-size: 13px; font-weight: 700; letter-spacing: 0.03em;
+  text-transform: uppercase; color: rgb(var(--v-theme-on-surface));
+}
 .fc-queue { display: flex; gap: 24px; }
 .fc-q__n {
  font-size: 20px; font-weight: 700; line-height: 1.1;
@@ -164,6 +169,8 @@ async function onRecover(it) {
  font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em;
  color: rgb(var(--v-theme-on-surface-variant));
 }
+.fc-good { color: rgb(var(--v-theme-success)); }
+.fc-weak { color: rgb(var(--v-theme-error)); }
 .fc-defect {
  display: flex; align-items: center; gap: 12px;
  background: rgb(var(--v-theme-surface-light)); border-radius: 8px;
@@ -95,10 +95,14 @@

    <!-- Earned auto-apply -->
    <div class="fc-auto mt-6">
-      <SettingToggleRow
-        v-model="autoEnabled" :loading="settingBusy"
-        icon="mdi-lightning-bolt" label="Auto-apply" @change="onToggleAuto"
-      />
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
+        <v-icon size="18" color="accent">mdi-lightning-bolt</v-icon>
+        <span class="fc-section-h">Auto-apply</span>
+        <v-switch
+          v-model="autoEnabled" :loading="settingBusy" hide-details density="compact"
+          color="success" class="ml-auto" @update:model-value="onToggleAuto"
+        />
+      </div>
      <p class="fc-muted text-body-2 mb-3">
        Graduated heads (⚡, with ≥ {{ autoMinPosInput }} examples) apply their tag
        on their own where they clear {{ Math.round((autoPrecisionInput || 0) * 100) }}%
@@ -107,14 +111,17 @@
      </p>

      <div class="d-flex mb-3" style="gap: 12px;">
-        <SettingNumberField
-          v-model="autoPrecisionInput" label="Precision target"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+        <v-text-field
+          v-model.number="autoPrecisionInput" label="Precision target"
+          type="number" min="0.5" max="0.999" step="0.01" density="compact"
+          hide-details style="max-width: 200px;" :disabled="settingBusy"
          @change="onSaveSettings"
        />
-        <SettingNumberField
-          v-model="autoMinPosInput" label="Min examples to fire"
-          :min="1" :disabled="settingBusy" @change="onSaveSettings"
+        <v-text-field
+          v-model.number="autoMinPosInput" label="Min examples to fire"
+          type="number" min="1" density="compact" hide-details
+          style="max-width: 200px;" :disabled="settingBusy"
+          @change="onSaveSettings"
        />
      </div>

@@ -154,11 +161,15 @@

    <!-- Presentation chrome auto-hide (#141) -->
    <div class="fc-auto mt-6">
-      <SettingToggleRow
-        v-model="presentationEnabled" :loading="settingBusy"
-        icon="mdi-image-off-outline" label="Hide presentation chrome"
-        @change="onTogglePresentation"
-      />
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
+        <v-icon size="18" color="accent">mdi-image-off-outline</v-icon>
+        <span class="fc-section-h">Hide presentation chrome</span>
+        <v-switch
+          v-model="presentationEnabled" :loading="settingBusy" hide-details
+          density="compact" color="success" class="ml-auto"
+          @update:model-value="onTogglePresentation"
+        />
+      </div>
      <p class="fc-muted text-body-2 mb-3">
        Auto-hide <code>banner</code> chrome from the gallery once a head has
        learned it (≥ {{ minPositives }} examples) and clears
@@ -169,14 +180,16 @@
        tag), it's flagged for review instead of buried. Every auto-hide is reversible.
      </p>
      <div class="d-flex mb-3" style="gap: 12px;">
-        <SettingNumberField
-          v-model="presentationThresholdInput" label="Hide confidence"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+        <v-text-field
+          v-model.number="presentationThresholdInput" label="Hide confidence"
+          type="number" min="0.5" max="0.999" step="0.01" density="compact"
+          hide-details style="max-width: 200px;" :disabled="settingBusy"
          @change="onSavePresentation"
        />
-        <SettingNumberField
-          v-model="presentationConflictInput" label="Flag if content ≥"
-          :min="0" :max="1" :step="0.05" :disabled="settingBusy"
+        <v-text-field
+          v-model.number="presentationConflictInput" label="Flag if content ≥"
+          type="number" min="0" max="1" step="0.05" density="compact"
+          hide-details style="max-width: 200px;" :disabled="settingBusy"
          @change="onSavePresentation"
        />
      </div>
@@ -184,11 +197,15 @@

    <!-- Process auto-tagging (#1464): wip / editor screenshot -->
    <div class="fc-auto mt-6">
-      <SettingToggleRow
-        v-model="processEnabled" :loading="settingBusy"
-        icon="mdi-progress-wrench" label="Auto-tag work-in-progress"
-        @change="onToggleProcess"
-      />
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
+        <v-icon size="18" color="accent">mdi-progress-wrench</v-icon>
+        <span class="fc-section-h">Auto-tag work-in-progress</span>
+        <v-switch
+          v-model="processEnabled" :loading="settingBusy" hide-details
+          density="compact" color="success" class="ml-auto"
+          @update:model-value="onToggleProcess"
+        />
+      </div>
      <p class="fc-muted text-body-2 mb-3">
        Auto-tag <code>wip</code> and <code>editor screenshot</code> process art
        once a head has learned them (≥ {{ minPositives }} examples) and clears
@@ -200,14 +217,16 @@
        manual tags, never its own guesses — so it can't run away. Every tag reversible.
      </p>
      <div class="d-flex mb-3" style="gap: 12px;">
-        <SettingNumberField
-          v-model="processThresholdInput" label="Tag confidence"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+        <v-text-field
+          v-model.number="processThresholdInput" label="Tag confidence"
+          type="number" min="0.5" max="0.999" step="0.01" density="compact"
+          hide-details style="max-width: 200px;" :disabled="settingBusy"
          @change="onSaveProcess"
        />
-        <SettingNumberField
-          v-model="processConflictInput" label="Flag if content ≥"
-          :min="0" :max="1" :step="0.05" :disabled="settingBusy"
+        <v-text-field
+          v-model.number="processConflictInput" label="Flag if content ≥"
+          type="number" min="0" max="1" step="0.05" density="compact"
+          hide-details style="max-width: 200px;" :disabled="settingBusy"
          @change="onSaveProcess"
        />
      </div>
@@ -237,7 +256,7 @@
              <td class="fc-r fc-mono">{{ c.n_auto_applied }}</td>
              <td class="fc-r fc-mono">{{ c.n_misfires }}</td>
              <td class="fc-r fc-mono" :class="rateClass(c.misfire_rate)">
-                {{ pct(c.misfire_rate) }}
+                {{ ratePct(c.misfire_rate) }}
              </td>
              <td class="fc-r fc-mono">{{ c.n_underfires }}</td>
            </tr>
@@ -253,9 +272,6 @@ import { toast } from '../../utils/toast.js'
 import { computed, onMounted, onUnmounted, ref } from 'vue'

 import MaintenanceTile from '../common/MaintenanceTile.vue'
-import SettingNumberField from '../common/SettingNumberField.vue'
-import SettingToggleRow from '../common/SettingToggleRow.vue'
-import { useSettingSave } from '../../composables/useSettingSave.js'
 import { useHeadsStore } from '../../stores/heads.js'
 import { useMLStore } from '../../stores/ml.js'

@@ -269,9 +285,7 @@ let pollTimer = null
 const autoEnabled = ref(false)
 const autoPrecisionInput = ref(0.97)
 const autoMinPosInput = ref(30)
-// Shared settings-save flow (busy + toast + revert); `settingBusy` gates the
-// toggles/fields, `save` returns ok/false for the optimistic-switch revert.
-const { busy: settingBusy, save } = useSettingSave(mlSettings.patchSettings)
+const settingBusy = ref(false)
 const autoBusy = ref(false)
 const autoStatus = ref(null)
 const metricsData = ref(null)
@@ -381,39 +395,81 @@ function startAutoPoll() {
 function stopAutoPoll() { if (autoTimer) { clearInterval(autoTimer); autoTimer = null } }

 async function onToggleAuto(val) {
-  const ok = await save({ head_auto_apply_enabled: !!val },
-    { successMessage: val ? 'Auto-apply on' : 'Auto-apply off', errorPrefix: 'Could not update' })
-  if (!ok) autoEnabled.value = !val   // revert the switch
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({ head_auto_apply_enabled: !!val })
+    toast({ text: val ? 'Auto-apply on' : 'Auto-apply off', type: 'success' })
+  } catch (e) {
+    autoEnabled.value = !val   // revert the switch
+    toast({ text: `Could not update: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }
 async function onSaveSettings() {
-  await save({
-    head_auto_apply_precision: Number(autoPrecisionInput.value),
-    head_auto_apply_min_positives: Number(autoMinPosInput.value),
-  })
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({
+      head_auto_apply_precision: Number(autoPrecisionInput.value),
+      head_auto_apply_min_positives: Number(autoMinPosInput.value),
+    })
+  } catch (e) {
+    toast({ text: `Could not save: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }

 async function onTogglePresentation(val) {
-  const ok = await save({ presentation_auto_apply_enabled: !!val },
-    { successMessage: val ? 'Chrome auto-hide on' : 'Chrome auto-hide off', errorPrefix: 'Could not update' })
-  if (!ok) presentationEnabled.value = !val   // revert the switch
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({ presentation_auto_apply_enabled: !!val })
+    toast({ text: val ? 'Chrome auto-hide on' : 'Chrome auto-hide off', type: 'success' })
+  } catch (e) {
+    presentationEnabled.value = !val   // revert the switch
+    toast({ text: `Could not update: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }
 async function onSavePresentation() {
-  await save({
-    presentation_auto_apply_threshold: Number(presentationThresholdInput.value),
-    presentation_conflict_threshold: Number(presentationConflictInput.value),
-  })
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({
+      presentation_auto_apply_threshold: Number(presentationThresholdInput.value),
+      presentation_conflict_threshold: Number(presentationConflictInput.value),
+    })
+  } catch (e) {
+    toast({ text: `Could not save: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }

 async function onToggleProcess(val) {
-  const ok = await save({ process_auto_apply_enabled: !!val },
-    { successMessage: val ? 'WIP auto-tag on' : 'WIP auto-tag off', errorPrefix: 'Could not update' })
-  if (!ok) processEnabled.value = !val   // revert the switch
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({ process_auto_apply_enabled: !!val })
+    toast({ text: val ? 'WIP auto-tag on' : 'WIP auto-tag off', type: 'success' })
+  } catch (e) {
+    processEnabled.value = !val   // revert the switch
+    toast({ text: `Could not update: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }
 async function onSaveProcess() {
-  await save({
-    process_auto_apply_threshold: Number(processThresholdInput.value),
-    process_conflict_threshold: Number(processConflictInput.value),
-  })
+  settingBusy.value = true
+  try {
+    await mlSettings.patchSettings({
+      process_auto_apply_threshold: Number(processThresholdInput.value),
+      process_conflict_threshold: Number(processConflictInput.value),
+    })
+  } catch (e) {
+    toast({ text: `Could not save: ${e.message}`, type: 'error' })
+  } finally {
+    settingBusy.value = false
+  }
 }
 function onPreview() { startSweep(true) }
 function onApplyNow() { startSweep(false) }
@@ -439,6 +495,7 @@ function sweepConcepts(run) {
    .sort((a, b) => b.applied - a.applied)
 }
 function sweepTotal(run) { return run?.n_applied ?? 0 }
+function ratePct(x) { return x == null ? '—' : `${Math.round(x * 100)}%` }
 function rateClass(x) {
  if (x == null) return ''
  if (x <= 0.03) return 'fc-good'
@@ -469,6 +526,12 @@ function relTime(iso) {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
+
+.fc-section-h {
+  font-size: 13px; font-weight: 700; letter-spacing: 0.03em;
+  text-transform: uppercase; color: rgb(var(--v-theme-on-surface));
+}
 .fc-auto {
  border-top: 1px solid rgb(var(--v-theme-surface-light)); padding-top: 16px;
 }
@@ -525,5 +588,7 @@ function relTime(iso) {
  background: rgb(var(--v-theme-surface-light));
  padding: 1px 6px; border-radius: 999px;
 }
+.fc-good { color: rgb(var(--v-theme-success)); }
 .fc-ok { color: rgb(var(--v-theme-on-surface)); }
+.fc-weak { color: rgb(var(--v-theme-error)); }
 </style>
@@ -39,14 +39,13 @@
 import { toast } from '../../utils/toast.js'
 import { onMounted, ref } from 'vue'
 import { useMLStore } from '../../stores/ml.js'
-import { useSettingSave } from '../../composables/useSettingSave.js'
 import MaintenanceTile from '../common/MaintenanceTile.vue'
 import QueueStatusBar from './QueueStatusBar.vue'
 const store = useMLStore()
-const { busy: saving, save } = useSettingSave(store.patchSettings)
 const busy = ref(false)
 const done = ref(false)
 const enabled = ref(true)
+const saving = ref(false)
 onMounted(async () => {
  try {
    await store.loadSettings()
@@ -56,12 +55,21 @@ onMounted(async () => {
  } catch { /* non-fatal */ }
 })
 async function onToggle() {
-  const ok = await save({ cpu_embed_enabled: enabled.value }, {
-    successMessage: enabled.value
-      ? 'CPU embedding on — imports queue embeds for the ml-worker'
-      : 'CPU embedding off — the GPU embed backfill owns whole-image embeds',
-  })
-  if (!ok) enabled.value = !enabled.value
+  saving.value = true
+  try {
+    await store.patchSettings({ cpu_embed_enabled: enabled.value })
+    toast({
+      text: enabled.value
+        ? 'CPU embedding on — imports queue embeds for the ml-worker'
+        : 'CPU embedding off — the GPU embed backfill owns whole-image embeds',
+      type: 'success',
+    })
+  } catch (e) {
+    toast({ text: `Could not save: ${e.message}`, type: 'error' })
+    enabled.value = !enabled.value
+  } finally {
+    saving.value = false
+  }
 }
 async function run() {
  busy.value = true
@@ -72,4 +80,5 @@ async function run() {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
 </style>
@@ -12,17 +12,17 @@
      </div>
      <v-row>
        <v-col cols="12" sm="6">
-          <SettingNumberField
-            v-model="local.video_frame_interval_seconds"
-            label="Frame interval (s)" :min="0.5" :step="0.5"
-            density="comfortable" max-width="none" @change="onSave"
+          <v-text-field
+            v-model.number="local.video_frame_interval_seconds"
+            label="Frame interval (s)" type="number" min="0.5" step="0.5"
+            density="comfortable" hide-details @change="save"
          />
        </v-col>
        <v-col cols="12" sm="6">
-          <SettingNumberField
-            v-model="local.video_max_frames"
-            label="Max frames" :min="1" :step="1"
-            density="comfortable" max-width="none" @change="onSave"
+          <v-text-field
+            v-model.number="local.video_max_frames"
+            label="Max frames" type="number" min="1" step="1"
+            density="comfortable" hide-details @change="save"
          />
        </v-col>
      </v-row>
@@ -32,23 +32,21 @@
 </template>

 <script setup>
+import { toast } from '../../utils/toast.js'
 import { reactive, watch } from 'vue'
 import { useMLStore } from '../../stores/ml.js'
 import MaintenanceTile from '../common/MaintenanceTile.vue'
-import SettingNumberField from '../common/SettingNumberField.vue'
-import { useSettingSave } from '../../composables/useSettingSave.js'

 const store = useMLStore()
-const { save } = useSettingSave(store.patchSettings)
 const local = reactive({})
 watch(() => store.settings, (s) => { if (s) Object.assign(local, s) }, { immediate: true })

-// SettingNumberField clamps interval to ≥0.5 and max-frames to ≥1 before this
-// fires, so an out-of-range value never reaches the API.
-function onSave() {
-  save({
-    video_frame_interval_seconds: Number(local.video_frame_interval_seconds),
-    video_max_frames: Number(local.video_max_frames),
-  })
+async function save() {
+  const patch = {
+    video_frame_interval_seconds: local.video_frame_interval_seconds,
+    video_max_frames: local.video_max_frames
+  }
+  try { await store.patchSettings(patch) }
+  catch (e) { toast({ text: e.message, type: 'error' }) }
 }
 </script>
@@ -24,7 +24,6 @@
        the CPU fallback.
      </p>
      <div class="fc-tile-stack">
-        <VideoEmbeddingCard />
        <GpuAgentCard />
        <GpuTriageCard />
        <MLBackfillCard />
@@ -37,6 +36,7 @@
        Suggestion thresholds, trained heads and tag aliases.
      </p>
      <div class="fc-tile-stack">
+        <MLThresholdSliders />
        <CropProposersCard />
        <HeadsCard />
        <AliasTable />
@@ -77,7 +77,7 @@ import ArchiveReextractCard from './ArchiveReextractCard.vue'
 import MissingFileRepairCard from './MissingFileRepairCard.vue'
 import GpuTriageCard from './GpuTriageCard.vue'
 import DbMaintenanceCard from './DbMaintenanceCard.vue'
-import VideoEmbeddingCard from './VideoEmbeddingCard.vue'
+import MLThresholdSliders from './MLThresholdSliders.vue'
 import CropProposersCard from './CropProposersCard.vue'
 import HeadsCard from './HeadsCard.vue'
 import GpuAgentCard from './GpuAgentCard.vue'
@@ -1,33 +0,0 @@
-import { ref } from 'vue'
-import { toast } from '../utils/toast.js'
-
-// The shared "persist a settings patch" flow for the ML settings cards. Flips a
-// busy flag, calls the store's patch (which rethrows on failure), toasts
-// success/error, and returns true/false so a toggle handler can revert its
-// optimistic switch on failure. Centralises the try/catch/toast the cards each
-// hand-rolled (HeadsCard x6, CropProposersCard, MLBackfillCard) — and where the
-// threshold-clamp drifted; the clamp now lives in <SettingNumberField>.
-//
-// Pass the store's patch fn, e.g. useSettingSave(ml.patchSettings).
-export function useSettingSave(patchFn) {
-  const busy = ref(false)
-
-  // opts.successMessage — toast on success (toggles announce their new state;
-  // silent field-saves omit it). opts.errorPrefix — the failure toast prefix
-  // ("Could not save" default; toggles used "Could not update").
-  async function save(patch, { successMessage = '', errorPrefix = 'Could not save' } = {}) {
-    busy.value = true
-    try {
-      await patchFn(patch)
-      if (successMessage) toast({ text: successMessage, type: 'success' })
-      return true
-    } catch (e) {
-      toast({ text: `${errorPrefix}: ${e.message}`, type: 'error' })
-      return false
-    } finally {
-      busy.value = false
-    }
-  }
-
-  return { busy, save }
-}
@@ -40,20 +40,6 @@
   emits, so no specificity/reorder fight — no !important needed. */
 .fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }

-/* Section sub-heading in settings cards (DRY pass #161): was redefined
-   identically in 4 cards, and TranslationCard used the class with NO local def
-   so its section headers rendered unstyled. Now one global utility. */
-.fc-section-h {
-  font-size: 13px; font-weight: 700; letter-spacing: 0.03em;
-  text-transform: uppercase; color: rgb(var(--v-theme-on-surface));
-}
-
-/* Status text colours (DRY pass #161): fc-good = success, fc-weak = error,
-   consolidated from the GPU / heads cards. fc-ok is intentionally NOT global —
-   it means on-surface in HeadsCard but success in QueuesTable. */
-.fc-good { color: rgb(var(--v-theme-success)); }
-.fc-weak { color: rgb(var(--v-theme-error)); }
-
 /* Vuetify 4 dropped its global CSS reset (normalisation moved into each
   component). FC's layouts assumed the reset zeroed margins on text elements, so
   restore just that — the "minimal reset" from the v4 upgrade guide — inside
@@ -284,6 +284,7 @@ onUnmounted(() => {
 </script>

 <style scoped>
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }

 /* Full-height workspace under the sticky top nav. --fc-nav-h is the nav's REAL
   measured height (set by TopNav) — a hardcoded 64px here overflowed the
@@ -349,6 +349,7 @@ async function onDeleteTagConfirm() {
 .fc-tags__sentinel {
  display: flex; justify-content: center; padding: 32px 0; min-height: 60px;
 }
+.fc-muted { color: rgb(var(--v-theme-on-surface-variant)); }
 .fc-merge-preview {
  padding: 10px 12px;
  border: 1px solid rgba(var(--v-theme-on-surface), 0.12);
@@ -1,59 +0,0 @@
-"""Shared ML helpers extracted in the DRY pass (milestone #161). These pin the
-single sources the auto-apply sweeps now trust, so a future edit can't silently
-drift them: `_applied_or_rejected` is the skip-set used by auto_apply_sweep,
-system_tag_auto_apply_sweep (heads.py) and scheduled_ccip_auto_apply (tasks/ml.py);
-`_sigmoid` is the head score→prob transform used at every scoring site."""
-import pytest
-
-from backend.app.models import ImageRecord, Tag, TagKind, TagSuggestionRejection
-from backend.app.models.tag import image_tag
-from backend.app.services.ml.training_data import _applied_or_rejected
-
-
-def test_sigmoid_matches_naive_form():
-    import numpy as np
-
-    from backend.app.services.ml.heads import _sigmoid
-
-    z = np.array([-3.0, -0.5, 0.0, 1.5, 12.0], dtype=np.float32)
-    assert np.allclose(_sigmoid(z, np), 1.0 / (1.0 + np.exp(-z)))
-    assert float(_sigmoid(np.array([0.0]), np)[0]) == pytest.approx(0.5)
-
-
-@pytest.mark.integration
-def test_applied_or_rejected_unions_applied_any_source_and_rejected(db_sync):
-    a = Tag(name="dry-helper-a", kind=TagKind.general)
-    b = Tag(name="dry-helper-b", kind=TagKind.general)
-    db_sync.add_all([a, b])
-    db_sync.flush()
-
-    imgs = []
-    for i in range(5):
-        img = ImageRecord(
-            path=f"/images/dryhelp{i}.jpg", sha256=f"{i:064d}", size_bytes=1,
-            mime="image/jpeg", width=1, height=1, origin="imported_filesystem",
-            integrity_status="unknown", siglip_embedding=[0.0] * 1152,
-        )
-        db_sync.add(img)
-        imgs.append(img)
-    db_sync.flush()
-
-    # tag a: applied manually (img0), applied by an AUTO source (img1), rejected (img2).
-    db_sync.execute(image_tag.insert().values(
-        image_record_id=imgs[0].id, tag_id=a.id, source="manual"))
-    db_sync.execute(image_tag.insert().values(
-        image_record_id=imgs[1].id, tag_id=a.id, source="head_auto"))
-    db_sync.add(TagSuggestionRejection(image_record_id=imgs[2].id, tag_id=a.id))
-    # tag b: applied to img3 only.
-    db_sync.execute(image_tag.insert().values(
-        image_record_id=imgs[3].id, tag_id=b.id, source="manual"))
-    db_sync.flush()
-
-    skip = _applied_or_rejected(db_sync, [a.id, b.id])
-
-    # Applied-under-ANY-source (manual + head_auto) ∪ rejected, kept per-tag; the
-    # untouched image (img4) appears under neither tag.
-    assert skip[a.id] == {imgs[0].id, imgs[1].id, imgs[2].id}
-    assert skip[b.id] == {imgs[3].id}
-    assert imgs[4].id not in skip[a.id]
-    assert imgs[4].id not in skip[b.id]
@@ -1,63 +0,0 @@
-"""recover_stalled_head_training_runs + recover_stalled_head_auto_apply_runs share
-one helper (_recover_stalled_runs, DRY pass #161). These pin BOTH wrappers so the
-shared source stays correct: a 'running' row with no progress past the stall
-threshold flips to 'error'; a fresh 'running' row is left alone."""
-from datetime import UTC, datetime, timedelta
-
-import pytest
-from sqlalchemy import select
-
-from backend.app.models import HeadAutoApplyRun, HeadTrainingRun
-
-pytestmark = pytest.mark.integration
-
-
-def test_recover_stalled_head_training_runs_flips_stalled_keeps_fresh(db_sync):
-    from backend.app.tasks.maintenance import recover_stalled_head_training_runs
-
-    stale = HeadTrainingRun(
-        params={}, status="running",
-        last_progress_at=datetime.now(UTC) - timedelta(days=1),
-    )
-    fresh = HeadTrainingRun(
-        params={}, status="running", last_progress_at=datetime.now(UTC),
-    )
-    db_sync.add_all([stale, fresh])
-    db_sync.commit()
-    stale_id, fresh_id = stale.id, fresh.id
-
-    assert recover_stalled_head_training_runs.apply().get() == 1
-
-    db_sync.expire_all()
-    assert db_sync.execute(
-        select(HeadTrainingRun.status).where(HeadTrainingRun.id == stale_id)
-    ).scalar_one() == "error"
-    assert db_sync.execute(
-        select(HeadTrainingRun.status).where(HeadTrainingRun.id == fresh_id)
-    ).scalar_one() == "running"
-
-
-def test_recover_stalled_head_auto_apply_runs_flips_stalled_keeps_fresh(db_sync):
-    from backend.app.tasks.maintenance import recover_stalled_head_auto_apply_runs
-
-    stale = HeadAutoApplyRun(
-        dry_run=False, params={}, status="running",
-        last_progress_at=datetime.now(UTC) - timedelta(days=1),
-    )
-    fresh = HeadAutoApplyRun(
-        dry_run=False, params={}, status="running",
-        last_progress_at=datetime.now(UTC),
-    )
-    db_sync.add_all([stale, fresh])
-    db_sync.commit()
-    stale_id, fresh_id = stale.id, fresh.id
-
-    assert recover_stalled_head_auto_apply_runs.apply().get() == 1
-
-    db_sync.expire_all()
-    assert db_sync.execute(
-        select(HeadAutoApplyRun.status).where(HeadAutoApplyRun.id == stale_id)
-    ).scalar_one() == "error"
-    assert db_sync.execute(
-        select(HeadAutoApplyRun.status).where(HeadAutoApplyRun.id == fresh_id)
-    ).scalar_one() == "running"