@reconcrap/boss-recommend-mcp 2.0.54 → 2.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.54",
+  "version": "2.0.55",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/domains/chat/constants.js

@@ -1,4 +1,9 @@
-export const CHAT_TARGET_URL = "https://www.zhipin.com/web/chat/index";
+import {
+  BOSS_ACCOUNT_RIGHTS_PANEL_CLOSE_SELECTORS,
+  BOSS_ACCOUNT_RIGHTS_PANEL_TEXT_QUERIES
+} from "../common/account-rights-panel.js";
+
+export const CHAT_TARGET_URL = "https://www.zhipin.com/web/chat/index";
 
 export const CHAT_CARD_SELECTORS = Object.freeze([
   ".geek-item[data-id]",
@@ -208,29 +213,9 @@ export const CHAT_RESUME_CLOSE_SELECTORS = Object.freeze([
   '[title*="关闭"]'
 ]);
 
-export const CHAT_BLOCKING_PANEL_TEXT_QUERIES = Object.freeze([
-  "我的权益",
-  "VVIP账号-精选版专享权益",
-  "全部账号权益使用量",
-  "职位发布权益总量",
-  "每日使用权益总量"
-]);
-
-export const CHAT_BLOCKING_PANEL_CLOSE_SELECTORS = Object.freeze([
-  ".boss-popup__close",
-  ".boss-dialog__close",
-  ".side-panel-close",
-  ".drawer-close",
-  ".panel-close",
-  ".popup-close",
-  ".modal-close",
-  ".dialog-close",
-  ".close-btn",
-  ".icon-close",
-  "[class*=\"close\"]",
-  '[aria-label*="关闭"]',
-  '[title*="关闭"]'
-]);
+export const CHAT_BLOCKING_PANEL_TEXT_QUERIES = BOSS_ACCOUNT_RIGHTS_PANEL_TEXT_QUERIES;
+
+export const CHAT_BLOCKING_PANEL_CLOSE_SELECTORS = BOSS_ACCOUNT_RIGHTS_PANEL_CLOSE_SELECTORS;
 
 export const CHAT_PROFILE_NETWORK_PATTERNS = Object.freeze([
   /\/wapi\/zpjob\/view\/geek\/info(?:\/v2)?\b/i,

package/src/domains/chat/detail.js

@@ -12,13 +12,17 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
-import {
-  buildScreeningCandidateFromDetail,
-  htmlToText
-} from "../../core/screening/index.js";
-import {
-  CHAT_ACTIVE_CANDIDATE_SELECTORS,
-  CHAT_ASK_RESUME_BUTTON_SELECTORS,
+import {
+  buildScreeningCandidateFromDetail,
+  htmlToText
+} from "../../core/screening/index.js";
+import {
+  closeBossAccountRightsBlockingPanel,
+  findBossAccountRightsBlockingPanel
+} from "../common/account-rights-panel.js";
+import {
+  CHAT_ACTIVE_CANDIDATE_SELECTORS,
+  CHAT_ASK_RESUME_BUTTON_SELECTORS,
   CHAT_ATTACHMENT_RESUME_BUTTON_SELECTORS,
   CHAT_BLOCKING_PANEL_CLOSE_SELECTORS,
   CHAT_BLOCKING_PANEL_TEXT_QUERIES,
@@ -735,185 +739,29 @@ export async function quickChatResumeModalOpenProbe(client, {
   };
 }
 
-async function performDomTextSearch(client, query, {
-  limit = 6
-} = {}) {
-  if (typeof client?.DOM?.performSearch !== "function"
-    || typeof client?.DOM?.getSearchResults !== "function") {
-    return [];
-  }
-  const searchOnce = async () => {
-    let searchId = "";
-    try {
-      const search = await client.DOM.performSearch({
-        query,
-        includeUserAgentShadowDOM: true
-      });
-      searchId = search?.searchId || "";
-      const resultCount = Math.min(Number(search?.resultCount) || 0, Math.max(0, Number(limit) || 0));
-      if (!searchId || resultCount <= 0) return [];
-      const results = await client.DOM.getSearchResults({
-        searchId,
-        fromIndex: 0,
-        toIndex: resultCount
-      });
-      return results?.nodeIds || [];
-    } catch {
-      return [];
-    } finally {
-      if (searchId && typeof client?.DOM?.discardSearchResults === "function") {
-        try {
-          await client.DOM.discardSearchResults({ searchId });
-        } catch {
-          // Best-effort cleanup only.
-        }
-      }
-    }
-  };
-
-  const firstPass = await searchOnce();
-  if (!firstPass.length) return [];
-  const firstPassNodeIds = firstPass.filter((nodeId) => Number(nodeId) > 0);
-  if (firstPassNodeIds.length || typeof client?.DOM?.getDocument !== "function") return firstPassNodeIds;
-  try {
-    await client.DOM.getDocument({
-      depth: -1,
-      pierce: true
-    });
-  } catch {
-    return firstPassNodeIds;
-  }
-  return (await searchOnce()).filter((nodeId) => Number(nodeId) > 0);
-}
-
-export async function findChatBlockingPanel(client, {
-  textQueries = CHAT_BLOCKING_PANEL_TEXT_QUERIES
-} = {}) {
-  for (const query of textQueries || []) {
-    const nodeIds = await performDomTextSearch(client, query);
-    for (const nodeId of nodeIds) {
-      try {
-        const box = await getNodeBox(client, nodeId);
-        if (box?.rect?.width > 2 && box?.rect?.height > 2) {
-          return {
-            open: true,
-            reason: "blocking_panel_text_visible",
-            query,
-            node_id: nodeId,
-            rect: box.rect,
-            center: box.center
-          };
-        }
-      } catch {
-        // Hidden or stale text hits are ignored.
-      }
-    }
-  }
-  return {
-    open: false
-  };
-}
-
-function blockingPanelOutsideClickPoint(probe = {}) {
-  const rect = probe?.rect || {};
-  // Click the empty lower-left sidebar area. It is outside the rights drawer
-  // and avoids top nav, chat rows, message controls, and candidate actions.
-  const x = 84;
-  const y = Number.isFinite(Number(rect.y))
-    ? Math.max(560, Math.min(680, Number(rect.y) + 600))
-    : 660;
-  return {
-    x,
-    y,
-    mode: "empty-lower-left-sidebar"
-  };
-}
-
-export async function closeChatBlockingPanels(client, {
-  attemptsLimit = 2
-} = {}) {
-  const attempts = [];
-  let probe = await findChatBlockingPanel(client);
-  if (!probe.open) {
-    return {
-      closed: true,
-      already_closed: true,
-      probe,
-      attempts
-    };
-  }
-
-  for (let index = 0; index < attemptsLimit; index += 1) {
-    const outsidePoint = blockingPanelOutsideClickPoint(probe);
-    try {
-      await clickPoint(client, outsidePoint.x, outsidePoint.y, DETERMINISTIC_CLICK_OPTIONS);
-      attempts.push({
-        mode: "outside-click",
-        point: outsidePoint
-      });
-    } catch (error) {
-      attempts.push({
-        mode: "outside-click-error",
-        point: outsidePoint,
-        error: error?.message || String(error)
-      });
-    }
-    await sleep(700);
-
-    probe = await findChatBlockingPanel(client);
-    if (!probe.open) {
-      return {
-        closed: true,
-        already_closed: false,
-        probe,
-        attempts
-      };
-    }
-
-    const rootState = await getChatRoots(client);
-    const closeTarget = await findVisibleTarget(client, rootState.roots, CHAT_BLOCKING_PANEL_CLOSE_SELECTORS);
-    if (closeTarget) {
-      try {
-        await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
-        attempts.push({
-          mode: "close-selector",
-          selector: closeTarget.selector,
-          root: closeTarget.root
-        });
-      } catch (error) {
-        attempts.push({
-          mode: "close-selector-error",
-          selector: closeTarget.selector,
-          root: closeTarget.root,
-          error: error?.message || String(error)
-        });
-      }
-    } else {
-      await pressEscape(client);
-      attempts.push({ mode: "Escape" });
-    }
-    await sleep(700);
-
-    probe = await findChatBlockingPanel(client);
-    if (!probe.open) {
-      return {
-        closed: true,
-        already_closed: false,
-        probe,
-        attempts
-      };
-    }
-  }
-
-  return {
-    closed: false,
-    already_closed: false,
-    probe,
-    attempts
-  };
-}
-
-export async function readChatResumeHtml(client, resumeState) {
+export async function findChatBlockingPanel(client, {
+  textQueries = CHAT_BLOCKING_PANEL_TEXT_QUERIES
+} = {}) {
+  const panel = await findBossAccountRightsBlockingPanel(client, { textQueries });
+  return panel.open
+    ? { ...panel, reason: "blocking_panel_text_visible" }
+    : panel;
+}
+
+export async function closeChatBlockingPanels(client, {
+  attemptsLimit = 2,
+  closeSelectors = CHAT_BLOCKING_PANEL_CLOSE_SELECTORS,
+  textQueries = CHAT_BLOCKING_PANEL_TEXT_QUERIES
+} = {}) {
+  return closeBossAccountRightsBlockingPanel(client, {
+    attemptsLimit,
+    closeSelectors,
+    resolveRoots: getChatRoots,
+    textQueries
+  });
+}
+
+export async function readChatResumeHtml(client, resumeState) {
   let popupHTML = "";
   let contentHTML = "";
   let resumeIframeHTML = "";

package/src/domains/common/account-rights-panel.js

@@ -0,0 +1,314 @@
+import {
+  clickPoint,
+  DETERMINISTIC_CLICK_OPTIONS,
+  getDocumentRoot,
+  getNodeBox,
+  pressKey,
+  querySelectorAll,
+  sleep
+} from "../../core/browser/index.js";
+
+export const BOSS_ACCOUNT_RIGHTS_PANEL_TEXT_QUERIES = Object.freeze([
+  "我的权益",
+  "VVIP账号-精选版专享权益",
+  "全部账号权益使用量",
+  "职位发布权益总量",
+  "每日使用权益总量"
+]);
+
+export const BOSS_ACCOUNT_RIGHTS_PANEL_CLOSE_SELECTORS = Object.freeze([
+  ".boss-popup__close",
+  ".boss-dialog__close",
+  ".side-panel-close",
+  ".drawer-close",
+  ".panel-close",
+  ".popup-close",
+  ".modal-close",
+  ".dialog-close",
+  ".close-btn",
+  ".icon-close",
+  "[class*=\"close\"]",
+  '[aria-label*="关闭"]',
+  '[title*="关闭"]'
+]);
+
+async function performDomTextSearch(client, query, {
+  limit = 6
+} = {}) {
+  if (typeof client?.DOM?.performSearch !== "function"
+    || typeof client?.DOM?.getSearchResults !== "function") {
+    return [];
+  }
+
+  const searchOnce = async () => {
+    let searchId = "";
+    try {
+      const search = await client.DOM.performSearch({
+        query,
+        includeUserAgentShadowDOM: true
+      });
+      searchId = search?.searchId || "";
+      const resultCount = Math.min(Number(search?.resultCount) || 0, Math.max(0, Number(limit) || 0));
+      if (!searchId || resultCount <= 0) return [];
+      const results = await client.DOM.getSearchResults({
+        searchId,
+        fromIndex: 0,
+        toIndex: resultCount
+      });
+      return results?.nodeIds || [];
+    } catch {
+      return [];
+    } finally {
+      if (searchId && typeof client?.DOM?.discardSearchResults === "function") {
+        try {
+          await client.DOM.discardSearchResults({ searchId });
+        } catch {
+          // Best-effort cleanup only.
+        }
+      }
+    }
+  };
+
+  const firstPass = await searchOnce();
+  if (!firstPass.length) return [];
+  const firstPassNodeIds = firstPass.filter((nodeId) => Number(nodeId) > 0);
+  if (firstPassNodeIds.length || typeof client?.DOM?.getDocument !== "function") return firstPassNodeIds;
+
+  try {
+    await client.DOM.getDocument({
+      depth: -1,
+      pierce: true
+    });
+  } catch {
+    return firstPassNodeIds;
+  }
+  return (await searchOnce()).filter((nodeId) => Number(nodeId) > 0);
+}
+
+export async function findBossAccountRightsBlockingPanel(client, {
+  textQueries = BOSS_ACCOUNT_RIGHTS_PANEL_TEXT_QUERIES
+} = {}) {
+  for (const query of textQueries || []) {
+    const nodeIds = await performDomTextSearch(client, query);
+    for (const nodeId of nodeIds) {
+      try {
+        const box = await getNodeBox(client, nodeId);
+        if (box?.rect?.width > 2 && box?.rect?.height > 2) {
+          return {
+            open: true,
+            reason: "account_rights_panel_text_visible",
+            query,
+            node_id: nodeId,
+            rect: box.rect,
+            center: box.center
+          };
+        }
+      } catch {
+        // Hidden or stale text hits are ignored.
+      }
+    }
+  }
+  return {
+    open: false
+  };
+}
+
+export function accountRightsPanelOutsideClickPoint(probe = {}) {
+  const rect = probe?.rect || {};
+  // Click the empty lower-left sidebar area. It is outside the rights drawer
+  // and avoids top nav, chat rows, message controls, and candidate actions.
+  const x = 84;
+  const y = Number.isFinite(Number(rect.y))
+    ? Math.max(560, Math.min(680, Number(rect.y) + 600))
+    : 660;
+  return {
+    x,
+    y,
+    mode: "empty-lower-left-sidebar"
+  };
+}
+
+async function resolveBlockingPanelRoots(client, {
+  roots = null,
+  rootState = null,
+  resolveRoots = null
+} = {}) {
+  if (Array.isArray(roots) && roots.some((root) => root?.nodeId)) {
+    return roots.filter((root) => root?.nodeId);
+  }
+  if (Array.isArray(rootState?.roots) && rootState.roots.some((root) => root?.nodeId)) {
+    return rootState.roots.filter((root) => root?.nodeId);
+  }
+  if (typeof resolveRoots === "function") {
+    try {
+      const resolved = await resolveRoots(client);
+      if (Array.isArray(resolved)) return resolved.filter((root) => root?.nodeId);
+      if (Array.isArray(resolved?.roots)) return resolved.roots.filter((root) => root?.nodeId);
+    } catch {
+      // Fall through to the top document. The rights panel lives there.
+    }
+  }
+  try {
+    const topRoot = await getDocumentRoot(client);
+    return [{ name: "top", nodeId: topRoot.nodeId }];
+  } catch {
+    return [];
+  }
+}
+
+async function findVisibleCloseTarget(client, roots, selectors) {
+  let fallback = null;
+  for (const root of roots || []) {
+    if (!root?.nodeId) continue;
+    for (const selector of selectors || []) {
+      let nodeIds = [];
+      try {
+        nodeIds = await querySelectorAll(client, root.nodeId, selector);
+      } catch {
+        nodeIds = [];
+      }
+      for (const nodeId of nodeIds) {
+        const target = {
+          root: root.name,
+          root_node_id: root.nodeId,
+          selector,
+          node_id: nodeId
+        };
+        if (!fallback) fallback = target;
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box?.rect?.width > 2 && box?.rect?.height > 2) {
+            return {
+              ...target,
+              center: box.center,
+              rect: box.rect
+            };
+          }
+        } catch {
+          // Stale close candidates are ignored.
+        }
+      }
+    }
+  }
+  return fallback;
+}
+
+async function pressEscape(client) {
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+}
+
+export async function closeBossAccountRightsBlockingPanel(client, {
+  attemptsLimit = 2,
+  closeSelectors = BOSS_ACCOUNT_RIGHTS_PANEL_CLOSE_SELECTORS,
+  resolveRoots = null,
+  roots = null,
+  rootState = null,
+  textQueries = BOSS_ACCOUNT_RIGHTS_PANEL_TEXT_QUERIES,
+  waitMs = 700
+} = {}) {
+  const attempts = [];
+  let probe = await findBossAccountRightsBlockingPanel(client, { textQueries });
+  if (!probe.open) {
+    return {
+      closed: true,
+      already_closed: true,
+      probe,
+      attempts
+    };
+  }
+
+  for (let index = 0; index < attemptsLimit; index += 1) {
+    const outsidePoint = accountRightsPanelOutsideClickPoint(probe);
+    try {
+      await clickPoint(client, outsidePoint.x, outsidePoint.y, DETERMINISTIC_CLICK_OPTIONS);
+      attempts.push({
+        mode: "outside-click",
+        point: outsidePoint
+      });
+    } catch (error) {
+      attempts.push({
+        mode: "outside-click-error",
+        point: outsidePoint,
+        error: error?.message || String(error)
+      });
+    }
+    await sleep(waitMs);
+
+    probe = await findBossAccountRightsBlockingPanel(client, { textQueries });
+    if (!probe.open) {
+      return {
+        closed: true,
+        already_closed: false,
+        probe,
+        attempts
+      };
+    }
+
+    const resolvedRoots = await resolveBlockingPanelRoots(client, { roots, rootState, resolveRoots });
+    const closeTarget = await findVisibleCloseTarget(client, resolvedRoots, closeSelectors);
+    if (closeTarget) {
+      try {
+        if (closeTarget.center) {
+          await clickPoint(client, closeTarget.center.x, closeTarget.center.y, DETERMINISTIC_CLICK_OPTIONS);
+        }
+        attempts.push({
+          mode: "close-selector",
+          selector: closeTarget.selector,
+          root: closeTarget.root
+        });
+      } catch (error) {
+        attempts.push({
+          mode: "close-selector-error",
+          selector: closeTarget.selector,
+          root: closeTarget.root,
+          error: error?.message || String(error)
+        });
+      }
+      await sleep(waitMs);
+
+      probe = await findBossAccountRightsBlockingPanel(client, { textQueries });
+      if (!probe.open) {
+        return {
+          closed: true,
+          already_closed: false,
+          probe,
+          attempts
+        };
+      }
+    }
+
+    try {
+      await pressEscape(client);
+      attempts.push({ mode: closeTarget ? "Escape-fallback" : "Escape" });
+    } catch (error) {
+      attempts.push({
+        mode: "Escape-error",
+        error: error?.message || String(error)
+      });
+    }
+    await sleep(waitMs);
+
+    probe = await findBossAccountRightsBlockingPanel(client, { textQueries });
+    if (!probe.open) {
+      return {
+        closed: true,
+        already_closed: false,
+        probe,
+        attempts
+      };
+    }
+  }
+
+  return {
+    closed: false,
+    already_closed: false,
+    reason: "account_rights_panel_still_visible_after_close_attempts",
+    probe,
+    attempts
+  };
+}
+

package/src/domains/recommend/detail.js

@@ -9,11 +9,15 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
-import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
-import {
-  buildScreeningCandidateFromDetail,
-  htmlToText
-} from "../../core/screening/index.js";
+import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
+import {
+  buildScreeningCandidateFromDetail,
+  htmlToText
+} from "../../core/screening/index.js";
+import {
+  closeBossAccountRightsBlockingPanel,
+  findBossAccountRightsBlockingPanel
+} from "../common/account-rights-panel.js";
 import {
   DETAIL_CLOSE_SELECTORS,
   DETAIL_NETWORK_PATTERNS,
@@ -41,7 +45,7 @@ export function matchesRecommendDetailNetwork(url) {
   return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
-export function createRecommendDetailNetworkRecorder(client) {
+export function createRecommendDetailNetworkRecorder(client) {
   const events = [];
   client.Network.responseReceived((event) => {
     const url = event?.response?.url || "";
@@ -76,9 +80,20 @@ export function createRecommendDetailNetworkRecorder(client) {
       events.length = 0;
     }
   };
-}
-
-export async function waitForRecommendDetailNetworkEvents(recorder, {
+}
+
+export async function findRecommendBlockingPanel(client, options = {}) {
+  return findBossAccountRightsBlockingPanel(client, options);
+}
+
+export async function closeRecommendBlockingPanels(client, options = {}) {
+  return closeBossAccountRightsBlockingPanel(client, {
+    resolveRoots: getRecommendRoots,
+    ...options
+  });
+}
+
+export async function waitForRecommendDetailNetworkEvents(recorder, {
   minCount = 1,
   requireLoaded = true,
   timeoutMs = 3500,

package/src/domains/recommend/run-service.js

@@ -45,7 +45,8 @@ import {
   llmResultToScreening,
   screenCandidate
 } from "../../core/screening/index.js";
-import {
+import {
+  closeRecommendBlockingPanels,
   closeRecommendDetail,
   createRecommendDetailNetworkRecorder,
   extractRecommendDetailCandidate,
@@ -465,12 +466,17 @@ function countPassedResults(results = []) {
 
 function compactCloseResult(closeResult) {
   if (!closeResult) return null;
-  return {
+  const result = {
     closed: Boolean(closeResult.closed),
     reason: closeResult.reason || null,
+    probe: closeResult.probe || null,
     attempts: closeResult.attempts || [],
     verification: closeResult.verification || null
   };
+  if (closeResult.already_closed !== undefined) {
+    result.already_closed = Boolean(closeResult.already_closed);
+  }
+  return result;
 }
 
 function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
@@ -482,6 +488,9 @@ function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
   if (error.close_result) {
     result.close_result = compactCloseResult(error.close_result);
   }
+  if (error.phase) {
+    result.phase = error.phase;
+  }
   if (error.refresh_attempt) {
     result.refresh_attempt = error.refresh_attempt;
   }
@@ -507,6 +516,14 @@ function createRecommendCloseFailureError(closeResult) {
   return error;
 }
 
+function createRecommendBlockingPanelCloseFailureError(closeResult, phase = "") {
+  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
+  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  error.phase = phase || null;
+  return error;
+}
+
 function createRecommendRefreshFailureError(refreshAttempt, {
   listEndReason = "",
   targetCount = 0,
@@ -699,10 +716,11 @@ export async function runRecommendWorkflow({
   let refreshRounds = 0;
   let contextRecoveryAttempts = 0;
   let greetCount = 0;
-  const candidateRecoveryCounts = new Map();
-  let jobSelection = null;
+  const candidateRecoveryCounts = new Map();
+  let jobSelection = null;
   let pageScopeSelection = null;
   let filterResult = null;
+  let rootState = null;
   let cardNodeIds = [];
   let listEndReason = "";
   let lastHumanEvent = null;
@@ -769,9 +787,9 @@ export async function runRecommendWorkflow({
     });
   }
 
-  function checkpointInProgressCandidate({
-    index = results.length,
-    candidateKey = "",
+  function checkpointInProgressCandidate({
+    index = results.length,
+    candidateKey = "",
     cardNodeId = null,
     detailStep = "",
     error = null
@@ -785,11 +803,22 @@ export async function runRecommendWorkflow({
         counters: countRecommendResultStatuses(results, { greetCount }),
         error: compactError(error, "RECOMMEND_IN_PROGRESS_ERROR")
       },
-      candidate_list: compactInfiniteListState(listState)
-    });
-  }
-
-  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
+      candidate_list: compactInfiniteListState(listState)
+    });
+  }
+
+  async function closeRecommendBlockingPanelsForRun(phase = "cleanup") {
+    const result = await closeRecommendBlockingPanels(client, {
+      attemptsLimit: 2,
+      rootState
+    });
+    if (!result?.closed) {
+      throw createRecommendBlockingPanelCloseFailureError(result, phase);
+    }
+    return result;
+  }
+
+  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
     forceRecentNotView = true
   } = {}) {
     await runControl.waitIfPaused();
@@ -797,9 +826,9 @@ export async function runRecommendWorkflow({
     const started = Date.now();
     runControl.setPhase("recommend:recover-context");
     contextRecoveryAttempts += 1;
-    const refreshResult = await refreshRecommendListAtEnd(client, {
-      rootState,
-      jobLabel,
+    const refreshResult = await refreshRecommendListAtEnd(client, {
+      rootState,
+      jobLabel,
       pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
       fallbackPageScope: normalizedFallbackPageScope,
       filter: normalizedFilter,
@@ -808,16 +837,24 @@ export async function runRecommendWorkflow({
       targetUrl: targetUrl || RECOMMEND_TARGET_URL,
       forceRecentNotView,
       cardTimeoutMs,
-      buttonSettleMs: refreshButtonSettleMs,
-      reloadSettleMs: refreshReloadSettleMs
-    });
-    const compactRefresh = {
-      ...compactRefreshAttempt(refreshResult),
-      context_recovery: true,
-      recovery_reason: reason,
-      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
-      elapsed_ms: Date.now() - started
-    };
+      buttonSettleMs: refreshButtonSettleMs,
+      reloadSettleMs: refreshReloadSettleMs
+    });
+    let blockingPanelClose = null;
+    if (refreshResult.ok) {
+      blockingPanelClose = await closeRecommendBlockingPanels(client, {
+        attemptsLimit: 2,
+        rootState: refreshResult.root_state || rootState
+      });
+    }
+    const compactRefresh = {
+      ...compactRefreshAttempt(refreshResult),
+      context_recovery: true,
+      recovery_reason: reason,
+      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
+      account_rights_panel_close: compactCloseResult(blockingPanelClose),
+      elapsed_ms: Date.now() - started
+    };
     refreshAttempts.push(compactRefresh);
     runControl.checkpoint({
       context_recovery: {
@@ -834,10 +871,15 @@ export async function runRecommendWorkflow({
         refresh_method: refreshResult.method || null,
         refresh_forced_recent_not_view: forceRecentNotView,
         recovery_reason: reason
-      });
-      throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
-    }
-    rootState = refreshResult.root_state || await getRecommendRoots(client);
+      });
+      throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
+    }
+    if (!blockingPanelClose?.closed) {
+      const panelError = createRecommendBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
+      panelError.refresh_attempt = compactRefresh;
+      throw panelError;
+    }
+    rootState = refreshResult.root_state || await getRecommendRoots(client);
     rootState = await ensureRecommendViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
       timeoutMs: cardTimeoutMs,
@@ -863,13 +905,14 @@ export async function runRecommendWorkflow({
     return refreshResult;
   }
 
-  runControl.setPhase("recommend:cleanup");
-  await closeRecommendDetail(client, { attemptsLimit: 2 });
-
-  await runControl.waitIfPaused();
-  runControl.throwIfCanceled();
-  runControl.setPhase("recommend:roots");
-  let rootState = await getRecommendRoots(client);
+  runControl.setPhase("recommend:cleanup");
+  await closeRecommendDetail(client, { attemptsLimit: 2 });
+  await closeRecommendBlockingPanelsForRun("cleanup");
+
+  await runControl.waitIfPaused();
+  runControl.throwIfCanceled();
+  runControl.setPhase("recommend:roots");
+  rootState = await getRecommendRoots(client);
   rootState = await ensureRecommendViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
@@ -1067,9 +1110,28 @@ export async function runRecommendWorkflow({
       try {
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
-        runControl.setPhase("recommend:detail");
-        detailStep = "ensure_viewport";
-        rootState = await ensureRecommendViewport(rootState, "detail");
+        runControl.setPhase("recommend:detail");
+        detailStep = "ensure_viewport";
+        rootState = await ensureRecommendViewport(rootState, "detail");
+        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
+          attemptsLimit: 2,
+          rootState
+        });
+        if (!blockingPanelClose?.closed) {
+          const panelError = createRecommendBlockingPanelCloseFailureError(
+            blockingPanelClose,
+            "before_detail_open"
+          );
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
+          await recoverAndReapplyRecommendContext("account_rights_panel_before_detail", panelError, {
+            forceRecentNotView: true
+          });
+          continue;
+        }
+        if (blockingPanelClose.already_closed === false) {
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+        }
         checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailStep = "open_detail";
         networkRecorder.clear();
@@ -1182,12 +1244,13 @@ export async function runRecommendWorkflow({
               const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
               if (recoveryCount < 1) {
                 candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
-                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
-                  forceRecentNotView: true
-                });
+                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
+                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
+                  forceRecentNotView: true
+                });
                 continue;
               }
               imageEvidence = createRecoverableImageCaptureEvidence(error, {
@@ -1232,20 +1295,22 @@ export async function runRecommendWorkflow({
         if (!isRecoverableRecommendDetailError(error)) throw error;
         const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
         if (recoveryCount < 1) {
-          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
-          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
-            forceRecentNotView: true
-          });
+          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
+          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
+            forceRecentNotView: true
+          });
           continue;
         }
-        recoverableDetailError = error;
-        detailResult = null;
-        timings.detail_recovered_error = compactRecoverableDetailError(error);
-        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-      }
+        recoverableDetailError = error;
+        detailResult = null;
+        timings.detail_recovered_error = compactRecoverableDetailError(error);
+        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+      }
     }
 
     await runControl.waitIfPaused();

package/src/domains/recruit/detail.js

@@ -13,6 +13,10 @@ import {
   buildScreeningCandidateFromDetail,
   htmlToText
 } from "../../core/screening/index.js";
+import {
+  closeBossAccountRightsBlockingPanel,
+  findBossAccountRightsBlockingPanel
+} from "../common/account-rights-panel.js";
 import {
   RECRUIT_DETAIL_CLOSE_SELECTORS,
   RECRUIT_DETAIL_NETWORK_PATTERNS,
@@ -64,6 +68,17 @@ export function createRecruitDetailNetworkRecorder(client) {
   };
 }
 
+export async function findRecruitBlockingPanel(client, options = {}) {
+  return findBossAccountRightsBlockingPanel(client, options);
+}
+
+export async function closeRecruitBlockingPanels(client, options = {}) {
+  return closeBossAccountRightsBlockingPanel(client, {
+    resolveRoots: getRecruitRoots,
+    ...options
+  });
+}
+
 export async function waitForRecruitDetailNetworkEvents(recorder, {
   minCount = 1,
   requireLoaded = true,

package/src/domains/recruit/run-service.js

@@ -44,6 +44,7 @@ import {
   screenCandidate
 } from "../../core/screening/index.js";
 import {
+  closeRecruitBlockingPanels,
   closeRecruitDetail,
   createRecruitDetailNetworkRecorder,
   extractRecruitDetailCandidate,
@@ -159,6 +160,12 @@ function compactError(error, fallbackCode = "RECRUIT_RUN_ERROR") {
     code: error.code || fallbackCode,
     message: error.message || String(error)
   };
+  if (error.close_result) {
+    result.close_result = compactCloseResult(error.close_result);
+  }
+  if (error.phase) {
+    result.phase = error.phase;
+  }
   if (error.refresh_attempt) {
     result.refresh_attempt = error.refresh_attempt;
   }
@@ -174,6 +181,21 @@ function compactError(error, fallbackCode = "RECRUIT_RUN_ERROR") {
   return result;
 }
 
+function compactCloseResult(closeResult) {
+  if (!closeResult) return null;
+  const result = {
+    closed: Boolean(closeResult.closed),
+    reason: closeResult.reason || null,
+    probe: closeResult.probe || null,
+    attempts: closeResult.attempts || [],
+    verification: closeResult.verification || null
+  };
+  if (closeResult.already_closed !== undefined) {
+    result.already_closed = Boolean(closeResult.already_closed);
+  }
+  return result;
+}
+
 function createRecruitCloseFailureError(closeResult) {
   const error = new Error(closeResult?.reason || "Recruit detail did not close before recovery");
   error.code = "DETAIL_CLOSE_FAILED";
@@ -181,6 +203,14 @@ function createRecruitCloseFailureError(closeResult) {
   return error;
 }
 
+function createRecruitBlockingPanelCloseFailureError(closeResult, phase = "") {
+  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
+  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  error.phase = phase || null;
+  return error;
+}
+
 function createRecruitRefreshFailureError(refreshAttempt, {
   listEndReason = "",
   targetCount = 0,
@@ -397,6 +427,7 @@ export async function runRecruitWorkflow({
   let refreshRounds = 0;
   let contextRecoveryAttempts = 0;
   const candidateRecoveryCounts = new Map();
+  let rootState = null;
   let cardNodeIds = [];
   let listEndReason = "";
   let lastHumanEvent = null;
@@ -482,6 +513,17 @@ export async function runRecruitWorkflow({
     });
   }
 
+  async function closeRecruitBlockingPanelsForRun(phase = "cleanup") {
+    const result = await closeRecruitBlockingPanels(client, {
+      attemptsLimit: 2,
+      rootState
+    });
+    if (!result?.closed) {
+      throw createRecruitBlockingPanelCloseFailureError(result, phase);
+    }
+    return result;
+  }
+
   async function recoverAndReapplyRecruitContext(reason = "context_recovery", error = null, {
     forceRecentViewed = true
   } = {}) {
@@ -499,11 +541,18 @@ export async function runRecruitWorkflow({
       cityOptionTimeoutMs,
       forceRecentViewed
     });
+    let blockingPanelClose = null;
+    if (refreshResult.ok) {
+      blockingPanelClose = await closeRecruitBlockingPanels(client, {
+        attemptsLimit: 2
+      });
+    }
     const compactRefresh = {
       ...compactRefreshAttempt(refreshResult),
       context_recovery: true,
       recovery_reason: reason,
       trigger_error: compactError(error, "RECRUIT_CONTEXT_RECOVERY_TRIGGER"),
+      account_rights_panel_close: compactCloseResult(blockingPanelClose),
       elapsed_ms: Date.now() - started
     };
     refreshAttempts.push(compactRefresh);
@@ -525,6 +574,11 @@ export async function runRecruitWorkflow({
       });
       throw new Error(`Recruit context recovery failed after ${reason}: ${refreshResult.application?.reason || "refresh returned no cards"}`);
     }
+    if (!blockingPanelClose?.closed) {
+      const panelError = createRecruitBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
+      panelError.refresh_attempt = compactRefresh;
+      throw panelError;
+    }
     rootState = await getRecruitRoots(client);
     rootState = await ensureRecruitViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecruitCardNodeIds(client, rootState.iframe.documentNodeId, {
@@ -553,11 +607,12 @@ export async function runRecruitWorkflow({
 
   runControl.setPhase("recruit:cleanup");
   await closeRecruitDetail(client, { attemptsLimit: 2 });
+  await closeRecruitBlockingPanelsForRun("cleanup");
 
   await runControl.waitIfPaused();
   runControl.throwIfCanceled();
   runControl.setPhase("recruit:roots");
-  let rootState = await getRecruitRoots(client);
+  rootState = await getRecruitRoots(client);
   rootState = await ensureRecruitViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
@@ -732,6 +787,25 @@ export async function runRecruitWorkflow({
         runControl.setPhase("recruit:detail");
         detailStep = "ensure_viewport";
         rootState = await ensureRecruitViewport(rootState, "detail");
+        const blockingPanelClose = await closeRecruitBlockingPanels(client, {
+          attemptsLimit: 2,
+          rootState
+        });
+        if (!blockingPanelClose?.closed) {
+          const panelError = createRecruitBlockingPanelCloseFailureError(
+            blockingPanelClose,
+            "before_detail_open"
+          );
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
+          await recoverAndReapplyRecruitContext("account_rights_panel_before_detail", panelError, {
+            forceRecentViewed: true
+          });
+          continue;
+        }
+        if (blockingPanelClose.already_closed === false) {
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+        }
         checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailStep = "open_detail";
         networkRecorder.clear();
@@ -835,6 +909,7 @@ export async function runRecruitWorkflow({
                 timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
                 checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
                 await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
                 await recoverAndReapplyRecruitContext(`image_capture:${detailStep}`, error, {
                   forceRecentViewed: true
                 });
@@ -907,6 +982,7 @@ export async function runRecruitWorkflow({
           timings.detail_recovery_trigger = compactRecoverableDetailError(error);
           checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
           await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
           await recoverAndReapplyRecruitContext(`detail:${detailStep}`, error, {
             forceRecentViewed: true
           });
@@ -916,6 +992,7 @@ export async function runRecruitWorkflow({
         detailResult = null;
         timings.detail_recovered_error = compactRecoverableDetailError(error);
         await closeRecruitDetail(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecruitBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
       }
     }