On-only test: copy-first + light fallback, MAX=4, freeze/liveStarting fixes

Dockerfile

@@ -13,24 +13,27 @@ 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=4 \
+    YOUTUBE_MAX_EVENTS=4 \
     YOUTUBE_TITLE_TEMPLATE="{broadcaster} | {date} {time}" \
     YOUTUBE_SEND_MODE=auto \
     YOUTUBE_AUTO_TRANSCODE=1 \
+    YOUTUBE_LIGHT_MAX=1 \
+    YOUTUBE_LIGHT_BITRATE=1800k \
+    YOUTUBE_COPY_RECOVERY_SECONDS=45 \
     YOUTUBE_AUDIO_PROFILE=aac_low \
     YOUTUBE_AUDIO_BITRATE=128k \
     YOUTUBE_AUDIO_CHANNELS=2 \
     YOUTUBE_GOP=60 \
     YOUTUBE_INPUT_RECOVERY=1 \
     YOUTUBE_PREFER_H264=1 \
-    YOUTUBE_CODEC_FALLBACK_MODE=fixed720 \
+    YOUTUBE_CODEC_FALLBACK_MODE=light \
     YOUTUBE_RETRY_MIN=1 \
     YOUTUBE_RETRY_MAX=60 \
     YOUTUBE_SOURCE_LIMIT=6 \
     YOUTUBE_FORMAT_GUARD=on \
     YOUTUBE_FLAP_LIMIT=4 \
-    YOUTUBE_FLAP_FALLBACK_MODE=fixed720 \
+    YOUTUBE_FLAP_FALLBACK_MODE=light \
     YOUTUBE_X264_PRESET=veryfast \
     YOUTUBE_CRF=22 \
     YOUTUBE_FIFO_TIMESHIFT=0 \

app.py

@@ -596,6 +596,8 @@ def _relay_snapshot(user):
         'relay_dest':slot.get('dest') if slot else '',
         'restarts':hub.restart_count(user),
         'send_mode':snap.get('send_mode') or '',
+        'relay_state':snap.get('relay_state') or '',
+        'transcode_reason':snap.get('transcode_reason') or '',
     }
 
 def _cgroup_usage_ns():
@@ -820,6 +822,8 @@ def health_public():
                     'last_error':tsk.get('last_error') or '','source_age':rs.get('source_age'),
                     'output_seconds':rs.get('output_seconds') or 0,
                     'send_mode':rs.get('send_mode') or '',
+                    'relay_state':rs.get('relay_state') or '',
+                    'transcode_reason':rs.get('transcode_reason') or '',
                     'youtube_health':str(ye.get('youtube_health') or ''),
                     'youtube_issues':str(ye.get('youtube_issues') or '')[:120],
                     'youtube_status':str(ye.get('youtube_status') or '')})
@@ -934,6 +938,10 @@ def state():
                 'last_data_time':rs.get('last_data_time'),'relay_alive':rs.get('relay_alive'),
                 'session_title':rs.get('session_title') or '','restarts':rs.get('restarts') or 0,
                 'source_age':rs.get('source_age'),
+                'send_mode':rs.get('send_mode') or '',
+                'relay_state':rs.get('relay_state') or '',
+                'transcode_reason':rs.get('transcode_reason') or '',
+                'output_seconds':rs.get('output_seconds') or 0,
                 'youtube_health':str(ye.get('youtube_health') or ''),
                 'youtube_issues':str(ye.get('youtube_issues') or '')[:120],
                 'youtube_status':str(ye.get('youtube_status') or ('relay' if rs.get('relay_alive') else (t.get('state') or '')))})

index.html

@@ -144,8 +144,9 @@ async function refresh(){
           ${x.nickname?' · '+esc(x.nickname):''}</p>
         <p>LIVE منذ: ${live?esc(fmtDur(x.live_for||0)):'—'}</p>
         <p>المصدر: ${esc(x.source||'—')}</p>
+        <p>MODE: ${esc(x.send_mode||x.relay_state||'—')}${x.transcode_reason?' · '+esc(x.transcode_reason):''}</p>
         <p>Codec: ${esc(x.codec||'—')} · ${esc(x.quality||'')} · room ${esc(x.room_id||'—')}</p>
-        <p>PID: ${x.relay_pid||'—'} · بايت: ${esc(x.bytes_received||0)} · إعادة: ${esc(x.restarts||0)}</p>
+        <p>PID: ${x.relay_pid||'—'} · بايت: ${esc(x.bytes_received||0)} · إعادة: ${esc(x.restarts||0)} · out ${esc(x.output_seconds||0)}ث</p>
         <p>آخر بايت: ${x.source_age==null||x.source_age===''?'—':(Number(x.source_age).toFixed(1)+'ث')}</p>
         <p>YouTube: ${esc(x.youtube_status||'—')} · health ${esc(x.youtube_health||'—')}${x.relay_alive?' · Relay':''}</p>
         <small>${esc(x.status||'')}${x.last_error?' · '+esc(x.last_error):''}</small>

relay.py

@@ -100,6 +100,13 @@ class Sender:
         # event. Without this the flap window expires after 10 quiet minutes and the
         # sender silently drops back to copy mode, restarting the whole failure loop.
         self.sticky_mode=None
+        self.last_send_mode=''
+        self.relay_state='IDLE'
+        self.transcode_reason=''
+        self.transcode_since=None
+        self.copy_ok_since=None
+        self.yt_health=''
+        self.session_out_codec='h264'
         # Candidate handed to send_mode() so the codec rule can judge the real source.
         self.current_candidate=None
         # Journal setting wins over the environment so the mode can be changed from the UI
@@ -117,9 +124,11 @@ 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']=self.sticky_mode or self.mode_override or ''
+            d['send_mode']=self.last_send_mode or self.sticky_mode or self.mode_override or ''
         except Exception:
             d['send_mode']=''
+        d['relay_state']=getattr(self,'relay_state','') or ''
+        d['transcode_reason']=getattr(self,'transcode_reason','') or ''
         # Hide leftover TLS/EOF from a previous handshake while this FFmpeg is actually sending.
         try:
             alive=self.alive()
@@ -167,12 +176,16 @@ class Sender:
            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','fixed1080','fixed720'):
-            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
+        if mode not in ('auto','copy','light','fixed1080','fixed720'):
+            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو light أو 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.
         if self.sticky_mode:
+            # light stays until the manager hysteresis (H264 + YT health good for
+            # YOUTUBE_COPY_RECOVERY_SECONDS). Do not drop on the first H264 packet.
+            if self.sticky_mode=='light':
+                return 'light'
             cand=self.current_candidate or {}
             blob=(str(cand.get('codec') or '')+' '+str(cand.get('label') or '')+' '+str(cand.get('brief') or '')).lower()
             if any(k in blob for k in ('h264','avc')):
@@ -195,18 +208,17 @@ 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 ('fixed1080','fixed720'):
+                fb=os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','light').strip().lower()
+                if fb in ('light','fixed1080','fixed720'):
                     self.sticky_mode=fb
                     mode=fb
         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)
+            fb=os.getenv('YOUTUBE_FLAP_FALLBACK_MODE','light').strip().lower()
+            if fb in ('light','fixed1080','fixed720'):
+                self.log('system','تغيّرت أبعاد المصدر عدة مرات؛ copy لم يكفِ — ترميز خفيف (%s) بمفتاح IDR كل 2ث'%fb)
             else:
                 self.log('system','تغيّرت أبعاد المصدر عدة مرات؛ نُبقي copy ونعيد توصيل تيك توك على نفس جلسة يوتيوب')
     @staticmethod
@@ -244,12 +256,11 @@ 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','fixed720').strip().lower()
-        if mode not in ('fixed1080','fixed720'):mode='fixed720'
+        mode=os.getenv('YOUTUBE_CODEC_FALLBACK_MODE','light').strip().lower()
+        if mode not in ('light','fixed1080','fixed720'):mode='light'
         self.sticky_mode=mode
         why=('ffprobe: '+str(probed)) if probed else (('مُعلَن: '+declared) if declared else 'ترميز مجهول والفحص لم يأتِ بنتيجة')
-        self.log('system','لا يمكن نسخ المصدر كما هو ('+why+') — تحويل تلقائي إلى '+mode+
-                 '؛ هذا يمنع تجمّد الصورة عند المشاهدين عند تغيّر المقاس أو في جولات PK')
+        self.log('system','لا يمكن نسخ المصدر كما هو ('+why+') — ترميز خفيف ('+mode+') لا fixed720 الثقيل')
         return mode
     def set_probe(self,probe):
         """Injected by the manager: probe(candidate) -> {'video':..,'audio':..} or None."""
@@ -337,14 +348,34 @@ class Sender:
     def command(self,destination,candidate=None):
         # إعلان Enhanced-RTMP يُقاس على الترميز المدفوع فعلًا؛ ملفات الاختبار المحلية لا بروتوكول لها.
         mode=self.send_mode()
+        self.last_send_mode=mode
+        if mode=='copy':
+            if self.relay_state in ('IDLE','COPY_RECOVERY','REATTACH','ALTERNATE_SOURCE','SOURCE_FAULT',''):
+                self.relay_state='COPY_STABLE'
+        elif mode=='light':
+            self.relay_state='TRANSCODE_STABLE' if self.relay_state in ('TRANSCODE_FALLBACK','TRANSCODE_STABLE') else 'TRANSCODE_FALLBACK'
+            if self.transcode_since is None:
+                self.transcode_since=time.monotonic()
         network=destination.startswith(('rtmp://','rtmps://'))
         enhanced=self.enhanced_advertisement(mode,candidate) if network else []
         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']
+        elif mode=='light':
+            # YouTube 720p30 floor ~1500 kbps + GOP 2s. ultrafast keeps cpu-basic
+            # usable; measured fixed720/veryfast/4000k filled 2 cores at 2 publishers.
+            width,height,bitrate=720,1280,(os.getenv('YOUTUBE_LIGHT_BITRATE','1800k').strip() or '1800k')
+            try:
+                bufsize=str(int(str(bitrate).rstrip('kK'))*2)+'k'
+            except (TypeError, ValueError):
+                bufsize='3600k'
+            video=['-vf',self.canvas(width,height),'-c:v','libx264','-preset','ultrafast',
+                   '-tune','zerolatency','-profile:v','main',
+                   '-b:v',bitrate,'-maxrate',bitrate,'-bufsize',bufsize,
+                   '-force_key_frames','expr:gte(t,n_forced*2)',
+                   '-g','60','-keyint_min','30','-sc_threshold','0',
+                   '-pix_fmt','yuv420p','-fps_mode','cfr']
         else:
             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
@@ -627,7 +658,8 @@ class Sender:
             sess['stall_reason'] = ''
             sess['force_stop'] = False
             sess['timeouts'] = 0
-            sess['last'] = time.monotonic()
+            # Do NOT refresh sess['last'] here: HTTP open is not a video byte.
+            # Resetting last turned a 12s source stall into 8×reattach of a frozen picture.
             sess['reattaches'] = int(sess.get('reattaches') or 0) + 1
             self.current_candidate = cand
             self.set(source=cand.get('label') or cand.get('brief') or '', stalled=False)
@@ -822,15 +854,32 @@ class Sender:
             # ---- الحارس: لا تعتمد على poll() ولا على رمز الخروج ----
             stall_limit = self._stall_seconds()
             progress_limit = max(30.0, float(os.getenv('YOUTUBE_PROGRESS_STALL_SECONDS', '60')))
+            # Measured COPY_RECOVERY: origin 1920 copy after light 720 left pid alive,
+            # source bytes flowing, out_time=0 for the full 60s progress window.
+            # Zero output while the source is fresh is a failed start, not a mid-stream freeze.
+            start_limit = max(5.0, float(os.getenv('YOUTUBE_OUTPUT_START_SECONDS', '12')))
+            started_at = time.monotonic()
             next_report = 0.0
             while not stop.is_set():
                 now = time.monotonic()
+                if progress['seconds'] < 1.0 and now - started_at > start_limit:
+                    src_fresh = (now - (sess['ff_last'] if response is None else sess['last'])) < max(stall_limit or 12.0, 12.0)
+                    if src_fresh or response is None:
+                        raise SourceStalled('FFmpeg لم يُخرج إطارًا منذ %.0f ث والمصدر يتدفق (out=0)' % (now - started_at))
                 # الدليل على أن المصدر لم يصمت هو بايتات تيك توك نفسها. تقدّم FFmpeg وحده لا
                 # يكفي: في وضع النسخ يفرّغ المخزن الداخلي لدقائق بعد صمت المصدر، فيبدو البث
                 # حيًا ويوتيوب يبقى على آخر ثانية — وهذا هو التعليق الذي شكا منه المستخدم.
                 # في HLS يستحيل القياس إلا على FFmpeg (هو من يفتح القائمة)، فنقبل تقدّمه.
                 _fresh = (sess['ff_last'] if response is None else sess['last'])
+                freeze_limit = max(float(stall_limit or 12.0), 12.0)
+                # Frozen picture: out_time stopped. Splicing TikTok into the same FFmpeg
+                # does not create IDRs and leaves YouTube on the last frame (measured
+                # mrjooj_7: out=123s for 60s, health still good, source_age 20→61).
+                if progress['seconds'] >= 1.0 and now - progress['last'] > freeze_limit:
+                    raise SourceStalled('تجمّد خرج FFmpeg منذ %.0f ث — نعيد copy على نفس حدث يوتيوب' % (now - progress['last']))
                 if stall_limit and not sess.get('swapping') and now - _fresh > stall_limit:
+                    if progress['seconds'] >= 1.0 and now - progress['last'] > stall_limit:
+                        raise SourceStalled('المصدر صامت وخرج FFmpeg متوقف منذ %.0f ث' % (now - progress['last']))
                     attached=None
                     for _try in range(3):
                         attached = self._try_reattach(user, p, bridge, sess, stop, refresh,

youtube_manager.py

@@ -55,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={};self._ingest_bad_since={};self._good_copy={};self._spawn_at={};self._recover_copy=set();self._last_out={}
         # هل تقبل دالة الرصد المحقونة force=؟ (app.py يفعّلها؛ الاختبارات قد لا تفعل)
         try:self._observe_force='force' in inspect.signature(self.observe).parameters
         except (TypeError,ValueError):self._observe_force=False
@@ -172,8 +172,11 @@ class ManagedYouTube:
             if w and h:
                 # 720x1440 vertical is 720-class (~1 Mbps), not a 1440p master.
                 return min(w,h)>=1440 or (w*h)>=(1600*900)
-            text=str(c.get('label') or c.get('brief') or '')
-            return any(x in text for x in ('2160','4k','4K'))
+            text=str(c.get('label') or c.get('brief') or c.get('quality_name') or '').lower()
+            # Missing width/height: "origin 1920p" must not rank as a 720 copy target.
+            if 'origin' in text or '1920' in text or '2160' in text or '4k' in text:
+                return True
+            return False
         if busy>=2:
             light=[c for c in out if not _too_heavy(c)]
             if light:
@@ -322,13 +325,20 @@ class ManagedYouTube:
         صلاحية/حساب = قفل طويل. سقف متزامن أو خطأ عابر = قفل قصير يُفرَّغ عندما ينتهي
         حدث شقيق حتى يُفتح copy للمذيع المنتظر دون ترميز.
         """
+        hard=self._403_is_hard(reason)
+        keep=('ready','testing','live','liveStarting')
         _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:
+            ev=self.journal.read()['events'].get(_k) or {}
+            # Soft 403 (quota/rateLimit) must not tear down a bound event that already
+            # needs FFmpeg. Finish only planned/unbound shells that cannot ingest.
+            if (not hard) and ev.get('bound') and ev.get('broadcast_id') and str(ev.get('youtube_status') or '') in keep:
+                self.log(user,'[MONITOR] 403/%s على إنشاء جديد؛ نبقي الحدث القائم %s والحالة %s'%(reason, ev.get('broadcast_id'), ev.get('youtube_status')))
+                continue
             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}
@@ -379,7 +389,7 @@ 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','fixed1080','fixed720'):
+            if clean['send_mode'] and clean['send_mode'] not in ('auto','copy','light','fixed1080','fixed720'):
                 raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
             if clean['privacy'] not in ('public','unlisted','private'):raise ValueError('خصوصية غير صالحة')
             if 'send_mode' in values:
@@ -792,6 +802,12 @@ class ManagedYouTube:
         # حين تبدأ الحافة بقبولنا فعلًا يُمسح العقاب وأثره — لا يُتركان حتى أول انقطاع لاحق
         sender.on_stable=lambda u=ev['username']: self.mark_stream_stable(u)
         sender.mode_override=self.send_mode_setting() or None
+        if ev.get('force_light'):
+            cap=max(0,int(os.getenv('YOUTUBE_LIGHT_MAX','1')))
+            if cap>0 and self._light_count()<cap:
+                sender.sticky_mode='light'
+            else:
+                self.log(ev['username'],'[RELAY] سقف الترميز الخفيف ممتلئ عند الإقلاع؛ نُبقي copy')
         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}
@@ -925,12 +941,16 @@ class ManagedYouTube:
                     # الوجهة تُقرأ في كل دورة: لو تغيّر مفتاح الاستقبال (إعادة استخدام المصدر أو
                     # إعادة ربط للحدث) بقي هذا الخيط يطرق الباب القديم بمفتاح قديم إلى الأبد.
                     destination = self.destinations.get(user) or destination
+                    if getattr(sender,'sticky_mode',None)=='light' and self._light_count(except_sender=sender)>=max(0,int(os.getenv('YOUTUBE_LIGHT_MAX','1'))):
+                        sender.sticky_mode=None
+                        self.log(user,'[RELAY] سقف الترميز الخفيف ممتلئ؛ هذا المذيع يبقى copy')
                     try:
                         self.log(user,'[RELAY] @%s starting (%s)'%(user,self._source_brief(candidate)))
                         if sender.send(user,candidate,destination,stop, refresh=lambda: self._refresh_flv(user)):sent=True
                     except RelayStartError as e:
                         self.log(user,'[RELAY] @%s start failed; trying fallback (%s)'%(user,self.safe_error(e)[:90]))
                         if candidate is not None:self.mark_unstable(user,candidate,'start failed')
+                        self._copy_recovery_miss(key,user,'start failed')
                         continue
                     except SourceStalled as e:
                         # Signed URLs in the hold cache are stale once bytes stop. Drop the
@@ -950,6 +970,7 @@ class ManagedYouTube:
                         stalled=True
                         self._skip_probe_once[user]=True
                         self.retry[user]=self.retry_min
+                        self._copy_recovery_miss(key,user,'stalled out=0')
                         break
                     except FormatChanged:
                         # Source resolution/layout changed (PK round started or ended, app
@@ -1006,6 +1027,7 @@ class ManagedYouTube:
                 cand=getattr(snd,'current_candidate',None) if snd else None
                 if cand and cand.get('url'):
                     self._good_copy[user]=dict(cand)
+                    self._recover_copy.discard(user)
                     break
         except Exception:
             pass
@@ -1206,6 +1228,23 @@ class ManagedYouTube:
                 preferred.insert(0, _alt)
                 self.log(user, '[WATCHDOG] @%s FLV starved; trying fallback %s'%(user,str(_alt.get('media') or 'alt').upper()))
         ordered=preferred+demoted
+        if user in getattr(self,'_recover_copy',set()):
+            def _shortside(c):
+                try:return min(int(c.get('width') or 0), int(c.get('height') or 0))
+                except (TypeError, ValueError):return 0
+            def _720(c):
+                s=_shortside(c)
+                if 700<=s<=900:return True
+                lab=str(c.get('label') or c.get('brief') or c.get('quality_name') or '').lower()
+                if 'origin' in lab or '1920' in lab:return False
+                return 'hd' in lab and 'h264' in lab
+            ranked=[c for c in ordered if _720(c)]
+            rest=[c for c in ordered if c not in ranked]
+            if ranked:
+                ordered=ranked+rest
+                self.log(user,'[SOURCE] @%s COPY_RECOVERY: %d مرشح فئة 720 قبل origin'%(user,len(ranked)))
+            else:
+                self.log(user,'[SOURCE] @%s COPY_RECOVERY بلا فئة 720 — نُبقي الترتيب ونُمهل out=0 12ث'%user)
         self.log(user,'[SOURCE] @%s selecting source (%d candidates)'%(user,len(ordered)))
         if self._skip_probe_once.pop(user, False):
             # After a stall, HTTP probe of every rendition took ~15s of relays=0 (measured).
@@ -1711,11 +1750,14 @@ class ManagedYouTube:
             if life=='live' and 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.
+            # liveStarting = transition already requested. Stopping FFmpeg here is the
+            # spinner: YouTube waits for ingest, we refuse to send. Measured On @a3dam_111
+            # 2026-09-28: youtube_status=liveStarting, relay_pid=None, events=1.
             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)
+            self._output_freeze_watchdog(key,user,ev)
             return
 
         # life is expected to be 'ready' or 'testing' for a newly bound event
@@ -1748,15 +1790,133 @@ class ManagedYouTube:
                 elif not ev.get('note'):
                     self.event_note(key,'انتظار تأكيد استقبال يوتيوب قبل بدء الحدث')
 
+
+
+
+    def _copy_recovery_miss(self, key, user, why):
+        if user not in getattr(self,'_recover_copy',set()):
+            return
+        ev=self.journal.read()['events'].get(key) or {}
+        n=int(ev.get('copy_recovery_fail') or 0)+1
+        self.event_update(key, copy_recovery_fail=n)
+        self.log(user,'[RELAY] COPY_RECOVERY miss ×%d (%s)'%(n, why))
+        if n>=2:
+            self._recover_copy.discard(user)
+            entry=self.senders.get(key) or {}
+            snd=entry.get('sender')
+            if snd and self._maybe_light(user, snd, 'copy recovery out=0 ×%d'%n, key=key):
+                self.log(user,'[RELAY] نعود light على نفس الحدث بعد فشل copy recovery')
+
+    def _maybe_copy_recovery(self, key, user, ev, snd):
+        """Hysteresis: light → copy only after H264 + YT health good for recovery window.
+
+        First H264 packet is not enough (oscillation). Window default 45s = one fast
+        YouTube health cycle (measured YOUTUBE_HEALTH_FAST_INTERVAL).
+        """
+        if not snd or getattr(snd,'sticky_mode',None)!='light':
+            if snd: snd.copy_ok_since=None
+            return False
+        health=(ev.get('youtube_health') or getattr(snd,'yt_health','') or '')
+        cand=snd.current_candidate or {}
+        blob=(str(cand.get('codec') or '')+' '+str(cand.get('label') or '')+' '+str(cand.get('brief') or '')).lower()
+        h264=any(k in blob for k in ('h264','avc'))
+        if health not in ('good','ok') or not h264:
+            snd.copy_ok_since=None
+            return False
+        now=time.monotonic()
+        if snd.copy_ok_since is None:
+            snd.copy_ok_since=now
+            snd.relay_state='TRANSCODE_STABLE'
+            return False
+        need=float(os.getenv('YOUTUBE_COPY_RECOVERY_SECONDS','45'))
+        if now-snd.copy_ok_since<need:
+            return False
+        fails=int(ev.get('copy_recovery_fail') or 0)
+        if fails>=2:
+            self.log(user,'[RELAY] COPY_RECOVERY فشل مرتين هذه الجلسة؛ نُبقي light (لا oscillation)')
+            return False
+        snd.sticky_mode=None
+        snd.relay_state='COPY_RECOVERY'
+        snd.transcode_reason=''
+        self._held.pop(user, None)
+        self._skip_hold.add(user)
+        getattr(self,'_recover_copy',None)
+        if not hasattr(self,'_recover_copy'):
+            self._recover_copy=set()
+        self._recover_copy.add(user)
+        self.event_update(key, force_light=False, copy_recovery=True)
+        self.log(user,'[RELAY] H264 مستقر %.0fs وyoutube_health=%s — عودة copy (فئة 720، مصدر منعش) على نفس الحدث'%(need,health))
+        self.stop_sender(key)
+        return True
+
+    def _light_count(self, except_sender=None):
+        n=0
+        for e in (self.senders or {}).values():
+            snd=e.get('sender')
+            if not snd or snd is except_sender:
+                continue
+            try:
+                if snd.sticky_mode=='light' or snd.send_mode()=='light':
+                    n+=1
+            except Exception:
+                pass
+        return n
+
+    def _maybe_light(self, user, sender, why, key=None):
+        cap=max(0,int(os.getenv('YOUTUBE_LIGHT_MAX','1')))
+        if cap<=0:
+            return False
+        if self._light_count(except_sender=sender)>=cap:
+            self.log(user,'[RELAY] ترميز خفيف عند السقف (%d)؛ نُبقي copy'%cap)
+            return False
+        sender.sticky_mode='light'
+        sender.relay_state='TRANSCODE_FALLBACK'
+        sender.transcode_reason=str(why or '')[:160]
+        sender.transcode_since=time.monotonic()
+        sender.copy_ok_since=None
+        if key:
+            self.event_update(key, force_light=True)
+        self.log(user,'[RELAY] copy لم يحقق ingest مستقر (%s) — ترميز خفيف ultrafast 1800k GOP 2ث'%why)
+        return True
+
+    def _output_freeze_watchdog(self, key, user, ev):
+        """YouTube health=good is not a moving picture. Frozen out_time = frozen frame.
+
+        Measured: mrjooj_7 copy out=123s for ~60s, source_age 61s, youtube_health=good.
+        """
+        entry=self.senders.get(key) or {}
+        snd=entry.get('sender')
+        try:
+            snap=snd.snapshot() if snd else {}
+            out=float((snap or {}).get('output_seconds') or 0)
+            alive=bool(snd and snd.alive())
+        except Exception:
+            return
+        now=time.monotonic()
+        prev=self._last_out.get(key)
+        if out>=1.0 and prev and out<=prev[0]+0.15:
+            if alive and now-prev[1]>=12.0 and self._yt_public(ev):
+                self.log(user,'[WATCHDOG] out_time مجمّد %.0fs (%.1fث) والصحة يوتيوب=%s — إعادة copy نفس الحدث'%(now-prev[1], out, ev.get('youtube_health') or ''))
+                self._last_out.pop(key, None)
+                self.stop_sender(key)
+                return
+            return
+        self._last_out[key]=(out, now)
+
     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.
+        FFmpeg alive is not proof of ingest. noData/bad + fresh source_age → restart copy;
+        after ≥2 copy restarts escalate to light (capped). same broadcast_id.
         """
         health=(ev.get('youtube_health') or '')
         if health in ('good','ok'):
             self._ingest_bad_since.pop(key,None)
+            entry=self.senders.get(key) or {}
+            snd=entry.get('sender')
+            if snd:
+                snd.yt_health=health
+                self._maybe_copy_recovery(key,user,ev,snd)
             return
         if health not in ('noData','bad','noStream'):
             return
@@ -1786,6 +1946,12 @@ class ManagedYouTube:
         if now-since<wait:
             return
         self._ingest_bad_since[key]=now
+        retries=int(ev.get('copy_retries') or 0)+1
+        self.event_update(key, copy_retries=retries)
+        if retries>=2 and snd:
+            if self._maybe_light(user, snd, 'noData/bad ×%d'%retries, key=key):
+                self.stop_sender(key)
+                return
         self.log(user,'[WATCHDOG] يوتيوب ingest=%s والمصدر يتدفق (age=%s ث)؛ إعادة copy على نفس الحدث %s'%(health,age,ev.get('broadcast_id') or ''))
         self.stop_sender(key)
 
@@ -1816,10 +1982,32 @@ 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)
+        # GOP too long / starved ingest → YouTube loading. bitrateLow alone is not enough
+        # (measured: 3× H264 copy ~1 Mbps stayed good/ok at ~8% CPU).
+        hard=any(k in (text or '') for k in ('gopSizeLong','openGop','videoIngestionStarved'))
+        entry=self.senders.get(key) or {}
+        snd=entry.get('sender')
+        if snd:
+            snd.yt_health=health.get('status','')
+        if hard:
+            if snd and self._maybe_light(user, snd, text[:80], key=key):
+                self.stop_sender(key)
+                return
+        if snd:
+            self._maybe_copy_recovery(key,user,self.journal.read()['events'].get(key) or ev,snd)
     def run_manager(self):
         checked=False
         last_tick=0.0
         try:
+            # Journal force_light survives Space rebuild and started origin 1920 as light
+            # at 90–100% of 2 cores (On 2026-09-28). Copy-first on boot; light only from
+            # a live ingest fault in this process.
+            try:
+                for _k,_ev in list(self.journal.read()['events'].items()):
+                    if _ev.get('force_light') or _ev.get('copy_recovery_fail'):
+                        self.event_update(_k, force_light=False, copy_recovery_fail=0)
+            except Exception:
+                pass
             while not self.manager_stop.is_set():
                 delay=self.scan
                 try: