Revert Prayer-Time-Bot to 0be4ca683e2a (user: 0pe4ca6) — H264 FLV copy, no HEVC origin fallthrough

Dockerfile

@@ -13,8 +13,8 @@ ENV TZ=Asia/Baghdad \
     CHECK_INTERVAL=20 \
     SOURCE_STALL_TIMEOUT=12 \
     YOUTUBE_SOURCE_STALL_SECONDS=12 \
-    MAX_CONCURRENT_RELAYS=5 \
-    YOUTUBE_MAX_EVENTS=5 \
+    MAX_CONCURRENT_RELAYS=2 \
+    YOUTUBE_MAX_EVENTS=2 \
     YOUTUBE_TITLE_TEMPLATE="{broadcaster} | {date} {time}" \
     YOUTUBE_SEND_MODE=auto \
     YOUTUBE_AUTO_TRANSCODE=1 \

app.py

@@ -537,7 +537,7 @@ def _maybe_start_direct(user, obs):
         return
     if hub.at_capacity(except_user=user):
         update(user, state='BACKOFF', status='بلغنا حد MAX_CONCURRENT_RELAYS')
-        log(user,'[RELAY] @%s waiting: at MAX_CONCURRENT_RELAYS=%s'%(user, max_concurrent_relays() or 'open'))
+        log(user,'[RELAY] @%s waiting: at MAX_CONCURRENT_RELAYS=%d'%(user, max_concurrent_relays()))
         return
     stop=threading.Event()
     title=format_session_title(obs.get('nickname') or user)[0]
@@ -786,15 +786,9 @@ def _pick_last_error(tasks_map):
             return err, u
     return last_error, last_error_user
 
-_health_cache={'t':0.0,'v':None}
-
 @app.get('/health')
 @app.get('/healthz')
 def health_public():
-    now=time.monotonic()
-    cached=_health_cache.get('v')
-    if cached is not None and now-float(_health_cache.get('t') or 0)<2.0:
-        return cached
     with lock:
         n=len(tasks);enabled=sum(1 for t in tasks.values() if t.get('enabled'))
         last_error, last_error_user=_pick_last_error(tasks)
@@ -842,7 +836,7 @@ def health_public():
             pass
     except Exception:
         pass
-    payload={'application':'running','monitor':'running' if _monitor_alive.is_set() else 'stopped',
+    return {'application':'running','monitor':'running' if _monitor_alive.is_set() else 'stopped',
             'accounts':n,'enabled':enabled,'active_relays':active,
             'max_concurrent_relays':max_concurrent_relays(),
             'source_stall_timeout':SOURCE_STALL_TIMEOUT,
@@ -858,8 +852,6 @@ def health_public():
             'youtube_status':y_status,'youtube_events':y_events,'youtube_history':y_hist,
             'youtube_senders':y_senders,'youtube_skip':y_skip,
             'broadcasters':per}
-    _health_cache['t']=time.monotonic(); _health_cache['v']=payload
-    return payload
 
 @app.get('/api/health')
 def health_detail():

index.html

@@ -181,7 +181,7 @@ async function refresh(){
     const lastErr=tasks.map(t=>t.last_error).filter(Boolean)[0] || (s0.logs||[]).filter(l=>/error|فشل|stall|خطأ/i.test(l.message||'')).slice(-1)[0]?.message || 'لا يوجد';
     $('mon').textContent=s0.monitor_running?'يعمل':'متوقف';
     $('nacc').textContent=String(tasks.length);
-    const _nrel=String(s0.active_relays||evs.length||0);const _cap=s0.max_concurrent_relays;$('nrel').textContent=_nrel+' / '+((_cap&&_cap>0)?_cap:'مفتوح');
+    $('nrel').textContent=String(s0.active_relays||evs.length||0)+' / '+(s0.max_concurrent_relays||'?');
     $('ncpu').textContent=(s0.load1!=null?('load '+s0.load1+' / '+ (s0.cpus||'?')+' CPU'):'—');
     $('nram').textContent=(s0.mem_avail_mb!=null?(s0.mem_avail_mb+' MB متاح / '+s0.mem_total_mb+' MB'):'—');
     $('lasterr').textContent=lastErr;

ingest.py

@@ -28,36 +28,19 @@ def rtmp_configured():
     return bool(env_rtmp_destination())
 
 
-def _open_cap(raw, default='0'):
-    """0 / open / unlimited = no global cap. Hub still 0-or-1 per broadcaster."""
-    s = str(raw if raw is not None else default).strip().lower()
-    if s in ('', '0', 'unlimited', 'open', 'none', 'off', 'no', 'false'):
-        return 0
-    try:
-        n = int(s)
-    except (TypeError, ValueError):
-        return 0
-    return n if n > 0 else 0
-
-
 def max_concurrent_relays():
-    """Simultaneous FFmpeg publishers. 0 = every LIVE broadcaster may copy.
+    """Cap on simultaneous FFmpeg publishers. Not a quality guarantee.
 
-    Hub still enforces 0 or 1 relay per username. A positive MAX_CONCURRENT_RELAYS
-    is an optional extra cap; there is no hidden ceiling of 8.
+    Default 2: cpu-basic has carried 1 comfortably and 2 at high quota; 3+ is
+    not a pass. Operators may raise MAX_CONCURRENT_RELAYS; health reports the
+    value actually in force. Ceiling 8 is only a fork-bomb guard.
     """
-    raw = os.getenv('MAX_CONCURRENT_RELAYS')
-    if raw is None or str(raw).strip() == '':
-        raw = os.getenv('YOUTUBE_MAX_EVENTS') or '0'
-    return _open_cap(raw, '0')
-
-
-def youtube_max_events():
-    """Simultaneous YouTube events. 0 = no extra cap beyond one event per user."""
-    raw = os.getenv('YOUTUBE_MAX_EVENTS')
-    if raw is None or str(raw).strip() == '':
-        return max_concurrent_relays()
-    return _open_cap(raw, '0')
+    raw = os.getenv('MAX_CONCURRENT_RELAYS') or os.getenv('YOUTUBE_MAX_EVENTS') or '2'
+    try:
+        n = int(str(raw).strip())
+    except (TypeError, ValueError):
+        n = 2
+    return max(1, min(n, 8))
 
 
 def format_session_title(broadcaster, when=None):
@@ -162,12 +145,9 @@ class RelayHub:
 
     def at_capacity(self, except_user=None):
         with self.lock:
-            cap = max_concurrent_relays()
-            if cap <= 0:
-                return False
             n = sum(1 for u, v in self.slots.items()
                     if u != except_user and self._ffmpeg_alive(v))
-            return n >= cap
+            return n >= max_concurrent_relays()
 
     def env_key_busy(self, except_user=None):
         """A single env stream key can only accept one publisher (any owner)."""

relay.py

@@ -117,18 +117,9 @@ class Sender:
         stamp=d.get('last_source_at')
         if stamp:d['source_age']=round(max(0.0,time.monotonic()-stamp),1)
         try:
-            d['send_mode']=getattr(self,'last_mode',None) or self.sticky_mode or self.mode_override or ''
+            d['send_mode']=self.sticky_mode or self.mode_override or ''
         except Exception:
             d['send_mode']=''
-        # Hide leftover TLS/EOF from a previous handshake while this FFmpeg is actually sending.
-        try:
-            alive=self.alive()
-        except Exception:
-            alive=False
-        if alive and float(d.get('output_seconds') or 0)>=15 and float(d.get('source_age') or 99)<3:
-            d['ffmpeg_errors']=[]
-            d['ffmpeg_diagnostics']=[]
-            d['source_gap']=0
         return d
     def wait_until(self,condition,stop,poll=1.0,timeout=None):
         """Block while `condition()` holds; returns as soon as it stops or a stop is requested."""
@@ -163,13 +154,12 @@ class Sender:
                         FLV is exactly the "picture froze, viewers must leave the app and come
                         back" symptom, because the player latches onto the first configuration.
            copy      -> forward the source untouched (needs a proven H.264 source)
-           match     -> re-encode at the source size (never upscale); GOP 2s for YouTube
-           fixed1080 -> constant 1080x1920 canvas, re-encodes (upscale — operator only)
-           fixed720  -> constant  720x1280 canvas, re-encodes
+           fixed1080 -> constant 1080x1920 canvas, re-encodes
+           fixed720  -> constant  720x1280 canvas, re-encodes (lighter on CPU)
         """
         mode=(self.mode_override or os.getenv('YOUTUBE_SEND_MODE','auto')).strip().lower()
-        if mode not in ('auto','copy','match','fixed1080','fixed720'):
-            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو match أو fixed1080 أو fixed720')
+        if mode not in ('auto','copy','fixed1080','fixed720'):
+            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
         # Sticky transcode is for HEVC / layout flap only. Measured 2026-09-27 on cpu-basic:
         # two fixed720 publishers used 1.67–1.85 of 2.0 quota (peak 92.6%) with YouTube
         # health still good — no headroom for a third. If this candidate is H264, copy.
@@ -196,20 +186,14 @@ class Sender:
             now=time.monotonic()
             while flap and now-flap[0]>600:flap.popleft()
             if len(flap)>=int(os.getenv('YOUTUBE_FLAP_LIMIT','4')):
-                fb=os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','').strip().lower()
-                # copy-first: resolution flap must not switch to transcode unless operator set fixed*.
-                if fb in ('match','fixed1080','fixed720'):
-                    self.sticky_mode=fb
-                    mode=fb
+                mode=os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','fixed720').strip().lower()
+                if mode not in ('fixed1080','fixed720'):mode='fixed720'
+                self.sticky_mode=mode
         return mode
     def note_format_change(self):
         self.flap.append(time.monotonic())
         if len(self.flap)>=int(os.getenv('YOUTUBE_FLAP_LIMIT','4')):
-            fb=os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','').strip().lower()
-            if fb in ('fixed1080','fixed720'):
-                self.log('system','تغيّرت أبعاد المصدر عدة مرات خلال 10 دقائق؛ التحول إلى كانفس ثابت (%s) بطلب المشغّل'%fb)
-            else:
-                self.log('system','تغيّرت أبعاد المصدر عدة مرات؛ نُبقي copy ونعيد توصيل تيك توك على نفس جلسة يوتيوب')
+            self.log('system','تغيّرت أبعاد المصدر عدة مرات خلال 10 دقائق؛ التحول تلقائيًا إلى كانفس ثابت (%s) لمنع تكرار الانقطاع'%os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','fixed720'))
     @staticmethod
     def copy_is_safe(declared,probed):
         """Stream copy is allowed only on positive proof of H.264, never on absence of evidence.
@@ -245,8 +229,8 @@ class Sender:
         label=str(cand.get('label') or cand.get('brief') or '')
         if any(k in str(declared).lower() for k in ('h264','avc')) or any(k in label.lower() for k in ('h264','avc')):
             return None
-        mode=os.getenv('YOUTUBE_CODEC_FALLBACK_MODE','match').strip().lower()
-        if mode not in ('match','fixed1080','fixed720'):mode='match'
+        mode=os.getenv('YOUTUBE_CODEC_FALLBACK_MODE','fixed720').strip().lower()
+        if mode not in ('fixed1080','fixed720'):mode='fixed720'
         self.sticky_mode=mode
         why=('ffprobe: '+str(probed)) if probed else (('مُعلَن: '+declared) if declared else 'ترميز مجهول والفحص لم يأتِ بنتيجة')
         self.log('system','لا يمكن نسخ المصدر كما هو ('+why+') — تحويل تلقائي إل�� '+mode+
@@ -335,64 +319,15 @@ class Sender:
             return []
         return ['-rtmp_enhanced_codecs', 'hvc1'] if self.hevc_payload(candidate) else []
 
-    def _match_geometry(self, candidate):
-        """Same size as the broadcaster. Never upscale. Bitrate follows the source."""
-        c=candidate or {}
-        try:
-            w=int(c.get('width') or 0); h=int(c.get('height') or 0)
-        except (TypeError, ValueError):
-            w=h=0
-        if w<2 or h<2:
-            # label like hd 1280p / origin 1920p when TikTok omitted width
-            text=' '.join(str(c.get(k) or '') for k in ('brief','label','quality_name','resolution'))
-            nums=[int(n) for n in __import__('re').findall(r'\d+', text)]
-            tall=max(nums) if nums else 1280
-            if tall>=1800: w,h=1080,1920
-            elif tall>=1400: w,h=720,1440
-            elif tall>=1000: w,h=720,1280
-            else: w,h=720,1280
-        w-=w%2; h-=h%2
-        # YouTube useful cap; decrease only, never grow.
-        if min(w,h)>1080 or max(w,h)>1920:
-            if h>=w:
-                scale=min(1080/min(w,h), 1920/max(w,h))
-            else:
-                scale=min(1920/max(w,h), 1080/min(w,h))
-            w=int(w*scale); h=int(h*scale)
-            w-=w%2; h-=h%2
-        env=(os.getenv('VIDEO_BITRATE') or '').strip()
-        if env:
-            br=env
-        else:
-            raw=c.get('bitrate') or c.get('bitrate_kbps') or 0
-            try:
-                n=int(str(raw).lower().replace('k','').split('.')[0] or 0)
-            except (TypeError, ValueError):
-                n=0
-            if n>20000:
-                n=n//1000
-            if n<400:
-                n=int(max(w*h, 720*1280)*30*0.08/1000)
-            n=max(1200, min(n, 6000))
-            br='%dk'%n
-        return w,h,br
     def command(self,destination,candidate=None):
         # إعلان Enhanced-RTMP يُقاس على الترميز المدفوع فعلًا؛ ملفات الاختبار المحلية لا بروتوكول لها.
         mode=self.send_mode()
         network=destination.startswith(('rtmp://','rtmps://'))
         enhanced=self.enhanced_advertisement(mode,candidate) if network else []
-        self.last_mode=mode
         if mode=='copy':
             video=['-c:v','copy']
-            # Repeat SPS/PPS on every IDR so a YouTube viewer who hits loading can
-            # resync without leaving the app. Video remains copy (no re-encode).
-            if not self.hevc_payload(candidate):
-                video += ['-bsf:v','dump_extra=freq=keyframe']
         else:
-            if mode=='match':
-                width,height,bitrate=self._match_geometry(candidate)
-            else:
-                width,height,bitrate=(1080,1920,'6000k') if mode=='fixed1080' else (720,1280,'4000k')
+            width,height,bitrate=(1080,1920,'6000k') if mode=='fixed1080' else (720,1280,'4000k')
             # VIDEO_BITRATE was documented in the README but never read anywhere; it now caps the
             # transcode path (copy mode never re-encodes, so it has no bitrate to set).
             bitrate=os.getenv('VIDEO_BITRATE','').strip() or bitrate
@@ -654,8 +589,6 @@ class Sender:
             except Exception as e:
                 self.log(user, '[RELAY] تعذر رصد مصدر بديل دون قطع يوتيوب (%s)' % type(e).__name__)
                 return None
-            if not cand or not cand.get('url'):
-                cand = getattr(self, 'current_candidate', None)
             if not cand or cand.get('media') == 'hls' or not cand.get('url'):
                 return None
             try:
@@ -877,17 +810,10 @@ class Sender:
                 # في HLS يستحيل القياس إلا على FFmpeg (هو من يفتح القائمة)، فنقبل تقدّمه.
                 _fresh = (sess['ff_last'] if response is None else sess['last'])
                 if stall_limit and not sess.get('swapping') and now - _fresh > stall_limit:
-                    attached=None
-                    for _try in range(3):
-                        attached = self._try_reattach(user, p, bridge, sess, stop, refresh,
-                                                      read_timeout, retries, response, pump)
-                        if attached:
-                            response, pump = attached
-                            break
-                        if stop.is_set() or (p.poll() is not None):
-                            break
-                        time.sleep(1.0)
+                    attached = self._try_reattach(user, p, bridge, sess, stop, refresh,
+                                                  read_timeout, retries, response, pump)
                     if attached:
+                        response, pump = attached
                         continue
                     # نُفيق الخيط أولًا (قد يكون محبوسًا في write على أنبوب ممتلئ)، ثم نرفع:
                     # إغلاق stdin يجعل FFmpeg يرى EOF ويتوقف بلطف بدل SIGKILL.
@@ -899,22 +825,6 @@ class Sender:
                             pass
                     raise SourceStalled('انقطع تدفق المصدر منذ %.0f ث (FFmpeg ما زال حيًا، '
                                         'ويوتيوب يبقى على آخر ثانية وصلته)' % (now - _fresh))
-                if sess.get('format_changed') and p.poll() is None:
-                    sess['format_changed'] = False
-                    self.log(user, '[RELAY] تغيّر شكل المصدر؛ إعادة توصيل تيك توك على نفس FFmpeg — لا قطع يوتيوب')
-                    attached=None
-                    for _try in range(3):
-                        attached = self._try_reattach(user, p, bridge, sess, stop, refresh,
-                                                      read_timeout, retries, response, pump)
-                        if attached:
-                            response, pump = attached
-                            break
-                        if stop.is_set() or p.poll() is not None:
-                            break
-                        time.sleep(1.0)
-                    if attached:
-                        continue
-                    raise FormatChanged()
                 rc = p.poll()
                 if rc is not None:
                     if sess['format_changed']:

youtube_manager.py

@@ -12,7 +12,7 @@ from flv_bridge import FormatChanged
 import inspect
 
 from youtube_api import GoogleAPI, Journal, APIError
-from ingest import hub, env_rtmp_destination, rtmp_configured, format_session_title, APP_VERSION, max_concurrent_relays, youtube_max_events
+from ingest import hub, env_rtmp_destination, rtmp_configured, format_session_title, APP_VERSION, max_concurrent_relays
 
 class ManagedYouTube:
     def __init__(self,ffmpeg,observe,log,accounts,path,headers_for=None):
@@ -45,9 +45,8 @@ class ManagedYouTube:
         # إيقاع إعادة المحاولة عندما تكون تيك توك «مباشرة» بلا مرشّحات (لحظات انتقال جولات PK):
         # كان الحدث ينتظر دورة المشغّل كاملة (30ث) مع كاش رصد قديم، فبدا «معلّقًا على يوتيوب».
         self.source_retry=max(5,int(os.getenv('YOUTUBE_SOURCE_RETRY',str(min(15,self.scan)))))
-        self.max_events=youtube_max_events()
+        self.max_events=max(1,int(os.getenv('YOUTUBE_MAX_EVENTS') or max_concurrent_relays()))
         self.last_logged=None;self.status_text='متوقف'
-        self._match_lock=set();self._gop_bad={}
         # Written in _select_source / _skip_note; declared here so a fresh manager never has to
         # rely on getattr() defaults (and so the reason survives the first skip).
         self._probe_note='';self._skip_last={}
@@ -56,7 +55,7 @@ class ManagedYouTube:
         # حتى لو كانت روابطه الموقّعة ما زالت صالحة لساعات. YOUTUBE_OBS_HOLD_SECONDS يضبط
         # السقف، و0 يطفئ الاحتفاظ.
         self.hold_seconds=max(0.0,float(os.getenv('YOUTUBE_OBS_HOLD_SECONDS','900')))
-        self._held={};self._last_force_at={};self.hammer={};self.retry_at={};self._offline_logged=set();self._gate_note_at={};self.auth_pause={};self.starve={};self._hold_notes={};self.last_seen_status={};self._blocked403={};self._skip_probe_once={};self._skip_hold=set();self._loop_miss={};self._ingest_bad_since={};self._good_copy={};self._spawn_at={}
+        self._held={};self._last_force_at={};self.hammer={};self.retry_at={};self._offline_logged=set();self._gate_note_at={};self.auth_pause={};self.starve={};self._hold_notes={};self.last_seen_status={};self._blocked403={};self._skip_probe_once={};self._skip_hold=set();self._loop_miss={}
         # هل تقبل دالة الرصد المحقونة force=؟ (app.py يفعّلها؛ الاختبارات قد لا تفعل)
         try:self._observe_force='force' in inspect.signature(self.observe).parameters
         except (TypeError,ValueError):self._observe_force=False
@@ -179,19 +178,6 @@ class ManagedYouTube:
             light=[c for c in out if not _too_heavy(c)]
             if light:
                 out=light
-        def _short(c):
-            try:
-                return min(int(c.get('width') or 0), int(c.get('height') or 0))
-            except (TypeError, ValueError):
-                return 0
-        # copy-first: never chase a 640/320 PK blip when a 720-class H264 FLV exists.
-        hi=[c for c in out if _short(c)>=700]
-        if hi:
-            out=hi+ [c for c in out if c not in hi]
-        out=sorted(out, key=lambda c: (
-            0 if str(c.get('media') or '')=='flv' else 1,
-            -_short(c),
-        ))
         return out[:limit]
     @staticmethod
     def _adult_account(user):
@@ -274,66 +260,20 @@ class ManagedYouTube:
         if self.is_fault_note(ev.get('note')):
             self.event_update(key, note='')
 
-    def _403_is_hard(self,reason):
-        s=(reason or '').lower()
-        return any(k in s for k in (
-            'livestreamingnotenabled','insufficientlivepermissions','livepermissionblocked',
-            'youtubesignuprequired','accessnotconfigured','autherror','invalid_grant','forbidden'))
-
-    def _403_info(self,key):
-        info=self._blocked403.get(key)
-        if info is None:
-            return None
-        if isinstance(info,(int,float)):
-            return {'t':float(info),'reason':'','hard':True}
-        return info
-
-    def _403_blocked(self,key,user):
-        info=self._403_info(key)
-        if not info:
-            return False
-        hard=bool(info.get('hard'))
-        limit=float(os.getenv('YOUTUBE_403_BLOCK_SECONDS') or (600 if hard else 90))
-        left=int(limit-(time.monotonic()-float(info.get('t') or 0)))
-        if left>0:
-            why=(info.get('reason') or '?')
-            self._skip_note(user,'يوتيوب رفض إنشاء حدث لهذه الجلسة (403/%s)؛ ننتظر %d ث قبل المحاولة من جديد'%(why,left))
-            return True
-        self._blocked403.pop(key,None)
-        return False
-
-    def _release_soft_403(self,except_user=None):
-        """A finished sibling event may free a YouTube concurrent slot — retry copy, do not transcode."""
-        drop=[]
-        for k,info in list(self._blocked403.items()):
-            meta=info if isinstance(info,dict) else {'hard':True}
-            if meta.get('hard'):
-                continue
-            u=k.split(':',1)[0]
-            if except_user and u==except_user:
-                continue
-            drop.append(k)
-        for k in drop:
-            self._blocked403.pop(k,None)
-            self.log(k.split(':',1)[0],'[MONITOR] أُخلي قفل 403 المؤقت بعد تحرّر مقعد يوتيوب؛ سيُعاد فتح copy')
-
     def _youtube_rejected(self,user,room_id,reason):
-        """N16/N16b: رفض يوتيوب 403 عند إنشاء الحدث أو تحديثه.
-
-        صلاحية/حساب = قفل طويل. سقف متزامن أو خطأ عابر = قفل قصير يُفرَّغ عندما ينتهي
-        حدث شقيق حتى يُفتح copy للمذيع المنتظر دون ترميز.
-        """
+        """N16/N16b: رفض يوتيوب 403 (صلاحية/سقف) عند إنشاء الحدث أو تحديثه.
+        ليست خطأً عابرًا: حدث planned بلا مفتاح يعني مقعدًا محروقًا من السقف وحالة
+        مربكة على اللوحة، وإعادة المحاولة كل دورة مسح تكرر الرفض بلا نهاية. نكتب
+        ملاحظة صادقة، نُنهي كل أحداث المستخدم غير المغلقة، ونقفل مفتاح الجلسة داخل
+        نافذة زمنية — يُعاد الاكتشاف تلقائيًا بعد معالجة الصلاحية أو انقضاء النافذة."""
         _keys=[k for k,ev in self.journal.read()['events'].items() if ev.get('username')==user and not ev.get('closing')]
         for _k in _keys:
             self.event_note(_k,'يوتيوب رفض إنشاء/تحديث الحدث (%s): تحقّق من صلاحية البث المباشر وسقف الأحداث في حسابك' % reason)
             try:self.finish_event(_k)
             except Exception:self.archive_event(_k,'local_cancelled_'+str(reason))
         _rid=str(room_id or '')
-        hard=self._403_is_hard(reason)
-        limit=float(os.getenv('YOUTUBE_403_BLOCK_SECONDS') or (600 if hard else 90))
-        if _rid:
-            self._blocked403[user+':'+_rid]={'t':time.monotonic(),'reason':str(reason or ''),'hard':hard}
-        self.log(user,'[MONITOR] يوتيوب رفض إنشاء الحدث (403/%s hard=%s)؛ قفل %d ث — copy سيُعاد بعد النافذة أو بعد تحرّر مقعد'%(reason,hard,int(limit)))
+        if _rid:self._blocked403[user+':'+_rid]=time.monotonic()
+        self.log(user,'[MONITOR] يوتيوب رفض إنشاء الحدث (403/%s)؛ أُغلق حدثه ويُمنع تكرار المفتاح %d ث — يُعاد الاكتشاف بعد معالجة الصلاحية'%(reason,int(float(os.getenv('YOUTUBE_403_BLOCK_SECONDS','600')))))
 
     # ---------- channel / settings ----------
     def check_channel(self,allow_switch=False,expected=None,report_only=False):
@@ -380,8 +320,8 @@ class ManagedYouTube:
         with self.operations:
             d=self.journal.read()
             clean={k:str(values.get(k,'')).strip() for k in ('name','privacy','title','description','send_mode')}
-            if clean['send_mode'] and clean['send_mode'] not in ('auto','copy','match','fixed1080','fixed720'):
-                raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو match أو fixed1080 أو fixed720')
+            if clean['send_mode'] and clean['send_mode'] not in ('auto','copy','fixed1080','fixed720'):
+                raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
             if clean['privacy'] not in ('public','unlisted','private'):raise ValueError('خصوصية غير صالحة')
             if 'send_mode' in values:
                 # The ingestion mode is safe to change mid-broadcast: it only decides what the
@@ -561,7 +501,9 @@ class ManagedYouTube:
         d=self.journal.read();key=user+':'+observation['room_id']
         # قفل رفض 403 يُفحص أولًا: بعد الإغلاق يبقى المفتاح في history والفحص اللاحق كان
         # يسمح بلوغ الحدث مرة أخرى كل دورة رفض متكررة (الرفض حصل لأن المفتاح في history).
-        if self._403_blocked(key,user):
+        block=self._blocked403.get(key)
+        if block and time.monotonic()-block<float(os.getenv('YOUTUBE_403_BLOCK_SECONDS','600')):
+            self._skip_note(user,'يوتيوب رفض إنشاء حدث لهذه الجلسة (403) مؤخرًا؛ ننتظر %d ث قبل المحاولة من جديد'%int(float(os.getenv('YOUTUBE_403_BLOCK_SECONDS','600'))-(time.monotonic()-block)))
             return False
         if key in d['events'] or any(h['session_key']==key for h in d['history']):return False
         dt=datetime.now(ZoneInfo('Asia/Baghdad'));settings=d['settings']
@@ -598,7 +540,7 @@ class ManagedYouTube:
                 body={'snippet':{'title':ev['title'],'description':ev['description'],
                     'scheduledStartTime':(datetime.now(timezone.utc)+timedelta(seconds=30)).isoformat()},
                     'status':dict({'privacyStatus':ev['privacy']},**({'selfDeclaredMadeForKids':False} if self._adult_account(ev['username']) else {})),
-                    'contentDetails':{'enableAutoStart':True,'enableAutoStop':False,'enableDvr':True,
+                    'contentDetails':{'enableAutoStart':False,'enableAutoStop':False,'enableDvr':True,
                                       'recordFromStart':True,'monitorStream':{'enableMonitorStream':False}}}
                 try:r=self.api.call('liveBroadcasts','POST',{'part':'snippet,status,contentDetails'},body)
                 except APIError as e:
@@ -632,9 +574,6 @@ class ManagedYouTube:
     def finish_event(self,key):
         ev=self.journal.read()['events'].get(key)
         if not ev:return True
-        self._match_lock.discard(ev.get('username'))
-        self._gop_bad.pop(key, None)
-        self._release_soft_403(except_user=ev.get('username'))
         self.event_update(key,closing=True,phase='closing')
         if not self.stop_sender(key):return False
         ev=self.journal.read()['events'].get(key)
@@ -701,25 +640,11 @@ class ManagedYouTube:
             self.log(user or 'system', '[WATCHDOG] أُلغي تأجيل إعادة الاتصال (%d حدث) — %s' % (dropped, why))
         return dropped
 
-
-    def _yt_public(self, ev):
-        """Viewers can already open the watch URL — any delay is a YouTube loading spinner."""
-        if not ev:
-            return False
-        if ev.get('was_live'):
-            return True
-        return str(ev.get('youtube_status') or '') in ('live', 'testing', 'liveStarting')
     def start_sender(self,key):
-        ev=self.journal.read()['events'].get(key)
-        public=self._yt_public(ev)
-        # عقاب الوتيرة يجب أن يصمد أمام نقرات tick() قبل أن يصبح الحدث علنيًا.
-        # بعد live أي تأخير = دائرة تحميل أمام المشاهد — نلغي القفل ونعيد copy فورًا.
+        # عقاب الوتيرة يجب أن يصمد أمام نقرات tick(): أي أن إعادة الاتصال المؤجّلة بسبب رفض
+        # الوجهة (187) لا تُبطلها دورة رصد جاءت بعد 15 ث. بدون هذا القفل يبقى التأجيل شكليًا
+        # لأن tick/drive_event يستدعيان start_sender كل دورة.
         until=self.retry_at.get(key)
-        if public:
-            if until:
-                self.retry_at.pop(key, None)
-                self._gate_note_at.pop(key, None)
-            until=None
         if until and time.monotonic()<until:
             left=int(round(until-time.monotonic()))
             # الصمت هنا هو بالضبط «بالانتظار بلا سبب» الذي شكا منه المستخدم: القفل صحيح لكن يجب
@@ -779,12 +704,10 @@ class ManagedYouTube:
             self.event_note(key,'مفتاح RTMPS البيئي مشغول بمذيع آخر؛ لن نخلط بثّين على نفس المفتاح')
             return
         if hub.at_capacity(except_user=ev['username']):
-            self.log(ev['username'],'[RELAY] @%s waiting: at MAX_CONCURRENT_RELAYS=%s'%(ev['username'], max_concurrent_relays() or 'open'))
+            self.log(ev['username'],'[RELAY] @%s waiting: at MAX_CONCURRENT_RELAYS=%d'%(ev['username'], max_concurrent_relays()))
             return
         if hub.busy(ev['username']):
             return
-        if (not public) and time.monotonic()-float(self._spawn_at.get(ev['username']) or 0)<8:
-            return
         # لا نلمس entry هنا: بعد موت خيط الإرسال تُبقي tick() القيد الميت في self.senders،
         # و`entry['candidate']=None` على قيد ميت كان يرمي TypeError عند كل دورة مشغّل
         # (هذا تحديدًا ما جمّد حدث viggoo313 على phase=bound مع output_seconds=0)،
@@ -794,9 +717,7 @@ class ManagedYouTube:
         sender.set_probe(self.codec_probe)
         # حين تبدأ الحافة بقبولنا فعلًا يُمسح العقاب وأثره — لا يُتركان حتى أول انقطاع لاحق
         sender.on_stable=lambda u=ev['username']: self.mark_stream_stable(u)
-        sender.mode_override=(os.getenv('YOUTUBE_SEND_MODE') or '').strip() or self.send_mode_setting() or None
-        if ev.get('username') in getattr(self,'_match_lock',set()):
-            sender.sticky_mode='match'
+        sender.mode_override=self.send_mode_setting() or None
         thread=threading.Thread(target=self.sender_loop,
             args=(key,ev['username'],ev['room_id'],destination,stop,sender),daemon=True)
         self.senders[key]={'thread':thread,'stop':stop,'sender':sender}
@@ -804,7 +725,6 @@ class ManagedYouTube:
             self.senders.pop(key,None)
             self.log(ev['username'],'[RELAY] @%s skipped duplicate session'%ev['username'])
             return
-        self._spawn_at[ev['username']]=time.monotonic()
         self.log(ev['username'], '[RESTART] جلسة إرسال جديدة للحساب (خيط إشراف أُقلع من الصفر)')
         thread.start()
     def restart_dead_senders(self):
@@ -831,8 +751,7 @@ class ManagedYouTube:
                 if not since:
                     entry['idle_since']=time.monotonic()
                     continue
-                grace=2.0 if self._yt_public(ev) else 20.0
-                if time.monotonic()-since<grace:
+                if time.monotonic()-since<20:
                     continue
                 self.log(ev.get('username') or key,
                          '[RELAY] @%s sender thread without FFmpeg; recycle'%ev.get('username'))
@@ -979,11 +898,7 @@ class ManagedYouTube:
             # Skip the idle wait right after a resolution change; otherwise keep polling.
             if restart_at and time.monotonic()-restart_at<30:restart_at=0.0;continue
             gap=float(getattr(sender,'last_source_gap',0) or 0)
-            ev_now=(self.journal.read()['events'].get(key) or {})
-            if self._yt_public(ev_now):
-                wait=0.5
-            else:
-                wait=0.5 if gap>=8 else self._backoff(user)
+            wait=0.5 if gap>=8 else self._backoff(user)
             if stop.wait(wait):return
     def mark_stream_stable(self, user):
         """الحافة تقبل التدفق: تُرمى نافذة العقاب وملاحظتها وعدّادها. تُستدعى من المرسل عند أول
@@ -1005,15 +920,6 @@ class ManagedYouTube:
                 cleared += 1
         if self.hammer.pop(user, None) is not None:
             cleared += 1
-        try:
-            for e in (self.senders or {}).values():
-                snd=e.get('sender')
-                cand=getattr(snd,'current_candidate',None) if snd else None
-                if cand and cand.get('url'):
-                    self._good_copy[user]=dict(cand)
-                    break
-        except Exception:
-            pass
         if cleared:
             self.retry[user] = self.retry_min
             self.log(user, '[WATCHDOG] الاستقبال يقبل التدفق؛ مُسح تأجيل العقاب وأثره من اللوحة (النوافذ: %d)' % cleared)
@@ -1078,21 +984,15 @@ class ManagedYouTube:
                 except Exception as e:
                     self.log(user, '[WATCHDOG] تعذر تجديد عنوان الاستقبال: ' + self.safe_error(e)[:120])
         if n >= 3:
-            public=any(self._yt_public(ev) for ev in _evs)
-            if public:
-                # الحدث أمام المشاهد: أي تأجيل = دائرة تحميل. نعيد copy على نفس المفتاح فورًا.
-                for k in [k for k, ev in self.journal.read()['events'].items() if ev.get('username') == user]:
-                    self.retry_at.pop(k, None)
-                self.retry[user] = self.retry_min
-                self.log(user, '[WATCHDOG] يوتيوب أغلق RTMPS والحدث ما زال live — إعادة copy فورًا على نفس المفتاح (بلا تأجيل %d×)'%n)
-            else:
-                wait = min(120.0, max(20.0, self.retry_min) * (2 ** (n - 3)))
-                self.retry[user] = max(self.retry.get(user, 0) or 0, wait)
-                for k in [k for k, ev in self.journal.read()['events'].items() if ev.get('username') == user]:
-                    self.retry_at[k] = time.monotonic() + wait
-                self.log(user, '[WATCHDOG] الوجهة أغلقت الاتصال بعد %.0f ث (رمز %s) — المرة %d: تأجيل إعادة الاتصال إلى %d ث بدل النقر على حافة ترفض%s'
-                         % (lasted, code, n, int(self._backoff(user)),
-                            '؛ السبب المعلوم: الحدث لم يُشغَّل بعد' if not_started else ''))
+            # أرضية 20 ث × تصاعد هندسي: retry_min=1 في الصورة كان يجعل الطلعة الثالثة «2 ث»
+            # (لا شيء يتغيّر فعليًا)، لذا الحدّ الأدنى 20 ث ثم 40 و80 حتى 120.
+            wait = min(120.0, max(20.0, self.retry_min) * (2 ** (n - 3)))
+            self.retry[user] = max(self.retry.get(user, 0) or 0, wait)
+            for k in [k for k, ev in self.journal.read()['events'].items() if ev.get('username') == user]:
+                self.retry_at[k] = time.monotonic() + wait        # يقفل start_sender من tick() نفسه
+            self.log(user, '[WATCHDOG] الوجهة أغلقت الاتصال بعد %.0f ث (رمز %s) — المرة %d: تأجيل إعادة الاتصال إلى %d ث بدل النقر على حافة ترفض%s'
+                     % (lasted, code, n, int(self._backoff(user)),
+                        '؛ السبب المعلوم: الحدث لم يُشغَّل بعد' if not_started else ''))
         return
 
     def _backoff(self,user):
@@ -1173,25 +1073,10 @@ class ManagedYouTube:
             return None
         if (obs or {}).get('status')!='live':
             return None
-        good=getattr(self,'_good_copy',{}).get(user) or {}
-        try:
-            gh=min(int(good.get('width') or 0), int(good.get('height') or 0))
-        except (TypeError, ValueError):
-            gh=0
-        fallback=None
         for c in self._select_source(user, obs) or []:
-            if c.get('media')=='hls' or not c.get('url'):
-                continue
-            try:
-                sh=min(int(c.get('width') or 0), int(c.get('height') or 0))
-            except (TypeError, ValueError):
-                sh=0
-            if gh>=700 and sh and sh<500:
-                if fallback is None:
-                    fallback=c
-                continue
-            return c
-        return fallback
+            if c.get('media')!='hls' and c.get('url'):
+                return c
+        return None
     def _select_source(self,user,obs):
         """All relayable renditions, stable first. Never drop a working lower-quality source."""
         candidates=self.video_sources(obs.get('sources') or [])
@@ -1348,7 +1233,7 @@ class ManagedYouTube:
                 return False
             if any(e.get('username')==user for e in d['events'].values()):
                 return False
-            if self.max_events>0 and len(d['events'])>=self.max_events:
+            if len(d['events'])>=self.max_events:
                 return False
             key=user+':'+str(obs['room_id'])
             entry=next((h for h in d['history'] if h.get('session_key')==key),None)
@@ -1443,7 +1328,7 @@ class ManagedYouTube:
         # 2) Discover new live sessions, one event per account, up to the concurrency cap.
         cap=self.max_events;active=len(d['events']);capped=False
         for user in accounts:
-            if cap>0 and active>=cap:capped=True;break
+            if active>=cap:capped=True;break
             if any(e['username']==user for e in d['events'].values()):continue
             # رفض الهوية (توكن منتهٍ) لا يُعالَج بوتيرة الرصد: كل دورة كانت تضرب تيك توك
             # برفض مؤكد (~10/د على خمسة حسابات) وتُغرق السجل حتى وهو مكبوت. إيقاف لكل
@@ -1712,34 +1597,13 @@ class ManagedYouTube:
 
         if life in ('complete','revoked'):
             self.event_update(key,closing=True);self.finish_event(key);return
-        if life in ('live','liveStarting'):
-            if life=='live' and not ev['was_live']:
+        if life=='live':
+            if not ev['was_live']:
                 self.event_update(key,was_live=True,phase='live')
                 self.log(user,'[LIVE] يوتيوب أكد أن الحدث مباشر: '+ev['broadcast_id'])
-            # liveStarting without FFmpeg = frozen/loading picture. Keep pushing copy.
+            # Now safe to ensure sender is running; viewer already watching
             self.start_sender(key)
             self.stream_health(key,user,ev)
-            ev=self.journal.read()['events'].get(key) or ev
-            self._ingest_copy_watchdog(key,user,ev)
-            # Measured Prayer-Time-Bot: life=liveStarting, health=ok, out≈wall for 10+ min,
-            # public never left «starting». Re-request live while ingest is healthy.
-            if life=='liveStarting' and needs_poll:
-                healthy=(str(ev.get('youtube_health') or '') in ('good','ok'))
-                try:
-                    snap=(self.senders.get(key) or {}).get('sender')
-                    out=float((snap.snapshot() if snap else {}).get('output_seconds') or 0)
-                except Exception:
-                    out=0.0
-                if healthy or out>=30:
-                    if not ev.get('was_live'):
-                        self.event_update(key,was_live=True,phase='starting')
-                    try:
-                        self.api.call('liveBroadcasts/transition','POST',{'part':'id,status','id':ev['broadcast_id'],'broadcastStatus':'live'})
-                        self.event_note(key,'يوتيوب يستقبل؛ أُعيد طلب التحويل من liveStarting إلى مباشر')
-                        self.log(user,'[LIVE] إعادة طلب live من liveStarting '+str(ev.get('broadcast_id')))
-                    except APIError as e:
-                        # already transitioning / not allowed — keep copy, do not tear down
-                        self.log(user,'[LIVE] تحويل liveStarting: '+self.safe_error(e)[:120])
             return
 
         # life is expected to be 'ready' or 'testing' for a newly bound event
@@ -1771,82 +1635,13 @@ class ManagedYouTube:
                     self.event_update(key, note='انتظار تأكيد استقبال يوتيوب قبل بدء الحدث')
                 elif not ev.get('note'):
                     self.event_note(key,'انتظار تأكيد استقبال يوتيوب قبل بدء الحدث')
-
-    def _ingest_copy_watchdog(self,key,user,ev):
-        """Restart copy onto the same broadcast when YouTube ingest is dead but TikTok still flows.
-
-        FFmpeg alive is not proof of ingest. noData/bad + fresh source_age → new copy sender,
-        same broadcast_id. Never switches to transcode.
-        """
-        health=(ev.get('youtube_health') or '')
-        if health in ('good','ok'):
-            self._ingest_bad_since.pop(key,None)
-            return
-        if health not in ('noData','bad','noStream'):
-            return
-        if time.time()-float(ev.get('created_at') or 0)<90:
-            return
-        entry=self.senders.get(key) or {}
-        snd=entry.get('sender')
-        try:
-            alive=bool(snd and snd.alive())
-        except Exception:
-            alive=False
-        if not alive:
-            self._ingest_bad_since.pop(key,None)
-            return
-        try:
-            age=(snd.snapshot() or {}).get('source_age')
-        except Exception:
-            age=None
-        if age is None or float(age)>3:
-            return
-        now=time.monotonic()
-        since=self._ingest_bad_since.get(key)
-        if since is None:
-            self._ingest_bad_since[key]=now
-            return
-        wait=float(os.getenv('YOUTUBE_NODATA_RESTART_SECONDS','90'))
-        if now-since<wait:
-            return
-        self._ingest_bad_since[key]=now
-        self.log(user,'[WATCHDOG] يوتيوب ingest=%s والمصدر يتدفق (age=%s ث)؛ إعادة copy على نفس الحدث %s'%(health,age,ev.get('broadcast_id') or ''))
-        self.stop_sender(key)
-
-    def _maybe_match_from_health(self,key,user,ev):
-        """Copy first. One switch to source-sized transcode if YouTube GOP/ingest cannot play copy.
-
-        No upscale. No oscillation: lock match for the rest of this process/event.
-        bitrateLow alone is not a reason to transcode.
-        """
-        if user in getattr(self,'_match_lock',set()):
-            return
-        issues=str(ev.get('youtube_issues') or '').lower()
-        health=str(ev.get('youtube_health') or '')
-        gop=any(k in issues for k in ('gopsize','opengop','videoingestionstarved','videocodec','videoresolution'))
-        if not gop and health not in ('bad','noData','noStream'):
-            self._gop_bad.pop(key, None)
-            return
-        if not gop:
-            return
-        n=int(self._gop_bad.get(key) or 0)+1
-        self._gop_bad[key]=n
-        need=max(2, int(os.getenv('YOUTUBE_MATCH_AFTER_HEALTH','2')))
-        if n<need:
-            return
-        self._match_lock.add(user)
-        self.log(user,'[RELAY] يوتيوب لا يقبل copy (GOP/ingest)؛ ترميز بنفس مقاس المصدر — بلا تكبير')
-        self.stop_sender(key)
     def stream_health(self,key,user,ev):
         """Read YouTube's own verdict on the inbound stream. The Live Streaming API reports
         exactly why viewers buffer (videoIngestionStarved), why the picture can be rejected
         (videoResolutionUnsupported / videoCodec) and why playback stalls (gopSizeLong /
         openGop). Surfacing it replaces guesswork with ground truth. Polled on a slower
         cadence than the life-cycle check so it stays inside the quota budget."""
-        prev_h=(ev.get('youtube_health') or '')
-        slow=max(60,int(os.getenv('YOUTUBE_HEALTH_INTERVAL','180')))
-        fast=max(30,int(os.getenv('YOUTUBE_HEALTH_FAST_INTERVAL','45')))
-        interval=fast if prev_h in ('','noData','bad','noStream') else slow
+        interval=max(60,int(os.getenv('YOUTUBE_HEALTH_INTERVAL','180')))
         if time.time()-float(ev.get('last_health') or 0)<interval:return
         stream_id=(self.journal.read()['streams'].get(user) or {}).get('id')
         if not stream_id:return
@@ -1864,7 +1659,6 @@ class ManagedYouTube:
         self.event_update(key,youtube_health=health.get('status',''),youtube_issues=text,last_issues=text)
         if text and text!=prev:
             self.log(user,'يوتيوب يشخّص البث: '+text)
-        self._maybe_match_from_health(key,user,self.journal.read()['events'].get(key) or ev)
     def run_manager(self):
         checked=False
         last_tick=0.0