From 3b60a21ebe28c1617d321c98069dfdad9d573c12 Mon Sep 17 00:00:00 2001
From: jerinpeter <jerinpeter@gmail.com>
Date: Tue, 19 May 2026 14:22:30 -0700
Subject: [PATCH 1/4] update selfie-logic

---
 .gitignore                                    |   1 +
 .../face_recog_stream/__init__.py             |   1 +
 .../face_recog_stream/gallery.py              | 107 +++-
 .../face_recog_stream/http_api.py             | 574 ++++++++++++++++--
 .../anonymizationSys/face_recog_stream/run.py |  32 +
 .../face_recog_stream/selfie_logic.py         | 335 ++++++++++
 6 files changed, 994 insertions(+), 56 deletions(-)
 create mode 100644 src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py

diff --git a/.gitignore b/.gitignore
index 2c7af04..9fdd4dc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ __pycache__
 *.engine
 *.onnx
 venv/
+.venv/
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/__init__.py b/src/om1_vlm/anonymizationSys/face_recog_stream/__init__.py
index 662d8f2..a75ffc0 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/__init__.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/__init__.py
@@ -10,6 +10,7 @@
     "scrfd",
     "gallery",
     "io",
+    "selfie_logic",
     "http_api",
     "who_tracker",
     "yolo_pose",
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/gallery.py b/src/om1_vlm/anonymizationSys/face_recog_stream/gallery.py
index 92c1a48..05b6fbb 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/gallery.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/gallery.py
@@ -282,13 +282,109 @@ def add_aligned_snapshot(
         cv2.imwrite(absf, img_112_bgr, [cv2.IMWRITE_JPEG_QUALITY, 95])
 
         # Embed & append
-        vec = self._embed_single(img_112_bgr)
+        vec = self.embed_aligned(img_112_bgr)
         row = self._append_vectors(vec[None, :])
         self._index["items"][rel] = {"row": row, "label": label}
         self._save_index()
         self._recompute_stats()
         return rel
 
+    def add_aligned_no_stats(
+        self,
+        label: str,
+        img_112_bgr: np.ndarray,
+        vec: Optional[np.ndarray] = None,
+        fname_hint: Optional[str] = None,
+    ) -> str:
+        """
+        Add a 112×112 aligned snapshot WITHOUT recomputing stats.
+
+        Designed for multi-shot batch enrollment (e.g. /selfie collects N frames
+        and saves them all in one go). Behaves like ``add_aligned_snapshot`` but:
+
+        - Skips the trailing ``_recompute_stats()`` call. Caller MUST invoke
+          ``recompute_stats()`` after the batch finishes; otherwise stats.json
+          stays stale until the next refresh.
+        - If ``vec`` is provided, uses it directly (must be L2-normalized).
+          Avoids re-embedding the same crop when the caller already has it
+          (e.g. /selfie pipeline embedded it for dedup/novelty/consistency).
+
+        Parameters
+        ----------
+        label : str
+            Identity name (subfolder under gallery).
+        img_112_bgr : np.ndarray
+            Aligned BGR crop of shape ``(112,112,3)`` (will be resized if needed).
+        vec : np.ndarray, optional
+            Pre-computed L2-normalized embedding of shape ``(dim,)``. If
+            supplied and valid, the crop is not re-embedded. If shape/norm
+            looks wrong, falls back to a fresh embedding.
+        fname_hint : str, optional
+            Preferred filename (``.jpg`` appended if missing), by default ``None``.
+
+        Returns
+        -------
+        str
+            Relative path of the saved aligned image
+            (e.g., ``"wendy/aligned/2026-05-19T18-30-00_00.jpg"``).
+        """
+        if img_112_bgr is None or img_112_bgr.size == 0:
+            raise ValueError("empty snapshot")
+
+        if img_112_bgr.shape[:2] != (self.aligned_size, self.aligned_size):
+            img_112_bgr = cv2.resize(
+                img_112_bgr, (self.aligned_size, self.aligned_size)
+            )
+
+        # Save to gallery/<label>/aligned/ with collision-safe filename
+        label_dir = osp.join(self.gallery_dir, label, "aligned")
+        _ensure_dir(label_dir)
+        base = (fname_hint or f"{_now_iso()}.jpg").strip()
+        if not base.lower().endswith(".jpg"):
+            base += ".jpg"
+        rel = osp.join(label, "aligned", base).replace("\\", "/")
+        absf = osp.join(self.gallery_dir, rel)
+        i = 0
+        while osp.exists(absf):
+            i += 1
+            stem, ext = osp.splitext(base)
+            rel = osp.join(label, "aligned", f"{stem}_{i}{ext}").replace("\\", "/")
+            absf = osp.join(self.gallery_dir, rel)
+
+        cv2.imwrite(absf, img_112_bgr, [cv2.IMWRITE_JPEG_QUALITY, 95])
+
+        # Embed (or use the provided vector with defensive validation)
+        if vec is None:
+            vec = self.embed_aligned(img_112_bgr)
+        else:
+            vec = np.asarray(vec, dtype=np.float32).reshape(-1)
+            if vec.shape[0] != self._dim:
+                vec = self.embed_aligned(img_112_bgr)
+            else:
+                n = float(np.linalg.norm(vec))
+                if n < 1e-9:
+                    vec = self.embed_aligned(img_112_bgr)
+                elif abs(n - 1.0) > 1e-4:
+                    vec = (vec / n).astype(np.float32, copy=False)
+
+        # Append to vectors.f32 + update index
+        row = self._append_vectors(vec[None, :])
+        self._index["items"][rel] = {"row": int(row), "label": label}
+        self._save_index()
+        # NB: deliberately NO self._recompute_stats() here — caller does it once
+        return rel
+
+    def recompute_stats(self) -> None:
+        """
+        Public wrapper for ``_recompute_stats()``.
+
+        Call once at the end of a batch of ``add_aligned_no_stats()`` to update
+        per-identity centroids in stats.json. Behaviorally identical to the
+        internal ``_recompute_stats``; the wrapper exists so external callers
+        don't have to reach into an underscored name.
+        """
+        self._recompute_stats()
+
     def delete_identity(self, label: str) -> tuple[bool, int, int, int]:
         """
         Delete one identity from the gallery and rebuild the embedding store.
@@ -568,9 +664,14 @@ def _embed_new_aligned(self) -> Tuple[int, int]:
         )
         return len(rels), feats.shape[0]
 
-    def _embed_single(self, img_112_bgr: np.ndarray) -> np.ndarray:
+    def embed_aligned(self, img_112_bgr: np.ndarray) -> np.ndarray:
         """Embed a single aligned 112×112 BGR crop and L2-normalize the vector.
 
+        Public method used by:
+        - Internal save paths (``add_aligned_snapshot``, ``add_aligned_no_stats``)
+        - External callers (e.g. ``HttpAPI._handle_selfie``) for dedup,
+          consistency, and novelty checks — no disk I/O.
+
         Parameters
         ----------
         img_112_bgr : np.ndarray
@@ -579,7 +680,7 @@ def _embed_single(self, img_112_bgr: np.ndarray) -> np.ndarray:
         Returns
         -------
         np.ndarray
-            Normalized embedding vector of shape ``(dim,)`` with dtype float32.
+            L2-normalized embedding of shape ``(dim,)`` with dtype float32.
         """
         vec = self.arc.infer([img_112_bgr])
         if vec.ndim == 2 and vec.shape[0] == 1:
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/http_api.py b/src/om1_vlm/anonymizationSys/face_recog_stream/http_api.py
index 4b50366..d67311a 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/http_api.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/http_api.py
@@ -32,6 +32,7 @@
 import cv2
 import numpy as np
 
+from . import selfie_logic as sl
 from .adaface import warp_face_by_5p
 
 
@@ -103,6 +104,12 @@ def __init__(
         self.server = None
         self.face_tracker = face_tracker
 
+        # Selfie pipeline state
+        self.selfie_lock = threading.Lock()  # serialize concurrent /selfie
+        self.enrollment_lock = threading.Lock()  # protect last_enrollment dict
+        self.audit_lock = threading.Lock()  # serialize corrections.log writes
+        self.last_enrollment: Optional[Dict[str, Any]] = None
+
     def stop(self) -> None:
         """Stop an attached HTTP server if present."""
         try:
@@ -202,6 +209,12 @@ def _handle(self, payload: Dict[str, Any], path: str) -> Dict[str, Any]:
             if path in ("/gallery/identities", "/gallery/list_identities"):
                 return self._handle_gallery_identities()
 
+            if path == "/gallery/move_samples":
+                return self._handle_gallery_move_samples(payload)
+
+            if path == "/gallery/forget_last":
+                return self._handle_gallery_forget_last(payload)
+
             return {"error": f"unknown path {path}"}
         except Exception as e:
             self.log.exception("HTTP error")
@@ -373,72 +386,270 @@ def _do_refresh():
 
     def _handle_selfie(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Save a clean snapshot from the latest frame (no overlays) into ALIGNED ONLY,
-        and embed immediately (no RAW for selfie).
+        Multi-frame selfie enrollment with score-based target selection,
+        dedup, identity-consistency check, and adaptive sample count.
 
-        Parameters
-        ----------
-        payload: { "id": "alice" }
-
-        Returns
+        Payload
         -------
-        dict
-            { ok, saved_aligned, identities }
+        id    : str  (required) — requested identity name (lowercase, alnum/_/-)
+        force : bool (optional) — bypass cross-name reject (twins/lookalikes)
 
-        Notes
-        -----
-        Uses the cached `frame_state` (clean frame + dets/kpss) to create one
-        aligned 112×112 crop without invoking extra inference in the HTTP thread.
-        The embedding and centroid update are executed on the main thread via
-        `run_job_sync`.
+        Returns (success)
+        -----------------
+        { ok:True, id, merged, forced, samples_saved, match_sim, identities }
+
+        Errors
+        ------
+        bad_id | recognition_disabled | busy | no_valid_frames |
+        insufficient_samples | ambiguous_subjects | face_belongs_to
         """
         if not self.gm:
-            return {"error": "recognition disabled"}
-        if not payload or "id" not in payload:
-            return {"error": "missing 'id'"}
-        person = str(payload["id"])
+            return {"error": "recognition_disabled"}
 
-        # Use last clean frame & cached dets/kpss captured in the main loop.
-        with self.frame_lock:
-            frm = (
-                None
-                if self.frame_state.frame_bgr is None
-                else self.frame_state.frame_bgr.copy()
-            )
-            dets = (
-                None if self.frame_state.dets is None else self.frame_state.dets.copy()
-            )
-            kpss = (
-                None if self.frame_state.kpss is None else self.frame_state.kpss.copy()
-            )
+        payload = payload or {}
+        requested = str(payload.get("id", "")).strip().lower()
+        ok, reason = sl.validate_identity_name(requested)
+        if not ok:
+            return {"error": "bad_id", "detail": reason}
 
-        if frm is None or dets is None or dets.shape[0] == 0:
-            return {"error": "no recent frame/detections yet"}
-        if dets.shape[0] != 1:
-            return {"error": f"expect exactly 1 face, got {int(dets.shape[0])}"}
+        force = bool(payload.get("force", False))
 
-        # Build aligned crop ONCE (no new inference)
-        if kpss is not None:
-            crop = warp_face_by_5p(frm, kpss[0], 112)
-        else:
-            x1, y1, x2, y2, _ = dets[0].astype(int)
-            face = frm[max(0, y1) : max(0, y2), max(0, x1) : max(0, x2)]
-            crop = cv2.resize(face if face.size > 0 else frm, (112, 112))
+        # Serialize concurrent /selfie calls — gallery + last_enrollment can't
+        # tolerate interleaved enrollment from two callers at once.
+        if not self.selfie_lock.acquire(blocking=False):
+            return {"error": "busy"}
 
-        ts = time.strftime("%Y-%m-%dT%H-%M-%S")
+        try:
+            return self._do_selfie(requested, force)
+        finally:
+            self.selfie_lock.release()
+
+    def _do_selfie(self, requested: str, force: bool) -> Dict[str, Any]:
+        """Core selfie collection loop. Caller holds self.selfie_lock."""
+        # Snapshot cfg once so thresholds stay consistent for this request
+        with self.cfg_lock:
+            cfg_snap = dict(self.cfg)
+
+        window_sec = float(cfg_snap["selfie_window_sec"])
+        tap_interval = float(cfg_snap["selfie_tap_interval_sec"])
+        min_samples = int(cfg_snap["selfie_min_samples"])
+        max_samples = int(cfg_snap["selfie_max_samples"])
+        score_floor = float(cfg_snap["selfie_min_engagement"])
+        ambig_ratio = float(cfg_snap["selfie_ambiguity_ratio"])
+        novelty_thr = float(cfg_snap["selfie_novelty_thr"])
+        consist_thr = float(cfg_snap["selfie_consistency_thr"])
+
+        deadline = time.monotonic() + window_sec
+        crops: List[np.ndarray] = []
+        embs: List[np.ndarray] = []
+        running_mean: Optional[np.ndarray] = None
+        target_id: Optional[str] = None
+        merged_flag = False
+        match_label: Optional[str] = None
+        match_sim_seen = 0.0
+        ambiguity_streak = 0
+        last_seen_token = -1  # frame-change detection (see below)
+
+        # ----- Phase 2: Collection loop -----
+        while len(crops) < max_samples and time.monotonic() < deadline:
+            # (A) Snapshot frame_state under lock, release fast
+            with self.frame_lock:
+                if self.frame_state.frame_bgr is None:
+                    frm = None
+                    dets = kpss = None
+                    ts = 0.0
+                else:
+                    frm = self.frame_state.frame_bgr.copy()
+                    dets = (
+                        None
+                        if self.frame_state.dets is None
+                        else self.frame_state.dets.copy()
+                    )
+                    kpss = (
+                        None
+                        if self.frame_state.kpss is None
+                        else self.frame_state.kpss.copy()
+                    )
+                    ts = float(getattr(self.frame_state, "last_ts", 0.0))
+
+            # Prefer explicit last_ts if run.py is up-to-date. If it's 0.0
+            # (older run.py without the field), fall back to id(frm) — the
+            # array's memory address changes per .copy(), so consecutive
+            # snapshots produce distinct tokens.
+            frame_token = ts if ts > 0 else (id(frm) if frm is not None else 0)
+
+            if frm is None or frame_token == last_seen_token:
+                time.sleep(0.02)
+                continue
+            last_seen_token = frame_token
+
+            # (B) No detections this frame
+            if dets is None or len(dets) == 0:
+                continue
+
+            # (C) Score every face: (bbox_area / frame_area) * frontality
+            h, w = frm.shape[:2]
+            frame_area = float(h * w)
+            scores = [
+                sl.score_face(
+                    dets[i],
+                    kpss[i] if kpss is not None and i < len(kpss) else None,
+                    frame_area,
+                )
+                for i in range(len(dets))
+            ]
 
-        def _do_add():
-            rel = self.gm.add_aligned_snapshot(person, crop, fname_hint=f"{ts}.jpg")
+            # (D) Ambiguity — fail fast on 2 consecutive ambiguous frames
+            is_amb, top_ratio = sl.check_ambiguity(scores, ambig_ratio, score_floor)
+            if is_amb:
+                ambiguity_streak += 1
+                if ambiguity_streak >= 2:
+                    self.log.info(
+                        "selfie ambiguous: ratio=%.3f n_engaged=%d",
+                        top_ratio,
+                        sum(1 for s in scores if s >= score_floor),
+                    )
+                    return {
+                        "error": "ambiguous_subjects",
+                        "top_ratio": round(top_ratio, 3),
+                        "n_engaged": sum(1 for s in scores if s >= score_floor),
+                    }
+                continue
+            ambiguity_streak = 0  # reset on any clean frame
+
+            # (E) Pick target & engagement floor
+            target_idx = int(np.argmax(scores))
+            if scores[target_idx] < score_floor:
+                continue
+
+            # (F) Need landmarks for alignment
+            if kpss is None or target_idx >= len(kpss):
+                continue
+            target_kps = kpss[target_idx]
+
+            # (G) Build aligned 112×112 crop + quality gate
+            crop = warp_face_by_5p(frm, target_kps, 112)
+            ok_q, q_reason = sl.quality_check(
+                crop, dets[target_idx], target_kps, cfg_snap
+            )
+            if not ok_q:
+                self.log.debug("selfie frame rejected: %s", q_reason)
+                continue
+
+            # (H) Embed on main thread (GPU)
+            v = self.run_job_sync(lambda c=crop: self.gm.embed_aligned(c))
+
+            # (I) First valid frame: dedup. Subsequent: consistency + novelty.
+            if target_id is None:
+                with self.gal_lock:
+                    feats = self.gal_state.gal_feats
+                    labels = list(self.gal_state.gal_labels)
+
+                decision = sl.resolve_target_id(
+                    v,
+                    requested,
+                    feats,
+                    labels,
+                    cfg_snap,
+                    force=force,
+                )
+
+                if decision.reject:
+                    self.log.info(
+                        "selfie face_belongs_to label=%s sim=%.3f",
+                        decision.match_label,
+                        decision.match_sim,
+                    )
+                    return {
+                        "error": "face_belongs_to",
+                        "name": decision.match_label,
+                        "sim": round(decision.match_sim, 3),
+                    }
+
+                target_id = decision.id
+                merged_flag = decision.merged
+                match_label = decision.match_label
+                match_sim_seen = decision.match_sim
+            else:
+                sim = sl.cosine_to_mean(running_mean, v)
+                if sim < consist_thr:
+                    # Different person showed up mid-window
+                    self.log.debug("selfie frame rejected: consistency=%.3f", sim)
+                    continue
+                if sim > novelty_thr:
+                    # Near-duplicate of what we've already collected
+                    self.log.debug("selfie frame rejected: not novel (sim=%.3f)", sim)
+                    continue
+
+            # (J) Accept the frame
+            crops.append(crop)
+            embs.append(v)
+            running_mean = sl.update_running_mean(running_mean, v, len(embs))
+            time.sleep(tap_interval)
+
+        # ----- Phase 3: Finalize -----
+        n = len(crops)
+        if n == 0:
+            return {"error": "no_valid_frames"}
+        if n < min_samples:
+            return {"error": "insufficient_samples", "got": n}
+
+        ts_str = time.strftime("%Y-%m-%dT%H-%M-%S")
+
+        # Single main-thread batch: save each crop with its pre-computed vec,
+        # then recompute stats ONCE, then snapshot centroids into gal_state.
+        def _do_save_batch():
+            saved = []
+            for k, (c, v) in enumerate(zip(crops, embs)):
+                rel = self.gm.add_aligned_no_stats(
+                    target_id,
+                    c,
+                    vec=v,
+                    fname_hint=f"{ts_str}_{k:02d}.jpg",
+                )
+                saved.append(rel)
+            self.gm.recompute_stats()
             feats, labels = self.gm.get_identity_means()
             with self.gal_lock:
-                self.gal_state.gal_feats, self.gal_state.gal_labels = feats, labels
-            return rel, len(labels)
+                self.gal_state.gal_feats = feats
+                self.gal_state.gal_labels = labels
+            return saved, len(labels)
+
+        saved_files, n_id = self.run_job_sync(_do_save_batch)
+
+        # Record for /gallery/move_samples and /gallery/forget_last
+        with self.enrollment_lock:
+            self.last_enrollment = {
+                "id": target_id,
+                "files": saved_files,
+                "monotonic_ts": time.monotonic(),
+                "wall_ts": time.time(),
+                "merged": merged_flag,
+                "forced": force,
+            }
 
-        rel, n_id = self.run_job_sync(_do_add)
-        saved_aligned = os.path.join(
-            self.gallery_dir, rel
-        )  # absolute path for convenience
-        return {"ok": True, "saved_aligned": saved_aligned, "identities": int(n_id)}
+        if force:
+            self._audit_log(
+                f"selfie forced id={target_id} samples={n} "
+                f"matched={match_label or '-'} sim={match_sim_seen:.3f}"
+            )
+        else:
+            self.log.info(
+                "selfie ok id=%s merged=%s samples=%d",
+                target_id,
+                merged_flag,
+                n,
+            )
+
+        return {
+            "ok": True,
+            "id": target_id,
+            "merged": merged_flag,
+            "forced": force,
+            "samples_saved": n,
+            "match_sim": round(match_sim_seen, 3),
+            "identities": int(n_id),
+        }
 
     def _handle_gallery_delete(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Delete one or more identities and rebuild the embed store.
@@ -588,6 +799,263 @@ def _count_images(dir_path: str) -> int:
 
         return {"ok": True, "total": len(identities), "identities": identities}
 
+    # -------------------- /gallery/move_samples --------------------- #
+    def _handle_gallery_move_samples(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Move samples from one identity to another.
+
+        Use cases:
+        - Rename (typo correction): to_id doesn't exist → folder is renamed.
+        - Merge into existing: to_id exists → samples merged in, from_id empty
+          folder deleted.
+
+        Payload
+        -------
+        from_id : str (required)
+        to_id   : str (required)
+        files   : List[str] (optional) — relative paths under gallery_dir.
+                  If omitted, uses last_enrollment.files (60s TTL; id must match).
+        """
+        if not self.gm:
+            return {"error": "recognition_disabled"}
+
+        payload = payload or {}
+        from_id = str(payload.get("from_id", "")).strip().lower()
+        to_id = str(payload.get("to_id", "")).strip().lower()
+
+        for label, name in (("from_id", from_id), ("to_id", to_id)):
+            ok, reason = sl.validate_identity_name(name)
+            if not ok:
+                return {"error": "bad_id", "detail": f"{label}: {reason}"}
+
+        if from_id == to_id:
+            return {"error": "same_id"}
+
+        payload_files = payload.get("files")
+        if payload_files:
+            files_to_move = [str(f) for f in payload_files]
+        else:
+            with self.enrollment_lock:
+                le = self.last_enrollment
+                if le is None or le["id"] != from_id:
+                    return {
+                        "error": "no_recent_enrollment",
+                        "detail": "supply files=[...] or call within 60s of /selfie",
+                    }
+                if time.monotonic() - le["monotonic_ts"] > 60.0:
+                    return {"error": "stale_enrollment"}
+                files_to_move = list(le["files"])
+
+        # Path traversal guard: every file must resolve to inside gallery_dir
+        safe_files = self._filter_safe_paths(files_to_move)
+        if not safe_files:
+            return {"error": "no_safe_files"}
+
+        t0 = time.monotonic()
+        moved, from_removed, n_id = self.run_job_sync(
+            lambda: self._do_move_samples(from_id, to_id, safe_files)
+        )
+
+        # Clear last_enrollment if we just consumed it
+        with self.enrollment_lock:
+            if (
+                self.last_enrollment is not None
+                and self.last_enrollment["id"] == from_id
+            ):
+                self.last_enrollment = None
+
+        return {
+            "ok": True,
+            "from_id": from_id,
+            "to_id": to_id,
+            "moved": int(moved),
+            "from_removed": bool(from_removed),
+            "identities": int(n_id),
+            "took_sec": round(time.monotonic() - t0, 3),
+        }
+
+    def _do_move_samples(
+        self, from_id: str, to_id: str, files: List[str]
+    ) -> "tuple[int, bool, int]":
+        """Main-thread worker. Returns (moved_count, from_removed, n_identities)."""
+        to_aligned = os.path.join(self.gallery_dir, to_id, "aligned")
+        os.makedirs(to_aligned, exist_ok=True)
+
+        moved = 0
+        for rel in files:
+            src = os.path.join(self.gallery_dir, rel)
+            if not os.path.isfile(src):
+                continue
+            fname = os.path.basename(rel)
+            dst = os.path.join(to_aligned, fname)
+            if os.path.exists(dst):
+                # Collision: append _moved<n> to disambiguate
+                base, ext = os.path.splitext(fname)
+                k = 1
+                while True:
+                    dst = os.path.join(to_aligned, f"{base}_moved{k}{ext}")
+                    if not os.path.exists(dst):
+                        break
+                    k += 1
+            shutil.move(src, dst)
+            moved += 1
+
+        from_removed = self._cleanup_empty_identity_dir(from_id)
+
+        # Rebuild from scratch — refresh() only adds, doesn't remove stale entries
+        self.gm.clear_and_rebuild()
+        feats, labels = self.gm.get_identity_means()
+        with self.gal_lock:
+            self.gal_state.gal_feats = feats
+            self.gal_state.gal_labels = labels
+
+        self._audit_log(
+            f"move {from_id}->{to_id} files={len(files)} moved={moved} "
+            f"from_removed={from_removed}"
+        )
+        return moved, from_removed, len(labels)
+
+    # -------------------- /gallery/forget_last --------------------- #
+    def _handle_gallery_forget_last(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Delete the samples saved by the most recent /selfie call.
+        Used when the wrong person was captured.
+
+        Payload (optional)
+        ------------------
+        id : str — if provided, must match last_enrollment.id (safety check)
+        """
+        if not self.gm:
+            return {"error": "recognition_disabled"}
+
+        payload = payload or {}
+
+        with self.enrollment_lock:
+            le = self.last_enrollment
+            if le is None:
+                return {"error": "no_recent_enrollment"}
+            if time.monotonic() - le["monotonic_ts"] > 60.0:
+                return {"error": "stale_enrollment"}
+
+            target_id = le["id"]
+            files = list(le["files"])
+
+            if "id" in payload:
+                requested = str(payload["id"]).strip().lower()
+                if requested != target_id:
+                    return {
+                        "error": "id_mismatch",
+                        "detail": f"last enrollment was {target_id}",
+                    }
+
+        safe_files = self._filter_safe_paths(files)
+        if not safe_files:
+            return {"error": "no_safe_files"}
+
+        t0 = time.monotonic()
+        deleted, identity_removed, n_id = self.run_job_sync(
+            lambda: self._do_forget_files(target_id, safe_files)
+        )
+
+        with self.enrollment_lock:
+            self.last_enrollment = None
+
+        return {
+            "ok": True,
+            "id": target_id,
+            "files_deleted": int(deleted),
+            "identity_removed": bool(identity_removed),
+            "identities": int(n_id),
+            "took_sec": round(time.monotonic() - t0, 3),
+        }
+
+    def _do_forget_files(
+        self, target_id: str, files: List[str]
+    ) -> "tuple[int, bool, int]":
+        """Main-thread worker for /gallery/forget_last."""
+        deleted = 0
+        for rel in files:
+            path = os.path.join(self.gallery_dir, rel)
+            if os.path.isfile(path):
+                try:
+                    os.remove(path)
+                    deleted += 1
+                except OSError as e:
+                    self.log.warning("failed to remove %s: %s", path, e)
+
+        identity_removed = self._cleanup_empty_identity_dir(target_id)
+
+        # Rebuild from scratch — refresh() leaves stale entries behind
+        self.gm.clear_and_rebuild()
+        feats, labels = self.gm.get_identity_means()
+        with self.gal_lock:
+            self.gal_state.gal_feats = feats
+            self.gal_state.gal_labels = labels
+
+        self._audit_log(
+            f"forget {target_id} files={len(files)} deleted={deleted} "
+            f"identity_removed={identity_removed}"
+        )
+        return deleted, identity_removed, len(labels)
+
+    # -------------------- helpers --------------------- #
+    def _filter_safe_paths(self, rel_paths: List[Any]) -> List[str]:
+        """
+        Return only the relative paths that resolve to inside gallery_dir.
+
+        Path-traversal guard for /gallery/move_samples (where `files` may
+        come from a payload). Rejects absolute paths, `../` escapes, and
+        anything pointing outside the gallery root.
+        """
+        safe: List[str] = []
+        base = os.path.abspath(self.gallery_dir) + os.sep
+        for rel in rel_paths:
+            if not isinstance(rel, str) or not rel:
+                continue
+            abs_path = os.path.abspath(os.path.join(self.gallery_dir, rel))
+            if not (abs_path + os.sep).startswith(base):
+                self.log.warning("rejecting path traversal attempt: %s", rel)
+                continue
+            safe.append(rel)
+        return safe
+
+    def _cleanup_empty_identity_dir(self, identity: str) -> bool:
+        """
+        Remove identity_dir and its empty subfolders. Returns True if removed.
+        Conservative: leaves the folder alone if anything (e.g. raw/*.jpg)
+        is still in it.
+        """
+        id_dir = os.path.join(self.gallery_dir, identity)
+        if not os.path.isdir(id_dir):
+            return False
+
+        for sub in ("aligned", "raw"):
+            sub_dir = os.path.join(id_dir, sub)
+            if os.path.isdir(sub_dir) and not os.listdir(sub_dir):
+                try:
+                    os.rmdir(sub_dir)
+                except OSError:
+                    pass
+
+        try:
+            if not os.listdir(id_dir):
+                os.rmdir(id_dir)
+                return True
+        except OSError:
+            pass
+        return False
+
+    def _audit_log(self, msg: str) -> None:
+        """Append a timestamped line to gallery_dir/corrections.log."""
+        log_path = os.path.join(self.gallery_dir, "corrections.log")
+        ts = time.strftime("%Y-%m-%dT%H:%M:%S")
+        try:
+            with self.audit_lock:
+                with open(log_path, "a") as f:
+                    f.write(f"{ts} {msg}\n")
+        except Exception as e:
+            self.log.warning("audit log failed: %s", e)
+
     @staticmethod
     def _load_112(
         image_path: Optional[str], image_b64: Optional[str]
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
index b4947e3..d1ca5ec 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
@@ -176,6 +176,9 @@ class _FrameState:
         Detection array of shape (N, 5) with [x1, y1, x2, y2, score], or None.
     kpss : np.ndarray | None
         Optional 5-point landmarks per detection, shape (N, 5, 2), or None.
+    last_ts : float
+        Monotonic timestamp of the last commit. Used by `/selfie` to detect
+        frame changes between taps (so it doesn't re-process the same frame).
     """
 
     def __init__(self):
@@ -184,6 +187,7 @@ def __init__(self):
         self.kpss: Optional[np.ndarray] = None
         self.current_faces: list = []
         self.current_unknowns: list = []
+        self.last_ts: float = 0.0
 
 
 def get_platform_prefix() -> str:
@@ -600,6 +604,33 @@ def main() -> None:
         "draw_skeleton": bool(args.draw_skeleton),
         "draw_pose_boxes": bool(args.draw_pose_boxes),
         "draw_fall_status": bool(args.draw_fall_status),
+        # ---- Selfie pipeline (all hot-tunable via /config) ----
+        # Collection window
+        "selfie_window_sec": 1.5,
+        "selfie_tap_interval_sec": 0.20,
+        # Adaptive sample count: min=1 lets static users still enroll
+        # with just the first valid frame; max=4 caps active users to keep
+        # storage and embedding work bounded.
+        "selfie_min_samples": 1,
+        "selfie_max_samples": 4,
+        # Selection: score = (bbox_area / frame_area) * frontality, in [0,1].
+        # Floor 0.005 = "face covers ~0.5% of frame AND is reasonably frontal".
+        # CALIBRATE on GTC footage; see notes in selfie_logic.score_face docstring.
+        "selfie_min_engagement": 0.015,
+        "selfie_ambiguity_ratio": 0.80,  # top2/top1 > this → ambiguous
+        # Quality gate on the chosen face crop
+        "selfie_min_face_px": 70,
+        "selfie_min_conf": 0.7,
+        "selfie_min_frontality": 0.4,
+        "selfie_sharp_thr": 50.0,
+        "selfie_brightness_min": 40,
+        "selfie_brightness_max": 220,
+        # Multi-frame
+        "selfie_novelty_thr": 0.95,  # cosine > → duplicate, skip
+        "selfie_consistency_thr": 0.50,  # cosine < → wrong person, skip
+        # Dedup
+        "selfie_merge_thr": 0.45,  # same-name family → merge
+        "selfie_cross_name_thr": 0.60,  # cross-name → reject (unless force)
     }
 
     # Last clean frame & detections for /selfie
@@ -769,6 +800,7 @@ def handle_sigint(_sig, _frame):
                 frame_state.frame_bgr = frame.copy()
                 frame_state.dets = None if dets is None else dets.copy()
                 frame_state.kpss = None if kpss is None else kpss.copy()
+                frame_state.last_ts = time.monotonic()
 
             # ---- Track-based recognition (BoTSORT + low-freq AdaFace) ----
             names: List[Optional[str]] = []
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
new file mode 100644
index 0000000..dc3d19e
--- /dev/null
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
@@ -0,0 +1,335 @@
+"""
+Pure logic for the selfie enrollment pipeline.
+
+Stateless. All shared state (gallery, frame_state, cfg) is owned by HttpAPI
+and passed in by parameter. No GPU work happens here; embeddings are computed
+elsewhere (main thread via run_job_sync) and passed in.
+
+Place at: src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import cv2
+import numpy as np
+
+# 5-point landmark indices (SCRFD / RetinaFace convention).
+# These are subject-perspective: subject's left eye, subject's right eye,
+# nose, subject's left mouth, subject's right mouth.
+EYE_A_IDX = 0
+EYE_B_IDX = 1
+NOSE_IDX = 2
+
+_VALID_ID = re.compile(r"^[a-z0-9_-]+$")
+# Reject names ending in _<digits> to avoid colliding with the suffix system.
+# E.g. user-supplied "wendy_1" would confuse next_suffix logic.
+_HAS_SUFFIX = re.compile(r"_\d+$")
+
+
+# Decision objects
+@dataclass
+class DedupDecision:
+    """Outcome of resolve_target_id()."""
+
+    id: Optional[str] = None  # Target folder name on success
+    merged: bool = False  # True if saving into existing folder
+    reject: bool = False  # True if cross-name conflict (no force)
+    match_label: Optional[str] = None  # Closest existing label (for telemetry)
+    match_sim: float = 0.0  # Cosine to closest match
+
+
+# Geometry: frontality from 5-point landmarks
+def frontality(kps: Optional[np.ndarray]) -> float:
+    """
+    Score in [0, 1] of how frontal a face is, from its 5 keypoints.
+
+    1.0 = eyes level AND nose centered between them.
+    0.0 = full profile OR extreme head tilt.
+
+    Robust to detector landmark ordering: we don't rely on which point is the
+    "left" vs "right" eye, only on the geometric relationship between the two
+    eye points and the nose. Absolute values everywhere.
+    """
+    if kps is None or len(kps) < 3:
+        return 0.0
+
+    eye_a = kps[EYE_A_IDX]
+    eye_b = kps[EYE_B_IDX]
+    nose = kps[NOSE_IDX]
+
+    eye_dx = abs(float(eye_b[0]) - float(eye_a[0]))
+    if eye_dx < 1.0:
+        # Degenerate: eyes at near-identical x (extreme angle or detector
+        # malfunction). Cannot meaningfully assess frontality.
+        return 0.0
+
+    # Yaw: how centered is the nose between the two eyes?
+    eye_mid_x = (float(eye_a[0]) + float(eye_b[0])) / 2.0
+    nose_off = (float(nose[0]) - eye_mid_x) / eye_dx
+    yaw_score = max(0.0, 1.0 - 2.0 * abs(nose_off))
+
+    # Roll: how level are the eyes?
+    eye_dy = abs(float(eye_b[1]) - float(eye_a[1]))
+    roll_score = max(0.0, 1.0 - eye_dy / eye_dx)
+
+    return yaw_score * roll_score
+
+
+# Scoring: who is the robot being addressed by?
+def score_face(
+    det: np.ndarray,
+    kps: Optional[np.ndarray],
+    frame_area: float,
+) -> float:
+    """
+    Engagement score in [0, 1] (resolution-independent).
+
+    score = (bbox_area / frame_area) * frontality
+
+    "Engaged" = close (large in frame) AND looking at robot (frontal).
+    Multiplicative — failing either component kills the score, so a huge
+    but turned-away face cannot beat a smaller frontal one.
+
+    Normalizing by frame_area decouples the threshold from camera resolution:
+    a face covering 1% of the frame is the same "size" at 720p and 4K.
+    """
+    if frame_area <= 0:
+        return 0.0
+    x1, y1, x2, y2 = float(det[0]), float(det[1]), float(det[2]), float(det[3])
+    bbox_area = max(0.0, x2 - x1) * max(0.0, y2 - y1)
+    front = frontality(kps) if kps is not None else 0.0
+    return (bbox_area / frame_area) * front
+
+
+# Frame-level filters
+def check_ambiguity(
+    scores: List[float],
+    ratio_thr: float,
+    score_floor: float,
+) -> Tuple[bool, float]:
+    """
+    Detect "who is the target" ambiguity within the current frame.
+
+    Returns (is_ambiguous, top_ratio).
+
+    Ambiguous iff top-1 AND top-2 are BOTH above score_floor (both faces
+    are "engaging") AND top2/top1 > ratio_thr (they're close in engagement).
+
+    Faces below the floor don't count — a small background bystander can't
+    create ambiguity even if their score is close to the target's.
+    """
+    if len(scores) < 2:
+        return False, 0.0
+
+    sorted_desc = sorted(scores, reverse=True)
+    top1, top2 = sorted_desc[0], sorted_desc[1]
+
+    if top1 < score_floor or top2 < score_floor:
+        return False, 0.0
+
+    ratio = top2 / top1 if top1 > 0 else 0.0
+    return ratio > ratio_thr, ratio
+
+
+def quality_check(
+    crop_112: np.ndarray,
+    det: np.ndarray,
+    kps: Optional[np.ndarray],
+    cfg: dict,
+) -> Tuple[bool, str]:
+    """
+    Per-frame quality gate on the selected face.
+
+    Returns (ok, reason). reason is "" on success, otherwise one of:
+    too_small | low_conf | bad_pose | blurry | too_dark | too_bright
+    """
+    x1, y1, x2, y2 = float(det[0]), float(det[1]), float(det[2]), float(det[3])
+    conf = float(det[4]) if len(det) >= 5 else 1.0
+    w, h = x2 - x1, y2 - y1
+
+    if min(w, h) < float(cfg["selfie_min_face_px"]):
+        return False, "too_small"
+
+    if conf < float(cfg["selfie_min_conf"]):
+        return False, "low_conf"
+
+    if kps is not None:
+        if frontality(kps) < float(cfg["selfie_min_frontality"]):
+            return False, "bad_pose"
+
+    gray = cv2.cvtColor(crop_112, cv2.COLOR_BGR2GRAY)
+    if cv2.Laplacian(gray, cv2.CV_64F).var() < float(cfg["selfie_sharp_thr"]):
+        return False, "blurry"
+
+    mb = float(gray.mean())
+    if mb < float(cfg["selfie_brightness_min"]):
+        return False, "too_dark"
+    if mb > float(cfg["selfie_brightness_max"]):
+        return False, "too_bright"
+
+    return True, ""
+
+
+# Identity name handling
+def validate_identity_name(name: str) -> Tuple[bool, str]:
+    """
+    Check identity name format. Returns (ok, reason).
+
+    Rules:
+    - non-empty, ≤32 chars
+    - lowercase alphanumeric, underscore, dash only
+    - must NOT end in `_<digits>` (reserved for suffix system)
+    """
+    if not name:
+        return False, "empty"
+    if len(name) > 32:
+        return False, "too_long"
+    if not _VALID_ID.match(name):
+        return False, "invalid_chars"
+    if _HAS_SUFFIX.search(name):
+        return False, "ends_with_suffix"
+    return True, ""
+
+
+def is_same_root(label: str, root: str) -> bool:
+    """True iff `label` is exactly `root` or `root_<digits>`."""
+    if label == root:
+        return True
+    return bool(re.fullmatch(rf"{re.escape(root)}_\d+", label))
+
+
+def next_suffix(name: str, existing_labels: List[str]) -> str:
+    """
+    Next available label in the {name, name_1, name_2, ...} family.
+
+    - If `name` itself is free → return `name`.
+    - Else return `name_<max_n + 1>` where max_n scans existing `name_<n>` labels.
+    """
+    existing = set(existing_labels)
+    if name not in existing:
+        return name
+
+    pat = re.compile(rf"^{re.escape(name)}_(\d+)$")
+    max_n = 0
+    for label in existing:
+        m = pat.match(label)
+        if m:
+            max_n = max(max_n, int(m.group(1)))
+
+    return f"{name}_{max_n + 1}"
+
+
+# Dedup
+def resolve_target_id(
+    embedding: np.ndarray,
+    requested_name: str,
+    gal_feats: Optional[np.ndarray],
+    gal_labels: List[str],
+    cfg: dict,
+    force: bool = False,
+) -> DedupDecision:
+    """
+    Decide which gallery folder a new face should go into.
+
+    One full-table cosine search, then 2×2 decision matrix on
+    (similarity tier, label-matches-requested-name).
+
+    Thresholds (from cfg):
+    - cross_thr (~0.60): strong cross-name match → reject (unless force)
+    - merge_thr (~0.45): same-name family match → merge into existing folder
+
+    Behavior:
+    - Empty gallery                                    → use requested_name
+    - sim >= cross_thr, same-root label                → merge
+    - sim >= cross_thr, different name, force=False    → REJECT
+    - sim >= cross_thr, different name, force=True     → new with suffix
+    - merge_thr <= sim < cross_thr, same-root          → merge
+    - otherwise                                        → new with suffix
+    """
+    cross_thr = float(cfg["selfie_cross_name_thr"])
+    merge_thr = float(cfg["selfie_merge_thr"])
+
+    if gal_feats is None or len(gal_labels) == 0:
+        return DedupDecision(id=requested_name)
+
+    # gal_feats rows and embedding are both unit-norm
+    sims = gal_feats @ embedding
+    j = int(np.argmax(sims))
+    best_sim = float(sims[j])
+    best_label = gal_labels[j]
+
+    same_root = is_same_root(best_label, requested_name)
+
+    # Strong match
+    if best_sim >= cross_thr:
+        if same_root:
+            return DedupDecision(
+                id=best_label,
+                merged=True,
+                match_label=best_label,
+                match_sim=best_sim,
+            )
+        if force:
+            return DedupDecision(
+                id=next_suffix(requested_name, gal_labels),
+                match_label=best_label,
+                match_sim=best_sim,
+            )
+        return DedupDecision(
+            reject=True,
+            match_label=best_label,
+            match_sim=best_sim,
+        )
+
+    # Soft match to same-root → merge
+    if best_sim >= merge_thr and same_root:
+        return DedupDecision(
+            id=best_label,
+            merged=True,
+            match_label=best_label,
+            match_sim=best_sim,
+        )
+
+    # No qualifying match → new identity (possibly with suffix)
+    return DedupDecision(
+        id=next_suffix(requested_name, gal_labels),
+        match_label=best_label,
+        match_sim=best_sim,
+    )
+
+
+# Multi-frame: running mean + novelty + consistency
+def update_running_mean(
+    current_mean: Optional[np.ndarray],
+    new_v: np.ndarray,
+    new_count: int,
+) -> np.ndarray:
+    """
+    Incremental L2-normalized running mean.
+
+    `new_count` is the count AFTER adding new_v (1, 2, 3, ...).
+    Always returns a unit-norm vector.
+    """
+    if current_mean is None or new_count <= 1:
+        out = new_v.astype(np.float32, copy=True)
+    else:
+        out = current_mean * (new_count - 1) + new_v
+
+    norm = float(np.linalg.norm(out))
+    if norm < 1e-12:
+        return new_v.astype(np.float32, copy=True)
+    return (out / norm).astype(np.float32, copy=False)
+
+
+def cosine_to_mean(running_mean: np.ndarray, new_v: np.ndarray) -> float:
+    """
+    Cosine similarity. Both inputs assumed unit-norm.
+
+    Used for BOTH novelty (skip frames too similar to running mean)
+    AND identity consistency (reject frames too different from collected so far).
+    """
+    return float(np.dot(running_mean, new_v))

From b958fce57bd28d1e773d001ba0f9a0bc04498d9e Mon Sep 17 00:00:00 2001
From: jerinpeter <jerinpeter@gmail.com>
Date: Tue, 19 May 2026 16:40:29 -0700
Subject: [PATCH 2/4] src/om1_vlm/anonymizationSys/face_recog_stream/run.py
 src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py

---
 .../anonymizationSys/face_recog_stream/run.py      | 14 +++++++-------
 .../face_recog_stream/selfie_logic.py              |  8 +++++++-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
index d1ca5ec..51984e6 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
@@ -616,20 +616,20 @@ def main() -> None:
         # Selection: score = (bbox_area / frame_area) * frontality, in [0,1].
         # Floor 0.005 = "face covers ~0.5% of frame AND is reasonably frontal".
         # CALIBRATE on GTC footage; see notes in selfie_logic.score_face docstring.
-        "selfie_min_engagement": 0.015,
+        "selfie_min_engagement": 0.005,
         "selfie_ambiguity_ratio": 0.80,  # top2/top1 > this → ambiguous
         # Quality gate on the chosen face crop
         "selfie_min_face_px": 70,
-        "selfie_min_conf": 0.7,
+        "selfie_min_conf": 0.4,
         "selfie_min_frontality": 0.4,
-        "selfie_sharp_thr": 50.0,
-        "selfie_brightness_min": 40,
-        "selfie_brightness_max": 220,
+        "selfie_sharp_thr": 5.0,
+        "selfie_brightness_min": 30,
+        "selfie_brightness_max": 230,
         # Multi-frame
-        "selfie_novelty_thr": 0.95,  # cosine > → duplicate, skip
+        "selfie_novelty_thr": 0.93,  # cosine > → duplicate, skip
         "selfie_consistency_thr": 0.50,  # cosine < → wrong person, skip
         # Dedup
-        "selfie_merge_thr": 0.45,  # same-name family → merge
+        "selfie_merge_thr": 0.5,  # same-name family → merge
         "selfie_cross_name_thr": 0.60,  # cross-name → reject (unless force)
     }
 
diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
index dc3d19e..fbdf325 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
@@ -325,11 +325,17 @@ def update_running_mean(
     return (out / norm).astype(np.float32, copy=False)
 
 
-def cosine_to_mean(running_mean: np.ndarray, new_v: np.ndarray) -> float:
+def cosine_to_mean(running_mean: Optional[np.ndarray], new_v: np.ndarray) -> float:
     """
     Cosine similarity. Both inputs assumed unit-norm.
 
     Used for BOTH novelty (skip frames too similar to running mean)
     AND identity consistency (reject frames too different from collected so far).
+
+    Returns 0.0 if running_mean is None (no frames accepted yet). This is a
+    defensive default — call sites only invoke this after a first frame has
+    been accepted, so None shouldn't happen, but typing makes it possible.
     """
+    if running_mean is None:
+        return 0.0
     return float(np.dot(running_mean, new_v))

From 81b57dc01e117f83c349c5ba52ad4db27cd8dca7 Mon Sep 17 00:00:00 2001
From: jerinpeter <jerinpeter@gmail.com>
Date: Tue, 19 May 2026 16:47:41 -0700
Subject: [PATCH 3/4] update the selfie logic

---
 .../anonymizationSys/face_recog_stream/selfie_logic.py    | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
index fbdf325..dc3d19e 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/selfie_logic.py
@@ -325,17 +325,11 @@ def update_running_mean(
     return (out / norm).astype(np.float32, copy=False)
 
 
-def cosine_to_mean(running_mean: Optional[np.ndarray], new_v: np.ndarray) -> float:
+def cosine_to_mean(running_mean: np.ndarray, new_v: np.ndarray) -> float:
     """
     Cosine similarity. Both inputs assumed unit-norm.
 
     Used for BOTH novelty (skip frames too similar to running mean)
     AND identity consistency (reject frames too different from collected so far).
-
-    Returns 0.0 if running_mean is None (no frames accepted yet). This is a
-    defensive default — call sites only invoke this after a first frame has
-    been accepted, so None shouldn't happen, but typing makes it possible.
     """
-    if running_mean is None:
-        return 0.0
     return float(np.dot(running_mean, new_v))

From a9bf9b276b074848106e4accfee126f39eaa0d3b Mon Sep 17 00:00:00 2001
From: jerinpeter <jerinpeter@gmail.com>
Date: Sat, 30 May 2026 21:20:18 -0700
Subject: [PATCH 4/4] update param

---
 src/om1_vlm/anonymizationSys/face_recog_stream/run.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
index 51984e6..0f22161 100644
--- a/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
+++ b/src/om1_vlm/anonymizationSys/face_recog_stream/run.py
@@ -606,8 +606,8 @@ def main() -> None:
         "draw_fall_status": bool(args.draw_fall_status),
         # ---- Selfie pipeline (all hot-tunable via /config) ----
         # Collection window
-        "selfie_window_sec": 1.5,
-        "selfie_tap_interval_sec": 0.20,
+        "selfie_window_sec": 0.8,
+        "selfie_tap_interval_sec": 0.10,
         # Adaptive sample count: min=1 lets static users still enroll
         # with just the first valid frame; max=4 caps active users to keep
         # storage and embedding work bounded.