channel-worker 2.5.40 → 2.5.43

package/lib/api-client.js

@@ -173,6 +173,26 @@ class ApiClient {
   async postExtensionLog({ level = 'info', message = '', data = null, profile_id = '', job_id = null } = {}) {
     return this.request('POST', '/extension/log', { level, message, data, profile_id, job_id });
   }
+
+  // Persist a browser screenshot captured by a Playwright publish script.
+  // The API stores the bytes on the media server; only the returned path/URL
+  // is written into extension_log, never the base64 payload itself.
+  async uploadDebugScreenshot({ filePath, tag = 'failure', command_id = '', job_id = '', profile_id = '', platform = '' } = {}) {
+    const fs = require('fs');
+    const path = require('path');
+    if (!filePath) throw new Error('debug screenshot filePath required');
+    const file = fs.readFileSync(filePath);
+    return this.request('POST', '/extension/debug-screenshot', {
+      image_base64: file.toString('base64'),
+      content_type: 'image/png',
+      file_name: path.basename(filePath),
+      tag,
+      command_id,
+      job_id,
+      profile_id,
+      platform,
+    });
+  }
 }
 
 module.exports = { ApiClient };

package/lib/command-poller.js

@@ -286,6 +286,17 @@ class CommandPoller {
       this.api.postExtensionLog?.({ level, message, data, profile_id: profileId, job_id: payload.job_id || null })
         .catch(() => {});
     };
+    // Publish scripts attach screenshots to warning logs through this helper.
+    // Keep the command/job identity here so the API and idea Publish History
+    // can associate an artifact with the exact platform attempt.
+    log.uploadDebugScreenshot = (filePath, meta = {}) => this.api.uploadDebugScreenshot({
+      filePath,
+      tag: meta.tag || 'failure',
+      command_id: String(command._id),
+      job_id: payload.job_id || '',
+      profile_id: profileId,
+      platform: scriptName.replace(/^upload_/, ''),
+    });
 
     try {
       const result = await runPlaywrightScript({
@@ -1443,6 +1454,33 @@ class CommandPoller {
       const domQ = typeof queueInfo === 'number' ? queueCount : (queueInfo?.dom_count || 0);
       if (!queueCount) { this._dispatching = false; return; }
 
+      // 4b. WHO can actually claim that queue. An idea pinned to one renderer
+      //     produces commands only that profile may claim — a raw total told us
+      //     "there's work, open another profile", the freshly-opened profile
+      //     claimed nothing, the round-robin below closed it as idle, and the
+      //     next cycle reopened it: a browser blinking open/closed every 5s
+      //     (observed on i5-pc: idea pinned to veo3-pro1, veo3-pro4 flapping).
+      //     unpinned_count === null means an older API that doesn't report the
+      //     breakdown → fall back to the previous "everything is claimable".
+      const unpinnedCount = (queueInfo && typeof queueInfo.unpinned_count === 'number')
+        ? queueInfo.unpinned_count
+        : null;
+      const pinnedMap = (queueInfo && queueInfo.pinned && typeof queueInfo.pinned === 'object')
+        ? queueInfo.pinned
+        : {};
+      const pinnedFor = (r) => {
+        const id = String(r?.nst_profile_id || '');
+        if (!id) return 0;
+        if (typeof pinnedMap[id] === 'number') return pinnedMap[id];
+        const lower = id.toLowerCase();
+        for (const k of Object.keys(pinnedMap)) {
+          if (k.toLowerCase() === lower) return pinnedMap[k];
+        }
+        return 0;
+      };
+      // Can this renderer claim anything at all right now?
+      const canClaim = (r) => (unpinnedCount === null) || unpinnedCount > 0 || pinnedFor(r) > 0;
+
       // 5. Parallel limit — sourced from THIS daemon's Worker.parallel_limit
       //    via /workers/me. Replaces the legacy global Settings
       //    (flowkit_max_concurrent / veo3_parallel_limit) which throttled
@@ -1476,7 +1514,19 @@ class CommandPoller {
         && (!r.pause_until || new Date(r.pause_until).getTime() > Date.now());
       let stillOffline = renderers.filter(r => !runningRenderers.includes(r) && !isPaused(r));
       const pausedCount = renderers.filter(isPaused).length;
-      console.log(`[scene-dispatch] running=${runningRenderers.length} cap=${parallelLimit} (flowkit=${flowkitQ} dom=${domQ}) offline=${stillOffline.length} paused=${pausedCount} queue=${queueCount} names=[${runningRenderers.map(r=>r.name)}]`);
+      const pinSummary = unpinnedCount === null
+        ? 'pins=n/a'
+        : `unpinned=${unpinnedCount} pins=${JSON.stringify(pinnedMap)}`;
+      console.log(`[scene-dispatch] running=${runningRenderers.length} cap=${parallelLimit} (flowkit=${flowkitQ} dom=${domQ}) offline=${stillOffline.length} paused=${pausedCount} queue=${queueCount} ${pinSummary} names=[${runningRenderers.map(r=>r.name)}]`);
+
+      // Offline renderers that could actually claim something. Everything else
+      // must stay closed — opening it would only produce the flap described
+      // above (open → claim nothing → closed as idle → reopen).
+      let launchable = stillOffline.filter(canClaim);
+      if (stillOffline.length > launchable.length) {
+        const blocked = stillOffline.filter(r => !canClaim(r)).map(r => r.name || r.nst_profile_id);
+        console.log(`[scene-dispatch] not launching [${blocked.join(',')}] — the whole queue is pinned to another renderer`);
+      }
 
       // ROUND-ROBIN ROTATION — when a running renderer just finished its
       // scene (no in-flight cmd) AND there's at least one OFFLINE sibling
@@ -1490,7 +1540,10 @@ class CommandPoller {
       // Round-robin close-idle is a SHARED-ACCOUNT safety (keep ≤1 Flow session
       // live per Google account). With independent_accounts every renderer is
       // its own account → skip it entirely and let them all run concurrently.
-      if (!independentAccounts && queueCount > 0 && stillOffline.length > 0 && runningRenderers.length > 0) {
+      // Rotate only when there is a sibling that can actually take over the
+      // remaining work — rotating toward a renderer the queue is not pinned to
+      // just closes a useful profile and opens a useless one.
+      if (!independentAccounts && queueCount > 0 && launchable.length > 0 && runningRenderers.length > 0) {
         const stoppedNames = [];
         for (const r of [...runningRenderers]) {
           // Skip externally-launched profiles (user opened manually via NST UI)
@@ -1523,7 +1576,9 @@ class CommandPoller {
       // the launcher picks the round-robin partner, not the one that just
       // finished. API populates last_command_assigned_at on every claim,
       // so this naturally implements turn-taking across siblings.
-      stillOffline = stillOffline.slice().sort((a, b) => {
+      // Re-filter first: the round-robin above may have pushed a just-closed
+      // renderer back into stillOffline.
+      launchable = stillOffline.filter(canClaim).slice().sort((a, b) => {
         const ta = a.last_command_assigned_at ? new Date(a.last_command_assigned_at).getTime() : 0;
         const tb = b.last_command_assigned_at ? new Date(b.last_command_assigned_at).getTime() : 0;
         return ta - tb;
@@ -1543,11 +1598,11 @@ class CommandPoller {
       const needNew = Math.max(0, queueCount);
       const neededLaunches = Math.min(
         parallelLimit - runningRenderers.length,
-        stillOffline.length,
+        launchable.length,
         needNew,
       );
       for (let li = 0; li < Math.max(0, neededLaunches); li++) {
-        const toLaunch = stillOffline[li];
+        const toLaunch = launchable[li];
         console.log(`[scene-dispatch] Launching ${toLaunch.name} (${runningRenderers.length + li + 1}/${parallelLimit})`);
         try {
           await this._launchRendererProfile(toLaunch);
@@ -1793,14 +1848,33 @@ class CommandPoller {
       const running = await this.nst.getRunningBrowsers();
       if (running.length === 0) return;
 
-      // Check if there are any queued commands — if so, don't close anything
+      // Check if there are any queued commands — if so, don't close anything.
+      // Exception: a queue that is ENTIRELY pinned to specific renderers keeps
+      // every other open profile idle forever, so it must not block the idle
+      // close (each profile is still spared individually below if the queue
+      // holds work pinned to it).
       const qi = await this.api.getSceneQueueCount();
       const queueCount = typeof qi === 'number' ? qi : (qi?.total || 0);
-      if (queueCount > 0) return;
+      const unpinnedCount = (qi && typeof qi.unpinned_count === 'number') ? qi.unpinned_count : null;
+      const pinnedMap = (qi && qi.pinned && typeof qi.pinned === 'object') ? qi.pinned : {};
+      const pinnedForId = (id) => {
+        if (!id) return 0;
+        if (typeof pinnedMap[id] === 'number') return pinnedMap[id];
+        const lower = String(id).toLowerCase();
+        for (const k of Object.keys(pinnedMap)) {
+          if (k.toLowerCase() === lower) return pinnedMap[k];
+        }
+        return 0;
+      };
+      // Old API (no breakdown) → previous behaviour: any queue blocks closing.
+      if (queueCount > 0 && (unpinnedCount === null || unpinnedCount > 0)) return;
 
       for (const browser of running) {
         const profileId = browser.profileId;
         const name = browser.name?.toLowerCase();
+        // Queue holds work pinned to THIS profile → it's about to be claimed,
+        // leave the browser open.
+        if (pinnedForId(profileId) > 0 || pinnedForId(name) > 0) continue;
         // Match by UUID or name (renderers use name as nst_profile_id)
         const lastActivity = this._profileLastActivity[profileId]
           || (name && this._profileLastActivity[name])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "channel-worker",
-  "version": "2.5.40",
+  "version": "2.5.43",
   "description": "Channel Manager worker daemon — runs on remote machines to execute video pipeline jobs",
   "main": "lib/daemon.js",
   "bin": {

package/scripts/upload_facebook.js

@@ -35,11 +35,11 @@ async function isActionable(el) {
   return true;
 }
 
-async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button' } = {}) {
+async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button', clickOpts = null } = {}) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await isActionable(loc)) {
-      await loc.click();
+      await loc.click(clickOpts || undefined);
       return;
     }
     await loc.page().waitForTimeout(800);
@@ -47,6 +47,106 @@ async function waitAndClick(loc, { timeoutMs = 60_000, log, label = 'button' } =
   throw new Error(`${label} never became actionable within ${timeoutMs}ms`);
 }
 
+// FB drops a "Thông báo mới" toast at the BOTTOM-LEFT of the wall (e.g. "… và
+// 96 người khác thích thước phim của bạn") that lands ON TOP of the Reels
+// composer's bottom CTA. Playwright's hit-target check then blocks every
+// click — "<b>96 người khác</b> from <div data-visualcompletion='ignore'>
+// subtree intercepts pointer events" — and the job dies at step 1 even though
+// the button is visible + enabled. Same story for the feed hover-cards behind
+// the modal. This mutes whatever sits over the button's centre point: from
+// elementFromPoint, walk up to the outermost ancestor that still does NOT
+// contain the target (= the toast/hover-card portal root) and kill its
+// pointer-events. Muted nodes are tagged so we can restore them right after
+// the click — leaving a portal permanently dead could break a later step that
+// renders into the same container. Returns how many layers were muted.
+async function muteClickInterceptors(page, selector) {
+  return page.evaluate((sel) => {
+    const el = document.querySelector(sel);
+    if (!el) return 0;
+    const r = el.getBoundingClientRect();
+    const cx = r.x + r.width / 2;
+    const cy = r.y + r.height / 2;
+    let muted = 0;
+    for (let pass = 0; pass < 4; pass++) {
+      const top = document.elementFromPoint(cx, cy);
+      if (!top || top === el || el.contains(top) || top.contains(el)) break;
+      let root = top;
+      while (root.parentElement && root.parentElement !== document.body && !root.parentElement.contains(el)) {
+        root = root.parentElement;
+      }
+      if (root === document.body || root.contains(el)) break;
+      // Already muted and STILL on top (a stylesheet !important beats our
+      // inline style) — muting again would overwrite the saved original with
+      // 'none' and leave the node permanently dead after the restore.
+      if (root.hasAttribute('__fbpw_muted__')) break;
+      root.setAttribute('__fbpw_muted__', root.style.pointerEvents || '_');
+      root.style.pointerEvents = 'none';
+      muted++;
+    }
+    return muted;
+  }, selector).catch(() => 0);
+}
+
+async function unmuteClickInterceptors(page) {
+  return page.evaluate(() => {
+    document.querySelectorAll('[__fbpw_muted__]').forEach((el) => {
+      const prev = el.getAttribute('__fbpw_muted__');
+      el.style.pointerEvents = prev === '_' ? '' : prev;
+      el.removeAttribute('__fbpw_muted__');
+    });
+  }).catch(() => {});
+}
+
+// Click that survives FB's overlay noise. Order of escalation:
+//   1. park the cursor in a corner (a mouse resting over the feed behind the
+//      modal keeps a hover-card alive right on top of the CTA),
+//   2. native click — highest fidelity,
+//   3. on failure, mute whatever intercepts the click point and retry natively,
+//   4. last resort, JS-dispatch el.click() (bypasses hit-testing entirely).
+// `jsFallback:false` for actions that must never fire twice (publish) — those
+// call sites run their own guarded fallback.
+// `landedCheck` guards the escalation: Playwright can report a timeout for a
+// click that DID register (the node detaches mid-action). Callers pass a probe
+// for "the UI already moved on" so we don't fire a second click on top of it.
+async function resilientClick(page, loc, selector, { timeout = 10_000, log, label = 'button', jsFallback = true, attempts = 3, landedCheck = null } = {}) {
+  try { await loc.scrollIntoViewIfNeeded({ timeout: 3000 }); } catch {}
+  await page.mouse.move(2, 2).catch(() => {});
+  let lastErr = null;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      await loc.click({ timeout });
+      await unmuteClickInterceptors(page);
+      return 'native';
+    } catch (e) {
+      lastErr = e;
+      if (landedCheck && await landedCheck().catch(() => false)) {
+        if (log) log('info', `[fb-pw] ${label} click reported a timeout but the UI advanced → treating as clicked`);
+        await unmuteClickInterceptors(page);
+        return 'landed';
+      }
+      const muted = await muteClickInterceptors(page, selector);
+      if (log) log('warn', `[fb-pw] ${label} click attempt ${attempt + 1}/${attempts} failed (${e.message.split('\n')[0].slice(0, 70)}) — muted ${muted} overlay layer(s)`);
+      await page.waitForTimeout(500);
+    }
+  }
+  if (jsFallback) {
+    const ok = await page.evaluate((sel) => {
+      const el = document.querySelector(sel);
+      if (!el) return false;
+      el.scrollIntoView({ block: 'center' });
+      el.click();
+      return true;
+    }, selector).catch(() => false);
+    if (ok) {
+      if (log) log('info', `[fb-pw] ${label} clicked via JS-dispatch fallback`);
+      await unmuteClickInterceptors(page);
+      return 'js';
+    }
+  }
+  await unmuteClickInterceptors(page);
+  throw lastErr || new Error(`${label}: click failed`);
+}
+
 // Same inventory dump as iter-2 (kept for failure diagnostics).
 async function dumpInventory(page, log, tag) {
   try {
@@ -119,7 +219,19 @@ async function dumpFailure(page, tag, log) {
     fs.mkdirSync(dir, { recursive: true });
     const png = path.join(dir, `fb-${tag}-${Date.now()}.png`);
     await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
-    log('warn', `[fb-pw] dump ${tag} — url=${page.url()} screenshot=${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[fb-pw] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[fb-pw] dump ${tag} — url=${page.url()} screenshot=${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
   } catch {}
 }
 
@@ -283,7 +395,7 @@ async function run({ page, payload, log }) {
   } = payload || {};
   if (!video_url) throw new Error('No video_url provided');
 
-  log('info', '[fb-pw] selectors version=2026.06.19d-reels-link-fallback');
+  log('info', '[fb-pw] selectors version=2026.08.02-overlay-proof-cta');
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
@@ -929,8 +1041,12 @@ async function run({ page, payload, log }) {
           if (!bestEl) bestEl = tryScope(null);
           if (!bestEl) return null;
           // Tag the element so Playwright can find it back. data-attribute is
-          // safe + ignored by FB's React reconciliation.
+          // safe + ignored by FB's React reconciliation. Clear stale markers
+          // FIRST: a click that threw never reached the cleanup below, so an
+          // old node could still carry the marker → the locator would resolve
+          // to 2 elements and every later click dies on strict mode.
           const marker = '__fbpw_target__';
+          document.querySelectorAll(`[${marker}]`).forEach((n) => n.removeAttribute(marker));
           bestEl.setAttribute(marker, '1');
           return { selector: `[${marker}='1']`, tag: bestEl.tagName.toLowerCase() };
         }, { verb: v, bottomHalf: requireBottomHalf });
@@ -938,17 +1054,23 @@ async function run({ page, payload, log }) {
           const loc = page.locator(found.selector);
           return {
             hit: {
-              click: async (opts) => {
-                // scrollIntoViewIfNeeded handles off-screen primary actions
-                // (e.g. Chia sẻ ngay at y=-274 after a step jump). Then
-                // Playwright's click auto-waits visible+stable.
-                try { await loc.scrollIntoViewIfNeeded({ timeout: 3000 }); } catch {}
-                await loc.click({ timeout: opts?.timeout || 5000 });
+              click: async (opts = {}) => {
+                // resilientClick handles scroll-into-view (off-screen primary
+                // actions like Chia sẻ ngay at y=-274 after a step jump) and,
+                // more importantly, FB's toast/hover-card overlays that cover
+                // the CTA and make Playwright's hit-target check fail forever.
+                await resilientClick(page, loc, found.selector, {
+                  timeout: opts?.timeout || 10_000,
+                  log,
+                  label: opts?.label || v,
+                  jsFallback: opts?.jsFallback !== false,
+                  landedCheck: opts?.landedCheck || null,
+                });
                 // Remove the marker so subsequent findByVerbs gets a fresh
                 // element instead of clinging to the now-stale node.
-                await page.evaluate((sel) => {
-                  document.querySelectorAll(sel).forEach((el) => el.removeAttribute(sel.replace(/[\[\]'=1]/g, '')));
-                }, found.selector).catch(() => {});
+                await page.evaluate(() => {
+                  document.querySelectorAll('[__fbpw_target__]').forEach((el) => el.removeAttribute('__fbpw_target__'));
+                }).catch(() => {});
               },
               isVisible: async () => loc.isVisible().catch(() => false),
               isEnabled: async () => loc.isEnabled().catch(() => true),
@@ -1565,6 +1687,23 @@ async function run({ page, payload, log }) {
           // the user re-posted → duplicate reel. So: if the button vanished
           // after we clicked, it went through.
           const publishBtnGone = async () => !(await findByVerbs(publishVerbs, { requireBottomHalf: true }));
+          // Marker-free twin of publishBtnGone, for use DURING a click retry:
+          // findByVerbs re-tags __fbpw_target__, which would yank the marker
+          // out from under the locator we're mid-click on.
+          const publishBtnGoneDom = async () => page.evaluate((verbs) => {
+            const scopes = [...document.querySelectorAll("[role='dialog']")];
+            for (const s of (scopes.length ? scopes : [document.body])) {
+              for (const b of s.querySelectorAll("button, [role='button']")) {
+                if (!verbs.includes((b.innerText || '').trim())) continue;
+                const r = b.getBoundingClientRect();
+                if (r.width < 8 || r.height < 8) continue;
+                if (r.y < window.innerHeight * 0.4) continue;
+                if (b.getAttribute('aria-disabled') === 'true' || b.disabled) continue;
+                return false;
+              }
+            }
+            return true;
+          }, publishVerbs).catch(() => false);
           for (let attempt = 0; attempt < 3 && !clickedPublish; attempt++) {
             const target = attempt === 0 ? pub : await findByVerbs(publishVerbs, { requireBottomHalf: true });
             if (!target) {
@@ -1573,7 +1712,16 @@ async function run({ page, payload, log }) {
             }
             attemptedClick = true;
             try {
-              await target.hit.click({ timeout: 15000 });
+              // jsFallback:false — publish must never fire twice. The guarded
+              // JS-dispatch below (attempt 3, after publishBtnGone checks) owns
+              // that escalation; the generic one inside resilientClick would
+              // bypass those guards. Overlay-muting + landedCheck still apply.
+              await target.hit.click({
+                timeout: 15000,
+                label: `Đăng(${step + 1})`,
+                jsFallback: false,
+                landedCheck: publishBtnGoneDom,
+              });
               clickedPublish = true;
             } catch (ce) {
               log('warn', `[fb-pw] publish click attempt ${attempt + 1}/3 threw: ${ce.message.slice(0, 90)}`);
@@ -1615,6 +1763,10 @@ async function run({ page, payload, log }) {
                   for (const b of btns) {
                     const t = (b.innerText || '').trim();
                     if (t === v) {
+                      // Clear stale markers first — a previous confirm attempt
+                      // that threw left its tag behind, and two tagged nodes
+                      // make the locator fail on strict mode.
+                      document.querySelectorAll('[__fbpw_confirm__]').forEach((n) => n.removeAttribute('__fbpw_confirm__'));
                       b.setAttribute('__fbpw_confirm__', '1');
                       return { selector: "[__fbpw_confirm__='1']", verb: v };
                     }
@@ -1628,8 +1780,18 @@ async function run({ page, payload, log }) {
           if (confirmHit) {
             log('info', `[fb-pw] confirming publish via dialog button "${confirmHit.verb}"`);
             const cLoc = page.locator(confirmHit.selector);
-            try { await cLoc.scrollIntoViewIfNeeded({ timeout: 2000 }); } catch {}
-            await cLoc.click({ timeout: 5000 }).catch((e) => log('warn', `[fb-pw] confirm click failed: ${e.message.slice(0, 80)}`));
+            // Was a plain 5s click: it failed on nearly EVERY run ("confirm
+            // click failed: Timeout 5000ms exceeded") because the new-post
+            // toast covers this dialog's CTA too. Escalate the same way —
+            // mute the overlay, then JS-dispatch. The confirm button lives in
+            // a dialog that disappears once it fires, so the fallback can't
+            // double-publish (querySelector returns null on the second pass).
+            await resilientClick(page, cLoc, confirmHit.selector, {
+              timeout: 8000,
+              log,
+              label: `confirm "${confirmHit.verb}"`,
+              attempts: 2,
+            }).catch((e) => log('warn', `[fb-pw] confirm click failed: ${e.message.split('\n')[0].slice(0, 80)}`));
             await page.waitForTimeout(3000);
           } else {
             log('info', '[fb-pw] no confirmation dialog detected after 8s — assuming direct publish');
@@ -1708,8 +1870,38 @@ async function run({ page, payload, log }) {
         throw new Error(`FB composer step ${step + 1}: neither publish nor Tiếp button found`);
       }
       log('info', `[fb-pw] click "${next.verb}" via "${next.sel}" (step ${step + 1})`);
+      // The composer's dialog aria-label names the current wizard step ("Tạo
+      // thước phim" → "Chỉnh sửa thước phim" → …). Snapshot it so a click that
+      // registered-then-timed-out is recognised instead of re-fired.
+      const composerStepLabel = async () => page.evaluate(() => {
+        const out = [];
+        document.querySelectorAll("[role='dialog']").forEach((d) => {
+          const r = d.getBoundingClientRect();
+          if (r.width < 8 || r.height < 8) return;
+          out.push(d.getAttribute('aria-label') || '');
+        });
+        return out.join('|');
+      }).catch(() => '');
+      const stepLabelBefore = await composerStepLabel();
       try {
-        await waitAndClick(next.hit, { timeoutMs: 180_000, log, label: `Tiếp(${step + 1})` });
+        await waitAndClick(next.hit, {
+          timeoutMs: 180_000,
+          log,
+          label: `Tiếp(${step + 1})`,
+          // 5s was too tight: FB's new-notification toast parks itself over the
+          // composer's bottom CTA and Playwright burns the whole budget on
+          // blocked retries. Give the click room + let it escalate (mute the
+          // overlay, then JS-dispatch), with landedCheck so we never advance
+          // the wizard twice.
+          clickOpts: {
+            timeout: 12_000,
+            label: `Tiếp(${step + 1})`,
+            landedCheck: async () => {
+              const now = await composerStepLabel();
+              return !!now && now !== stepLabelBefore;
+            },
+          },
+        });
       } catch (e) {
         await dumpInventory(page, log, `tiep-not-clickable-${step + 1}`);
         await dumpFailure(page, `tiep-not-clickable-${step + 1}`, log);
@@ -2145,3 +2337,6 @@ async function run({ page, payload, log }) {
 }
 
 module.exports = { run };
+// Exposed so the overlay-click escalation can be exercised against a synthetic
+// page (toast covering the CTA) without driving the whole upload flow.
+module.exports.__testables = { resilientClick, muteClickInterceptors, unmuteClickInterceptors };

package/scripts/upload_facebook_photo.js

@@ -47,7 +47,19 @@ async function dumpFailure(page, tag, log) {
     fs.mkdirSync(dir, { recursive: true });
     const png = path.join(dir, `fbphoto-${tag}-${Date.now()}.png`);
     await page.screenshot({ path: png, fullPage: false, timeout: 8000 }).catch(() => {});
-    log('warn', `[fbphoto] screenshot: ${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[fbphoto] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[fbphoto] screenshot: ${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
   } catch { /* ignore */ }
 }
 

package/scripts/upload_youtube.js

@@ -119,7 +119,19 @@ async function dumpFailure(page, tag, log) {
     const url = page.url();
     const title = await page.title().catch(() => '');
     const bodyHead = await page.evaluate(() => (document.body?.innerText || '').slice(0, 400)).catch(() => '');
-    log('warn', `[yt-pw] page dump on ${tag} — url=${url} | title=${title.slice(0, 80)} | head=${bodyHead.replace(/\s+/g, ' ').slice(0, 200)} | screenshot=${png}`);
+    let debugScreenshot = null;
+    if (fs.existsSync(png) && typeof log.uploadDebugScreenshot === 'function') {
+      try {
+        debugScreenshot = await log.uploadDebugScreenshot(png, { tag });
+      } catch (e) {
+        log('warn', `[yt-pw] debug screenshot upload failed: ${e.message}`);
+      }
+    }
+    log(
+      'warn',
+      `[yt-pw] page dump on ${tag} — url=${url} | title=${title.slice(0, 80)} | head=${bodyHead.replace(/\s+/g, ' ').slice(0, 200)} | screenshot=${debugScreenshot?.signed_url || png}`,
+      debugScreenshot ? { debug_screenshot: debugScreenshot } : { debug_screenshot_local_path: png },
+    );
 
     // Snapshot of every VISIBLE interactive element — so when Studio renames
     // an id or swaps a tag we see what's there instead.