channel-worker 2.5.44 → 2.5.45

package/lib/api-client.js

@@ -68,7 +68,7 @@ class ApiClient {
   async getNextCommand(workerId) {
     // Daemon-handled types. `_pw` variants route to the Playwright pipeline
     // (lib/playwright-runner → scripts/<base>.js) instead of the extension.
-    const workerTypes = 'launch_profile,close_profile,launch_veo3_profile,set_profile_proxy,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats,restart_worker,upload_youtube_pw,upload_tiktok_pw,upload_facebook_pw,upload_facebook_photo_pw,warmup_youtube_pw,warmup_facebook_pw,warmup_tiktok_pw,scrape_affiliate_products,ingest_shopee_product';
+    const workerTypes = 'launch_profile,close_profile,launch_veo3_profile,set_profile_proxy,save_file,set_thumbnail,set_tags,set_file_input,click_and_upload,type_text,verify_logins,update_extension,sync_youtube_stats,restart_worker,upload_youtube_pw,upload_tiktok_pw,upload_facebook_pw,upload_facebook_photo_pw,warmup_youtube_pw,warmup_facebook_pw,warmup_tiktok_pw,nurture_facebook_pw,scrape_affiliate_products,ingest_shopee_product';
     return this.request('GET', `/workers/commands?worker_id=${workerId}&types=${encodeURIComponent(workerTypes)}`);
   }
 

package/package.json

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

package/scripts/lib/fb-guard.js

@@ -0,0 +1,100 @@
+// Facebook session guard — shared by warmup_facebook.js and nurture_facebook.js.
+//
+// WHY: both scripts drive a long-lived NST profile that is SUPPOSED to be logged
+// into Facebook. When that session dies (cookie expired, FB forced a re-login,
+// checkpoint, or the account got disabled), the scripts used to fail with a
+// generic "Reels entry not found" / "no posts found" — indistinguishable from a
+// layout change. The nurture scheduler then kept driving a dead profile once a
+// day, silently, for weeks.
+//
+// So: detect the account state explicitly and throw an error whose message
+// STARTS with a machine-readable code. command-poller posts the thrown message
+// verbatim (truncated to 500 chars) into the command's `error`, and the API's
+// result hook parses the prefix → writes channel.nurture.account_status →
+// disables the scheduler → the notification centre rings.
+//
+// Codes: FB_ACCOUNT_LOGGED_OUT | FB_ACCOUNT_CHECKPOINT | FB_ACCOUNT_BANNED
+
+const CODES = {
+  logged_out: 'FB_ACCOUNT_LOGGED_OUT',
+  checkpoint: 'FB_ACCOUNT_CHECKPOINT',
+  banned: 'FB_ACCOUNT_BANNED',
+};
+
+// Phrases FB shows on a disabled/suspended account (vi + en). Kept narrow on
+// purpose — a false "banned" would switch off a healthy account's nurture loop.
+const BANNED_RE = /(tài khoản của bạn đã bị (vô hiệu hoá|vô hiệu hóa|khoá|khóa|đình chỉ))|(your account has been disabled)|(we (have )?(suspended|disabled) your account)|(tài khoản này đã bị vô hiệu hoá)|(account (is )?(disabled|suspended|restricted) )/i;
+// Identity/security interstitials — recoverable by a human, not by the script.
+const CHECKPOINT_RE = /(xác nhận danh tính)|(xác minh danh tính)|(hãy xác nhận đây là bạn)|(confirm your identity)|(help us confirm)|(we need to confirm)|(bảo mật tài khoản của bạn)|(unusual (login|activity))|(hoạt động bất thường)/i;
+
+// Read the account state of whatever page is currently open.
+// Returns { status: 'ok'|'logged_out'|'checkpoint'|'banned', detail }.
+async function readAccountState(page) {
+  const url = page.url() || '';
+  // URL is the strongest signal — FB redirects hard on all three states.
+  if (/\/checkpoint\//i.test(url)) return { status: 'checkpoint', detail: `redirected to ${url.slice(0, 120)}` };
+  if (/facebook\.com\/(login|recover)\b|login\.php|\/login\/device-based/i.test(url)) {
+    return { status: 'logged_out', detail: `redirected to ${url.slice(0, 120)}` };
+  }
+
+  const dom = await page.evaluate(() => {
+    const vis = (el) => {
+      if (!el) return false;
+      const r = el.getBoundingClientRect();
+      return r.width > 8 && r.height > 8 && el.offsetParent !== null;
+    };
+    // Login form present = the session is gone (FB renders email+pass on the
+    // logged-out home page too, so this catches a soft logout with no redirect).
+    const hasLoginForm = vis(document.querySelector("input[name='email'], input[name='pass'], input#email, input#pass"));
+    // A rendered FEED is proof of a live session: FB serves no posts on a
+    // login / checkpoint / disabled-account page. This matters because the
+    // text patterns below would otherwise fire on somebody's viral post about
+    // *their* account being disabled — a false "banned" would switch off a
+    // perfectly healthy account's nurture schedule.
+    const hasFeed = !!document.querySelector("[role='article']") ||
+      !!document.querySelector("[role='feed']");
+    return {
+      hasLoginForm,
+      hasFeed,
+      text: (document.body?.innerText || '').slice(0, 4000),
+    };
+  }).catch(() => null);
+
+  if (!dom) return { status: 'ok', detail: '' }; // page not readable — let the caller's own checks decide
+  if (dom.hasFeed) return { status: 'ok', detail: '' }; // posts render → session is alive
+
+  if (BANNED_RE.test(dom.text)) {
+    const m = dom.text.match(BANNED_RE);
+    return { status: 'banned', detail: (m && m[0] ? m[0] : 'disabled-account notice').slice(0, 160) };
+  }
+  if (CHECKPOINT_RE.test(dom.text)) {
+    const m = dom.text.match(CHECKPOINT_RE);
+    return { status: 'checkpoint', detail: (m && m[0] ? m[0] : 'checkpoint notice').slice(0, 160) };
+  }
+  if (dom.hasLoginForm) {
+    return { status: 'logged_out', detail: 'login form on page (session expired)' };
+  }
+  return { status: 'ok', detail: '' };
+}
+
+// Throw a coded error if the account is not usable. Call right after landing on
+// facebook.com, and again whenever a step fails unexpectedly (a mid-session
+// checkpoint is common — FB throws one the moment automated-looking activity
+// trips a threshold).
+async function assertAccountUsable(page, log) {
+  const st = await readAccountState(page);
+  if (st.status === 'ok') return st;
+  const code = CODES[st.status];
+  const human = st.status === 'banned'
+    ? 'Account Facebook đã bị vô hiệu hoá/khoá — phải xử lý bằng tay.'
+    : st.status === 'checkpoint'
+      ? 'Facebook chặn ở bước xác minh (checkpoint) — phải mở profile và xác minh bằng tay.'
+      : 'Profile đã ĐĂNG XUẤT khỏi Facebook — đăng nhập lại trong NST profile rồi bật lại.';
+  if (log) log('info', `[fb-guard] ${st.status}: ${st.detail}`);
+  // Code FIRST — command-poller truncates the message at 500 chars.
+  const err = new Error(`${code}: ${human} (${st.detail})`);
+  err.account_status = st.status;
+  throw err;
+}
+
+module.exports = { readAccountState, assertAccountUsable, CODES };

package/scripts/nurture_facebook.js

@@ -0,0 +1,369 @@
+// Facebook account nurture — ages an account so FB trusts it (the owner then
+// creates the Page BY HAND; this script never touches Page creation).
+//
+// Runs on the channel's own NST profile + residential proxy, once or twice a
+// day, driven by the API scheduler. One run = one "session": browse the real
+// newsfeed the way a person does, and — only once the account is old enough —
+// leave a few likes.
+//
+// PHASES (server decides, passed in payload.phase):
+//   1 (day 1-3)  read only — scroll, pause to read, watch a feed video. ZERO taps.
+//   2 (day 4-7)  + likes (3-5), + open a post to read comments.
+//   3 (day 8+)   + likes (5-10), + follow a page that shows up in the feed.
+//
+// NOT here: messaging (dropped — messaging strangers is the fastest way to a
+// spam checkpoint) and joining groups (approval questions strand the script).
+//
+// Contract: run({ page, payload, log }) → { phase, posts_seen, likes,
+// videos_watched, pages_followed, posts_opened, duration_sec }.
+// A dead session (logged out / checkpoint / disabled) throws a CODED error via
+// lib/fb-guard so the API can stop the schedule and raise a notification.
+
+const { assertAccountUsable } = require('./lib/fb-guard');
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
+function chance(p) { return Math.random() < p; }
+
+// Dismiss FB cookie / cross-sell / "not now" popups. Best-effort, never throws.
+// Never touches the composer or a reel viewer.
+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) => {
+      for (const dlg of document.querySelectorAll("[role='dialog']")) {
+        const r = dlg.getBoundingClientRect();
+        if (r.width < 8 || r.height < 8) continue;
+        const aria = (dlg.getAttribute('aria-label') || '').toLowerCase();
+        if (/tạo bài viết|create post|thước phim|reel/i.test(aria)) continue;
+        for (const v of vs) {
+          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 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);
+  }
+}
+
+// Count feed posts that entered the viewport since the last call, marking them
+// so they're counted once. Sponsored posts are marked too (so they're never
+// liked or watched) but do NOT count as "seen" — an ad isn't reading.
+async function markPostsInView(page) {
+  return page.evaluate(() => {
+    let fresh = 0;
+    for (const art of document.querySelectorAll("[role='article']")) {
+      // Comments render as NESTED articles — only top-level posts count.
+      if (art.parentElement && art.parentElement.closest("[role='article']")) continue;
+      if (art.hasAttribute('data-nur-seen')) continue;
+      const r = art.getBoundingClientRect();
+      const inView = r.bottom > 0 && r.top < window.innerHeight && r.height > 80;
+      if (!inView) continue;
+      art.setAttribute('data-nur-seen', '1');
+      const head = (art.innerText || '').slice(0, 400);
+      if (/Được tài trợ|Sponsored|Tài trợ/i.test(head)) { art.setAttribute('data-nur-ad', '1'); continue; }
+      fresh++;
+    }
+    return fresh;
+  }).catch(() => 0);
+}
+
+// Like ONE organic post near the centre of the viewport. Returns true on a
+// confirmed like. Deliberately picky: skips ads, skips already-liked posts, and
+// never grabs a COMMENT's like button (nested article).
+async function likeVisiblePost(page, log) {
+  const found = await page.evaluate(() => {
+    const mid = window.innerHeight / 2;
+    let best = null, bestDist = Infinity;
+    for (const art of document.querySelectorAll("[role='article']")) {
+      if (art.parentElement && art.parentElement.closest("[role='article']")) continue; // comment
+      if (art.hasAttribute('data-nur-ad') || art.hasAttribute('data-nur-liked')) continue;
+      const r = art.getBoundingClientRect();
+      if (r.bottom < 60 || r.top > window.innerHeight - 60 || r.height < 120) continue;
+      const dist = Math.abs((r.top + r.bottom) / 2 - mid);
+      if (dist < bestDist) { best = art; bestDist = dist; }
+    }
+    if (!best) return null;
+    if (/Được tài trợ|Sponsored/i.test((best.innerText || '').slice(0, 400))) { best.setAttribute('data-nur-ad', '1'); return null; }
+    for (const b of best.querySelectorAll("[role='button']")) {
+      const aria = (b.getAttribute('aria-label') || '').trim();
+      if (!/^(thích|like)$/i.test(aria)) continue;
+      if (b.getAttribute('aria-pressed') === 'true') continue;   // already liked
+      if (b.closest("[role='article']") !== best) continue;      // belongs to a comment
+      const r = b.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8 || b.offsetParent === null) continue;
+      best.setAttribute('data-nur-liked', 'pending');
+      b.setAttribute('__nur_like__', '1');
+      return { aria };
+    }
+    return null;
+  }).catch(() => null);
+  if (!found) return false;
+
+  const btn = page.locator("[__nur_like__='1']").first();
+  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 });
+    await page.waitForTimeout(randInt(900, 1800));
+    ok = await btn.evaluate((el) => el.getAttribute('aria-pressed') === 'true').catch(() => true);
+    if (ok === null || ok === undefined) ok = true;
+  } catch (e) {
+    log('info', `[nurture-fb] like failed: ${String(e.message || e).slice(0, 80)}`);
+  }
+  await page.evaluate((liked) => {
+    document.querySelectorAll('[__nur_like__]').forEach(e => e.removeAttribute('__nur_like__'));
+    document.querySelectorAll("[data-nur-liked='pending']").forEach(e => e.setAttribute('data-nur-liked', liked ? '1' : 'fail'));
+  }, !!ok).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(() => {
+    const vids = [...document.querySelectorAll('video')];
+    for (const v of vids) {
+      const r = v.getBoundingClientRect();
+      if (r.height < 100 || r.bottom < 0 || r.top > window.innerHeight) continue;
+      const art = v.closest("[role='article']");
+      if (art && art.hasAttribute('data-nur-ad')) continue;      // never watch ads
+      if (v.hasAttribute('data-nur-watched')) continue;
+      v.setAttribute('data-nur-watched', '1');
+      if (v.paused) { try { v.play(); } catch {} }
+      return true;
+    }
+    return false;
+  }).catch(() => false);
+  if (!has) return false;
+
+  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 {} }
+      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;
+    lastT = st.t;
+    await page.waitForTimeout(1000);
+  }
+  // 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(() => {});
+  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) {
+  const urlBefore = page.url();
+  const marked = await page.evaluate(() => {
+    const mid = window.innerHeight / 2;
+    let best = null, bestDist = Infinity;
+    for (const art of document.querySelectorAll("[role='article']")) {
+      if (art.parentElement && art.parentElement.closest("[role='article']")) continue;
+      if (art.hasAttribute('data-nur-ad') || art.hasAttribute('data-nur-opened')) continue;
+      const r = art.getBoundingClientRect();
+      if (r.bottom < 60 || r.top > window.innerHeight - 60) continue;
+      const dist = Math.abs((r.top + r.bottom) / 2 - mid);
+      if (dist < bestDist) { best = art; bestDist = dist; }
+    }
+    if (!best) return false;
+    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;
+      best.setAttribute('data-nur-opened', '1');
+      a.setAttribute('__nur_open__', '1');
+      return true;
+    }
+    return false;
+  }).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));
+
+  // Read comments: a couple of small scrolls with human pauses.
+  for (let i = 0; i < randInt(2, 4); i++) {
+    await page.mouse.wheel(0, randInt(200, 600)).catch(() => {});
+    await page.waitForTimeout(randInt(1500, 4000));
+  }
+  log('info', '[nurture-fb] opened a post and read comments');
+
+  // 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) {
+    await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+  } else {
+    await page.keyboard.press('Escape').catch(() => {});
+  }
+  await page.waitForTimeout(randInt(1500, 3000));
+  return true;
+}
+
+// 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(() => {
+    for (const b of document.querySelectorAll("[role='button'], a[role='button']")) {
+      const t = (b.innerText || '').trim();
+      const aria = (b.getAttribute('aria-label') || '').trim();
+      const label = t || aria;
+      if (!/^(theo dõi|follow|thích trang|like page)$/i.test(label)) continue;
+      const r = b.getBoundingClientRect();
+      if (r.width < 8 || r.height < 8 || b.offsetParent === null) continue;
+      if (r.bottom < 0 || r.top > window.innerHeight) continue;
+      const art = b.closest("[role='article']");
+      if (art && art.hasAttribute('data-nur-ad')) continue;   // not an ad's CTA
+      b.setAttribute('__nur_follow__', '1');
+      return label;
+    }
+    return null;
+  }).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 });
+    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(() => {});
+  return ok;
+}
+
+// ─── main ───────────────────────────────────────────────────────────────────
+async function run({ page, payload, log }) {
+  const t0 = Date.now();
+  const cfg = payload.config || {};
+  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);
+  const likesTarget = randInt(cfg.likes_min ?? 0, cfg.likes_max ?? 0);
+  const likeGap = Math.max(1, cfg.like_gap_posts ?? 5);
+  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}`);
+
+  page.on('dialog', (d) => { d.accept().catch(() => {}); });
+
+  await page.goto('https://www.facebook.com/', { waitUntil: 'domcontentloaded', timeout: 60000 });
+  await page.waitForTimeout(randInt(3000, 5000));
+  // Guard FIRST — everything below assumes a live logged-in session.
+  await assertAccountUsable(page, log);
+  await dismissDialogs(page, log);
+
+  let postsSeen = 0, likes = 0, videos = 0, pagesFollowed = 0, postsOpened = 0;
+  let postsSinceLike = likeGap;   // allow the first like once enough posts scroll by
+  let ticks = 0, emptyTicks = 0;
+  const deadline = t0 + sessionSec * 1000;
+
+  while (Date.now() < deadline) {
+    ticks++;
+    const fresh = await markPostsInView(page);
+    postsSeen += fresh;
+    postsSinceLike += fresh;
+    // Feed that stops yielding posts for ~15 ticks = end of feed, a wall, or a
+    // silent interstitial. Re-check the account, then nudge back to the top.
+    if (fresh === 0) {
+      if (++emptyTicks >= 15) {
+        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(() => {});
+        await page.waitForTimeout(randInt(2000, 4000));
+      }
+    } else {
+      emptyTicks = 0;
+    }
+
+    // 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++;
+    }
+
+    // Like — phase 2+ only, never two posts in a row (enforced by likeGap).
+    if (likes < likesTarget && postsSinceLike >= likeGap) {
+      if (await likeVisiblePost(page, log)) { likes++; postsSinceLike = 0; }
+      else postsSinceLike = Math.max(0, postsSinceLike - 1); // retry a bit later
+    }
+
+    // Open a post to read comments — phase 2+.
+    if (postsOpened < openPostMax && chance(0.05)) {
+      if (await openPostAndRead(page, log)) postsOpened++;
+    }
+
+    // Follow a page the feed already showed — phase 3.
+    if (pagesFollowed < followMax && chance(0.06)) {
+      if (await followVisiblePage(page, log)) pagesFollowed++;
+    }
+
+    // Human-shaped movement: mostly forward, sometimes a long read, sometimes
+    // a scroll back up (people re-read what they just passed).
+    const roll = Math.random();
+    if (roll < 0.15) {
+      await page.waitForTimeout(randInt(6000, 20000));            // stop and read
+    } else if (roll < 0.23) {
+      await page.mouse.wheel(0, -randInt(150, 400)).catch(() => {});
+      await page.waitForTimeout(randInt(1200, 3000));
+    } else {
+      await page.mouse.wheel(0, randInt(250, 900)).catch(() => {});
+      await page.waitForTimeout(randInt(800, 4000));
+    }
+
+    // Mid-session health check (~ every 12 ticks). FB throws a checkpoint the
+    // moment activity trips a threshold — better to stop than to keep poking.
+    if (ticks % 12 === 0) await assertAccountUsable(page, log);
+  }
+
+  const durationSec = Math.round((Date.now() - t0) / 1000);
+  log('info', `[nurture-fb] session done — posts=${postsSeen} likes=${likes}/${likesTarget} videos=${videos} pages=${pagesFollowed} opened=${postsOpened} duration=${durationSec}s`);
+  return {
+    phase,
+    day_index: dayIndex,
+    posts_seen: postsSeen,
+    likes,
+    videos_watched: videos,
+    pages_followed: pagesFollowed,
+    posts_opened: postsOpened,
+    duration_sec: durationSec,
+    account_status: 'ok',
+  };
+}
+
+module.exports = { run };

package/scripts/warmup_facebook.js

@@ -16,6 +16,8 @@
 // entry are hard requirements — their absence (not logged in / consent wall /
 // layout change) FAILS the session loudly (no silent bypass).
 
+const { assertAccountUsable } = require('./lib/fb-guard');
+
 // ─── helpers ────────────────────────────────────────────────────────────────
 function randInt(min, max) { return Math.floor(min + Math.random() * (max - min + 1)); }
 function shuffle(arr) {
@@ -353,12 +355,16 @@ async function run({ page, payload, log }) {
   // 1) Land on the FB home feed (organic entry — not a deep link).
   await page.goto('https://www.facebook.com/', { waitUntil: 'domcontentloaded', timeout: 60000 });
   await page.waitForTimeout(randInt(3000, 5000));
+  // A dead session (logged out / checkpoint / disabled account) used to surface
+  // as "Reels entry not found" — indistinguishable from a layout change. Name it.
+  await assertAccountUsable(page, log);
   await dismissDialogs(page, log);
   await organicScroll(page, randInt(1, 3));
 
   // 2) Click the "Reels" entry (left nav / shortcut) — natural navigation.
   const reelsOk = await clickReelsEntry(page, log);
   if (!reelsOk) {
+    await assertAccountUsable(page, log); // may throw a coded account error instead
     throw new Error('warmup-fb: "Reels" entry not found on FB home — check the profile is logged in to Facebook and the left-nav Reels shortcut is present');
   }
   await dismissDialogs(page, log);
@@ -372,6 +378,7 @@ async function run({ page, payload, log }) {
     // 3) Search the keyword via the top bar (from the Reels surface).
     const focused = await focusFbSearch(page, log);
     if (!focused) {
+      await assertAccountUsable(page, log); // logged out mid-session → coded error
       throw new Error('warmup-fb: search box not found — FB layout/login issue (cannot warm up without searching)');
     }
     log('info', `[warmup-fb] searching: "${kw}"`);