channel-worker 2.5.55 → 2.5.57

package/scripts/nurture_facebook.js

@@ -20,6 +20,8 @@
 // lib/fb-guard so the API can stop the schedule and raise a notification.
 
 const { assertAccountUsable } = require('./lib/fb-guard');
+const { pick, clickHandle } = require('./lib/dom-pick');
+const { humanMove, humanWheel, humanClick } = require('./lib/human');
 
 // Every markup shape Facebook has used for "one post in the feed". Used by the
 // secondary helpers (ad check, open-post) via closest()/querySelectorAll;
@@ -38,22 +40,23 @@ function chance(p) { return Math.random() < p; }
 async function centerMouse(page) {
   const vp = await page.evaluate(() => ({ w: window.innerWidth, h: window.innerHeight })).catch(() => null);
   if (!vp) return;
-  const jitter = (n) => n + randInt(-40, 40);
-  await page.mouse.move(jitter(Math.floor(vp.w / 2)), jitter(Math.floor(vp.h / 2))).catch(() => {});
+  const jitter = (n) => n + randInt(-120, 120);
+  await humanMove(page, jitter(Math.floor(vp.w / 2)), jitter(Math.floor(vp.h / 2)));
 }
 
 // Scroll by `dy` and VERIFY the page moved. Falls back through three rungs:
-// wheel → re-center the cursor and wheel again → window.scrollBy. Returns the
+// wheel burst (lib/human: several decelerating notches, not one big event) →
+// re-center the cursor and wheel again → window.scrollBy. Returns the
 // distance actually scrolled.
 async function humanScroll(page, dy) {
   const readY = () => page.evaluate(() => window.scrollY || document.documentElement.scrollTop || 0).catch(() => 0);
   const before = await readY();
-  await page.mouse.wheel(0, dy).catch(() => {});
+  await humanWheel(page, dy);
   await page.waitForTimeout(randInt(350, 700));
   let after = await readY();
   if (Math.abs(after - before) < 5) {
     await centerMouse(page);
-    await page.mouse.wheel(0, dy).catch(() => {});
+    await humanWheel(page, dy);
     await page.waitForTimeout(randInt(350, 700));
     after = await readY();
   }
@@ -73,7 +76,7 @@ async function humanScroll(page, dy) {
 async function dismissDialogs(page, log) {
   const verbs = ['Cho phép tất cả cookie', 'Allow all cookies', 'Để sau', 'Not now', 'Lúc khác', 'Không phải bây giờ', 'Bỏ qua', 'Skip', 'Đóng', 'Close', 'OK', 'Đã hiểu', 'Got it'];
   for (let round = 0; round < 3; round++) {
-    const hit = await page.evaluate((vs) => {
+    const { el } = await pick(page, (vs) => {
       for (const dlg of document.querySelectorAll("[role='dialog']")) {
         const r = dlg.getBoundingClientRect();
         if (r.width < 8 || r.height < 8) continue;
@@ -83,18 +86,16 @@ async function dismissDialogs(page, log) {
           for (const b of dlg.querySelectorAll("[role='button'], button")) {
             const t = (b.innerText || '').trim();
             if ((t === v || (b.getAttribute('aria-label') || '').trim() === v) && b.offsetParent !== null) {
-              b.setAttribute('__nur_dismiss__', '1');
-              return v;
+              return { el: b, verb: v };
             }
           }
         }
       }
-      return null;
-    }, verbs).catch(() => null);
-    if (!hit) break;
-    try { await page.locator("[__nur_dismiss__='1']").click({ timeout: 2500 }); } catch {}
-    await page.evaluate(() => document.querySelectorAll('[__nur_dismiss__]').forEach(e => e.removeAttribute('__nur_dismiss__'))).catch(() => {});
-    await page.waitForTimeout(800);
+      return { el: null };
+    }, verbs);
+    if (!el) break;
+    await clickHandle(page, el, { hoverMs: [300, 900], timeout: 2500, scroll: false });
+    await page.waitForTimeout(randInt(600, 1300));
   }
 }
 
@@ -107,10 +108,11 @@ async function dismissDialogs(page, log) {
 // real scrolling. The key is the permalink id (falling back to a text prefix),
 // which travels with the content instead of the container.
 //
-// Also marks a like candidate in the same pass — one evaluate keeps the key
-// derivation in exactly one place instead of drifting across two copies.
+// Also picks a like candidate in the same pass — one evaluate keeps the key
+// derivation in exactly one place instead of drifting across two copies. The
+// candidate comes back as an ElementHandle (`likeEl`), never as a DOM mark.
 async function scanFeed(page, { skipKeys = [], wantLike = false } = {}) {
-  return page.evaluate(({ skip, wantLike }) => {
+  const { el, data } = await pick(page, ({ skip, wantLike }) => {
     const skipSet = new Set(skip);
 
     // WHICH element is "a post"? Not a fixed selector — Facebook's feed markup
@@ -157,7 +159,7 @@ async function scanFeed(page, { skipKeys = [], wantLike = false } = {}) {
       if (dist < bestDist) { best = art; bestDist = dist; bestKey = key; }
     }
 
-    let likeKey = null;
+    let likeKey = null, likeBtn = null;
     if (best) {
       for (const b of best.querySelectorAll("[role='button']")) {
         const aria = (b.getAttribute('aria-label') || '').trim();
@@ -165,7 +167,7 @@ async function scanFeed(page, { skipKeys = [], wantLike = false } = {}) {
         if (b.getAttribute('aria-pressed') === 'true') continue;   // already liked
         const br = b.getBoundingClientRect();
         if (br.width < 8 || br.height < 8 || b.offsetParent === null) continue;
-        b.setAttribute('__nur_like__', '1');
+        likeBtn = b;
         likeKey = bestKey;
         break;
       }
@@ -184,88 +186,121 @@ async function scanFeed(page, { skipKeys = [], wantLike = false } = {}) {
       }
     }
     return {
+      el: likeBtn,
       posts, likeKey, scroller, scrollTop,
       scrollY: Math.round(window.scrollY || document.documentElement.scrollTop || 0),
       articlesInDom: units.length,
       selector: sel || '(none)',
       sample: posts.slice(0, 3).map((p) => p.key.slice(0, 46)),
     };
-  }, { skip: skipKeys, wantLike }).catch(() => ({ posts: [], likeKey: null, scrollY: 0, articlesInDom: 0 }));
+  }, { skip: skipKeys, wantLike });
+  return { posts: [], likeKey: null, scrollY: 0, articlesInDom: 0, ...data, likeEl: el };
 }
 
-// Click the like button scanFeed already marked (`__nur_like__`). Returns true
-// on a confirmed like. The picking — skip ads, skip already-liked, never a
+// Click the like button scanFeed already picked (`likeEl`). Returns true on a
+// confirmed like. The picking — skip ads, skip already-liked, never a
 // comment's button — happened in scanFeed; this only performs the click.
-async function clickMarkedLike(page, log) {
-  const btn = page.locator("[__nur_like__='1']").first();
+async function clickPickedLike(page, btn, log) {
+  if (!btn) return false;
   let ok = false;
   try {
-    await btn.scrollIntoViewIfNeeded({ timeout: 3000 }).catch(() => {});
-    // Hover first, then a short beat — a real cursor travels before it clicks.
-    await btn.hover({ timeout: 3000 }).catch(() => {});
-    await page.waitForTimeout(randInt(500, 1400));
-    // MUST be a Playwright click: an el.click() from page.evaluate is synthetic
-    // and React's handler ignores it (same lesson as the YouTube ad-skip).
-    await btn.click({ timeout: 4000 });
+    // MUST be a Playwright input click: an el.click() from page.evaluate is
+    // synthetic and React's handler ignores it (same lesson as the YouTube
+    // ad-skip). humanClick travels the cursor there, hovers a beat, clicks
+    // off-centre.
+    await humanClick(page, btn, { hoverMs: [500, 1400], timeout: 4000 });
     await page.waitForTimeout(randInt(900, 1800));
     const pressed = await btn.evaluate((el) => el.getAttribute('aria-pressed')).catch(() => null);
     ok = pressed === null ? true : pressed === 'true';  // button gone/re-rendered → treat as done
   } catch (e) {
     log('info', `[nurture-fb] like failed: ${String(e.message || e).slice(0, 80)}`);
   }
-  await page.evaluate(() => document.querySelectorAll('[__nur_like__]').forEach(e => e.removeAttribute('__nur_like__'))).catch(() => {});
+  await btn.dispose().catch(() => {});
   if (ok) log('info', '[nurture-fb] liked a post');
   return ok;
 }
 
 // Watch a video that's playing in the feed, counting only seconds where
 // playback actually ADVANCES (a frozen/buffering player must not bank time).
-async function watchFeedVideo(page, minSec, maxSec, log) {
-  const has = await page.evaluate((UNIT) => {
-    const vids = [...document.querySelectorAll('video')];
-    for (const v of vids) {
+//
+// "Already watched" lives in `watchedKeys` on the Node side, keyed by the
+// video's source (falling back to the post's text prefix) — the same idea as
+// likedKeys. It used to be a `data-nur-watched` attribute written onto the
+// <video> element and never removed; see lib/dom-pick.js for why that's gone.
+async function watchFeedVideo(page, minSec, maxSec, watchedKeys, log) {
+  const { el: vid, data } = await pick(page, ({ UNIT, skip }) => {
+    const skipSet = new Set(skip);
+    for (const v of document.querySelectorAll('video')) {
       const r = v.getBoundingClientRect();
       if (r.height < 100 || r.bottom < 0 || r.top > window.innerHeight) continue;
       const art = v.closest(UNIT);
       // Ads are re-detected from text — a node flag would be stale the moment
       // FB recycles the article for a different post.
       if (art && /Được tài trợ|Sponsored/i.test((art.innerText || '').slice(0, 400))) continue;
-      if (v.hasAttribute('data-nur-watched')) continue;
-      v.setAttribute('data-nur-watched', '1');
-      if (v.paused) { try { v.play(); } catch {} }
-      return true;
+      const key = v.currentSrc || v.src || v.poster
+        || ('txt:' + ((art && art.innerText) || '').replace(/\s+/g, ' ').slice(0, 90));
+      if (skipSet.has(key)) continue;
+      return { el: v, key };
     }
-    return false;
-  }, UNIT_SEL).catch(() => false);
-  if (!has) return false;
+    return { el: null };
+  }, { UNIT: UNIT_SEL, skip: [...watchedKeys] });
+  if (!vid) return false;
+  watchedKeys.add(data.key);
+
+  // A real viewer clicks the player to start it, not HTMLMediaElement.play().
+  // The click is on the video itself; if it's already rolling FB ignores it
+  // (or toggles mute/fullscreen UI — harmless). Fall back to play() only if the
+  // click didn't get it going.
+  // Feed videos normally autoplay muted once in view, so this branch is rare.
+  const paused0 = await vid.evaluate((v) => v.paused).catch(() => true);
+  if (paused0) {
+    const urlBefore = page.url();
+    await humanClick(page, vid, { hoverMs: [300, 800], timeout: 3000 }).catch(() => {});
+    await page.waitForTimeout(randInt(600, 1200));
+    if (page.url() !== urlBefore) {
+      // Some cards open a viewer instead of playing inline — back out, and
+      // let the feed loop pick something else next tick.
+      await page.keyboard.press('Escape').catch(() => {});
+      await page.waitForTimeout(randInt(500, 1000));
+      if (page.url() !== urlBefore) await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+      await vid.dispose().catch(() => {});
+      return false;
+    }
+    await vid.evaluate((v) => { if (v.paused && !v.ended) { try { v.play(); } catch {} } }).catch(() => {});
+  }
 
   const budgetMs = randInt(minSec, maxSec) * 1000;
   let watched = 0, lastT = -1, frozen = 0;
   while (watched < budgetMs) {
-    const st = await page.evaluate(() => {
-      const v = document.querySelector("video[data-nur-watched='1']");
-      if (!v) return null;
-      if (v.paused && !v.ended) { try { v.play(); } catch {} }
+    const st = await vid.evaluate((v) => {
+      if (!v.isConnected) return null;
       return { t: Number(v.currentTime) || 0, ended: !!v.ended, dur: (isFinite(v.duration) && v.duration > 0) ? v.duration : 0, loop: !!v.loop };
     }).catch(() => null);
     if (!st) break;
     if (!st.loop && (st.ended || (st.dur > 0 && st.t >= st.dur - 0.6))) break;
     const advanced = st.t > lastT + 0.2 || st.t < lastT - 0.5; // forward, or loop wrap
-    if (advanced) { watched += 1000; frozen = 0; } else if (++frozen >= 6) break;
+    const step = randInt(700, 1400);
+    if (advanced) { watched += step; frozen = 0; } else if (++frozen >= 6) break;
     lastT = st.t;
-    await page.waitForTimeout(1000);
+    await page.waitForTimeout(step);
   }
-  // Release the marker so a later video in the feed can be picked.
-  await page.evaluate(() => document.querySelectorAll("video[data-nur-watched='1']").forEach(v => v.setAttribute('data-nur-watched', 'done'))).catch(() => {});
+  await vid.dispose().catch(() => {});
   if (watched > 0) log('info', `[nurture-fb] watched a feed video ~${Math.round(watched / 1000)}s`);
   return watched > 0;
 }
 
 // Open a post's permalink, read the comments for a bit, then go back.
 // Phase 2+. Best-effort: if the click doesn't navigate, nothing is lost.
-async function openPostAndRead(page, log) {
+//
+// Facebook ships most permalinks with target="_blank". This used to be patched
+// to target="_self" before the click — a DOM mutation on FB's own anchor, ~1s
+// before it gets clicked. Now the link is clicked exactly as rendered: if a
+// new tab opens, the reading happens THERE and the tab is closed afterwards
+// (that is what a person does; the feed also keeps its scroll position). If
+// it navigates in place or opens an overlay, fall back to goBack/Escape.
+async function openPostAndRead(page, context, tabGate, log) {
   const urlBefore = page.url();
-  const marked = await page.evaluate((UNIT) => {
+  const { el } = await pick(page, (UNIT) => {
     const mid = window.innerHeight / 2;
     let best = null, bestDist = Infinity;
     for (const art of document.querySelectorAll(UNIT)) {
@@ -278,42 +313,42 @@ async function openPostAndRead(page, log) {
       const dist = Math.abs((r.top + r.bottom) / 2 - mid);
       if (dist < bestDist) { best = art; bestDist = dist; }
     }
-    if (!best) return false;
+    if (!best) return { el: null };
     for (const a of best.querySelectorAll("a[href*='/posts/'], a[href*='/permalink/'], a[href*='story_fbid'], a[href*='/photo']")) {
       const r = a.getBoundingClientRect();
       if (r.width < 8 || r.height < 8 || a.offsetParent === null) continue;
-      // Facebook ships most permalinks with target="_blank": clicked as-is the
-      // post lands in a NEW tab while the script keeps driving the old one, so
-      // every opened post leaves a dead tab behind. Force same-tab — goBack()
-      // below is what returns us to the feed.
-      a.setAttribute('target', '_self');
-      a.setAttribute('__nur_open__', '1');
-      return true;
+      return { el: a };
     }
-    return false;
-  }, UNIT_SEL).catch(() => false);
-  if (!marked) return false;
-
-  try {
-    await page.locator("[__nur_open__='1']").first().click({ timeout: 4000 });
-  } catch {
-    await page.evaluate(() => document.querySelectorAll('[__nur_open__]').forEach(e => e.removeAttribute('__nur_open__'))).catch(() => {});
-    return false;
-  }
-  await page.evaluate(() => document.querySelectorAll('[__nur_open__]').forEach(e => e.removeAttribute('__nur_open__'))).catch(() => {});
-  await page.waitForTimeout(randInt(2500, 4000));
+    return { el: null };
+  }, UNIT_SEL);
+  if (!el) return false;
+
+  // Let guardSingleTab hand us the next tab instead of killing it.
+  let popup = null;
+  const waitPopup = context
+    ? new Promise((resolve) => { tabGate.resolve = resolve; })
+    : Promise.resolve(null);
+  tabGate.open = true;
+  const clicked = await clickHandle(page, el, { hoverMs: [400, 1100] });
+  if (!clicked) { tabGate.open = false; tabGate.resolve = null; return false; }
+  popup = await Promise.race([waitPopup, page.waitForTimeout(4000).then(() => null)]);
+  tabGate.open = false; tabGate.resolve = null;
+
+  const reader = popup || page;
+  if (popup) await popup.waitForLoadState('domcontentloaded', { timeout: 30000 }).catch(() => {});
+  await reader.waitForTimeout(randInt(2500, 4000));
 
   // Read comments: a couple of small scrolls with human pauses.
-  await centerMouse(page);
+  await centerMouse(reader);
   for (let i = 0; i < randInt(2, 4); i++) {
-    await humanScroll(page, randInt(200, 600));
-    await page.waitForTimeout(randInt(1500, 4000));
+    await humanScroll(reader, randInt(200, 600));
+    await reader.waitForTimeout(randInt(1500, 4000));
   }
-  log('info', '[nurture-fb] opened a post and read comments');
+  log('info', `[nurture-fb] opened a post and read comments${popup ? ' (tab mới)' : ''}`);
 
-  // Back to the feed. A photo/post overlay closes with Escape, a real
-  // navigation needs goBack — try both, feed check happens next loop.
-  if (page.url() !== urlBefore) {
+  if (popup) {
+    await popup.close({ runBeforeUnload: false }).catch(() => {});
+  } else if (page.url() !== urlBefore) {
     await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
   } else {
     await page.keyboard.press('Escape').catch(() => {});
@@ -325,7 +360,7 @@ async function openPostAndRead(page, log) {
 // Follow a page/creator surfaced by the feed itself (phase 3, ≤ config max).
 // Only clicks a Follow/Like-Page button that's already on screen — never hunts.
 async function followVisiblePage(page, log) {
-  const marked = await page.evaluate((UNIT) => {
+  const { el, data } = await pick(page, (UNIT) => {
     for (const b of document.querySelectorAll("[role='button'], a[role='button']")) {
       const t = (b.innerText || '').trim();
       const aria = (b.getAttribute('aria-label') || '').trim();
@@ -336,26 +371,70 @@ async function followVisiblePage(page, log) {
       if (r.bottom < 0 || r.top > window.innerHeight) continue;
       const art = b.closest(UNIT);
       if (art && /Được tài trợ|Sponsored/i.test((art.innerText || '').slice(0, 400))) continue; // not an ad's CTA
-      b.setAttribute('__nur_follow__', '1');
-      return label;
+      return { el: b, label };
     }
-    return null;
-  }, UNIT_SEL).catch(() => null);
-  if (!marked) return false;
-  let ok = false;
-  try {
-    const btn = page.locator("[__nur_follow__='1']").first();
-    await btn.hover({ timeout: 2500 }).catch(() => {});
-    await page.waitForTimeout(randInt(400, 1100));
-    await btn.click({ timeout: 4000 });
+    return { el: null };
+  }, UNIT_SEL);
+  if (!el) return false;
+  const ok = await clickHandle(page, el, { hoverMs: [400, 1100], scroll: false });
+  if (ok) {
     await page.waitForTimeout(randInt(1200, 2200));
-    ok = true;
-    log('info', `[nurture-fb] followed a page ("${marked}")`);
-  } catch {}
-  await page.evaluate(() => document.querySelectorAll('[__nur_follow__]').forEach(e => e.removeAttribute('__nur_follow__'))).catch(() => {});
+    log('info', `[nurture-fb] followed a page ("${data.label}")`);
+  }
   return ok;
 }
 
+// A short detour off the feed — the kind of thing that happens in any real
+// session and never happened in ours: peek at notifications, or open one's
+// own profile and glance at it. Best-effort, bilingual, never throws; if the
+// control isn't where we expect, we simply stay on the feed.
+async function sideTrip(page, log) {
+  const which = chance(0.6) ? 'notifications' : 'profile';
+  if (which === 'notifications') {
+    const { el } = await pick(page, () => {
+      for (const b of document.querySelectorAll("[role='banner'] [role='button'], [role='banner'] a, [aria-label]")) {
+        const a = (b.getAttribute('aria-label') || '').trim();
+        if (!/^(thông báo|notifications)$/i.test(a)) continue;
+        const r = b.getBoundingClientRect();
+        if (r.width < 8 || r.height < 8 || b.offsetParent === null) continue;
+        return { el: b };
+      }
+      return { el: null };
+    });
+    if (!el) return false;
+    if (!(await clickHandle(page, el, { hoverMs: [300, 900], scroll: false }))) return false;
+    await page.waitForTimeout(randInt(2500, 6000));
+    if (chance(0.6)) { await humanWheel(page, randInt(150, 400)); await page.waitForTimeout(randInt(1500, 4000)); }
+    await page.keyboard.press('Escape').catch(() => {});
+    await page.waitForTimeout(randInt(800, 1800));
+    log('info', '[nurture-fb] ghé xem thông báo');
+    return true;
+  }
+  const urlBefore = page.url();
+  const { el } = await pick(page, () => {
+    for (const a of document.querySelectorAll("[role='navigation'] a[href], [role='banner'] a[href]")) {
+      const href = a.getAttribute('href') || '';
+      const label = ((a.getAttribute('aria-label') || '') + ' ' + (a.innerText || '')).trim();
+      if (!(/\/me\/?(\?|$)/.test(href) || /trang cá nhân của bạn|your profile/i.test(label))) continue;
+      const r = a.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8 || a.offsetParent === null) continue;
+      return { el: a };
+    }
+    return { el: null };
+  });
+  if (!el) return false;
+  if (!(await clickHandle(page, el, { hoverMs: [300, 900], scroll: false }))) return false;
+  await page.waitForTimeout(randInt(3000, 6000));
+  if (page.url() === urlBefore) return false;
+  await centerMouse(page);
+  for (let i = 0; i < randInt(1, 3); i++) { await humanScroll(page, randInt(200, 600)); await page.waitForTimeout(randInt(1500, 4000)); }
+  await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+  await page.waitForTimeout(randInt(2000, 4000));
+  await centerMouse(page);
+  log('info', '[nurture-fb] ghé trang cá nhân rồi quay lại feed');
+  return true;
+}
+
 // Is this profile browsing AS A PAGE rather than as the person?
 //
 // Why it matters: a Page's feed contains only the Page's own posts, so there is
@@ -392,7 +471,7 @@ async function detectProfileMode(page) {
 // window is a wall of tabs.
 //
 // Closing them is safe: nurturing needs exactly one tab (the feed), and the
-// permalink click is forced to same-tab navigation in openPostAndRead.
+// permalink tab openPostAndRead deliberately opens is closed by it as well.
 async function closeOtherTabs(context, keep, log) {
   const before = context.pages().length;
   let closed = 0;
@@ -406,12 +485,19 @@ async function closeOtherTabs(context, keep, log) {
   return closed;
 }
 
-// Anything Facebook manages to pop open mid-session dies on arrival. Registered
-// once per session; the listener is scoped to this context, which the runner
-// detaches from when the script returns.
-function guardSingleTab(context, keep, log) {
+// Anything Facebook manages to pop open mid-session dies on arrival — EXCEPT
+// while `gate.open` is set: then the tab is handed to whoever is waiting on
+// `gate.resolve` (openPostAndRead clicking a target=_blank permalink) and they
+// own closing it. Registered once per session; the listener is scoped to this
+// context, which the runner detaches from when the script returns.
+function guardSingleTab(context, keep, gate, log) {
   context.on('page', async (p) => {
     if (p === keep || p.isClosed()) return;
+    if (gate.open && typeof gate.resolve === 'function') {
+      const r = gate.resolve; gate.resolve = null; gate.open = false;
+      r(p);
+      return;
+    }
     try {
       await p.close({ runBeforeUnload: false });
       log('info', '[nurture-fb] tab mới bị Facebook bung ra — đã đóng ngay');
@@ -446,23 +532,33 @@ async function run({ page, context, payload, log }) {
   const phase = Math.max(1, Math.min(3, parseInt(payload.phase, 10) || 1));
   const dayIndex = parseInt(payload.day_index, 10) || 1;
 
-  const sessionSec = randInt(cfg.session_min_sec ?? 480, cfg.session_max_sec ?? 900);
+  let sessionSec = randInt(cfg.session_min_sec ?? 480, cfg.session_max_sec ?? 900);
+  // ~8% of sessions end early — people get interrupted. The full-length
+  // "always runs to the deadline" shape was one of the tells.
+  const cutShort = chance(0.08);
+  if (cutShort) sessionSec = Math.round(sessionSec * randInt(35, 65) / 100);
   const likesTarget = randInt(cfg.likes_min ?? 0, cfg.likes_max ?? 0);
-  const likeGap = Math.max(1, cfg.like_gap_posts ?? 5);
+  // like_gap_posts is a centre: the actual gap is re-rolled after every like
+  // (gap-2 .. gap+3), so likes never land on a fixed every-Nth-post beat.
+  const likeGapBase = Math.max(1, cfg.like_gap_posts ?? 5);
+  const rollLikeGap = () => randInt(Math.max(1, likeGapBase - 2), likeGapBase + 3);
+  let likeGap = rollLikeGap();
   const videosMax = cfg.videos_max ?? 3;
   const openPostMax = cfg.open_post_max ?? 0;
   const followMax = cfg.follow_page_max ?? 0;
   const watchMin = cfg.video_watch_min_sec ?? 10;
   const watchMax = Math.max(watchMin, cfg.video_watch_max_sec ?? 30);
 
-  log('info', `[nurture-fb] session start — phase ${phase} (ngày ${dayIndex}), ~${Math.round(sessionSec / 60)} phút, like tối đa ${likesTarget}, video ≤${videosMax}`);
+  log('info', `[nurture-fb] session start — phase ${phase} (ngày ${dayIndex}), ~${Math.round(sessionSec / 60)} phút${cutShort ? ' (phiên ngắn)' : ''}, like tối đa ${likesTarget}, video ≤${videosMax}`);
 
   page.on('dialog', (d) => { d.accept().catch(() => {}); });
 
   // Clear the profile's leftovers BEFORE loading the feed, then keep it clear.
+  // tabGate lets openPostAndRead claim ONE deliberately-opened tab.
+  const tabGate = { open: false, resolve: null };
   if (context) {
     await closeOtherTabs(context, page, log);
-    guardSingleTab(context, page, log);
+    guardSingleTab(context, page, tabGate, log);
   }
 
   await page.goto('https://www.facebook.com/', { waitUntil: 'domcontentloaded', timeout: 60000 });
@@ -489,12 +585,17 @@ async function run({ page, context, payload, log }) {
   if (payload.debug) await dumpFeedShot(page, log, 'feed-start');
 
   let postsSeen = 0, likes = 0, videos = 0, pagesFollowed = 0, postsOpened = 0;
-  let postsSinceLike = likeGap;   // allow the first like once enough posts scroll by
+  // Start part-way through the gap, never at it: the first like used to be
+  // allowed on the very first post seen, ~10s into every session.
+  let postsSinceLike = randInt(0, Math.max(0, likeGap - 2));
+  let sideTrips = 0;
+  const sideTripsMax = randInt(0, 2);
   let ticks = 0, emptyTicks = 0, stuckScrolls = 0;
   const deadline = t0 + sessionSec * 1000;
 
   const seenKeys = new Set();    // post ids already counted (survives DOM recycling)
   const likedKeys = new Set();   // post ids already attempted — never twice
+  const watchedKeys = new Set(); // feed videos already watched (by source)
   let lastScan = { scrollY: 0, articlesInDom: 0 };
 
   while (Date.now() < deadline) {
@@ -522,7 +623,13 @@ async function run({ page, context, payload, log }) {
         emptyTicks = 0;
         await assertAccountUsable(page, log);
         log('info', '[nurture-fb] feed idle — quay lại đầu trang');
-        await page.evaluate(() => window.scrollTo({ top: 0, behavior: 'smooth' })).catch(() => {});
+        for (let i = 0; i < 6; i++) {
+          const y = await page.evaluate(() => window.scrollY || document.documentElement.scrollTop || 0).catch(() => 0);
+          if (y < 50) break;
+          await humanWheel(page, -Math.min(y, randInt(700, 1400)));
+          await page.waitForTimeout(randInt(250, 700));
+        }
+        await page.evaluate(() => { if (window.scrollY > 50) window.scrollTo({ top: 0, behavior: 'smooth' }); }).catch(() => {});
         await page.waitForTimeout(randInt(2000, 4000));
       }
     } else {
@@ -531,20 +638,25 @@ async function run({ page, context, payload, log }) {
 
     // Watch a feed video now and then (all phases — watching is passive).
     if (videos < videosMax && chance(0.22)) {
-      if (await watchFeedVideo(page, watchMin, watchMax, log)) videos++;
+      if (await watchFeedVideo(page, watchMin, watchMax, watchedKeys, log)) videos++;
     }
 
     // Like — phase 2+ only, never two posts in a row (enforced by likeGap).
     // scanFeed already marked the button; a post is only ever attempted once.
     if (wantLike && scan.likeKey) {
       likedKeys.add(scan.likeKey);
-      if (await clickMarkedLike(page, log)) { likes++; postsSinceLike = 0; }
+      if (await clickPickedLike(page, scan.likeEl, log)) { likes++; postsSinceLike = 0; likeGap = rollLikeGap(); }
       else postsSinceLike = Math.max(0, postsSinceLike - 1); // try another post later
     }
 
+    // A detour off the feed now and then (any phase — it's just looking).
+    if (sideTrips < sideTripsMax && ticks > 6 && chance(0.035)) {
+      if (await sideTrip(page, log)) sideTrips++;
+    }
+
     // Open a post to read comments — phase 2+.
     if (postsOpened < openPostMax && chance(0.05)) {
-      if (await openPostAndRead(page, log)) postsOpened++;
+      if (await openPostAndRead(page, context, tabGate, log)) postsOpened++;
     }
 
     // Follow a page the feed already showed — phase 3.