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
Merge pull request 'fix(ui): softer chrome-gradient falloff + segmented media toggle (#1478 )' (#228 ) from dev into main
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 · 2026-07-13 14:12:41 -04:00
41 changed files with 547 additions and 852 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)
+        s = (
-    # Table-driven off _EDITABLE (which PATCH also writes) so a new settings field
+            await session.execute(select(MLSettings).where(MLSettings.id == 1))
-    # can never be silently absent from GET — the split that historically dropped
+        ).scalar_one()
-    # fields. _EDITABLE already includes *_DETECTOR_FIELDS.
+    return jsonify(
-    return jsonify({f: getattr(s, f) for f in _EDITABLE})
+        {
            "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):
+    if not (0.5 <= float(p["head_auto_apply_precision"]) <= 0.999):
-        return f"head_auto_apply_precision must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+        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):
+    if not (0.5 <= float(p["ccip_match_threshold"]) <= 0.999):
-        return f"ccip_match_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+        return "ccip_match_threshold must be between 0.5 and 0.999"
-    if not (AUTO_APPLY_THRESHOLD_MIN <= float(p["ccip_auto_apply_threshold"]) <= AUTO_APPLY_THRESHOLD_MAX):
+    if not (0.5 <= float(p["ccip_auto_apply_threshold"]) <= 0.999):
-        return f"ccip_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+        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):
+    if not (0.5 <= float(p["presentation_auto_apply_threshold"]) <= 0.999):
-        return f"presentation_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+        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):
+    if not (0.5 <= float(p["process_auto_apply_threshold"]) <= 0.999):
-        return f"process_auto_apply_threshold must be between {AUTO_APPLY_THRESHOLD_MIN} and {AUTO_APPLY_THRESHOLD_MAX}"
+        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
+    return jsonify({
-    # can't be silently absent from GET.
+        "min_width": row.min_width,
-    return jsonify({f: getattr(row, f) for f in _EDITABLE_FIELDS})
+        "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,13 +924,16 @@ 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.execute(
-                            session,
+                            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,18 +993,23 @@ 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.execute(
-                        session,
+                        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()
    return {"n_scanned": scanned, "n_flagged": n_flagged}
@@ -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:
+def _lookup_via_api(vanity: str, cookies_path: str | None) -> str | 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)."""
    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"},
+            params=params,
-            headers={"User-Agent": _USER_AGENT, "Accept": "application/vnd.api+json"},
+            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]
-
+    if not isinstance(payload, dict):
 def _lookup_via_api(vanity: str, cookies_path: str | None) -> str | None:
    first = _campaigns_api_first(vanity, cookies_path)
    if first is None:
        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)
+    jar = _load_cookie_jar(cookies_path)
-    if first is None:
+    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
-    name = (first.get("attributes") or {}).get("name")
+        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
    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(
+    SessionLocal = _sync_session_factory()
-        HeadTrainingRun,
+    now = datetime.now(UTC)
-        stall_minutes=HEAD_TRAINING_STALL_THRESHOLD_MINUTES,
+    cutoff = now - timedelta(minutes=HEAD_TRAINING_STALL_THRESHOLD_MINUTES)
-        keep_runs=HEAD_TRAINING_KEEP_RUNS,
+    with SessionLocal() as session:
-        label="recover_stalled_head_training_runs",
+        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(
+    SessionLocal = _sync_session_factory()
-        HeadAutoApplyRun,
+    now = datetime.now(UTC)
-        stall_minutes=HEAD_AUTO_APPLY_STALL_THRESHOLD_MINUTES,
+    cutoff = now - timedelta(minutes=HEAD_AUTO_APPLY_STALL_THRESHOLD_MINUTES)
-        keep_runs=HEAD_AUTO_APPLY_KEEP_RUNS,
+    with SessionLocal() as session:
-        label="recover_stalled_head_auto_apply_runs",
+        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]:
@@ -31,68 +31,6 @@ browser.runtime.onInstalled.addListener(() => ensureInitialized());
 browser.runtime.onStartup.addListener(() => ensureInitialized());
 ensureInitialized().catch(e => console.error('init failed:', e));
 // ---- Extension self-update check (#1489) ----
 // Installed per-instance from the operator's FC host, so Firefox's static
 // update_url can't apply (each instance has a different host). Instead ask the
 // configured backend for the latest published version and nudge the operator to
 // reinstall the freshly-signed XPI — surfaced as a popup banner (on demand) and
 // a toolbar badge (daily). /api/extension/manifest is public and returns
 // {version, latest_url, sha256}; the XPI is served from the web root (not /api).
 function versionIsNewer(candidate, current) {
  // Dotted numeric compare so 1.0.10 > 1.0.9 (a plain string compare wouldn't).
  const a = String(candidate).split('.').map(n => parseInt(n, 10) || 0);
  const b = String(current).split('.').map(n => parseInt(n, 10) || 0);
  for (let i = 0; i < Math.max(a.length, b.length); i++) {
    if ((a[i] || 0) !== (b[i] || 0)) return (a[i] || 0) > (b[i] || 0);
  }
  return false;
 }
 async function checkForUpdateInfo() {
  await ensureInitialized();
  if (!api.isConfigured()) return { updateAvailable: false, configured: false };
  let info;
  try {
    info = await api.getExtensionManifest();
  } catch (e) {
    return { updateAvailable: false, error: e.message };
  }
  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();
  return {
    updateAvailable: !!latestVersion && versionIsNewer(latestVersion, currentVersion),
    currentVersion,
    latestVersion,
    xpiUrl: info && info.latest_url ? `${base}${info.latest_url}` : null,
  };
 }
 async function refreshUpdateBadge() {
  let r;
  try { r = await checkForUpdateInfo(); } catch { return; }
  try {
    await browser.action.setBadgeText({ text: r.updateAvailable ? '↑' : '' });
    if (r.updateAvailable) {
      await browser.action.setBadgeBackgroundColor({ color: '#F4BA7A' });
      await browser.action.setTitle({ title: `FabledCurator — update available (v${r.latestVersion})` });
    } else {
      await browser.action.setTitle({ title: 'FabledCurator' });
    }
  } catch { /* action API unavailable — non-fatal */ }
 }
 // Daily proactive check (needs the "alarms" permission). create() is idempotent
 // by name, so re-running it on each event-page load is safe.
 browser.alarms.create('fc-update-check', { periodInMinutes: 24 * 60, delayInMinutes: 1 });
 browser.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'fc-update-check') refreshUpdateBadge();
 });
 browser.runtime.onStartup.addListener(() => refreshUpdateBadge());
 browser.runtime.onInstalled.addListener(() => refreshUpdateBadge());
 // ---- Discord token capture via webRequest ----
 browser.webRequest.onBeforeSendHeaders.addListener(
@@ -210,21 +148,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 +192,22 @@ browser.runtime.onMessage.addListener(async (msg) => {
      if (!platform) return { error: `Unknown platform: ${key}` };
      try {
        if (platform.authType === 'cookies') {
-          const r = await exportPlatformCookies(key);
+          const cookies = await extractCookiesForPlatform(key);
-          if (r.status === 'empty') return { error: 'No cookies found — log in first.' };
+          if (cookies.length === 0) return { error: 'No cookies found — log in first.' };
-          if (r.status === 'stale') {
+          // 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 +235,18 @@ browser.runtime.onMessage.addListener(async (msg) => {
          continue;
        }
        try {
-          const r = await exportPlatformCookies(key);
+          const cookies = await extractCookiesForPlatform(key);
-          if (r.status === 'empty') results[key] = { skipped: true, reason: 'no cookies' };
+          if (cookies.length === 0) {
-          else if (r.status === 'stale') results[key] = { error: `verify failed: ${r.reason}` };
+            results[key] = { skipped: true, reason: 'no cookies' };
-          else results[key] = { success: true, cookieCount: r.cookieCount, verified: r.verified };
+            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 +283,11 @@ browser.runtime.onMessage.addListener(async (msg) => {
      }
    case 'OPEN_ARTIST_PAGE': {
-      // The SPA artist route (/artist/:slug) is served from the web root, not
+      // apiUrl is configured with the /api suffix (see
-      // the JSON API — see api.webRoot().
+      // options/options.html placeholder); the SPA artist route is
-      const base = api.webRoot();
+      // /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 {
@@ -357,9 +298,6 @@ browser.runtime.onMessage.addListener(async (msg) => {
      }
    }
    case 'CHECK_UPDATE':
      return await checkForUpdateInfo();
    default:
      return { error: `Unknown message type: ${msg.type}` };
  }
@@ -89,19 +89,6 @@ class FabledCuratorAPI {
    const qs = new URLSearchParams({ url }).toString();
    return this.request('GET', `/extension/probe?${qs}`);
  }
  // Latest published extension version on this instance — drives the in-app
  // update prompt. Public endpoint (no key needed, but request() sends it
  // harmlessly). Returns {version, xpi_url, latest_url, sha256}.
  getExtensionManifest() {
    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() {
@@ -1,7 +1,7 @@
 {
  "manifest_version": 3,
  "name": "FabledCurator",
-  "version": "1.0.9",
+  "version": "1.0.8",
  "description": "Export cookies from supported platforms to FabledCurator and add creators as sources in one click.",
  "browser_specific_settings": {
@@ -22,8 +22,7 @@
    "tabs",
    "activeTab",
    "webRequest",
-    "webRequestBlocking",
+    "webRequestBlocking"
    "alarms"
  ],
  "host_permissions": [
@@ -1,6 +1,6 @@
 {
  "name": "fabledcurator-extension",
-  "version": "1.0.9",
+  "version": "1.0.8",
  "private": true,
  "description": "Firefox extension for FabledCurator",
  "scripts": {
@@ -72,17 +72,6 @@ body {
 .btn.block { display: block; width: 100%; margin-top: 8px; }
 .btn.link { background: none; color: var(--on-surface-variant); padding: 4px; }
 .btn.link:hover { color: var(--accent); }
 .btn.small { padding: 6px 12px; font-size: 13px; }
 /* In-app update prompt (accent-tinted so it reads as an actionable notice). */
 .update-banner {
  display: flex; align-items: center; gap: 10px;
  margin: 10px 10px 0; padding: 10px 12px;
  background: rgba(244, 186, 122, 0.12);
  border: 1px solid rgba(244, 186, 122, 0.4);
  border-radius: 6px;
 }
 #update-text { flex: 1; font-size: 13px; }
 .source-row .play {
  background: none; border: none; color: var(--on-surface-variant);
@@ -20,11 +20,6 @@
  </section>
  <section id="main-content" class="main hidden">
    <div id="update-banner" class="update-banner hidden">
      <span id="update-text"></span>
      <button id="update-btn" class="btn primary small">Update</button>
    </div>
    <nav class="tabs">
      <button class="tab active" data-tab="platforms">Platforms</button>
      <button class="tab" data-tab="sources">Sources</button>
@@ -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' });
@@ -23,7 +14,6 @@ async function init() {
    setupEventListeners();
    showPlatformsLoading();
    testConnectionIfNeeded();
    checkForUpdate();
    loadPlatformStatus().catch(e => showError(`Failed to load platforms: ${e.message}`));
  } catch (e) {
    showSetupRequired();
@@ -47,7 +37,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() {
@@ -70,26 +63,6 @@ function updateConnectionDot(connected) {
  d.title = connected ? 'Connected to FabledCurator' : 'Disconnected';
 }
 // Nudge to reinstall when the configured instance publishes a newer signed XPI
 // (the extension is self-hosted, so there's no Firefox auto-update). Never
 // blocks the popup — a failed check just leaves the banner hidden.
 async function checkForUpdate() {
  try {
    const r = await browser.runtime.sendMessage({ type: 'CHECK_UPDATE' });
    if (r && r.updateAvailable && r.xpiUrl) showUpdateBanner(r);
  } catch { /* non-fatal */ }
 }
 function showUpdateBanner(r) {
  document.getElementById('update-text').textContent =
    `Update available — v${r.latestVersion} (installed v${r.currentVersion})`;
  // Opening the signed XPI triggers Firefox's native install prompt.
  document.getElementById('update-btn').addEventListener('click', () => {
    browser.tabs.create({ url: r.xpiUrl });
  });
  document.getElementById('update-banner').classList.remove('hidden');
 }
 async function loadPlatformStatus() {
  const status = await browser.runtime.sendMessage({ type: 'GET_PLATFORM_STATUS' });
  const c = document.getElementById('platforms-list');
@@ -189,7 +162,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 +176,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
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
-        v-model="p.on" :loading="busy" :icon="p.icon"
+        <v-icon size="18" :color="p.on ? 'accent' : undefined">{{ p.icon }}</v-icon>
-        :icon-color="p.on ? 'accent' : null" :label="p.label"
+        <span class="fc-section-h">{{ p.label }}</span>
-        @change="v => saveToggle(p, v)"
+        <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-text-field
-          v-model="p.conf" label="Confidence" :min="0" :max="1" :step="0.05"
+          v-model.number="p.conf" label="Confidence" type="number"
-          max-width="140px" :disabled="busy || !p.on"
+          min="0" max="1" step="0.05" density="compact" hide-details
-          @change="saveField({ [`detector_${p.key}_conf`]: Number(p.conf) })"
+          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"
+          v-model.number="c.val" :label="c.label" type="number"
-          :min="c.min" :max="c.max" :step="c.step || 1"
+          :min="c.min" :max="c.max" :step="c.step || 1" density="compact"
-          max-width="165px" :disabled="busy"
+          hide-details style="max-width: 165px;" :disabled="busy"
-          @change="saveField({ [c.key]: Number(c.val) })"
+          @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
+async function save(patch, revert) {
-// already clamped numeric values to their [min,max] before this fires.
+  busy.value = true
-function saveField(patch) {
+  try {
-  save(patch, { successMessage: 'Saved' })
+    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' })
+  save({ [`detector_${p.key}_enabled`]: !!v }, () => { p.on = !v })
  if (!ok) 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
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
-        v-model="autoEnabled" :loading="settingBusy"
+        <v-icon size="18" color="accent">mdi-lightning-bolt</v-icon>
-        icon="mdi-lightning-bolt" label="Auto-apply" @change="onToggleAuto"
+        <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-text-field
-          v-model="autoPrecisionInput" label="Precision target"
+          v-model.number="autoPrecisionInput" label="Precision target"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+          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-text-field
-          v-model="autoMinPosInput" label="Min examples to fire"
+          v-model.number="autoMinPosInput" label="Min examples to fire"
-          :min="1" :disabled="settingBusy" @change="onSaveSettings"
+          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
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
-        v-model="presentationEnabled" :loading="settingBusy"
+        <v-icon size="18" color="accent">mdi-image-off-outline</v-icon>
-        icon="mdi-image-off-outline" label="Hide presentation chrome"
+        <span class="fc-section-h">Hide presentation chrome</span>
-        @change="onTogglePresentation"
+        <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-text-field
-          v-model="presentationThresholdInput" label="Hide confidence"
+          v-model.number="presentationThresholdInput" label="Hide confidence"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+          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-text-field
-          v-model="presentationConflictInput" label="Flag if content ≥"
+          v-model.number="presentationConflictInput" label="Flag if content ≥"
-          :min="0" :max="1" :step="0.05" :disabled="settingBusy"
+          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
+      <div class="d-flex align-center mb-1" style="gap: 10px;">
-        v-model="processEnabled" :loading="settingBusy"
+        <v-icon size="18" color="accent">mdi-progress-wrench</v-icon>
-        icon="mdi-progress-wrench" label="Auto-tag work-in-progress"
+        <span class="fc-section-h">Auto-tag work-in-progress</span>
-        @change="onToggleProcess"
+        <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-text-field
-          v-model="processThresholdInput" label="Tag confidence"
+          v-model.number="processThresholdInput" label="Tag confidence"
-          :min="0.5" :max="0.999" :step="0.01" :disabled="settingBusy"
+          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-text-field
-          v-model="processConflictInput" label="Flag if content ≥"
+          v-model.number="processConflictInput" label="Flag if content ≥"
-          :min="0" :max="1" :step="0.05" :disabled="settingBusy"
+          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
+const settingBusy = ref(false)
 // toggles/fields, `save` returns ok/false for the optimistic-switch revert.
 const { busy: settingBusy, save } = useSettingSave(mlSettings.patchSettings)
 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 },
+  settingBusy.value = true
-    { successMessage: val ? 'Auto-apply on' : 'Auto-apply off', errorPrefix: 'Could not update' })
+  try {
-  if (!ok) autoEnabled.value = !val   // revert the switch
+    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({
+  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 },
+  settingBusy.value = true
-    { successMessage: val ? 'Chrome auto-hide on' : 'Chrome auto-hide off', errorPrefix: 'Could not update' })
+  try {
-  if (!ok) presentationEnabled.value = !val   // revert the switch
+    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({
+  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 },
+  settingBusy.value = true
-    { successMessage: val ? 'WIP auto-tag on' : 'WIP auto-tag off', errorPrefix: 'Could not update' })
+  try {
-  if (!ok) processEnabled.value = !val   // revert the switch
+    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({
+  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 }, {
+  saving.value = true
-    successMessage: enabled.value
+  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',
    })
-  if (!ok) enabled.value = !enabled.value
+  } 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-text-field
-            v-model="local.video_frame_interval_seconds"
+            v-model.number="local.video_frame_interval_seconds"
-            label="Frame interval (s)" :min="0.5" :step="0.5"
+            label="Frame interval (s)" type="number" min="0.5" step="0.5"
-            density="comfortable" max-width="none" @change="onSave"
+            density="comfortable" hide-details @change="save"
          />
        </v-col>
        <v-col cols="12" sm="6">
-          <SettingNumberField
+          <v-text-field
-            v-model="local.video_max_frames"
+            v-model.number="local.video_max_frames"
-            label="Max frames" :min="1" :step="1"
+            label="Max frames" type="number" min="1" step="1"
-            density="comfortable" max-width="none" @change="onSave"
+            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
+async function save() {
-// fires, so an out-of-range value never reaches the API.
+  const patch = {
-function onSave() {
+    video_frame_interval_seconds: local.video_frame_interval_seconds,
-  save({
+    video_max_frames: local.video_max_frames
-    video_frame_interval_seconds: Number(local.video_frame_interval_seconds),
+  }
-    video_max_frames: Number(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"