@reconcrap/boss-recommend-mcp 2.0.48 → 2.0.50

package/package.json

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

package/src/domains/chat/jobs.js

@@ -443,6 +443,34 @@ export async function closeChatJobDropdown(client, rootNodeId, {
   });
   if (settleMs > 0) await sleep(settleMs);
   const after = await visibleChatJobOptions(client, rootNodeId);
+  if (after.length) {
+    const currentRootNodeId = await freshTopRootNodeId(client, rootNodeId);
+    for (const selector of CHAT_JOB_TRIGGER_SELECTORS) {
+      const nodeIds = await safeQuerySelectorAll(client, currentRootNodeId, selector);
+      for (const nodeId of nodeIds) {
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box.rect.width <= 2 || box.rect.height <= 2) continue;
+          await clickPoint(client, box.center.x, box.center.y, DETERMINISTIC_CLICK_OPTIONS);
+          if (settleMs > 0) await sleep(settleMs);
+          const afterToggle = await visibleChatJobOptions(client, currentRootNodeId);
+          if (!afterToggle.length) {
+            return {
+              ok: true,
+              closed: true,
+              reason: "trigger_toggle",
+              visible_before_count: before.length,
+              visible_after_count: 0,
+              first_visible_before: before[0] || null,
+              first_visible_after: null
+            };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
   return {
     ok: after.length === 0,
     closed: after.length === 0,

package/src/domains/chat/page-guard.js

@@ -3,6 +3,14 @@ import {
   sleep,
   waitForMainFrameUrl
 } from "../../core/browser/index.js";
+import {
+  buildChatSelfHealConfig,
+  resolveChatSelfHealRoots
+} from "../../core/self-heal/index.js";
+import {
+  createRecoverySettleError,
+  waitForMiniFreshStartSettle
+} from "../common/recovery-settle.js";
 import { CHAT_TARGET_URL } from "./constants.js";
 
 export const CHAT_FORBIDDEN_TOP_LEVEL_RESUME_CODE = "CHAT_FORBIDDEN_TOP_LEVEL_RESUME_NAVIGATION";
@@ -63,7 +71,8 @@ export async function recoverChatShell(client, {
   timeoutMs = 60000,
   intervalMs = 500,
   forceNavigate = false,
-  settleMs = 1200
+  settleMs = 1200,
+  settleAfterNavigate = false
 } = {}) {
   const before = await getChatTopLevelState(client);
   if (before.is_chat_shell && !forceNavigate) {
@@ -85,11 +94,26 @@ export async function recoverChatShell(client, {
     intervalMs
   });
   const after = await getChatTopLevelState(client);
+  let miniFreshStart = null;
+  if (after.is_chat_shell && settleAfterNavigate) {
+    miniFreshStart = await waitForMiniFreshStartSettle(client, {
+      domain: "chat",
+      timeoutMs,
+      intervalMs: Math.max(intervalMs, 800),
+      settleMs: Math.min(settleMs, 5000),
+      selfHealConfig: buildChatSelfHealConfig(),
+      resolveSelfHealRoots: resolveChatSelfHealRoots
+    });
+    if (!miniFreshStart.ok) {
+      throw createRecoverySettleError("chat", miniFreshStart);
+    }
+  }
   return {
     recovered: waited.ok && after.is_chat_shell,
     refreshed: Boolean(forceNavigate && before.is_chat_shell && after.is_chat_shell),
     before,
     after,
+    mini_fresh_start: miniFreshStart,
     wait: waited,
     navigate_result: navigateResult || null,
     navigate_url: targetUrl,

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

@@ -788,7 +788,8 @@ export async function runChatWorkflow({
   if (!initialTopLevelState.is_chat_shell) {
     const recovery = await recoverChatShell(client, {
       targetUrl,
-      timeoutMs: readyTimeoutMs
+      timeoutMs: readyTimeoutMs,
+      settleAfterNavigate: true
     });
     runControl.checkpoint({
       chat_shell_recovery: {
@@ -831,7 +832,8 @@ export async function runChatWorkflow({
     const shellRecovery = await recoverChatShell(client, {
       targetUrl,
       timeoutMs: readyTimeoutMs,
-      forceNavigate: forceRefresh
+      forceNavigate: forceRefresh,
+      settleAfterNavigate: true
     });
     runControl.checkpoint({
       chat_shell_recovery: {

package/src/domains/common/recovery-settle.js

@@ -0,0 +1,159 @@
+import {
+  bringPageToFront,
+  detectBossLoginState,
+  sleep
+} from "../../core/browser/index.js";
+import {
+  HEALTH_STATUS,
+  runSelfHealCheck
+} from "../../core/self-heal/index.js";
+
+function compactProbe(probe = {}) {
+  return {
+    id: probe.id || "",
+    type: probe.type || "",
+    status: probe.status || "",
+    count: probe.count || 0,
+    required: Boolean(probe.required),
+    error: probe.error || null
+  };
+}
+
+export function compactRecoveryHealth(check = null) {
+  if (!check) return null;
+  return {
+    domain: check.domain || "",
+    status: check.status || "",
+    summary: check.summary || null,
+    drift_report: check.drift_report || null,
+    probes: (check.probes || []).map(compactProbe)
+  };
+}
+
+export function createRecoverySettleError(domain, settle = {}) {
+  const status = settle.status || settle.reason || "unknown";
+  const error = new Error(`${domain} mini fresh-start settle failed: ${status}`);
+  error.code = `${String(domain || "boss").toUpperCase()}_RECOVERY_SETTLE_FAILED`;
+  error.recovery_settle = settle;
+  error.retryable = true;
+  return error;
+}
+
+export async function waitForMiniFreshStartSettle(client, {
+  domain = "boss",
+  timeoutMs = 90000,
+  intervalMs = 800,
+  settleMs = 0,
+  readinessLabel = "ready",
+  checkReady = null,
+  selfHealConfig = null,
+  resolveSelfHealRoots = null
+} = {}) {
+  const started = Date.now();
+  let lastReady = null;
+  let lastHealth = null;
+  let lastRoots = null;
+  let lastLoginDetection = null;
+
+  if (typeof client?.Network?.setCacheDisabled === "function") {
+    await client.Network.setCacheDisabled({ cacheDisabled: true }).catch(() => null);
+  }
+  await bringPageToFront(client).catch(() => null);
+  if (settleMs > 0) await sleep(settleMs);
+
+  while (Date.now() - started <= timeoutMs) {
+    lastLoginDetection = await detectBossLoginState(client).catch((error) => ({
+      requires_login: false,
+      reason: "login_detection_failed",
+      error: error?.message || String(error || "")
+    }));
+    if (lastLoginDetection?.requires_login) {
+      return {
+        ok: false,
+        domain,
+        status: "login_required",
+        reason: "login_required",
+        elapsed_ms: Date.now() - started,
+        login_detection: lastLoginDetection,
+        readiness: lastReady,
+        health: compactRecoveryHealth(lastHealth),
+        roots: lastRoots
+      };
+    }
+
+    if (typeof checkReady === "function") {
+      lastReady = await checkReady({
+        elapsedMs: Date.now() - started,
+        remainingMs: Math.max(1, timeoutMs - (Date.now() - started))
+      }).catch((error) => ({
+        ok: false,
+        reason: "readiness_check_failed",
+        error: error?.message || String(error || "")
+      }));
+      if (lastReady?.ok) {
+        return {
+          ok: true,
+          domain,
+          status: "ready",
+          reason: readinessLabel,
+          elapsed_ms: Date.now() - started,
+          readiness: lastReady,
+          health: compactRecoveryHealth(lastHealth),
+          roots: lastRoots
+        };
+      }
+    }
+
+    if (selfHealConfig && typeof resolveSelfHealRoots === "function") {
+      const rootsResult = await resolveSelfHealRoots(client, selfHealConfig).catch((error) => ({
+        roots: {},
+        error: error?.message || String(error || "")
+      }));
+      lastRoots = rootsResult?.roots || {};
+      lastHealth = await runSelfHealCheck({
+        client,
+        domain,
+        roots: lastRoots,
+        selectorProbes: selfHealConfig.selectorProbes || [],
+        accessibilityProbes: selfHealConfig.accessibilityProbes || [],
+        viewportProbes: selfHealConfig.viewportProbes || []
+      }).catch((error) => ({
+        domain,
+        status: "failed",
+        summary: {
+          status: "failed",
+          failed_required: 1
+        },
+        probes: [],
+        drift_report: [],
+        error: error?.message || String(error || "")
+      }));
+      if (lastHealth?.status === HEALTH_STATUS.HEALTHY) {
+        return {
+          ok: true,
+          domain,
+          status: HEALTH_STATUS.HEALTHY,
+          reason: "self_heal_healthy",
+          elapsed_ms: Date.now() - started,
+          readiness: lastReady,
+          health: compactRecoveryHealth(lastHealth),
+          roots: lastRoots
+        };
+      }
+    }
+
+    await sleep(intervalMs);
+  }
+
+  return {
+    ok: false,
+    domain,
+    status: lastHealth?.status || lastReady?.reason || "timeout",
+    reason: "timeout",
+    elapsed_ms: Date.now() - started,
+    login_detection: lastLoginDetection,
+    readiness: lastReady,
+    health: compactRecoveryHealth(lastHealth),
+    roots: lastRoots
+  };
+}

package/src/domains/recommend/detail.js

@@ -312,7 +312,7 @@ export async function readRecommendDetailHtml(client, detailState) {
 
 export function isStaleRecommendNodeError(error) {
   const message = String(error?.message || error || "");
-  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node/i.test(message);
+  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node|Could not compute box model/i.test(message);
 }
 
 export function isRecommendDetailOpenMissError(error) {

package/src/domains/recommend/jobs.js

@@ -1,5 +1,6 @@
 import {
   clickNodeCenter,
+  clickPoint,
   DETERMINISTIC_CLICK_OPTIONS,
   getAttributesMap,
   getNodeBox,
@@ -12,6 +13,7 @@ import {
   htmlToText,
   normalizeText
 } from "../../core/screening/index.js";
+import { isStaleRecommendNodeError } from "./detail.js";
 
 export const RECOMMEND_JOB_SELECTORS = Object.freeze({
   trigger: ".job-selecter-wrap, [class*=\"job-selecter-wrap\"], .ui-dropmenu",
@@ -52,15 +54,26 @@ function isVisibleBox(box) {
 }
 
 async function readJobOption(client, nodeId, index) {
-  const [attributes, outerHTML] = await Promise.all([
-    getAttributesMap(client, nodeId),
-    getOuterHTML(client, nodeId)
-  ]);
+  let attributes = null;
+  let outerHTML = "";
+  try {
+    [attributes, outerHTML] = await Promise.all([
+      getAttributesMap(client, nodeId),
+      getOuterHTML(client, nodeId)
+    ]);
+  } catch (error) {
+    if (isStaleRecommendNodeError(error)) {
+      return null;
+    }
+    throw error;
+  }
   const label = normalizeText(htmlToText(outerHTML));
   let box = null;
   try {
     box = await getNodeBox(client, nodeId);
-  } catch {}
+  } catch (error) {
+    if (!isStaleRecommendNodeError(error)) throw error;
+  }
   const className = attributes.class || "";
   return {
     node_id: nodeId,
@@ -75,19 +88,40 @@ async function readJobOption(client, nodeId, index) {
   };
 }
 
+async function readJobTrigger(client, nodeId) {
+  let box = null;
+  try {
+    box = await getNodeBox(client, nodeId);
+  } catch {}
+  if (!isVisibleBox(box)) return null;
+
+  let label = "";
+  let className = "";
+  try {
+    const outerHTML = await getOuterHTML(client, nodeId);
+    label = normalizeText(htmlToText(outerHTML));
+  } catch {}
+  try {
+    const attributes = await getAttributesMap(client, nodeId);
+    className = attributes.class || "";
+  } catch {}
+
+  return {
+    node_id: nodeId,
+    center: box.center,
+    rect: box.rect,
+    label,
+    label_without_salary: trimSalarySuffix(label),
+    class_name: className,
+    visible: true
+  };
+}
+
 export async function findRecommendJobTrigger(client, frameNodeId) {
   const nodeIds = await querySelectorAll(client, frameNodeId, RECOMMEND_JOB_SELECTORS.trigger);
   for (const nodeId of nodeIds) {
-    try {
-      const box = await getNodeBox(client, nodeId);
-      if (isVisibleBox(box)) {
-        return {
-          node_id: nodeId,
-          center: box.center,
-          rect: box.rect
-        };
-      }
-    } catch {}
+    const trigger = await readJobTrigger(client, nodeId);
+    if (trigger) return trigger;
   }
   return null;
 }
@@ -162,6 +196,7 @@ export async function openRecommendJobDropdown(client, frameNodeId, {
     }
   }
   const error = new Error("Recommend job dropdown did not expose visible options after trigger click");
+  error.trigger = trigger;
   error.job_dropdown_attempts = attempts;
   throw error;
 }
@@ -204,6 +239,7 @@ export async function listRecommendJobOptions(client, frameNodeId, {
     if (seen.has(nodeId)) continue;
     seen.add(nodeId);
     const option = await readJobOption(client, nodeId, index);
+    if (!option) continue;
     if (!option.label) continue;
     if (option.label.length > 120) continue;
     options.push(option);
@@ -230,6 +266,150 @@ export async function closeRecommendJobDropdown(client) {
   };
 }
 
+async function readVisibleRecommendJobOptions(client, frameNodeId) {
+  const options = await listRecommendJobOptions(client, frameNodeId, {
+    openDropdown: false
+  }).catch(() => []);
+  return {
+    options,
+    visible_options: options.filter((option) => option.visible)
+  };
+}
+
+export async function closeRecommendJobDropdownFully(client, frameNodeId, {
+  settleMs = 300,
+  timeoutMs = 1200
+} = {}) {
+  const before = await readVisibleRecommendJobOptions(client, frameNodeId);
+  const attempts = [];
+  if (!before.visible_options.length) {
+    return {
+      ok: true,
+      closed: false,
+      reason: "already_closed",
+      visible_before_count: 0,
+      visible_after_count: 0,
+      attempts
+    };
+  }
+
+  const started = Date.now();
+  for (let attempt = 1; attempt <= 2 && Date.now() - started <= timeoutMs; attempt += 1) {
+    const close = await closeRecommendJobDropdown(client);
+    if (settleMs > 0) await sleep(settleMs);
+    const afterEscape = await readVisibleRecommendJobOptions(client, frameNodeId);
+    attempts.push({
+      method: "escape",
+      attempt,
+      ok: afterEscape.visible_options.length === 0,
+      visible_after_count: afterEscape.visible_options.length,
+      close
+    });
+    if (!afterEscape.visible_options.length) {
+      return {
+        ok: true,
+        closed: true,
+        reason: "escape",
+        visible_before_count: before.visible_options.length,
+        visible_after_count: 0,
+        attempts
+      };
+    }
+  }
+
+  const trigger = await findRecommendJobTrigger(client, frameNodeId).catch(() => null);
+  if (trigger?.node_id) {
+    const click = await clickNodeCenter(client, trigger.node_id, DETERMINISTIC_CLICK_OPTIONS).catch((error) => ({
+      error: error?.message || String(error || "")
+    }));
+    if (settleMs > 0) await sleep(settleMs);
+    const afterToggle = await readVisibleRecommendJobOptions(client, frameNodeId);
+    attempts.push({
+      method: "trigger_toggle",
+      ok: afterToggle.visible_options.length === 0,
+      visible_after_count: afterToggle.visible_options.length,
+      click
+    });
+    if (!afterToggle.visible_options.length) {
+      return {
+        ok: true,
+        closed: true,
+        reason: "trigger_toggle",
+        visible_before_count: before.visible_options.length,
+        visible_after_count: 0,
+        attempts
+      };
+    }
+  }
+
+  const outside = await clickPoint(client, 12, 12, DETERMINISTIC_CLICK_OPTIONS).catch((error) => ({
+    error: error?.message || String(error || "")
+  }));
+  if (settleMs > 0) await sleep(settleMs);
+  const afterOutside = await readVisibleRecommendJobOptions(client, frameNodeId);
+  attempts.push({
+    method: "outside_click",
+    ok: afterOutside.visible_options.length === 0,
+    visible_after_count: afterOutside.visible_options.length,
+    click: outside
+  });
+
+  return {
+    ok: afterOutside.visible_options.length === 0,
+    closed: afterOutside.visible_options.length === 0,
+    reason: afterOutside.visible_options.length ? "still_visible_after_close_attempts" : "outside_click",
+    visible_before_count: before.visible_options.length,
+    visible_after_count: afterOutside.visible_options.length,
+    attempts,
+    first_visible_after: afterOutside.visible_options[0] ? compactJobOption(afterOutside.visible_options[0]) : null
+  };
+}
+
+export async function verifyRecommendJobSelection(client, frameNodeId, {
+  jobLabel = "",
+  delayMs = 2000,
+  dropdownTimeoutMs = 4000,
+  closeSettleMs = 300
+} = {}) {
+  const requested = normalizeText(jobLabel);
+  if (delayMs > 0) await sleep(delayMs);
+  let options = [];
+  let openError = null;
+  try {
+    options = await listRecommendJobOptions(client, frameNodeId, {
+      openDropdown: true
+    });
+  } catch (error) {
+    openError = error;
+    options = await listRecommendJobOptions(client, frameNodeId, {
+      openDropdown: false
+    }).catch(() => []);
+  }
+  const current = options.find((option) => option.current) || null;
+  const verified = Boolean(current && jobLabelMatches(current.label, requested));
+  const menuClose = await closeRecommendJobDropdownFully(client, frameNodeId, {
+    settleMs: closeSettleMs,
+    timeoutMs: Math.max(1200, Math.min(4000, dropdownTimeoutMs))
+  }).catch((error) => ({
+    ok: false,
+    closed: false,
+    reason: "close_failed",
+    error: error?.message || String(error || "")
+  }));
+  return {
+    verified,
+    requested,
+    current_label: current?.label || "",
+    current_label_without_salary: current?.label_without_salary || "",
+    current_option: current ? compactJobOption(current) : null,
+    option_count: options.length,
+    visible_option_count: options.filter((option) => option.visible).length,
+    options: options.map(compactJobOption),
+    open_error: openError ? (openError?.message || String(openError)) : null,
+    menu_close: menuClose
+  };
+}
+
 export async function selectRecommendJob(client, frameNodeId, {
   jobLabel = "",
   settleMs = 6000,
@@ -245,10 +425,42 @@ export async function selectRecommendJob(client, frameNodeId, {
     };
   }
 
-  const opened = await openRecommendJobDropdown(client, frameNodeId, {
-    timeoutMs: dropdownTimeoutMs,
-    triggerTimeoutMs: dropdownTimeoutMs
-  });
+  let opened = null;
+  try {
+    opened = await openRecommendJobDropdown(client, frameNodeId, {
+      timeoutMs: dropdownTimeoutMs,
+      triggerTimeoutMs: dropdownTimeoutMs
+    });
+  } catch (error) {
+    const currentOptions = await listRecommendJobOptions(client, frameNodeId, {
+      openDropdown: false
+    }).catch(() => []);
+    const currentMatch = currentOptions.find((option) => (
+      option.current && jobLabelMatches(option.label, target)
+    ));
+    if (currentMatch) {
+      const menuClose = await closeRecommendJobDropdownFully(client, frameNodeId).catch((closeError) => ({
+        ok: false,
+        closed: false,
+        reason: "close_failed",
+        error: closeError?.message || String(closeError || "")
+      }));
+      return {
+        requested: target,
+        selected: true,
+        already_current: true,
+        selected_option: compactJobOption({
+          ...currentMatch,
+          source: "current_option_without_visible_dropdown"
+        }),
+        options: currentOptions.map(compactJobOption),
+        dropdown_error: error?.message || String(error),
+        job_dropdown_attempts: error?.job_dropdown_attempts || [],
+        menu_close: menuClose
+      };
+    }
+    throw error;
+  }
   const options = opened.options.length
     ? opened.options
     : await listRecommendJobOptions(client, frameNodeId, { openDropdown: false });
@@ -272,13 +484,19 @@ export async function selectRecommendJob(client, frameNodeId, {
   }
 
   if (match.current) {
-    await closeRecommendJobDropdown(client);
+    const menuClose = await closeRecommendJobDropdownFully(client, frameNodeId).catch((error) => ({
+      ok: false,
+      closed: false,
+      reason: "close_failed",
+      error: error?.message || String(error || "")
+    }));
     return {
       requested: target,
       selected: true,
       already_current: true,
       selected_option: compactJobOption(match),
-      options: options.map(compactJobOption)
+      options: options.map(compactJobOption),
+      menu_close: menuClose
     };
   }
 
@@ -289,6 +507,12 @@ export async function selectRecommendJob(client, frameNodeId, {
 
   const clickedBox = await clickNodeCenter(client, match.node_id, DETERMINISTIC_CLICK_OPTIONS);
   if (settleMs > 0) await sleep(settleMs);
+  const menuClose = await closeRecommendJobDropdownFully(client, frameNodeId).catch((error) => ({
+    ok: false,
+    closed: false,
+    reason: "close_failed",
+    error: error?.message || String(error || "")
+  }));
   return {
     requested: target,
     selected: true,
@@ -298,7 +522,8 @@ export async function selectRecommendJob(client, frameNodeId, {
       center: clickedBox.center,
       rect: clickedBox.rect
     },
-    options: options.map(compactJobOption)
+    options: options.map(compactJobOption),
+    menu_close: menuClose
   };
 }
 
@@ -311,6 +536,7 @@ function compactJobOption(option) {
     class_name: option.class_name,
     node_id: option.node_id,
     center: option.center,
-    rect: option.rect
+    rect: option.rect,
+    source: option.source || null
   };
 }

package/src/domains/recommend/refresh.js

@@ -1,4 +1,12 @@
 import { sleep } from "../../core/browser/index.js";
+import {
+  buildRecommendSelfHealConfig,
+  resolveRecommendSelfHealRoots
+} from "../../core/self-heal/index.js";
+import {
+  createRecoverySettleError,
+  waitForMiniFreshStartSettle
+} from "../common/recovery-settle.js";
 import {
   clickRecommendEndRefreshButton,
   waitForRecommendCardNodeIds
@@ -8,12 +16,16 @@ import {
   RECOMMEND_TARGET_URL
 } from "./constants.js";
 import { selectAndConfirmFirstSafeFilter } from "./filters.js";
-import { selectRecommendJob } from "./jobs.js";
+import {
+  selectRecommendJob,
+  verifyRecommendJobSelection
+} from "./jobs.js";
 import { selectRecommendPageScope } from "./scopes.js";
 import {
   getRecommendRoots,
   waitForRecommendRoots
 } from "./roots.js";
+import { isStaleRecommendNodeError } from "./detail.js";
 
 function normalizeLabels(labels = []) {
   return labels.map((label) => String(label || "").trim()).filter(Boolean);
@@ -102,8 +114,9 @@ function compactFilterReapplyError(error) {
 }
 
 export function isRetryableRecommendJobSelectionError(error) {
+  if (isStaleRecommendNodeError(error)) return true;
   const message = String(error?.message || error || "");
-  return /Recommend job trigger was not found|Recommend job dropdown did not mount options|Recommend job dropdown did not expose visible options|Matched recommend job has no clickable center|Matched recommend job has no visible clickable option/i.test(message);
+  return /Recommend job trigger was not found|Recommend job dropdown did not mount options|Recommend job dropdown did not expose visible options|Matched recommend job has no clickable center|Matched recommend job has no visible clickable option|Recommend job selection was not sticky|Recommend job dropdown remained open after sticky verification/i.test(message);
 }
 
 function compactJobSelectionAttempt({
@@ -121,10 +134,40 @@ function compactJobSelectionAttempt({
     attempt,
     iframe_document_node_id: iframeDocumentNodeId || 0,
     selected: Boolean(selection?.selected),
-    selection_reason: selection?.reason || null
+    selection_reason: selection?.reason || null,
+    sticky_verified: selection?.sticky_verification?.verified ?? null,
+    sticky_current_label: selection?.sticky_verification?.current_label_without_salary
+      || selection?.sticky_verification?.current_label
+      || null,
+    sticky_menu_closed: selection?.sticky_verification?.menu_close?.ok ?? null
   };
 }
 
+async function waitForRecommendRecoverySettle(client, {
+  reloadSettleMs = 8000,
+  timeoutMs = 90000
+} = {}) {
+  return waitForMiniFreshStartSettle(client, {
+    domain: "recommend",
+    timeoutMs,
+    intervalMs: reloadSettleMs > 10000 ? 1200 : 800,
+    settleMs: Math.max(0, Math.min(reloadSettleMs || 0, 5000)),
+    selfHealConfig: buildRecommendSelfHealConfig(),
+    resolveSelfHealRoots: resolveRecommendSelfHealRoots
+  });
+}
+
+async function waitForFreshRecommendRoots(client, {
+  timeoutMs = 10000,
+  intervalMs = 500
+} = {}) {
+  const rootState = await waitForRecommendRoots(client, {
+    timeoutMs,
+    intervalMs
+  });
+  return rootState?.iframe?.documentNodeId ? rootState : null;
+}
+
 export async function selectRecommendJobWithRootRefresh(client, rootState, {
   jobLabel = "",
   settleMs = 6000,
@@ -141,7 +184,10 @@ export async function selectRecommendJobWithRootRefresh(client, rootState, {
   while (Date.now() - started <= totalTimeoutMs) {
     attempt += 1;
     if (!currentRootState?.iframe?.documentNodeId) {
-      currentRootState = await getRecommendRoots(client);
+      currentRootState = await waitForFreshRecommendRoots(client, {
+        timeoutMs: Math.min(10000, Math.max(2000, totalTimeoutMs - (Date.now() - started))),
+        intervalMs: 500
+      });
     }
     const iframeDocumentNodeId = currentRootState?.iframe?.documentNodeId || 0;
     try {
@@ -150,6 +196,31 @@ export async function selectRecommendJobWithRootRefresh(client, rootState, {
         settleMs,
         dropdownTimeoutMs
       });
+      if (selection.selected) {
+        const stickyRootState = await waitForFreshRecommendRoots(client, {
+          timeoutMs: Math.min(10000, Math.max(2000, totalTimeoutMs - (Date.now() - started))),
+          intervalMs: 500
+        }) || currentRootState;
+        const stickyFrameNodeId = stickyRootState?.iframe?.documentNodeId || iframeDocumentNodeId;
+        const stickyVerification = await verifyRecommendJobSelection(client, stickyFrameNodeId, {
+          jobLabel,
+          delayMs: 2000,
+          dropdownTimeoutMs,
+          closeSettleMs: 300
+        });
+        selection.sticky_verification = stickyVerification;
+        currentRootState = stickyRootState || currentRootState;
+        if (!stickyVerification.verified) {
+          const stickyError = new Error(`Recommend job selection was not sticky after 2s: requested=${jobLabel}; current=${stickyVerification.current_label_without_salary || stickyVerification.current_label || "unknown"}`);
+          stickyError.sticky_verification = stickyVerification;
+          throw stickyError;
+        }
+        if (stickyVerification.menu_close && stickyVerification.menu_close.ok === false) {
+          const closeError = new Error(`Recommend job dropdown remained open after sticky verification: ${stickyVerification.menu_close.reason || "unknown"}`);
+          closeError.sticky_verification = stickyVerification;
+          throw closeError;
+        }
+      }
       attempts.push(compactJobSelectionAttempt({
         ok: true,
         attempt,
@@ -176,7 +247,10 @@ export async function selectRecommendJobWithRootRefresh(client, rootState, {
         break;
       }
       if (retryDelayMs > 0) await sleep(retryDelayMs);
-      currentRootState = await getRecommendRoots(client);
+      currentRootState = await waitForFreshRecommendRoots(client, {
+        timeoutMs: Math.min(10000, Math.max(2000, totalTimeoutMs - (Date.now() - started))),
+        intervalMs: 500
+      });
     }
   }
 
@@ -251,13 +325,20 @@ async function applyRefreshMethod(client, method, {
   let pageScopeResult = null;
   let filterResult = null;
   let filterReapplyAttempts = [];
+  let recoverySettle = null;
   try {
     if (method === "page_navigate") {
       await client.Page.navigate({ url: targetUrl || RECOMMEND_TARGET_URL });
     } else {
       await client.Page.reload({ ignoreCache: true });
     }
-    if (reloadSettleMs > 0) await sleep(reloadSettleMs);
+    recoverySettle = await waitForRecommendRecoverySettle(client, {
+      reloadSettleMs,
+      timeoutMs: Math.max(45000, reloadSettleMs * 6)
+    });
+    if (!recoverySettle.ok) {
+      throw createRecoverySettleError("recommend", recoverySettle);
+    }
     currentRootState = await waitForRecommendRoots(client, {
       timeoutMs: Math.max(45000, reloadSettleMs * 6),
       intervalMs: 500
@@ -318,6 +399,7 @@ async function applyRefreshMethod(client, method, {
       target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
       job_selection_attempts: jobSelectionAttempts,
+      recovery_settle: recoverySettle,
       page_scope: pageScopeResult,
       filter: filterResult,
       filter_reapply_attempts: filterReapplyAttempts,
@@ -335,6 +417,7 @@ async function applyRefreshMethod(client, method, {
       target_url: method === "page_navigate" ? (targetUrl || RECOMMEND_TARGET_URL) : null,
       job_selection: jobSelection,
       job_selection_attempts: error?.job_selection_attempts || jobSelectionAttempts,
+      recovery_settle: error?.recovery_settle || recoverySettle,
       page_scope: pageScopeResult,
       filter: filterResult,
       filter_reapply_attempts: error?.filter_reapply_attempts || filterReapplyAttempts,

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

@@ -144,10 +144,33 @@ function compactJobSelection(jobSelection) {
   return {
     requested: jobSelection.requested || "",
     selected: Boolean(jobSelection.selected),
-    already_current: Boolean(jobSelection.already_current),
-    reason: jobSelection.reason || null,
-    selected_option: jobSelection.selected_option || null,
-    options: (jobSelection.options || []).map((option) => ({
+    already_current: Boolean(jobSelection.already_current),
+    reason: jobSelection.reason || null,
+    selected_option: jobSelection.selected_option || null,
+    menu_close: jobSelection.menu_close
+      ? {
+          ok: Boolean(jobSelection.menu_close.ok),
+          closed: Boolean(jobSelection.menu_close.closed),
+          reason: jobSelection.menu_close.reason || ""
+        }
+      : null,
+    sticky_verification: jobSelection.sticky_verification
+      ? {
+          verified: Boolean(jobSelection.sticky_verification.verified),
+          current_label: jobSelection.sticky_verification.current_label_without_salary
+            || jobSelection.sticky_verification.current_label
+            || "",
+          visible_option_count: jobSelection.sticky_verification.visible_option_count || 0,
+          menu_close: jobSelection.sticky_verification.menu_close
+            ? {
+                ok: Boolean(jobSelection.sticky_verification.menu_close.ok),
+                closed: Boolean(jobSelection.sticky_verification.menu_close.closed),
+                reason: jobSelection.sticky_verification.menu_close.reason || ""
+              }
+            : null
+        }
+      : null,
+    options: (jobSelection.options || []).map((option) => ({
       label: option.label,
       label_without_salary: option.label_without_salary,
       current: Boolean(option.current),
@@ -364,11 +387,19 @@ function compactRefreshAttempt(refreshAttempt) {
     method: refreshAttempt.method || "",
     reason: refreshAttempt.reason || null,
     error: refreshAttempt.error || null,
-    forced_recent_not_view: Boolean(refreshAttempt.forced_recent_not_view),
-    target_url: refreshAttempt.target_url || null,
-    card_count: refreshAttempt.card_count || 0,
-    elapsed_ms: refreshAttempt.elapsed_ms || 0,
-    attempts: (refreshAttempt.attempts || []).map((attempt) => ({
+    forced_recent_not_view: Boolean(refreshAttempt.forced_recent_not_view),
+    target_url: refreshAttempt.target_url || null,
+    card_count: refreshAttempt.card_count || 0,
+    elapsed_ms: refreshAttempt.elapsed_ms || 0,
+    recovery_settle: refreshAttempt.recovery_settle
+      ? {
+          ok: Boolean(refreshAttempt.recovery_settle.ok),
+          status: refreshAttempt.recovery_settle.status || "",
+          reason: refreshAttempt.recovery_settle.reason || "",
+          elapsed_ms: refreshAttempt.recovery_settle.elapsed_ms || 0
+        }
+      : null,
+    attempts: (refreshAttempt.attempts || []).map((attempt) => ({
       ok: Boolean(attempt.ok),
       method: attempt.method || "",
       reason: attempt.reason || null,
@@ -1256,11 +1287,13 @@ export async function runRecommendWorkflow({
       : useLlmScreening
         ? llmResultToScreening(llmResult, screeningCandidate)
         : screenCandidate(screeningCandidate, { criteria });
-    let actionDiscovery = null;
-    let postActionResult = null;
-    if (postActionEnabled && detailResult) {
-      const postActionStarted = Date.now();
-      await runControl.waitIfPaused();
+    let actionDiscovery = null;
+    let postActionResult = null;
+    let closeFailureError = null;
+    let closeRecoveryFailure = null;
+    if (postActionEnabled && detailResult) {
+      const postActionStarted = Date.now();
+      await runControl.waitIfPaused();
       runControl.throwIfCanceled();
       runControl.setPhase("recommend:post-action");
       await maybeHumanActionCooldown("before_post_action", timings);
@@ -1288,21 +1321,34 @@ export async function runRecommendWorkflow({
       detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
       await maybeHumanActionCooldown("after_detail_close", timings);
       if (!detailResult.close_result?.closed) {
-        const closeError = createRecommendCloseFailureError(detailResult.close_result);
-        const recovery = await recoverAndReapplyRecommendContext("detail_close_failed", closeError, {
-          forceRecentNotView: true
-        });
-        detailResult.cv_acquisition = {
-          ...(detailResult.cv_acquisition || {}),
-          close_recovery: {
-            ok: Boolean(recovery.ok),
-            method: recovery.method || "",
-            forced_recent_not_view: Boolean(recovery.forced_recent_not_view),
-            card_count: recovery.card_count || 0
-          }
-        };
-      }
-    }
+        closeFailureError = createRecommendCloseFailureError(detailResult.close_result);
+        try {
+          const recovery = await recoverAndReapplyRecommendContext("detail_close_failed", closeFailureError, {
+            forceRecentNotView: true
+          });
+          detailResult.cv_acquisition = {
+            ...(detailResult.cv_acquisition || {}),
+            close_recovery: {
+              ok: Boolean(recovery.ok),
+              method: recovery.method || "",
+              forced_recent_not_view: Boolean(recovery.forced_recent_not_view),
+              card_count: recovery.card_count || 0
+            }
+          };
+        } catch (error) {
+          closeRecoveryFailure = error;
+          detailResult.cv_acquisition = {
+            ...(detailResult.cv_acquisition || {}),
+            close_recovery: {
+              ok: false,
+              reason: "context_recovery_failed",
+              error: error?.message || String(error),
+              forced_recent_not_view: true
+            }
+          };
+        }
+      }
+    }
     timings.total_ms = Date.now() - candidateStarted;
     const compactResult = {
       index,
@@ -1313,12 +1359,14 @@ export async function runRecommendWorkflow({
       llm_screening: detailResult ? null : compactScreeningLlmResult(llmResult),
       screening: compactScreening(screening),
       action_discovery: compactActionDiscovery(actionDiscovery),
-      post_action: postActionResult,
-      error: recoverableDetailError
-        ? compactRecoverableDetailError(recoverableDetailError)
-        : detailResult?.image_evidence?.ok === false
-        ? compactError({
-          code: detailResult.image_evidence.error_code,
+      post_action: postActionResult,
+      error: recoverableDetailError
+        ? compactRecoverableDetailError(recoverableDetailError)
+        : closeRecoveryFailure
+        ? compactError(closeFailureError, "DETAIL_CLOSE_FAILED")
+        : detailResult?.image_evidence?.ok === false
+        ? compactError({
+          code: detailResult.image_evidence.error_code,
           message: detailResult.image_evidence.error
         }, "IMAGE_CAPTURE_FAILED")
         : null,
@@ -1353,9 +1401,13 @@ export async function runRecommendWorkflow({
         error: compactResult.error,
         post_action: postActionResult
       }
-    });
-    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
-
+    });
+    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
+
+    if (closeRecoveryFailure) {
+      throw closeRecoveryFailure;
+    }
+
     if (postActionResult?.stop_run) {
       listEndReason = postActionResult.reason || "post_action_stop";
       break;

package/src/domains/recruit/refresh.js

@@ -39,6 +39,7 @@ export async function refreshRecruitSearchAtEnd(client, {
     forced_recent_viewed: Boolean(forceRecentViewed),
     search_params: refreshSearchParams,
     card_count: cardCount,
+    recovery_settle: application.reset?.mini_fresh_start || null,
     application
   };
 }

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

@@ -129,6 +129,14 @@ function compactRefreshAttempt(refreshAttempt) {
     forced_recent_viewed: Boolean(refreshAttempt.forced_recent_viewed),
     card_count: refreshAttempt.card_count || 0,
     search_params: refreshAttempt.search_params || null,
+    recovery_settle: refreshAttempt.recovery_settle
+      ? {
+          ok: Boolean(refreshAttempt.recovery_settle.ok),
+          status: refreshAttempt.recovery_settle.status || "",
+          reason: refreshAttempt.recovery_settle.reason || "",
+          elapsed_ms: refreshAttempt.recovery_settle.elapsed_ms || 0
+        }
+      : null,
     application: refreshAttempt.application
       ? {
           applied: Boolean(refreshAttempt.application.applied),

package/src/domains/recruit/search.js

@@ -17,6 +17,10 @@ import {
   htmlToText,
   normalizeText
 } from "../../core/screening/index.js";
+import {
+  createRecoverySettleError,
+  waitForMiniFreshStartSettle
+} from "../common/recovery-settle.js";
 import {
   RECRUIT_CARD_SELECTOR,
   RECRUIT_TARGET_URL,
@@ -402,12 +406,30 @@ export async function waitForRecruitSearchControls(client, {
   };
 }
 
+async function settleRecruitSearchAfterReset(client, {
+  timeoutMs = DEFAULT_RECRUIT_RESET_TIMEOUT_MS,
+  settleMs = 5000
+} = {}) {
+  return waitForMiniFreshStartSettle(client, {
+    domain: "search",
+    timeoutMs,
+    intervalMs: 500,
+    settleMs: Math.max(0, Math.min(settleMs || 0, 5000)),
+    readinessLabel: "search_controls_ready",
+    checkReady: ({ remainingMs }) => waitForRecruitSearchControls(client, {
+      timeoutMs: Math.min(Math.max(1, remainingMs), 1500),
+      intervalMs: 300
+    })
+  });
+}
+
 export async function resetRecruitSearchPage(client, {
   url = RECRUIT_TARGET_URL,
   settleMs = 5000,
   timeoutMs = DEFAULT_RECRUIT_RESET_TIMEOUT_MS
 } = {}) {
   const actions = [];
+  let miniFreshStart = null;
   const rootTimeoutMs = Math.min(timeoutMs, 90000);
   async function waitForRootsAfterSettle() {
     await sleep(settleMs);
@@ -432,6 +454,21 @@ export async function resetRecruitSearchPage(client, {
     actions.push({ method: "Page.navigate", url });
   }
 
+  miniFreshStart = await settleRecruitSearchAfterReset(client, {
+    timeoutMs: Math.min(timeoutMs, 90000),
+    settleMs
+  });
+  actions.push({
+    method: "mini_fresh_start_settle",
+    ok: Boolean(miniFreshStart.ok),
+    status: miniFreshStart.status || "",
+    reason: miniFreshStart.reason || "",
+    elapsed_ms: miniFreshStart.elapsed_ms || 0
+  });
+  if (!miniFreshStart.ok) {
+    throw createRecoverySettleError("search", miniFreshStart);
+  }
+
   let roots = await waitForRootsAfterSettle();
   const frameReset = await navigateRecruitSearchFrame(client, roots?.iframe?.nodeId, {
     pageUrl: url,
@@ -459,6 +496,20 @@ export async function resetRecruitSearchPage(client, {
       actions.push(fallbackFrameReset);
       await sleep(settleMs);
     }
+    miniFreshStart = await settleRecruitSearchAfterReset(client, {
+      timeoutMs: Math.min(timeoutMs, 90000),
+      settleMs: Math.min(settleMs, 1500)
+    });
+    actions.push({
+      method: "mini_fresh_start_settle_after_navigate",
+      ok: Boolean(miniFreshStart.ok),
+      status: miniFreshStart.status || "",
+      reason: miniFreshStart.reason || "",
+      elapsed_ms: miniFreshStart.elapsed_ms || 0
+    });
+    if (!miniFreshStart.ok) {
+      throw createRecoverySettleError("search", miniFreshStart);
+    }
     controls = await waitForControls();
   }
   roots = await getRecruitRoots(client, { requireFrame: false });
@@ -473,6 +524,7 @@ export async function resetRecruitSearchPage(client, {
     target_url: url,
     iframe_selector: controls.iframe_selector || roots.iframe.selector,
     iframe_document_node_id: controls.iframe_document_node_id || roots.iframe.documentNodeId,
+    mini_fresh_start: miniFreshStart,
     controls
   };
 }