sync to e756766+9ee7f46: shared gate detection, fps-scaled gate timings, session hardening UI; adapt engine to new gate API

.gitattributes

@@ -40,3 +40,4 @@ rv2v_reference/5e178546-3ebf-40df-bb86-01613dd96c3b.png filter=lfs diff=lfs merg
 wheels/joyomni_ops-0.1.0-cp310-cp310-linux_x86_64.whl filter=lfs diff=lfs merge=lfs -text
 wheels/sageattention-2.2.0-cp310-cp310-linux_x86_64.whl filter=lfs diff=lfs merge=lfs -text
 libs/libstdc++.so.6 filter=lfs diff=lfs merge=lfs -text
+rv2v_reference/nailong.png filter=lfs diff=lfs merge=lfs -text

static/index.html

@@ -243,8 +243,7 @@
       <span id="upqTier" class="qtier">
         <button type="button" data-upq="0.2" data-i18n="q_low">低</button>
         <button type="button" data-upq="0.4" data-i18n="q_mid">中</button>
-        <button type="button" data-upq="0.6" data-i18n="q_high">高</button>
-        <button type="button" data-upq="auto" class="on" data-i18n="q_auto">自动</button>
+        <button type="button" data-upq="0.6" class="on" data-i18n="q_high">高</button>
       </span>
     </span>
     <span class="kvreset-field keep-min">
@@ -699,7 +698,6 @@ let downDelayMs = null;
 let downSkewMin = null;
 let downSkewAt = 0;
 let upClamped = false;
-let upAuto = true;
 let upClearStreak = 0;
 let upClearNeed = 4;
 let upDrainFactor = 1;
@@ -765,7 +763,6 @@ function applyOrientation(o) {
   const dims = orientDims(o);
   document.getElementById("width").value = dims.width;
   document.getElementById("height").value = dims.height;
-  autoUpQuality();
   updateCropMask();
   updateMetrics();
 }
@@ -972,7 +969,6 @@ function updateMetrics() {
     netReadoutEl.textContent = t("net_label") + " " + fmt(_rtt, "ms") + _tail;
     netReadoutEl.classList.toggle("net-warn", _hi || _fd || _uc);
   }
-  if (upAuto) highlightUpqTier("auto");
   if (dispLatencyEl) {
     dispLatencyEl.textContent = t("disp_label") + " " + fmt(editLatencyLastMs, "ms");
   }
@@ -1662,18 +1658,13 @@ async function beginSession() {
     seed: SERVER_DEFAULTS.seed,
     kv_reset_frames: Math.max(0, Math.floor(Number(document.getElementById("kvResetFrames").value) || 0)),
     output_quality: Number(downQualityUi.value),
+    fps: sendTargetFps(),
     output_codec: h264DecodeOk ? "h264" : "mjpeg",
-    input_codec: upCodecH264 ? "h264" : "mjpeg",
-    no_person_blank: faceGateDebugEnabled(),
-    require_face: faceGateDebugEnabled(),
-    person_count_reedit: faceGateDebugEnabled()
+    input_codec: upCodecH264 ? "h264" : "mjpeg"
   };
   if (usingVideoFile) {
     startPayload.source = "file";
     startPayload.gate_enabled = false;
-    startPayload.no_person_blank = false;
-    startPayload.require_face = false;
-    startPayload.person_count_reedit = false;
   }
   if (cachedEnhancedPrompt) startPayload.enhanced_prompt = cachedEnhancedPrompt;
   if (refImage) startPayload.ref_image = refImage;
@@ -1921,6 +1912,7 @@ async function start() {
       }
       return;
     }
+    if (startingRun) return;
     const meta = pendingOutputMeta;
     pendingOutputMeta = null;
     receivedFrames += 1;
@@ -2010,6 +2002,7 @@ async function send() {
     try { if (usingVideoFile) camera.pause(); } catch (err) {}
     clearResultVideo();
     clearOutputQueue();
+    showOutputStart(true, t("busy_resetting"));
     const ok = await beginSession();
     if (ok) return;
     startingRun = false;
@@ -2024,13 +2017,13 @@ sendBtn.onclick = () => { suppressPeThisSend = false; send(); };
 const PROMPT_GROUPS = [
   {
     key: "change_clothes",
-    label: "实时换装", label_en: "Change Outfit",
+    label: "实时换装", label_en: "Real-Time Outfit Change",
     cases: [
       { title: "白T恤", title_en: "White Tee", desc: "上衣换成白色圆领纯棉T恤", desc_en: "Top → white crew-neck cotton tee", text: "将主角的上衣换成白色圆领纯棉 T 恤。", text_en: "Replace the subject's top with a white crew-neck cotton T-shirt." },
       { title: "皮夹克", title_en: "Leather Jacket", desc: "外套换成哑光黑色皮质机车夹克", desc_en: "Jacket → matte black leather biker jacket", text: "将主角的外套换成哑光黑色皮质机车夹克。", text_en: "Replace the subject's jacket with a matte black leather biker jacket." },
       { title: "汉服", title_en: "Hanfu", desc: "换成传统汉服交领右衽上衣", desc_en: "Traditional cross-collar Hanfu top", text: "将主角的服装换成传统汉服交领右衽上衣。", text_en: "Replace the subject's outfit with a traditional cross-collar (right-lapel) Hanfu top." },
       { title: "学院风衬衫", title_en: "Preppy Shirt", desc: "白衬衫配藏青V领马甲加酒红领带", desc_en: "White shirt, navy V-vest, wine tie", text: "将主角的上衣换成白衬衫搭配藏青色 V 领马甲和酒红色领带。", text_en: "Replace the subject's top with a white shirt paired with a navy V-neck vest and a wine-red tie." },
-      { title: "京东定制帽 + 墨镜", title_en: "JD Cap + Shades", desc: "戴上“京东”的红色鸭舌帽和墨镜", desc_en: "Red cap reading “京东” plus sunglasses", text: "给主角戴上写着“京东”两个汉字的红色鸭舌帽和墨镜。", text_en: "Put a red cap printed with the Chinese characters \"京东\" and a pair of sunglasses on the subject." },
+      { title: "京东定制帽 + 墨镜", title_en: "Custom JD Cap + Shades", desc: "戴上“京东”的红色鸭舌帽和墨镜", desc_en: "Red cap reading “京东” plus sunglasses", text: "给主角戴上写着“京东”两个汉字的红色鸭舌帽和墨镜。", text_en: "Put a red cap printed with the Chinese characters \"京东\" and a pair of sunglasses on the subject." },
     ],
   },
   {
@@ -2041,6 +2034,7 @@ const PROMPT_GROUPS = [
       { title: "红色围巾", title_en: "Red Scarf", desc: "围上参考图里的红色流苏围巾", desc_en: "Red tasseled scarf from the reference image", ref: "scarf", text: "将参考图中的红色流苏围巾围到主角的颈部。", text_en: "Wrap the red tasseled scarf from the reference image around the subject's neck." },
       { title: "粉色T恤", title_en: "Pink Tee", desc: "换上参考图里的粉色短袖 T 恤", desc_en: "Pink short-sleeve tee from the reference image", ref: "pink_tee", text: "将主角的衣服换成参考图里的粉色短袖 T 恤。", text_en: "Replace the subject's clothing with the pink short-sleeve T-shirt from the reference image." },
       { title: "橙色眼镜", title_en: "Orange Glasses", desc: "戴上参考图里的橙色镜片眼镜", desc_en: "Orange-tinted glasses from the reference image", ref: "orange_glasses", text: "给主角戴上参考图里的橙色镜片眼镜。", text_en: "Put the orange-tinted glasses from the reference image on the subject." },
+      { title: "奶龙", title_en: "Nailong", desc: "主角换成参考图里的黄色玩偶", desc_en: "Subject → yellow toy from the reference image", ref: "nailong", text: "将视频中的主角替换为参考图中的黄色玩偶。", text_en: "Replace the main subject in the video with the yellow toy from the reference image." },
     ],
   },
   {
@@ -2049,7 +2043,7 @@ const PROMPT_GROUPS = [
     cases: [
       { title: "3D动画", title_en: "3D Animation", desc: "渲染为3D动画电影风格", desc_en: "Render as 3D animated-film style", text: "将整个画面渲染为3D动画电影风格。应用平滑的三维建模质感、柔和的全局光照和景深，以及皮克斯风格的角色与场景渲染。", text_en: "Render the entire scene in a 3D animated-film style. Apply smooth 3D-modeled surfaces, soft global illumination and depth of field, and Pixar-style character and scene rendering." },
       { title: "油画质感", title_en: "Oil Painting", desc: "转成梵高厚涂油画风格", desc_en: "Van Gogh impasto oil-painting style", text: "将整个画面转换为梵高的画的风格。应用厚重、富有表现力的笔触，鲜艳且强烈的色彩，天空中和风景中动态旋转的纹理，以及梵高画作中特有的粗放油彩（厚涂法）效果。", text_en: "Convert the entire scene into the style of a Van Gogh painting. Apply thick, expressive brushstrokes, vivid and intense colors, dynamic swirling textures in the sky and landscape, and the coarse impasto oil effect characteristic of Van Gogh's work." },
-      { title: "像素游戏", title_en: "Pixel Art", desc: "渲染为16色像素画风格", desc_en: "Render as 16-color pixel art", text: "将整个画面渲染为16色像素画风格。", text_en: "Render the entire scene in a 16-color pixel-art style." },
+      { title: "像素画", title_en: "Pixel Art", desc: "渲染为16色像素画风格", desc_en: "Render as 16-color pixel art", text: "将整个画面渲染为16色像素画风格。", text_en: "Render the entire scene in a 16-color pixel-art style." },
       { title: "日漫赛璐璐", title_en: "Anime Cel", desc: "转成日式动漫赛璐璐风格", desc_en: "Japanese anime cel-shaded style", text: "将整个画面转换为日式动漫赛璐璐风格：干净的黑色描边、大面积平涂的纯色色块、明确的明暗二分硬边阴影和简洁的高光。", text_en: "Convert the entire scene into a Japanese anime cel-shaded style: clean black outlines, large flat areas of solid color, clear hard-edged two-tone shading, and simple highlights." },
     ],
   },
@@ -2057,10 +2051,10 @@ const PROMPT_GROUPS = [
     key: "face_edit",
     label: "外貌改造", label_en: "Look Edit",
     cases: [
-      { title: "戴上墨镜", title_en: "Sunglasses", desc: "戴一副粉色飞行员墨镜", desc_en: "Add pink aviator sunglasses", text: "给主角添加一副粉色飞行员墨镜架在鼻梁上。", text_en: "Add a pair of pink aviator sunglasses resting on the subject's nose." },
+      { title: "戴上墨镜", title_en: "Sunglasses", desc: "戴一副粉色飞行员墨镜", desc_en: "Add pink aviator sunglasses", text: "给主角添加一副粉色飞行员墨镜架在鼻梁上。", text_en: "Add a pair of pink aviator sunglasses resting on the bridge of the subject's nose." },
       { title: "戴口罩", title_en: "Face Mask", desc: "脸上戴一个医用口罩", desc_en: "Add a medical face mask", text: "给主角的脸上戴一个医用口罩。", text_en: "Put a medical face mask on the subject's face." },
       { title: "加耳环", title_en: "Earrings", desc: "双耳加一对金色圆环耳环", desc_en: "Add a pair of gold hoop earrings", text: "给主角的双耳耳垂添加一对抛光金色圆环耳环。", text_en: "Add a pair of polished gold hoop earrings to the subject's earlobes." },
-      { title: "加络腮胡", title_en: "Beard", desc: "下颌脸颊加浓密络腮胡", desc_en: "Add a thick full beard", text: "给主角的���颌和脸颊添加浓密的深黄色络腮胡须，自然卷曲，覆盖下巴和两颊。", text_en: "Add a thick dark-blond full beard to the subject's jaw and cheeks, naturally curly, covering the chin and both cheeks." },
+      { title: "加络腮胡", title_en: "Beard", desc: "下颌脸颊加浓密络腮胡", desc_en: "Add a thick full beard", text: "给主角的下颌和脸颊添加浓密的深黄色络腮胡须，自然卷曲，覆盖下巴和两颊。", text_en: "Add a thick dark-yellow full beard to the subject's jaw and cheeks, naturally curly, covering the chin and both cheeks." },
     ],
   },
   {
@@ -2069,9 +2063,8 @@ const PROMPT_GROUPS = [
     cases: [
       { title: "大理石雕塑", title_en: "Marble Statue", desc: "变成白色大理石雕塑", desc_en: "Turn into a white marble statue", text: "将主角整体转化为白色大理石雕塑：可见石材纹理和细微灰色脉络、表面呈抛光光泽、光线在曲面形成柔和高光，眼睛和头发同为石质，保持原有动作但带有雕塑般的质感。", text_en: "Transform the subject entirely into a white marble statue: visible stone texture and fine gray veining, a polished glossy surface, soft highlights on the curved surfaces, eyes and hair also made of stone, keeping the original motion but with a sculptural quality." },
       { title: "乐高小人", title_en: "LEGO Figure", desc: "变成乐高积木小人", desc_en: "Turn into a LEGO minifigure", text: "将主角转化为乐高积木小人风格：黄色圆柱形头部、表面为塑料亚光质感，五官简化为印刷贴纸式的黑色圆点眼睛和弧线微笑。", text_en: "Transform the subject into a LEGO minifigure style: a yellow cylindrical head with a matte plastic surface, facial features simplified into printed-sticker-style black dot eyes and a curved smile." },
-      { title: "赛博机械体", title_en: "Cyborg", desc: "变成半机械生化体", desc_en: "Turn into a cyborg", text: "将主角转化为机械生化体：面部露出银色金属骨架和精密齿轮、眼睛发出冷蓝光、皮肤接缝处可见荧光线路板纹路，关节处有可见的液压结构。", text_en: "Transform the subject into a cyborg: a silver metal skeleton and precision gears exposed on the face, eyes glowing cold blue, glowing circuit-board traces along the skin seams, and visible hydraulic structures at the joints." },
+      { title: "赛博机械体", title_en: "Cyborg", desc: "变成赛博机械体", desc_en: "Turn into a cyborg", text: "将主角转化为赛博机械体：面部露出银色金属骨架和精密齿轮、眼睛发出冷蓝光、皮肤接缝处可见荧光线路板纹路，关节处有可见的液压结构。", text_en: "Transform the subject into a cyborg: a silver metal skeleton and precision gears exposed on the face, eyes glowing cold blue, glowing circuit-board traces along the skin seams, and visible hydraulic structures at the joints." },
       { title: "黏土动画", title_en: "Claymation", desc: "变成定格黏土动画角色", desc_en: "Turn into a stop-motion clay character", text: "将主角转化为定格黏土动画角色：表面可见手工捏制的指纹压痕和不规则质感、色彩饱和但略带哑光、比例微微卡通化（头部略大）。", text_en: "Transform the subject into a stop-motion claymation character: visible hand-molded fingerprint dents and irregular texture, saturated but slightly matte colors, and mildly cartoonish proportions (a slightly larger head)." },
-      { title: "机器人", title_en: "Robot", desc: "变成机器人", desc_en: "Turn into a robot", text: "将主角变成一个机器人。", text_en: "Turn the subject into a robot." },
     ],
   },
   {
@@ -2085,12 +2078,12 @@ const PROMPT_GROUPS = [
   },
   {
     key: "swap_hero",
-    label: "主角变身", label_en: "Swap Identity",
+    label: "主角变身", label_en: "Transform Subject",
     cases: [
       { title: "梅西", title_en: "Messi", desc: "主角变成球星梅西", desc_en: "Turn the subject into Lionel Messi", text: "将主角变成足球明星梅西（Lionel Messi）的样貌。", text_en: "Change the subject's appearance into that of the football star Lionel Messi." },
       { title: "詹姆斯", title_en: "LeBron", desc: "主角变成球星詹姆斯", desc_en: "Turn the subject into LeBron James", text: "将主角变成篮球明星勒布朗·詹姆斯（LeBron James）的样貌。", text_en: "Change the subject's appearance into that of the basketball star LeBron James." },
       { title: "特朗普", title_en: "Trump", desc: "主角变成特朗普", desc_en: "Turn the subject into Donald Trump", text: "将主角变成美国总统特朗普（Donald Trump）的样貌。", text_en: "Change the subject's appearance into that of U.S. President Donald Trump." },
-      { title: "奥巴马", title_en: "Obama", desc: "主角变成奥巴马", desc_en: "Turn the subject into Barack Obama", text: "将主角变成美国总统奥巴马（Barack Obama）的样貌。", text_en: "Change the subject's appearance into that of U.S. President Barack Obama." },
+      { title: "奥巴马", title_en: "Obama", desc: "主角变成奥巴马", desc_en: "Turn the subject into Barack Obama", text: "将主角变成美国前总统奥巴马（Barack Obama）的样貌。", text_en: "Change the subject's appearance into that of former U.S. President Barack Obama." },
       { title: "奥特曼", title_en: "Ultraman", desc: "主角变成奥特曼", desc_en: "Turn the subject into Ultraman", text: "将主角的脸和身体变成奥特曼。", text_en: "Change the subject's face and body into Ultraman." },
       { title: "拉布拉多", title_en: "Labrador", desc: "主角变成拉布拉多", desc_en: "Turn the subject into a Labrador", text: "将主角的脸和身体变成一只拉布拉多犬。", text_en: "Change the subject's face and body into a Labrador dog." },
     ],
@@ -2542,43 +2535,18 @@ const qualityLegacyEl = document.getElementById("quality");
 function highlightUpqTier(v) {
   if (!upqTierEl) return;
   for (const b of upqTierEl.querySelectorAll("button")) {
-    const bv = b.getAttribute("data-upq");
-    b.classList.toggle("on", bv === String(v) || (v !== "auto" && Number(bv) === Number(v)));
-    b.classList.remove("auto-active");
-  }
-  if (v === "auto") {
-    const cur = effectiveUpQuality();
-    for (const b of upqTierEl.querySelectorAll("button")) {
-      if (Number(b.getAttribute("data-upq")) === Number(cur)) b.classList.add("auto-active");
-    }
+    b.classList.toggle("on", Number(b.getAttribute("data-upq")) === Number(v));
   }
 }
 function syncUpQualityUi() {
-  highlightUpqTier(upAuto ? "auto" : (qualityLegacyEl ? qualityLegacyEl.value : "0.4"));
-}
-function autoUpQuality() {
-  if (!upAuto) return;
-  const qEl = document.getElementById("quality");
-  if (!qEl) return;
-  qEl.value = 0.6;
-  highlightUpqTier("auto");
-}
-for (const id of ["width", "height", "fps"]) {
-  const el = document.getElementById(id);
-  if (el) el.addEventListener("change", autoUpQuality);
+  highlightUpqTier(qualityLegacyEl ? qualityLegacyEl.value : "0.6");
 }
 if (upqTierEl) {
   for (const b of upqTierEl.querySelectorAll("button")) {
     b.addEventListener("click", () => {
       const v = b.getAttribute("data-upq");
-      if (v === "auto") {
-        upAuto = true;
-        autoUpQuality();
-      } else {
-        upAuto = false;
-        if (qualityLegacyEl) qualityLegacyEl.value = v;
-        highlightUpqTier(v);
-      }
+      if (qualityLegacyEl) qualityLegacyEl.value = v;
+      highlightUpqTier(v);
       resetUplinkEncoder();
       updateMetrics();
     });
@@ -2639,7 +2607,6 @@ if (fpsTierEl) {
       if (fpsInputEl) fpsInputEl.value = v;
       for (const x of fpsTierEl.querySelectorAll("button")) x.classList.toggle("on", x === b);
       if (timer) { clearInterval(timer); timer = setInterval(tick, Math.floor(1000 / sendTargetFps())); }
-      autoUpQuality();
       updateMetrics();
     });
   }
@@ -2688,7 +2655,6 @@ function applyServerDefaults() {
       b.classList.toggle("on", Number(b.getAttribute("data-fps")) === Number(d.fps));
     }
   }
-  autoUpQuality();
   const boolMap = {
     freezeKvOnStatic: "freeze_kv_on_static",
     usePe: "use_pe",

xvideo/models/vae/vae.py

@@ -525,7 +525,10 @@ class Head(nn.Module):
 
 
 class XVAEChunkCausal(ModelMixin, ConfigMixin):
-
+    """For more technical details on high-resolution causal VAE decoding, see:
+    https://github.com/xin1u/UltraFlash
+    """
+    
     @register_to_config
     def __init__(
         self,

xvideo/serving/serve_joyomni_streaming.py

@@ -72,12 +72,15 @@ class SessionGate:
             ev.set()
 
 
+WS_SEND_TIMEOUT_S = 10.0
+
 REF_IMAGE_DIR = REPO_ROOT / "rv2v_reference"
 REF_IMAGE_FILES = {
     "hat": "4e481f7a-2443-4935-a841-af6113cc4236.png",
     "scarf": "5e178546-3ebf-40df-bb86-01613dd96c3b.png",
     "pink_tee": "1c182f2f-32cf-4825-904e-64c69aed2e31.png",
     "orange_glasses": "486b9561-e73d-45ca-bb2d-2a47998a0a73.png",
+    "nailong": "nailong.png",
 }
 
 def _load_ref_images() -> dict[str, str]:
@@ -125,6 +128,7 @@ def _snap_to_align(value: int, align: int) -> int:
 
 class _H264Stream:
     def __init__(self, quality: int) -> None:
+        self._lock = threading.Lock()
         self._enc = None
         self._size: tuple[int, int] | None = None
         self._crf = self.crf_for_quality(quality)
@@ -142,6 +146,10 @@ class _H264Stream:
         self._want_reset = True
 
     def encode(self, frames: list) -> list[tuple[bytes, bool]]:
+        with self._lock:
+            return self._encode_locked(frames)
+
+    def _encode_locked(self, frames: list) -> list[tuple[bytes, bool]]:
         import av
         import cv2
 
@@ -264,25 +272,37 @@ def _check_face_gate(image: Image.Image, *, onnx_path: str,
         return ("too_close", None, n_faces)
     return (None, (cx, cy, min(fw, fh) / frame_min), n_faces)
 
-def _face_present(image: Image.Image, *, onnx_path: str, score_thresh: float, min_ratio: float = 0.0, edge_margin: float = 0.0) -> bool:
+
+def _detect_gate_faces(image: Image.Image, *, onnx_path: str, score_thresh: float):
     det = _get_face_detector(onnx_path, score_thresh)
     if det is None:
-        return True
+        return None, 0.0, 0.0
+    import cv2
     import numpy as np
     rgb = np.asarray(image if image.mode == "RGB" else image.convert("RGB"))
     bgr = np.ascontiguousarray(rgb[:, :, ::-1])
     h, w = bgr.shape[:2]
+    if FACE_DETECTOR_DOWNSAMPLE > 1.0:
+        _s = 1.0 / FACE_DETECTOR_DOWNSAMPLE
+        bgr = cv2.resize(bgr, (max(2, int(round(w * _s))), max(2, int(round(h * _s)))), interpolation=cv2.INTER_AREA)
+        h, w = bgr.shape[:2]
+    det.setScoreThreshold(float(score_thresh))
     det.setInputSize((w, h))
     _, faces = det.detect(bgr)
+    out = []
+    if faces is not None:
+        for f in faces:
+            out.append((float(f[0]), float(f[1]), float(f[2]), float(f[3])))
+    return out, float(w), float(h)
+
+
+def _face_present_from(faces, w, h, *, min_ratio: float = 0.0, edge_margin: float = 0.0) -> bool:
     if faces is None:
-        return False
+        return True
     _min_side = float(min_ratio) * float(min(w, h))
     _mx = float(edge_margin) * float(w)
     _my = float(edge_margin) * float(h)
-    for f in faces:
-        if float(f[-1]) < float(score_thresh):
-            continue
-        fx, fy, fw, fh = float(f[0]), float(f[1]), float(f[2]), float(f[3])
+    for fx, fy, fw, fh in faces:
         if _min_side > 0.0 and min(fw, fh) < _min_side:
             continue
         if edge_margin > 0.0 and (fx < _mx or fy < _my or fx + fw > w - _mx or fy + fh > h - _my):
@@ -291,6 +311,22 @@ def _face_present(image: Image.Image, *, onnx_path: str, score_thresh: float, mi
     return False
 
 
+def _count_faces_from(faces, w, h, *, count_min_ratio: float) -> int:
+    if not faces:
+        return 0
+    frame_min = float(min(w, h))
+    best = None
+    best_area = -1.0
+    shorts = []
+    for fx, fy, fw, fh in faces:
+        shorts.append(min(fw, fh))
+        if fw * fh > best_area:
+            best_area = fw * fh
+            best = (fw, fh)
+    thr = max(0.05 * frame_min, float(count_min_ratio) * min(best))
+    return sum(1 for sh in shorts if sh >= thr)
+
+
 _PERSON_NET: dict[str, Any] = {}
 
 def _get_person_net(onnx_path: str):
@@ -744,16 +780,8 @@ def create_app(args: argparse.Namespace) -> FastAPI:
         pe_defer = False
         pe_task: asyncio.Task | None = None
         session_max_inflight = max(0, int(args.max_inflight_chunks or 0))
-        presence_monitor = False
-        face_required = False
-        count_monitor = False
-
-        fg_score = float(args.face_gate_score)
-        fg_min_below = float(args.face_gate_min_below_ratio)
-        fg_stable = int(args.face_gate_stable_frames)
-        fg_absent = int(args.presence_absent_frames)
 
-        gate_state = {"count": 0, "cx": None, "cy": None, "absent": 0, "passthrough": False,
+        gate_state = {"count": 0, "cx": None, "cy": None, "absent": 0,
                       "absent_hold": False, "present": 0, "person_check_i": 0, "person_last": True,
                       "subject_count": None, "cand": None, "cand_n": 0, "recount": False}
         kv_reset_frames = max(0, int(args.kv_reset_frames or 0))
@@ -803,10 +831,22 @@ def create_app(args: argparse.Namespace) -> FastAPI:
             "send_state": "idle",
         }
 
+        async def _ws_send_json(payload: dict[str, Any]) -> None:
+            try:
+                await asyncio.wait_for(websocket.send_json(payload), timeout=WS_SEND_TIMEOUT_S)
+            except asyncio.TimeoutError:
+                raise WebSocketDisconnect()
+
+        async def _ws_send_bytes(data: bytes) -> None:
+            try:
+                await asyncio.wait_for(websocket.send_bytes(data), timeout=WS_SEND_TIMEOUT_S)
+            except asyncio.TimeoutError:
+                raise WebSocketDisconnect()
+
         async def _send_json(payload: dict[str, Any]) -> None:
             async with send_lock:
                 ws_debug["send_state"] = f"json:{payload.get('type')}"
-                await websocket.send_json(payload)
+                await _ws_send_json(payload)
                 ws_debug["last_send_at"] = time.time()
                 ws_debug["send_state"] = "idle"
 
@@ -887,7 +927,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                             ws_debug["rec_out_written"] = _rec_o.frames_written
                             ws_debug["rec_out_dropped"] = _rec_o.frames_dropped_recording
                     async with send_lock:
-                        await websocket.send_json({
+                        await _ws_send_json({
                             "type": "flow_drop",
                             "count": count,
                             "outstanding": _outstanding,
@@ -918,7 +958,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
 
             async with send_lock:
                 ws_debug["send_state"] = f"chunk_start:{profile.get('chunk_idx')}"
-                await websocket.send_json(
+                await _ws_send_json(
                     {
                         "type": "chunk_start",
                         "count": count,
@@ -948,7 +988,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                     wire, is_key = encoded, False
                 async with send_lock:
                     ws_debug["send_state"] = f"chunk_frame:{profile.get('chunk_idx')}:{idx}"
-                    await websocket.send_json(
+                    await _ws_send_json(
                         {
                             "type": "output_frame",
                             "index": idx,
@@ -961,7 +1001,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                             "key": is_key,
                         }
                     )
-                    await websocket.send_bytes(wire)
+                    await _ws_send_bytes(wire)
                     frames_out += 1
                     ws_debug["frames_out"] = frames_out
                     ws_debug["output_bytes"] = int(ws_debug.get("output_bytes", 0)) + len(wire)
@@ -1002,7 +1042,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                 _chunk_done_msg["chunk_idx"] = profile.get("chunk_idx")
             async with send_lock:
                 ws_debug["send_state"] = f"chunk_done:{profile.get('chunk_idx')}"
-                await websocket.send_json(_chunk_done_msg)
+                await _ws_send_json(_chunk_done_msg)
                 ws_debug["chunk_results_sent"] = int(ws_debug.get("chunk_results_sent", 0)) + 1
                 ws_debug["last_send_at"] = time.time()
                 ws_debug["send_state"] = "idle"
@@ -1109,7 +1149,8 @@ def create_app(args: argparse.Namespace) -> FastAPI:
             return None
 
         def _close_session_sync(session_ref) -> None:
-            session_ref.close()
+            with app.state.inference_lock:
+                session_ref.close()
 
         async def _close_session_safely(session_ref, reason: str) -> None:
             try:
@@ -1219,6 +1260,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
             nonlocal session, frames_since_session_reset, reset_count
             if session is None:
                 return
+            print(f"#####[STREAM] session reset ({reason})", flush=True)
 
             await _stop_output_task()
             await _close_session_safely(session, "kv_reset")
@@ -1261,7 +1303,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
             last_activity = time.monotonic()
             last_frames_out = frames_out
             while True:
-                if frames_out != last_frames_out:
+                if frames_out != last_frames_out or pe_task is not None:
                     last_frames_out = frames_out
                     last_activity = time.monotonic()
                 if time.monotonic() - last_activity >= HOLDER_IDLE_TIMEOUT_S:
@@ -1336,7 +1378,8 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                         ))
                         use_pe = bool(payload.get("use_pe", args.use_pe)) and bool(os.environ.get("OPENAI_API_KEY"))
 
-                        face_gate_pending = bool(payload.get("gate_enabled", True))
+                        entry_gate = bool(payload.get("gate_enabled", True))
+                        face_gate_pending = entry_gate
                         flow["recv"] = None
                         flow["at"] = 0.0
                         flow["congested"] = False
@@ -1345,24 +1388,26 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                         flow["consec"] = 0
                         flow["base"] = frames_out
 
-                        presence_monitor = bool(args.online_gate) and bool(
-                            payload.get("no_person_blank", True)
-                        )
-
-                        face_required = bool(args.online_gate) and bool(payload.get("require_face", True))
-
-                        count_monitor = bool(args.online_gate) and bool(payload.get("person_count_reedit", True))
+                        gate_on = bool(args.online_gate) and entry_gate
 
                         fg_score = float(payload.get("fg_score", args.face_gate_score))
                         fg_min_below = float(payload.get("fg_min_below_ratio", args.face_gate_min_below_ratio))
                         fg_stable = max(1, int(payload.get("fg_stable_frames", args.face_gate_stable_frames)))
                         fg_absent = max(1, int(args.presence_absent_frames))
                         fg_return = max(1, int(args.presence_return_frames))
+                        _gate_fps = float(payload.get("fps") or args.fps or 24.0)
+                        _fscale = _gate_fps / 24.0
+                        fg_stable = max(1, int(round(fg_stable * _fscale)))
+                        fg_absent = max(1, int(round(fg_absent * _fscale)))
+                        fg_return = max(1, int(round(fg_return * _fscale)))
+                        count_change_frames = max(1, int(round(int(args.person_count_change_frames) * _fscale)))
+                        body_flip_frames = max(1, int(round(int(args.person_body_flip_frames) * _fscale)))
+                        person_stride = max(1, int(round(int(args.person_check_stride) * _fscale)))
+                        gate_move_eps = float(args.face_gate_move_eps) / _fscale
                         gate_state["count"] = 0
                         gate_state["cx"] = None
                         gate_state["cy"] = None
                         gate_state["absent"] = 0
-                        gate_state["passthrough"] = False
                         gate_state["absent_hold"] = False
                         gate_state["present"] = 0
                         gate_state["person_check_i"] = 0
@@ -1600,7 +1645,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                         continue
 
                 if kv_reset_frames > 0 and frames_since_session_reset >= kv_reset_frames:
-                    face_gate_pending = True
+                    face_gate_pending = entry_gate
                     gate_state["count"] = 0
                     gate_state["cx"] = None
                     gate_state["cy"] = None
@@ -1653,7 +1698,7 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                                 gate_state["csz"] = _csz
                                 return "off_center"
                             _pcx, _pcy, _pcsz = gate_state["cx"], gate_state["cy"], gate_state.get("csz")
-                            _eps = float(args.face_gate_move_eps)
+                            _eps = gate_move_eps
                             _cap = float(args.face_gate_settle_drift)
 
                             _szeps = _eps * 0.5
@@ -1679,96 +1724,92 @@ def create_app(args: argparse.Namespace) -> FastAPI:
                             gate_state["pe_anchor"] = frame
                             return "__gate_pe__"
 
-                    if (presence_monitor or count_monitor) and not face_gate_pending:
-                        if presence_monitor:
-                            stride = max(1, int(args.person_check_stride))
-                            _tick = gate_state.get("person_check_i", 0)
-                            if _tick == 0 or gate_state.get("absent_hold"):
-                                gate_state["person_last"] = _person_present(
-                                    frame, onnx_path=args.person_detector_onnx, conf=float(args.person_gate_conf))
-
-                                if face_required and gate_state["person_last"]:
-                                    gate_state["face_last"] = _face_present(
-                                        frame, onnx_path=args.face_detector_onnx, score_thresh=fg_score,
-                                        min_ratio=float(args.face_present_min_ratio),
-                                        edge_margin=float(args.face_present_edge_margin))
-                                else:
-                                    gate_state["face_last"] = True
-                            gate_state["person_check_i"] = (_tick + 1) % stride
-                            _body_here = bool(gate_state["person_last"])
-                            _face_here = bool(gate_state.get("face_last", True))
-                            _present = _body_here and _face_here
-                            _reason_now = "no_person" if not _body_here else ("no_face" if not _face_here else "")
-
-                            body_flip = max(1, int(args.person_body_flip_frames))
-                            if _body_here:
-                                gate_state["body_miss"] = 0
-                            else:
-                                gate_state["body_miss"] = gate_state.get("body_miss", 0) + 1
-                            if _present:
-                                gate_state["absent"] = 0
-                                if gate_state.get("absent_hold"):
-                                    gate_state["present"] = gate_state.get("present", 0) + 1
-                                    if gate_state["present"] >= fg_return:
-                                        gate_state["absent_hold"] = False
-                                        gate_state["present"] = 0
-                                        print("#####[PERSON-GATE] subject returned (stable) -> re-run startup gate (reset)", flush=True)
-                                        return ("__person_returned__",)
-
+                    if gate_on and not face_gate_pending:
+                        _tick = gate_state.get("person_check_i", 0)
+                        _gfaces, _gfw, _gfh = _detect_gate_faces(frame, onnx_path=args.face_detector_onnx, score_thresh=fg_score)
+                        if _tick == 0 or gate_state.get("absent_hold"):
+                            gate_state["person_last"] = _person_present(
+                                frame, onnx_path=args.person_detector_onnx, conf=float(args.person_gate_conf))
+
+                            if gate_state["person_last"]:
+                                gate_state["face_last"] = _face_present_from(
+                                    _gfaces, _gfw, _gfh,
+                                    min_ratio=float(args.face_present_min_ratio),
+                                    edge_margin=float(args.face_present_edge_margin))
                             else:
-                                gate_state["present"] = 0
-                                gate_state["absent"] += 1
-
-                                if _reason_now == "no_person" and gate_state.get("body_miss", 0) < body_flip:
-                                    _reason_now = "no_face" if face_required else ""
-                                gate_state["hold_reason"] = _reason_now or gate_state.get("hold_reason") or "no_person"
-                                if not gate_state.get("absent_hold") and gate_state["absent"] >= fg_absent:
-                                    gate_state["absent_hold"] = True
-
-                                    try:
-                                        if session is not None:
-                                            session.pending_frames.clear()
-                                            session.pending_metas.clear()
-                                    except Exception:
-                                        pass
-                                    print(f"#####[PERSON-GATE] {gate_state['hold_reason']} for {gate_state['absent']} frames -> black-hold", flush=True)
+                                gate_state["face_last"] = True
+                        gate_state["person_check_i"] = (_tick + 1) % person_stride
+                        _body_here = bool(gate_state["person_last"])
+                        _face_here = bool(gate_state.get("face_last", True))
+                        _present = _body_here and _face_here
+                        _reason_now = "no_person" if not _body_here else ("no_face" if not _face_here else "")
+
+                        body_flip = body_flip_frames
+                        if _body_here:
+                            gate_state["body_miss"] = 0
+                        else:
+                            gate_state["body_miss"] = gate_state.get("body_miss", 0) + 1
+                        if _present:
+                            gate_state["absent"] = 0
                             if gate_state.get("absent_hold"):
-                                return ("__no_person__", gate_state.get("hold_reason", "no_person"))
-
-                        if count_monitor:
-                            _reason_c, _, _n_faces = _check_face_gate(
-                                frame, onnx_path=args.face_detector_onnx,
-                                score_thresh=fg_score, min_below_ratio=fg_min_below,
-                                count_min_ratio=float(args.count_face_min_ratio))
-                            _n = _n_faces
-                            if gate_state["subject_count"] is None:
+                                gate_state["present"] = gate_state.get("present", 0) + 1
+                                if gate_state["present"] >= fg_return:
+                                    gate_state["absent_hold"] = False
+                                    gate_state["present"] = 0
+                                    print("#####[PERSON-GATE] subject returned (stable) -> re-run startup gate (reset)", flush=True)
+                                    return ("__person_returned__",)
+
+                        else:
+                            gate_state["present"] = 0
+                            gate_state["absent"] += 1
+
+                            if _reason_now == "no_person" and gate_state.get("body_miss", 0) < body_flip:
+                                _reason_now = "no_face"
+                            gate_state["hold_reason"] = _reason_now or gate_state.get("hold_reason") or "no_person"
+                            if not gate_state.get("absent_hold") and gate_state["absent"] >= fg_absent:
+                                gate_state["absent_hold"] = True
+
+                                try:
+                                    if session is not None:
+                                        session.pending_frames.clear()
+                                        session.pending_metas.clear()
+                                except Exception:
+                                    pass
+                                print(f"#####[PERSON-GATE] {gate_state['hold_reason']} for {gate_state['absent']} frames -> black-hold", flush=True)
+                        if gate_state.get("absent_hold"):
+                            return ("__no_person__", gate_state.get("hold_reason", "no_person"))
+
+                        _n = _count_faces_from(
+                            _gfaces, _gfw, _gfh,
+                            count_min_ratio=float(args.count_face_min_ratio))
+                        if gate_state["subject_count"] is None:
+                            gate_state["subject_count"] = _n
+                            gate_state["cand"] = None
+                            gate_state["cand_n"] = 0
+                        elif _n > gate_state["subject_count"]:
+                            if _n == gate_state["cand"]:
+                                gate_state["cand_n"] += 1
+                            else:
+                                gate_state["cand"] = _n
+                                gate_state["cand_n"] = 1
+                            if gate_state["cand_n"] >= count_change_frames:
+                                gate_state["recount"] = True
                                 gate_state["subject_count"] = _n
                                 gate_state["cand"] = None
                                 gate_state["cand_n"] = 0
-                            elif _n > gate_state["subject_count"]:
-                                if _n == gate_state["cand"]:
-                                    gate_state["cand_n"] += 1
-                                else:
-                                    gate_state["cand"] = _n
-                                    gate_state["cand_n"] = 1
-                                if gate_state["cand_n"] >= int(args.person_count_change_frames):
-                                    gate_state["recount"] = True
-                                    gate_state["subject_count"] = _n
-                                    gate_state["cand"] = None
-                                    gate_state["cand_n"] = 0
-                            elif _n < gate_state["subject_count"]:
-                                if _n == gate_state["cand"]:
-                                    gate_state["cand_n"] += 1
-                                else:
-                                    gate_state["cand"] = _n
-                                    gate_state["cand_n"] = 1
-                                if gate_state["cand_n"] >= int(args.person_count_change_frames):
-                                    gate_state["subject_count"] = _n
-                                    gate_state["cand"] = None
-                                    gate_state["cand_n"] = 0
+                        elif _n < gate_state["subject_count"]:
+                            if _n == gate_state["cand"]:
+                                gate_state["cand_n"] += 1
                             else:
+                                gate_state["cand"] = _n
+                                gate_state["cand_n"] = 1
+                            if gate_state["cand_n"] >= count_change_frames:
+                                gate_state["subject_count"] = _n
                                 gate_state["cand"] = None
                                 gate_state["cand_n"] = 0
+                        else:
+                            gate_state["cand"] = None
+                            gate_state["cand_n"] = 0
 
                     if pe_defer and not face_gate_pending:
                         gate_state["pe_anchor"] = frame
@@ -1974,22 +2015,22 @@ def build_parser() -> argparse.ArgumentParser:
 
     parser.add_argument("--face-detector-onnx", type=str, default=DEFAULT_FACE_DETECTOR_ONNX, help="YuNet ONNX weight for the face-presence gate. Missing -> gate disabled (edits run unconditionally).")
     parser.add_argument("--face-gate-score", type=float, default=0.35, help="Min YuNet confidence to count as a face. Lower = detects motion-blurred faces (fewer transient drops), but more false positives.")
-    parser.add_argument("--face-present-min-ratio", type=float, default=0.15, help="Mid-session presence: a detected face counts as 'present' only if its short side is >= this fraction of the frame short side. A too-small/partial face (subject sat down so only the top of the head shows) counts as no-face -> black-hold, instead of letting the model t2v-hallucinate a person. 0 = any face counts. Higher = stricter (black out sooner when the face gets small/far). Normal editing faces measure ~0.37, so 0.15 has a wide margin.")
+    parser.add_argument("--face-present-min-ratio", type=float, default=0.15, help="Mid-session presence: a detected face counts as 'present' only if its short side is >= this fraction of the frame short side. A too-small/partial face (subject sat down so only the top of the head shows) counts as no-face -> black-hold, instead of letting the model t2v-hallucinate a person. 0 = any face counts. Higher = stricter (black out sooner when the face gets small/far). Normal editing faces measure ~0.35, so 0.15 has a wide margin.")
     parser.add_argument("--face-present-edge-margin", type=float, default=0.0, help="Mid-session presence: a face whose box comes within this fraction of ANY frame border counts as a HALF/partial face (turned/leaned out) -> no-face -> black-hold, so the model never edits a half-face frame (which it fills in as a t2v hallucination). 0 = no edge check (default: disabled -- the face-box edge check false-blacked too eagerly when a face merely neared a border). Set e.g. 0.02 to re-enable a lenient check.")
-    parser.add_argument("--face-gate-min-below-ratio", type=float, default=0.20, help="Min fraction of frame HEIGHT that must be below the face (torso room, for garment try-on). Bigger -> stricter (must back up more).")
+    parser.add_argument("--face-gate-min-below-ratio", type=float, default=0.20, help="Min fraction of frame HEIGHT that must be below the face (torso room, for garment try-on). Bigger -> stricter: the chin must sit higher in frame (back up, sit taller, or re-aim the camera).")
+    parser.add_argument("--face-gate-center-margin", type=float, default=0.35, help="Max |face-center-x - 0.5| (fraction of width) for a SINGLE subject to count as centered. Bigger -> more lenient. SKIPPED entirely when 2+ comparable faces are present (side-by-side people can't be centered). Note: motion/stability is enforced separately by --face-gate-move-eps + --face-gate-settle-drift, so this does not affect the swing-into-frame ghost fix.")
+    parser.add_argument("--face-gate-move-eps", type=float, default=0.02, help="Max per-frame face-center movement (fraction of frame) to count as 'still'. Bigger -> tolerates more motion. Pairs with --face-gate-settle-drift (net drift from anchor) so a slow glide can't creep through frame-by-frame. Also requires per-frame face-size change <= 0.5*eps.")
+    parser.add_argument("--face-gate-settle-drift", type=float, default=0.05, help="Max net drift of the face center AND size from the settle-streak anchor (fraction of frame). Closes the 'slow continuous glide' hole where every per-frame step is < move-eps but they sum to a big slide (swing-into-frame motion baked into chunk0 -> ghost/duplicate person). Smaller = must hold more still. Complements --face-gate-move-eps (per-frame) + --face-gate-stable-frames (streak length).")
+    parser.add_argument("--face-gate-stable-frames", type=int, default=24, help="Consecutive centered+still frames required before editing starts (~24fps send rate, so 24 ≈ 1s).")
 
-    parser.add_argument("--face-gate-center-margin", type=float, default=0.28, help="Max |face-center-x - 0.5| (fraction of width) for a SINGLE subject to count as centered. Bigger -> more lenient. SKIPPED entirely when 2+ comparable faces are present (side-by-side people can't be centered). Note: motion/stability is enforced separately by --face-gate-move-eps + --face-gate-settle-drift, so this does not affect the swing-into-frame ghost fix.")
-    parser.add_argument("--face-gate-move-eps", type=float, default=0.02, help="Max per-frame face-center movement (fraction of frame) to count as 'still'. Bigger -> tolerates more motion. Pairs with --face-gate-settle-drift (cumulative) so a slow glide can't creep through frame-by-frame.")
-    parser.add_argument("--face-gate-settle-drift", type=float, default=0.05, help="Max CUMULATIVE face-center wander (fraction of frame) allowed across the whole settle streak. Closes the 'slow continuous glide' hole where every per-frame step is < move-eps but they sum to a big slide (swing-into-frame motion baked into chunk0 -> ghost/duplicate person). Smaller = must hold more still. Complements --face-gate-move-eps (per-frame) + --face-gate-stable-frames (streak length).")
-    parser.add_argument("--face-gate-stable-frames", type=int, default=12, help="Consecutive centered+still frames required before editing starts (~24fps send rate, so 12 ≈ 0.5s).")
-    parser.add_argument("--online-gate", action=argparse.BooleanOptionalAction, default=True, help="Master switch for MID-SESSION behavior (no-person black-hold + person-count re-edit). On (default) = presence/count monitoring runs for ALL sessions once editing begins. --no-online-gate to disable and make the inference path identical to the base commit.")
+    parser.add_argument("--online-gate", action=argparse.BooleanOptionalAction, default=True, help="Server-wide master for MID-SESSION monitoring (no-person black-hold + person-count re-edit). A session runs it only when its gate_enabled is also true (browser checkbox / start field, default true); the ENTRY gate follows gate_enabled alone. Also seeds the UI checkbox default. --no-online-gate disables mid-session monitoring for all sessions.")
     parser.add_argument("--presence-absent-frames", type=int, default=12, help="Consecutive not-present frames (body missing, OR face too small / half-out per --face-present-*) before the output goes black. Small = stop FAST (less T2V leak on a quick sit-down / turn-away); larger = tolerate a brief occlusion / head-turn without black-holding. ~24fps, 12 ≈ 0.5s.")
     parser.add_argument("--presence-return-frames", type=int, default=24, help="Consecutive present (body+face) frames required to LEAVE the black-hold and re-run the startup gate. Separate from --presence-absent-frames so entry stays fast (black out quickly) while exit is well de-bounced: a face flickering through finger gaps while hands cover the face won't bounce no_face<->settling. ~24fps, 24 ≈ 1s.")
-    parser.add_argument("--person-count-change-frames", type=int, default=24, help="Consecutive frames a NEW face count must hold before re-editing (reset chunk0) so people who enter later get edited. Debounce vs transient miscounts (sway / motion blur / a background face flickering in). ~24fps, 24 ≈ 1s.")
-    parser.add_argument("--count-face-min-ratio", type=float, default=0.45, help="For person-count-change: a face counts as an additional subject only if its short side is >= this fraction of the MAIN (largest/foreground) face's short side. Excludes far-smaller BACKGROUND people (e.g. a coworker behind the subject) that otherwise flip the count and trigger spurious re-edits. Higher = stricter (ignore more background). Default 0.45.")
-    parser.add_argument("--person-detector-onnx", type=str, default=DEFAULT_PERSON_DETECTOR_ONNX, help="YOLOv8n ONNX (fixed 320) for mid-session person presence via cv2.dnn. Missing -> passthrough disabled (edits always run).")
+    parser.add_argument("--person-count-change-frames", type=int, default=24, help="Consecutive frames a NEW face count must hold before it is accepted. An INCREASE then re-edits (reset chunk0) so people who enter later get edited; a decrease only lowers the baseline. Debounce vs transient miscounts (sway / motion blur / a background face flickering in). Keep this larger than --presence-absent-frames so a brief face loss black-holds instead of faking a 0->1 'new person' re-edit. ~24fps, 24 ≈ 1s.")
+    parser.add_argument("--count-face-min-ratio", type=float, default=0.45, help="For person-count-change: a face counts as an additional subject only if its short side is >= this fraction of the MAIN (largest/foreground) face's short side; an absolute floor of 5% of the frame short side also applies. Excludes far-smaller BACKGROUND people (e.g. a coworker behind the subject) that otherwise flip the count and trigger spurious re-edits. Higher = stricter (ignore more background).")
+    parser.add_argument("--person-detector-onnx", type=str, default=DEFAULT_PERSON_DETECTOR_ONNX, help="YOLOv8n ONNX (fixed 320 input) for mid-session body presence via cv2.dnn. Missing/unloadable -> the body check passes through (always 'present'); face-present rules still apply, so no_face black-holds can still trigger.")
     parser.add_argument("--person-gate-conf", type=float, default=0.4, help="Min YOLO person-class score to count the person as present.")
-    parser.add_argument("--person-check-stride", type=int, default=2, help="Run the person detector every Nth frame during editing (YOLO ~27ms; stride amortizes the cost). Smaller = faster stop/resume detection, more CPU.")
+    parser.add_argument("--person-check-stride", type=int, default=2, help="Run the person detector every Nth frame during editing (YOLO ~27ms; stride amortizes the cost). Smaller = notices the subject LEAVING sooner, more CPU. During a black-hold the check runs every frame regardless, so return detection is unaffected by the stride.")
     parser.add_argument("--person-body-flip-frames", type=int, default=6, help="Consecutive body-misses before the client reason flips to no_person. Below this, a lone YOLO dip (a hand/object over the face also clips the torso) keeps the current reason -- normally show_full_face -- so the hint doesn't strobe no_face<->no_person. Reason-only de-bounce; the black-hold timing (--presence-absent-frames) is unaffected. ~24fps, 6 ≈ 0.25s. Higher = more reluctant to ever show no_person; 1 = report no_person on the first miss (old behavior).")
     parser.add_argument("--output-quality", default="auto",
                         help="Downlink preview quality: 'auto' (RTT-adaptive) or a fixed 1-100.")

xvideo/serving/zerogpu_engine.py

@@ -14,8 +14,9 @@ is the transport: a `_QueueWebSocket` adapter presents the same
 the in/out queues instead of a socket.
 
 Reused verbatim (imported, not copied) from serve_joyomni_streaming:
-    _check_face_gate, _face_present, _person_present, _enhance_prompt_sync,
-    _decode_image, _decode_ref_image, _optional_positive_int
+    _check_face_gate, _detect_gate_faces, _face_present_from, _count_faces_from,
+    _person_present, _enhance_prompt_sync, _decode_image, _decode_ref_image,
+    _optional_positive_int
 """
 from __future__ import annotations
 
@@ -38,7 +39,9 @@ from xvideo.serving.serve_joyomni_streaming import (
     _decode_image,
     _decode_ref_image,
     _enhance_prompt_sync,
-    _face_present,
+    _count_faces_from,
+    _detect_gate_faces,
+    _face_present_from,
     _optional_positive_int,
     _person_present,
     _H264Stream,
@@ -266,9 +269,8 @@ async def _session_loop(runtime, args, websocket: _QueueWebSocket) -> None:
     face_gate_pending = False
     pe_defer = False
     session_max_inflight = max(0, int(args.max_inflight_chunks or 0))
-    presence_monitor = False
-    face_required = False
-    count_monitor = False
+    entry_gate = False
+    gate_on = False
     pe_report = None
 
     fg_score = float(args.face_gate_score)
@@ -276,6 +278,10 @@ async def _session_loop(runtime, args, websocket: _QueueWebSocket) -> None:
     fg_stable = int(args.face_gate_stable_frames)
     fg_absent = int(args.presence_absent_frames)
     fg_return = int(args.presence_return_frames)
+    count_change_frames = max(1, int(args.person_count_change_frames))
+    body_flip_frames = max(1, int(args.person_body_flip_frames))
+    person_stride = max(1, int(args.person_check_stride))
+    gate_move_eps = float(args.face_gate_move_eps)
     output_quality = 60 if args.output_quality == "auto" else int(args.output_quality)
     output_codec = "mjpeg"
     h264_stream: _H264Stream | None = None
@@ -424,10 +430,23 @@ async def _session_loop(runtime, args, websocket: _QueueWebSocket) -> None:
                 session_max_inflight = max(0, int(
                     payload.get("max_inflight_chunks", args.max_inflight_chunks) or 0))
                 use_pe = bool(payload.get("use_pe", args.use_pe)) and bool(os.environ.get("OPENAI_API_KEY"))
-                face_gate_pending = bool(payload.get("gate_enabled", True)) and bool(args.online_gate)
-                presence_monitor = bool(args.online_gate) and bool(payload.get("no_person_blank", True))
-                face_required = bool(args.online_gate) and bool(payload.get("require_face", True))
-                count_monitor = bool(args.online_gate) and bool(payload.get("person_count_reedit", True))
+                entry_gate = bool(payload.get("gate_enabled", True))
+                face_gate_pending = entry_gate
+                gate_on = bool(args.online_gate) and entry_gate
+                fg_score = float(payload.get("fg_score", args.face_gate_score))
+                fg_min_below = float(payload.get("fg_min_below_ratio", args.face_gate_min_below_ratio))
+                fg_stable = max(1, int(payload.get("fg_stable_frames", args.face_gate_stable_frames)))
+                fg_absent = max(1, int(args.presence_absent_frames))
+                fg_return = max(1, int(args.presence_return_frames))
+                _gate_fps = float(payload.get("fps") or args.fps or 24.0)
+                _fscale = _gate_fps / 24.0
+                fg_stable = max(1, int(round(fg_stable * _fscale)))
+                fg_absent = max(1, int(round(fg_absent * _fscale)))
+                fg_return = max(1, int(round(fg_return * _fscale)))
+                count_change_frames = max(1, int(round(int(args.person_count_change_frames) * _fscale)))
+                body_flip_frames = max(1, int(round(int(args.person_body_flip_frames) * _fscale)))
+                person_stride = max(1, int(round(int(args.person_check_stride) * _fscale)))
+                gate_move_eps = float(args.face_gate_move_eps) / _fscale
                 _reset_gate_state(gate_state)
                 pe_report = None
                 pe_defer = False
@@ -500,7 +519,7 @@ async def _session_loop(runtime, args, websocket: _QueueWebSocket) -> None:
                 continue
 
         if kv_reset_frames > 0 and frames_since_session_reset >= kv_reset_frames:
-            face_gate_pending = True
+            face_gate_pending = entry_gate
             _reset_gate_state(gate_state)
             await _reset_session("kv_reset_frames")
             continue
@@ -509,10 +528,11 @@ async def _session_loop(runtime, args, websocket: _QueueWebSocket) -> None:
             frame = uplink_frame if uplink_frame is not None else _decode_image(frame_bytes)
             sentinel = _apply_gate(
                 frame, gate_state, args,
-                face_gate_pending=face_gate_pending, presence_monitor=presence_monitor,
-                face_required=face_required, count_monitor=count_monitor, pe_defer=pe_defer,
+                face_gate_pending=face_gate_pending, gate_on=gate_on, pe_defer=pe_defer,
                 fg_score=fg_score, fg_min_below=fg_min_below, fg_stable=fg_stable,
-                fg_absent=fg_absent, fg_return=fg_return, session=session,
+                fg_absent=fg_absent, fg_return=fg_return, person_stride=person_stride,
+                body_flip_frames=body_flip_frames, count_change_frames=count_change_frames,
+                gate_move_eps=gate_move_eps, session=session,
             )
             if sentinel is not None:
                 return sentinel
@@ -614,9 +634,9 @@ def _reset_gate_state(gs: dict) -> None:
                "settle_ay": None, "settle_asz": None, "pe_anchor": None})
 
 
-def _apply_gate(frame, gs, args, *, face_gate_pending, presence_monitor, face_required,
-                count_monitor, pe_defer, fg_score, fg_min_below, fg_stable, fg_absent,
-                fg_return, session):
+def _apply_gate(frame, gs, args, *, face_gate_pending, gate_on, pe_defer, fg_score,
+                fg_min_below, fg_stable, fg_absent, fg_return, person_stride,
+                body_flip_frames, count_change_frames, gate_move_eps, session):
     if face_gate_pending:
         reason, center, nf = _check_face_gate(
             frame, onnx_path=args.face_detector_onnx,
@@ -631,7 +651,7 @@ def _apply_gate(frame, gs, args, *, face_gate_pending, presence_monitor, face_re
                 gs["settle_asz"] = None; gs["cx"] = cx; gs["cy"] = cy; gs["csz"] = csz
                 return "off_center"
             pcx, pcy, pcsz = gs.get("cx"), gs.get("cy"), gs.get("csz")
-            eps = float(args.face_gate_move_eps); cap = float(args.face_gate_settle_drift)
+            eps = gate_move_eps; cap = float(args.face_gate_settle_drift)
             szeps = eps * 0.5
             still = (pcx is not None and abs(cx - pcx) <= eps and abs(cy - pcy) <= eps
                      and pcsz is not None and abs(csz - pcsz) <= szeps)
@@ -648,69 +668,66 @@ def _apply_gate(frame, gs, args, *, face_gate_pending, presence_monitor, face_re
             gs["pe_anchor"] = frame
             return "__gate_pe__"
 
-    if (presence_monitor or count_monitor) and not face_gate_pending:
-        if presence_monitor:
-            stride = max(1, int(args.person_check_stride))
-            tick = gs.get("person_check_i", 0)
-            if tick == 0 or gs.get("absent_hold"):
-                gs["person_last"] = _person_present(
-                    frame, onnx_path=args.person_detector_onnx, conf=float(args.person_gate_conf))
-                if face_required and gs["person_last"]:
-                    gs["face_last"] = _face_present(
-                        frame, onnx_path=args.face_detector_onnx, score_thresh=fg_score,
-                        min_ratio=float(args.face_present_min_ratio),
-                        edge_margin=float(args.face_present_edge_margin))
-                else:
-                    gs["face_last"] = True
-            gs["person_check_i"] = (tick + 1) % stride
-            body_here = bool(gs["person_last"]); face_here = bool(gs.get("face_last", True))
-            present = body_here and face_here
-            reason_now = "no_person" if not body_here else ("no_face" if not face_here else "")
-            body_flip = max(1, int(args.person_body_flip_frames))
-            if body_here:
-                gs["body_miss"] = 0
+    if gate_on and not face_gate_pending:
+        gfaces, gfw, gfh = _detect_gate_faces(
+            frame, onnx_path=args.face_detector_onnx, score_thresh=fg_score)
+        tick = gs.get("person_check_i", 0)
+        if tick == 0 or gs.get("absent_hold"):
+            gs["person_last"] = _person_present(
+                frame, onnx_path=args.person_detector_onnx, conf=float(args.person_gate_conf))
+            if gs["person_last"]:
+                gs["face_last"] = _face_present_from(
+                    gfaces, gfw, gfh,
+                    min_ratio=float(args.face_present_min_ratio),
+                    edge_margin=float(args.face_present_edge_margin))
             else:
-                gs["body_miss"] = gs.get("body_miss", 0) + 1
-            if present:
-                gs["absent"] = 0
-                if gs.get("absent_hold"):
-                    gs["present"] = gs.get("present", 0) + 1
-                    if gs["present"] >= fg_return:
-                        gs["absent_hold"] = False; gs["present"] = 0
-                        return ("__person_returned__",)
-            else:
-                gs["present"] = 0; gs["absent"] += 1
-                if reason_now == "no_person" and gs.get("body_miss", 0) < body_flip:
-                    reason_now = "no_face" if face_required else ""
-                gs["hold_reason"] = reason_now or gs.get("hold_reason") or "no_person"
-                if not gs.get("absent_hold") and gs["absent"] >= fg_absent:
-                    gs["absent_hold"] = True
-                    try:
-                        if session is not None:
-                            session.pending_frames.clear(); session.pending_metas.clear()
-                    except Exception:  # noqa: BLE001
-                        pass
+                gs["face_last"] = True
+        gs["person_check_i"] = (tick + 1) % person_stride
+        body_here = bool(gs["person_last"]); face_here = bool(gs.get("face_last", True))
+        present = body_here and face_here
+        reason_now = "no_person" if not body_here else ("no_face" if not face_here else "")
+        body_flip = body_flip_frames
+        if body_here:
+            gs["body_miss"] = 0
+        else:
+            gs["body_miss"] = gs.get("body_miss", 0) + 1
+        if present:
+            gs["absent"] = 0
             if gs.get("absent_hold"):
-                return ("__no_person__", gs.get("hold_reason", "no_person"))
-
-        if count_monitor:
-            reason_c, _, n_faces = _check_face_gate(
-                frame, onnx_path=args.face_detector_onnx, score_thresh=fg_score,
-                min_below_ratio=fg_min_below, count_min_ratio=float(args.count_face_min_ratio))
-            n = n_faces
-            if gs["subject_count"] is None:
-                gs["subject_count"] = n; gs["cand"] = None; gs["cand_n"] = 0
-            elif n != gs["subject_count"]:
-                if n == gs["cand"]:
-                    gs["cand_n"] += 1
-                else:
-                    gs["cand"] = n; gs["cand_n"] = 1
-                if gs["cand_n"] >= int(args.person_count_change_frames):
-                    if n > gs["subject_count"]:
-                        gs["recount"] = True
-                    gs["subject_count"] = n; gs["cand"] = None; gs["cand_n"] = 0
+                gs["present"] = gs.get("present", 0) + 1
+                if gs["present"] >= fg_return:
+                    gs["absent_hold"] = False; gs["present"] = 0
+                    return ("__person_returned__",)
+        else:
+            gs["present"] = 0; gs["absent"] += 1
+            if reason_now == "no_person" and gs.get("body_miss", 0) < body_flip:
+                reason_now = "no_face"
+            gs["hold_reason"] = reason_now or gs.get("hold_reason") or "no_person"
+            if not gs.get("absent_hold") and gs["absent"] >= fg_absent:
+                gs["absent_hold"] = True
+                try:
+                    if session is not None:
+                        session.pending_frames.clear(); session.pending_metas.clear()
+                except Exception:  # noqa: BLE001
+                    pass
+        if gs.get("absent_hold"):
+            return ("__no_person__", gs.get("hold_reason", "no_person"))
+
+        n = _count_faces_from(
+            gfaces, gfw, gfh, count_min_ratio=float(args.count_face_min_ratio))
+        if gs["subject_count"] is None:
+            gs["subject_count"] = n; gs["cand"] = None; gs["cand_n"] = 0
+        elif n != gs["subject_count"]:
+            if n == gs["cand"]:
+                gs["cand_n"] += 1
             else:
-                gs["cand"] = None; gs["cand_n"] = 0
+                gs["cand"] = n; gs["cand_n"] = 1
+            if gs["cand_n"] >= count_change_frames:
+                if n > gs["subject_count"]:
+                    gs["recount"] = True
+                gs["subject_count"] = n; gs["cand"] = None; gs["cand_n"] = 0
+        else:
+            gs["cand"] = None; gs["cand_n"] = 0
 
     if pe_defer and not face_gate_pending:
         gs["pe_anchor"] = frame