@reconcrap/boss-recommend-mcp 2.0.17 → 2.0.18

package/package.json

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

package/src/chat-mcp.js

@@ -34,6 +34,7 @@ import {
 import {
   CHAT_TARGET_URL,
   closeChatResumeModal,
+  closeChatJobDropdown,
   createChatRunService,
   getChatRoots,
   isForbiddenChatResumeTopLevelUrl,
@@ -833,7 +834,18 @@ async function connectChatChromeSession({
 
 async function readChatJobOptionsFromSession(session) {
   const roots = await getChatRoots(session.client);
-  return readChatJobOptions(session.client, roots.rootNodes.top);
+  const result = await readChatJobOptions(session.client, roots.rootNodes.top);
+  try {
+    result.menu_close = await closeChatJobDropdown(session.client, roots.rootNodes.top);
+  } catch (error) {
+    result.menu_close = {
+      ok: false,
+      closed: false,
+      reason: "close_failed",
+      error: error?.message || String(error)
+    };
+  }
+  return result;
 }
 
 function normalizeChatStartInput(args = {}, configResolution = null) {

package/src/core/capture/index.js

@@ -246,6 +246,190 @@ function pickEvenly(items = [], limit = 1) {
   return Array.from(new Map(picked.map((item) => [item.node_id, item])).values());
 }
 
+function patternLabel(pattern) {
+  if (pattern instanceof RegExp) return pattern.source;
+  return normalizeText(pattern);
+}
+
+function stopBoundaryPatterns(patterns = []) {
+  return (Array.isArray(patterns) ? patterns : [patterns])
+    .filter(Boolean)
+    .map((pattern) => {
+      if (pattern instanceof RegExp) {
+        return {
+          raw: pattern,
+          label: pattern.source,
+          matches: (text) => pattern.test(text)
+        };
+      }
+      const normalized = normalizeText(pattern);
+      return {
+        raw: pattern,
+        label: normalized,
+        matches: (text) => normalized && text.includes(normalized)
+      };
+    });
+}
+
+async function collectStopBoundaryNodes(client, rootNodeId, {
+  selector = "",
+  textPatterns = [],
+  maxProbeNodes = 180,
+  maxTextLength = 700,
+  stepTimeoutMs = 45000
+} = {}) {
+  const patterns = stopBoundaryPatterns(textPatterns);
+  const normalizedSelector = normalizeText(selector);
+  if (!normalizedSelector && !patterns.length) {
+    return {
+      enabled: false,
+      ok: false,
+      reason: "not_configured",
+      nodes: []
+    };
+  }
+  const started = Date.now();
+  let nodeIds = [];
+  try {
+    nodeIds = uniqueNumbers(await querySelectorAll(
+      client,
+      rootNodeId,
+      normalizedSelector || DEFAULT_SCROLL_ANCHOR_SELECTOR
+    ));
+  } catch (error) {
+    return {
+      enabled: true,
+      ok: false,
+      reason: "query_selector_all_failed",
+      selector: normalizedSelector || DEFAULT_SCROLL_ANCHOR_SELECTOR,
+      error: error?.message || String(error),
+      nodes: []
+    };
+  }
+
+  const probeLimit = Math.max(1, Number(maxProbeNodes) || 180);
+  const maxStopTextLength = Math.max(40, Number(maxTextLength) || 700);
+  const perNodeTimeoutMs = Math.min(1000, Math.max(200, Math.floor((Number(stepTimeoutMs) || 45000) / 40)));
+  const nodes = [];
+  for (const nodeId of nodeIds.slice(0, probeLimit)) {
+    try {
+      let text = "";
+      let matchedPattern = null;
+      if (patterns.length) {
+        const outerHTML = await withCaptureTimeout(getOuterHTML(client, nodeId), {
+          label: `stop_boundary_html_${nodeId}`,
+          timeoutMs: perNodeTimeoutMs
+        });
+        text = normalizeText(htmlToText(outerHTML));
+        if (!text || text.length > maxStopTextLength) continue;
+        matchedPattern = patterns.find((pattern) => pattern.matches(text));
+        if (!matchedPattern) continue;
+      }
+      nodes.push({
+        node_id: nodeId,
+        text_preview: text.slice(0, 120),
+        matched_pattern: matchedPattern ? patternLabel(matchedPattern.raw) : null
+      });
+    } catch {}
+  }
+
+  return {
+    enabled: true,
+    ok: nodes.length > 0,
+    reason: nodes.length ? null : "no_matching_stop_boundary_nodes",
+    selector: normalizedSelector || DEFAULT_SCROLL_ANCHOR_SELECTOR,
+    elapsed_ms: Date.now() - started,
+    discovered_node_count: nodeIds.length,
+    probed_node_count: Math.min(nodeIds.length, probeLimit),
+    match_count: nodes.length,
+    pattern_labels: patterns.map((pattern) => pattern.label),
+    nodes
+  };
+}
+
+async function resolveVisibleStopBoundary(client, stopBoundaryPlan, clip, {
+  topPadding = 8,
+  minCaptureHeight = 180,
+  stepTimeoutMs = 45000
+} = {}) {
+  if (!stopBoundaryPlan?.nodes?.length || !clip) return null;
+  const clipTop = Number(clip.y) || 0;
+  const clipBottom = clipTop + (Number(clip.height) || 0);
+  const safePadding = Math.max(0, Number(topPadding) || 0);
+  const safeMinHeight = Math.max(1, Number(minCaptureHeight) || 180);
+  const perNodeTimeoutMs = Math.min(900, Math.max(180, Math.floor((Number(stepTimeoutMs) || 45000) / 50)));
+  const visible = [];
+
+  for (const node of stopBoundaryPlan.nodes) {
+    try {
+      const box = await withCaptureTimeout(getNodeBox(client, node.node_id), {
+        label: `stop_boundary_box_${node.node_id}`,
+        timeoutMs: perNodeTimeoutMs
+      });
+      const rect = box?.rect || {};
+      const width = Number(rect.width) || 0;
+      const height = Number(rect.height) || 0;
+      if (width < 40 || height < 6) continue;
+      const top = Number(rect.y) || 0;
+      const bottom = top + height;
+      if (bottom <= clipTop + 1) {
+        return {
+          action: "stop_before_capture",
+          reason: "stop_boundary_above_clip",
+          node_id: node.node_id,
+          matched_pattern: node.matched_pattern,
+          text_preview: node.text_preview,
+          rect,
+          clip
+        };
+      }
+      if (top < clipBottom && bottom > clipTop) {
+        visible.push({
+          ...node,
+          rect,
+          top,
+          bottom
+        });
+      }
+    } catch {}
+  }
+  if (!visible.length) return null;
+
+  visible.sort((a, b) => a.top - b.top);
+  const boundary = visible[0];
+  const boundaryY = Math.max(clipTop, boundary.top - safePadding);
+  const adjustedHeight = Math.max(0, boundaryY - clipTop);
+  if (adjustedHeight < safeMinHeight) {
+    return {
+      action: "stop_before_capture",
+      reason: "stop_boundary_near_clip_top",
+      node_id: boundary.node_id,
+      matched_pattern: boundary.matched_pattern,
+      text_preview: boundary.text_preview,
+      rect: boundary.rect,
+      clip,
+      adjusted_height: adjustedHeight,
+      min_capture_height: safeMinHeight
+    };
+  }
+
+  return {
+    action: "capture_then_stop",
+    reason: "stop_boundary_visible",
+    node_id: boundary.node_id,
+    matched_pattern: boundary.matched_pattern,
+    text_preview: boundary.text_preview,
+    rect: boundary.rect,
+    clip,
+    adjusted_clip: {
+      ...clip,
+      height: adjustedHeight
+    },
+    adjusted_height: adjustedHeight,
+    min_capture_height: safeMinHeight
+  };
+}
+
 async function collectDomScrollAnchors(client, rootNodeId, {
   selector = DEFAULT_SCROLL_ANCHOR_SELECTOR,
   maxScreenshots = 6,
@@ -525,6 +709,12 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   scrollAnchorSelector = DEFAULT_SCROLL_ANCHOR_SELECTOR,
   scrollAnchorMaxProbeNodes = 260,
   scrollAnchorMinGap = 180,
+  stopBoundarySelector = "",
+  stopBoundaryTextPatterns = [],
+  stopBoundaryMaxProbeNodes = 180,
+  stopBoundaryMaxTextLength = 700,
+  stopBoundaryTopPadding = 8,
+  stopBoundaryMinCaptureHeight = 180,
   metadata = {}
 } = {}) {
   if (!nodeId) throw new Error("captureScrolledNodeScreenshots requires nodeId");
@@ -540,11 +730,26 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
         stepTimeoutMs
       })
     : null;
+  const stopBoundaryEnabled = Boolean(
+    normalizeText(stopBoundarySelector)
+    || (Array.isArray(stopBoundaryTextPatterns)
+      ? stopBoundaryTextPatterns.length
+      : stopBoundaryTextPatterns)
+  );
+  let stopBoundaryPlan = {
+    enabled: false,
+    ok: false,
+    reason: "not_configured",
+    nodes: []
+  };
+  const stopBoundaryChecks = [];
   const screenshots = [];
   let consecutiveDuplicates = 0;
   let previousHash = "";
   let captureCount = 0;
   let droppedDuplicateCount = 0;
+  let forceInputScrollAfterDuplicate = false;
+  let stopBoundaryResult = null;
   let currentScrollMetadata = {
     before_capture: "initial",
     method: normalizedScrollMethod,
@@ -597,7 +802,37 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       timeoutMs: stepTimeoutMs
     });
     const clip = withPadding(box.rect, padding);
-    const captureOptions = captureViewport ? {
+    let visibleStopBoundary = null;
+    if (stopBoundaryEnabled) {
+      stopBoundaryPlan = await collectStopBoundaryNodes(client, nodeId, {
+        selector: stopBoundarySelector,
+        textPatterns: stopBoundaryTextPatterns,
+        maxProbeNodes: stopBoundaryMaxProbeNodes,
+        maxTextLength: stopBoundaryMaxTextLength,
+        stepTimeoutMs
+      });
+      stopBoundaryChecks.push({
+        capture_index: index,
+        ok: Boolean(stopBoundaryPlan.ok),
+        reason: stopBoundaryPlan.reason || null,
+        discovered_node_count: stopBoundaryPlan.discovered_node_count || 0,
+        probed_node_count: stopBoundaryPlan.probed_node_count || 0,
+        match_count: stopBoundaryPlan.match_count || 0,
+        elapsed_ms: stopBoundaryPlan.elapsed_ms || 0
+      });
+      visibleStopBoundary = await resolveVisibleStopBoundary(client, stopBoundaryPlan, clip, {
+        topPadding: stopBoundaryTopPadding,
+        minCaptureHeight: stopBoundaryMinCaptureHeight,
+        stepTimeoutMs
+      });
+    }
+    if (visibleStopBoundary?.action === "stop_before_capture") {
+      stopBoundaryResult = visibleStopBoundary;
+      break;
+    }
+    const effectiveClip = visibleStopBoundary?.adjusted_clip || clip;
+    const effectiveCaptureViewport = Boolean(captureViewport && !visibleStopBoundary?.adjusted_clip);
+    const captureOptions = effectiveCaptureViewport ? {
       format,
       fromSurface,
       captureBeyondViewport: false
@@ -605,7 +840,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       format,
       fromSurface,
       captureBeyondViewport,
-      clip
+      clip: effectiveClip
     };
     if (quality != null) {
       captureOptions.quality = quality;
@@ -658,16 +893,30 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
         file_path: outputPath,
         sha256: hash,
         duplicate_of_previous: Boolean(duplicateOfPrevious),
-        clip,
-        capture_viewport: Boolean(captureViewport),
+        clip: effectiveClip,
+        capture_viewport: effectiveCaptureViewport,
         node_rect: box.rect,
         scroll: currentScrollMetadata,
+        stop_boundary: visibleStopBoundary || null,
         metadata
       });
     }
 
+    if (visibleStopBoundary?.action === "capture_then_stop") {
+      stopBoundaryResult = visibleStopBoundary;
+      break;
+    }
+
     previousHash = hash;
-    if (consecutiveDuplicates >= Math.max(1, Number(duplicateStopCount) || 1)) {
+    forceInputScrollAfterDuplicate = Boolean(
+      duplicateOfPrevious
+      && normalizedScrollMethod === "dom-anchor-fallback-input"
+      && currentScrollMetadata?.method === "DOM.scrollIntoViewIfNeeded"
+    );
+    if (
+      consecutiveDuplicates >= Math.max(1, Number(duplicateStopCount) || 1)
+      && !forceInputScrollAfterDuplicate
+    ) {
       break;
     }
 
@@ -675,7 +924,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       assertCaptureTotalBudget(sequenceStarted, totalTimeoutMs, `scroll_after_page_${index + 1}`);
       let scrolledByDomAnchor = false;
       const nextAnchor = anchorPlan?.anchors?.[index + 1] || null;
-      if (nextAnchor?.node_id && normalizedScrollMethod !== "input") {
+      if (nextAnchor?.node_id && normalizedScrollMethod !== "input" && !forceInputScrollAfterDuplicate) {
         try {
           await scrollDomAnchorIntoView(client, nextAnchor.node_id, {
             label: `scroll_dom_anchor_${index + 1}`,
@@ -782,12 +1031,15 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       step_timeout_ms: Math.max(0, Number(stepTimeoutMs) || 0),
       total_timeout_ms: Math.max(0, Number(totalTimeoutMs) || 0),
       scroll_method: normalizedScrollMethod,
-      scroll_anchor_selector: scrollAnchorSelector,
-      scroll_anchor_max_probe_nodes: Math.max(1, Number(scrollAnchorMaxProbeNodes) || 260),
-      scroll_anchor_min_gap: Math.max(0, Number(scrollAnchorMinGap) || 0)
-    },
-    scroll_anchor_plan: anchorPlan,
-    file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
+    scroll_anchor_selector: scrollAnchorSelector,
+    scroll_anchor_max_probe_nodes: Math.max(1, Number(scrollAnchorMaxProbeNodes) || 260),
+    scroll_anchor_min_gap: Math.max(0, Number(scrollAnchorMinGap) || 0)
+  },
+  scroll_anchor_plan: anchorPlan,
+  stop_boundary_plan: stopBoundaryPlan,
+  stop_boundary_checks: stopBoundaryChecks,
+  stop_boundary_result: stopBoundaryResult,
+  file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,
     metadata
   };

package/src/core/cv-acquisition/index.js

@@ -138,6 +138,10 @@ export function summarizeImageEvidence(imageEvidence = null) {
     llm_original_total_byte_length: imageEvidence.llm_original_total_byte_length || 0,
     llm_composition_error: imageEvidence.llm_composition_error || null,
     optimization: imageEvidence.optimization || null,
+    scroll_anchor_plan: imageEvidence.scroll_anchor_plan || null,
+    stop_boundary_plan: imageEvidence.stop_boundary_plan || null,
+    stop_boundary_checks: imageEvidence.stop_boundary_checks || [],
+    stop_boundary_result: imageEvidence.stop_boundary_result || null,
     error_code: imageEvidence.error_code || imageEvidence.code || null,
     error: imageEvidence.error || null,
     file_paths: imageEvidence.file_paths || [],

package/src/domains/chat/jobs.js

@@ -4,6 +4,7 @@ import {
   getAttributesMap,
   getNodeBox,
   getOuterHTML,
+  pressKey,
   querySelector,
   querySelectorAll,
   sleep
@@ -256,6 +257,80 @@ async function clickFirstVisible(client, rootNodeId, selectors = []) {
   };
 }
 
+async function openChatJobDropdown(client, rootNodeId, {
+  timeoutMs = 12000,
+  intervalMs = 300,
+  settleMs = 800
+} = {}) {
+  const started = Date.now();
+  const triedPoints = new Set();
+  const attempts = [];
+  for (const selector of CHAT_JOB_TRIGGER_SELECTORS) {
+    const currentRootNodeId = await freshTopRootNodeId(client, rootNodeId);
+    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;
+        const y = box.center.y;
+        const xCandidates = [
+          ["center", box.center.x],
+          ["right_12", box.rect.x + box.rect.width - 12],
+          ["right_44", box.rect.x + box.rect.width - 44],
+          ["right_64", box.rect.x + box.rect.width - 64]
+        ].filter(([, x]) => x > box.rect.x + 4 && x < box.rect.x + box.rect.width - 4);
+        for (const [pointName, x] of xCandidates) {
+          const pointKey = `${nodeId}:${Math.round(x)}:${Math.round(y)}`;
+          if (triedPoints.has(pointKey)) continue;
+          triedPoints.add(pointKey);
+          await clickPoint(client, x, y);
+          if (settleMs > 0) await sleep(Math.min(settleMs, 800));
+          const remaining = Math.max(300, timeoutMs - (Date.now() - started));
+          const optionsResult = await waitForChatJobOptions(client, currentRootNodeId, {
+            timeoutMs: Math.min(remaining, 1800),
+            intervalMs,
+            requireVisible: true
+          });
+          const visibleCount = (optionsResult.job_options || []).filter((option) => option.visible).length;
+          const attempt = {
+            clicked: true,
+            selector,
+            node_id: nodeId,
+            point: pointName,
+            center: { x, y },
+            visible_option_count: visibleCount
+          };
+          attempts.push(attempt);
+          if (visibleCount > 0) {
+            return {
+              ...attempt,
+              attempts,
+              options_result: optionsResult
+            };
+          }
+          if (Date.now() - started > timeoutMs) break;
+        }
+      } catch (error) {
+        attempts.push({
+          clicked: false,
+          selector,
+          node_id: nodeId,
+          error: error?.message || String(error)
+        });
+      }
+      if (Date.now() - started > timeoutMs) break;
+    }
+    if (Date.now() - started > timeoutMs) break;
+  }
+  return {
+    clicked: attempts.some((attempt) => attempt.clicked),
+    selector: attempts.find((attempt) => attempt.clicked)?.selector || "",
+    node_id: attempts.find((attempt) => attempt.clicked)?.node_id || 0,
+    attempts,
+    options_result: null
+  };
+}
+
 async function waitForChatJobOptions(client, rootNodeId, {
   timeoutMs = 12000,
   intervalMs = 300,
@@ -312,6 +387,83 @@ async function waitForSelectedChatJob(client, rootNodeId, jobLabel = "", {
   };
 }
 
+async function visibleChatJobOptions(client, rootNodeId) {
+  const currentRootNodeId = await freshTopRootNodeId(client, rootNodeId);
+  const visible = [];
+  for (const selector of CHAT_JOB_OPTION_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) {
+          visible.push({
+            selector,
+            node_id: nodeId,
+            center: box.center,
+            rect: box.rect
+          });
+        }
+      } catch {
+        // Hidden job options are normal when the dropdown is closed.
+      }
+    }
+  }
+  return visible;
+}
+
+export async function closeChatJobDropdown(client, rootNodeId, {
+  settleMs = 180
+} = {}) {
+  const before = await visibleChatJobOptions(client, rootNodeId);
+  if (!before.length) {
+    return {
+      ok: true,
+      closed: false,
+      reason: "already_closed",
+      visible_before_count: 0,
+      visible_after_count: 0
+    };
+  }
+  if (typeof client?.Input?.dispatchKeyEvent !== "function") {
+    return {
+      ok: false,
+      closed: false,
+      reason: "dispatch_key_unavailable",
+      visible_before_count: before.length,
+      visible_after_count: before.length
+    };
+  }
+  await pressKey(client, "Escape", {
+    code: "Escape",
+    windowsVirtualKeyCode: 27,
+    nativeVirtualKeyCode: 27
+  });
+  if (settleMs > 0) await sleep(settleMs);
+  const after = await visibleChatJobOptions(client, rootNodeId);
+  return {
+    ok: after.length === 0,
+    closed: after.length === 0,
+    reason: after.length ? "still_visible_after_escape" : "escape",
+    visible_before_count: before.length,
+    visible_after_count: after.length,
+    first_visible_before: before[0] || null,
+    first_visible_after: after[0] || null
+  };
+}
+
+async function closeChatJobDropdownQuietly(client, rootNodeId, settleMs = 180) {
+  try {
+    return await closeChatJobDropdown(client, rootNodeId, { settleMs });
+  } catch (error) {
+    return {
+      ok: false,
+      closed: false,
+      reason: "close_failed",
+      error: error?.message || String(error)
+    };
+  }
+}
+
 export async function selectChatJob(client, rootNodeId, {
   jobLabel = "",
   timeoutMs = 12000,
@@ -340,6 +492,7 @@ export async function selectChatJob(client, rootNodeId, {
       || selectedLabelMatches(optionsResult.selected_label, requested)
     )
   ) {
+    const menuClose = await closeChatJobDropdownQuietly(client, currentRootNodeId, Math.min(settleMs, 300));
     return {
       selected: true,
       verified: true,
@@ -347,34 +500,41 @@ export async function selectChatJob(client, rootNodeId, {
       requested,
       selected_option: matched,
       options: optionsResult.job_options || [],
-      selected_label: optionsResult.selected_label || matched.label
+      selected_label: optionsResult.selected_label || matched.label,
+      menu_close: menuClose
     };
   }
 
   if (!matched || !matched.visible) {
     const triggerRootNodeId = await freshTopRootNodeId(client, currentRootNodeId);
-    const trigger = await clickFirstVisible(client, triggerRootNodeId, CHAT_JOB_TRIGGER_SELECTORS);
-    if (settleMs > 0) await sleep(settleMs);
+    const trigger = await openChatJobDropdown(client, triggerRootNodeId, {
+      timeoutMs,
+      intervalMs,
+      settleMs
+    });
     currentRootNodeId = await freshTopRootNodeId(client, triggerRootNodeId);
-    optionsResult = await waitForChatJobOptions(client, currentRootNodeId, {
+    optionsResult = trigger.options_result || await waitForChatJobOptions(client, currentRootNodeId, {
       timeoutMs,
       intervalMs,
       requireVisible: true
     });
     matched = (optionsResult.job_options || []).find((option) => matchJobOption(option, requested)) || null;
     if (!matched || !matched.visible) {
+      const menuClose = await closeChatJobDropdownQuietly(client, currentRootNodeId, Math.min(settleMs, 300));
       return {
         selected: false,
         reason: matched ? "job_option_not_visible" : "job_option_not_found",
         requested,
         trigger,
         options: optionsResult.job_options || [],
-        selected_label_before: optionsResult.selected_label || ""
+        selected_label_before: optionsResult.selected_label || "",
+        menu_close: menuClose
       };
     }
   }
 
   if (matched.active || normalizeJobText(optionsResult.selected_label).toLowerCase() === normalizeJobText(matched.label).toLowerCase()) {
+    const menuClose = await closeChatJobDropdownQuietly(client, currentRootNodeId, Math.min(settleMs, 300));
     return {
       selected: true,
       verified: true,
@@ -382,7 +542,8 @@ export async function selectChatJob(client, rootNodeId, {
       requested,
       selected_option: matched,
       options: optionsResult.job_options || [],
-      selected_label: optionsResult.selected_label || matched.label
+      selected_label: optionsResult.selected_label || matched.label,
+      menu_close: menuClose
     };
   }
 
@@ -408,6 +569,7 @@ export async function selectChatJob(client, rootNodeId, {
   const selectedLabel = normalizeJobText(after.selected_label || "");
   const activeMatch = activeMatchingJobOption(after.job_options || [], matched.label);
   const verified = Boolean(verification.verified || selectedLabelMatches(selectedLabel, matched.label) || activeMatch);
+  const menuClose = await closeChatJobDropdownQuietly(client, afterRootNodeId, Math.min(settleMs, 300));
 
   return {
     selected: verified,
@@ -420,6 +582,7 @@ export async function selectChatJob(client, rootNodeId, {
     options: after.job_options || optionsResult.job_options || [],
     selected_label: selectedLabel,
     before: optionsResult,
-    after
+    after,
+    menu_close: menuClose
   };
 }

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

@@ -21,7 +21,8 @@ import {
   createInfiniteListState,
   detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
-  markInfiniteListCandidateProcessed
+  markInfiniteListCandidateProcessed,
+  resetInfiniteListForRefreshRound
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import { createRunLifecycleManager } from "../../core/run/index.js";
@@ -117,6 +118,22 @@ function compactCandidate(candidate) {
   };
 }
 
+function compactChatJobGuard(result = null) {
+  if (!result || typeof result !== "object") return null;
+  return {
+    selected: Boolean(result.selected),
+    verified: Boolean(result.verified),
+    already_current: Boolean(result.already_current),
+    requested: result.requested || null,
+    reason: result.reason || null,
+    selected_label: result.selected_label || result.selected_option?.label || null,
+    selected_value: result.selected_option?.value || result.active_option?.value || null,
+    active_label: result.active_option?.label || null,
+    active_value: result.active_option?.value || null,
+    menu_close: result.menu_close || null
+  };
+}
+
 function compactDetail(detailResult) {
   if (!detailResult) return null;
   return {
@@ -146,13 +163,71 @@ function llmToScreening(llmResult, candidate) {
   };
 }
 
-function captureNodeIdFromResumeState(resumeState) {
-  return resumeState?.content?.node_id
-    || resumeState?.popup?.node_id
+export function captureNodeIdFromResumeState(resumeState) {
+  return resumeState?.popup?.node_id
+    || resumeState?.content?.node_id
     || resumeState?.resumeIframe?.node_id
     || null;
 }
 
+export function resolveChatDomFallbackWait({
+  normalizedDetailSource = "cascade",
+  parsedNetworkProfileCount = 0,
+  waitPlan = null,
+  resumeDomTimeoutMs = 60000
+} = {}) {
+  const detailSource = normalizeDetailSource(normalizedDetailSource);
+  const configuredTimeoutMs = Math.max(0, Number(resumeDomTimeoutMs) || 0);
+  if (detailSource === "image") {
+    return {
+      skipped: false,
+      timeout_ms: Math.min(configuredTimeoutMs, 3500),
+      configured_timeout_ms: configuredTimeoutMs,
+      short_probe: true,
+      reason: "forced_image_modal_probe"
+    };
+  }
+  if (detailSource === "dom") {
+    return {
+      skipped: false,
+      timeout_ms: configuredTimeoutMs,
+      configured_timeout_ms: configuredTimeoutMs,
+      short_probe: false,
+      reason: "dom_source_full_wait"
+    };
+  }
+
+  const profileCount = Math.max(0, Number(parsedNetworkProfileCount) || 0);
+  const previousImageMode = waitPlan?.mode_before === "image";
+  if (profileCount > 0) {
+    return {
+      skipped: false,
+      timeout_ms: Math.min(configuredTimeoutMs, previousImageMode ? 1500 : 3500),
+      configured_timeout_ms: configuredTimeoutMs,
+      short_probe: true,
+      reason: previousImageMode
+        ? "previous_image_mode_profile_only_network_short_dom_probe"
+        : "profile_only_network_short_dom_probe"
+    };
+  }
+  if (previousImageMode) {
+    return {
+      skipped: false,
+      timeout_ms: Math.min(configuredTimeoutMs, 2500),
+      configured_timeout_ms: configuredTimeoutMs,
+      short_probe: true,
+      reason: "previous_image_mode_network_miss_short_dom_probe"
+    };
+  }
+  return {
+    skipped: false,
+    timeout_ms: configuredTimeoutMs,
+    configured_timeout_ms: configuredTimeoutMs,
+    short_probe: false,
+    reason: "cascade_full_dom_wait"
+  };
+}
+
 function isRecoverableCdpNodeError(error) {
   return /(?:Could not find node|No node with given id|Cannot find node|Could not compute box model)/i
     .test(String(error?.message || error || ""));
@@ -208,6 +283,30 @@ const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
 const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
 const CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH = 650;
 const CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT = 3;
+const CHAT_RESUME_IMAGE_STOP_BOUNDARY_SELECTOR = [
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "p",
+  "span",
+  "section",
+  "article",
+  "div",
+  "[class*='privacy']",
+  "[class*='recommend']",
+  "[class*='similar']"
+].join(",");
+const CHAT_RESUME_IMAGE_STOP_BOUNDARY_TEXT = Object.freeze([
+  /其他名企大厂/,
+  /其他.*牛人/,
+  /毕业的牛人/,
+  /经历牛人/,
+  /为妥善保护/,
+  /查看全部.*项分析/,
+  /牛人分析器/
+]);
 const CHAT_FULL_CV_SECTION_PATTERNS = Object.freeze([
   /教育(?:经历|背景|经验)?/i,
   /工作(?:经历|经验)?/i,
@@ -738,6 +837,44 @@ export async function runChatWorkflow({
       });
       continue;
     }
+    if (normalizeText(job)) {
+      const jobGuard = await selectChatJob(client, rootState.rootNodes.top, {
+        jobLabel: job,
+        timeoutMs: Math.min(readyTimeoutMs, 12000),
+        settleMs: Math.min(listSettleMs, 800)
+      });
+      if (!jobGuard.selected || jobGuard.verified !== true) {
+        const error = new Error(`CHAT_JOB_GUARD_FAILED: requested=${job}; selected=${jobGuard.selected_label || "unknown"}; reason=${jobGuard.reason || "unknown"}`);
+        error.code = "CHAT_JOB_GUARD_FAILED";
+        error.chat_job_guard = compactChatJobGuard(jobGuard);
+        throw error;
+      }
+      if (!jobGuard.already_current) {
+        runControl.checkpoint({
+          chat_context_step: "job_guard_reselected",
+          job_guard: compactChatJobGuard(jobGuard),
+          candidate_list: resetInfiniteListForRefreshRound(listState, {
+            reason: "chat_job_drift_repaired",
+            round: listState.ledger?.length || 0,
+            method: "selectChatJob",
+            metadata: {
+              requested_job: job,
+              selected_label: jobGuard.selected_label || "",
+              selected_value: jobGuard.selected_option?.value || ""
+            }
+          })
+        });
+        rootState = await ensureChatViewport(await getChatRoots(client), "candidate_job_guard_reselected");
+        await sleep(Math.min(listSettleMs, 1200));
+        continue;
+      }
+      if (jobGuard.menu_close?.closed) {
+        runControl.checkpoint({
+          chat_context_step: "job_guard_closed_dropdown",
+          job_guard: compactChatJobGuard(jobGuard)
+        });
+      }
+    }
 
     const nextCandidateResult = await measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
       client,
@@ -962,10 +1099,40 @@ export async function runChatWorkflow({
 
             if (!detailResult) {
               detailStep = "wait_resume_content";
-              contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
-                timeoutMs: resumeDomTimeoutMs,
-                intervalMs: 300
-              }));
+              const domFallbackPlan = resolveChatDomFallbackWait({
+                normalizedDetailSource,
+                parsedNetworkProfileCount,
+                waitPlan,
+                resumeDomTimeoutMs
+              });
+              if (domFallbackPlan.skipped || domFallbackPlan.timeout_ms <= 0) {
+                contentWait = {
+                  ok: false,
+                  skipped: true,
+                  reason: domFallbackPlan.reason,
+                  elapsed_ms: 0,
+                  text_length: 0,
+                  resume_state: openedResume.resume_state,
+                  resume_html: null,
+                  dom_fallback_plan: domFallbackPlan,
+                  configured_timeout_ms: domFallbackPlan.configured_timeout_ms,
+                  timeout_ms: domFallbackPlan.timeout_ms,
+                  short_probe: Boolean(domFallbackPlan.short_probe)
+                };
+                addTiming(timings, "dom_fallback_ms", 0);
+              } else {
+                contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
+                  timeoutMs: domFallbackPlan.timeout_ms,
+                  intervalMs: 300
+                }));
+                contentWait.dom_fallback_plan = domFallbackPlan;
+                contentWait.configured_timeout_ms = domFallbackPlan.configured_timeout_ms;
+                contentWait.timeout_ms = domFallbackPlan.timeout_ms;
+                contentWait.short_probe = Boolean(domFallbackPlan.short_probe);
+                if (domFallbackPlan.short_probe && !contentWait.ok) {
+                  contentWait.reason = contentWait.reason || domFallbackPlan.reason;
+                }
+              }
               resumeState = contentWait.resume_state || openedResume.resume_state;
               resumeHtml = contentWait.resume_html || null;
               resumeNetworkEvents = networkRecorder.events.slice();
@@ -1012,23 +1179,29 @@ export async function runChatWorkflow({
                 quality: 72,
                 optimize: true,
                 resizeMaxWidth: 1100,
-                captureViewport: true,
-                padding: 8,
+                captureViewport: false,
+                padding: 0,
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
                 scrollMethod: "dom-anchor-fallback-input",
                 stepTimeoutMs: 45000,
                 totalTimeoutMs: 90000,
-            duplicateStopCount: 1,
-            skipDuplicateScreenshots: true,
-            composeForLlm: true,
-            llmPagesPerImage: 3,
-            llmResizeMaxWidth: 1100,
-            llmQuality: 72,
-            metadata: {
-              domain: "chat",
-              capture_mode: "scroll_sequence",
+                duplicateStopCount: 1,
+                skipDuplicateScreenshots: true,
+                composeForLlm: true,
+                llmPagesPerImage: 3,
+                llmResizeMaxWidth: 1100,
+                llmQuality: 72,
+                stopBoundarySelector: CHAT_RESUME_IMAGE_STOP_BOUNDARY_SELECTOR,
+                stopBoundaryTextPatterns: CHAT_RESUME_IMAGE_STOP_BOUNDARY_TEXT,
+                stopBoundaryMaxProbeNodes: 360,
+                stopBoundaryTopPadding: 10,
+                stopBoundaryMinCaptureHeight: 180,
+                metadata: {
+                  domain: "chat",
+                  capture_mode: "scroll_sequence",
+                  capture_scope: "resume_modal_clip",
                   acquisition_reason: normalizedDetailSource === "image"
                     ? "forced_image"
                     : "network_miss_image_fallback",
@@ -1165,7 +1338,12 @@ export async function runChatWorkflow({
               skipped: Boolean(contentWait.skipped),
               reason: contentWait.reason || null,
               elapsed_ms: contentWait.elapsed_ms,
-              text_length: contentWait.text_length
+              text_length: contentWait.text_length,
+              timeout_ms: contentWait.timeout_ms ?? contentWait.dom_fallback_plan?.timeout_ms ?? null,
+              configured_timeout_ms: contentWait.configured_timeout_ms
+                ?? contentWait.dom_fallback_plan?.configured_timeout_ms
+                ?? null,
+              short_probe: Boolean(contentWait.short_probe)
             },
             parsed_network_profile_count: parsedNetworkProfileCount,
             image_evidence: summarizeImageEvidence(imageEvidence),