@reconcrap/boss-recommend-mcp 2.0.10 → 2.0.12

package/package.json

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

package/src/core/capture/index.js

@@ -146,6 +146,14 @@ function filePathForSequence(basePath, index, extension) {
   return path.join(parsed.dir, `${parsed.name}-page-${page}${parsed.ext || `.${extension}`}`);
 }
 
+function filePathForLlmSequence(basePath, index) {
+  const resolved = resolveOutputPath(basePath);
+  if (!resolved) return null;
+  const parsed = path.parse(resolved);
+  const page = String(index + 1).padStart(2, "0");
+  return path.join(parsed.dir, `${parsed.name}-llm-${page}.jpg`);
+}
+
 function screenshotHash(buffer) {
   return crypto.createHash("sha256").update(buffer).digest("hex");
 }
@@ -207,6 +215,111 @@ async function optimizeScreenshotBuffer(buffer, {
   }
 }
 
+async function composeScreenshotsForLlm(screenshots = [], {
+  basePath,
+  pagesPerImage = 3,
+  resizeMaxWidth = 1100,
+  quality = 72
+} = {}) {
+  const fileScreenshots = screenshots.filter((item) => item?.file_path);
+  if (!basePath || fileScreenshots.length <= 1) {
+    return {
+      llm_file_paths: fileScreenshots.map((item) => item.file_path),
+      llm_screenshots: [],
+      llm_total_byte_length: 0,
+      llm_original_total_byte_length: 0,
+      llm_composition_error: null
+    };
+  }
+
+  const safePagesPerImage = Math.max(1, Math.min(5, Number(pagesPerImage) || 3));
+  const safeWidth = Math.max(700, Math.min(1400, Number(resizeMaxWidth) || 1100));
+  const safeQuality = Math.max(45, Math.min(90, Number(quality) || 72));
+  const llmScreenshots = [];
+
+  try {
+    for (let index = 0; index < fileScreenshots.length; index += safePagesPerImage) {
+      const group = fileScreenshots.slice(index, index + safePagesPerImage);
+      const prepared = [];
+      for (const item of group) {
+        const sourceBuffer = fs.readFileSync(item.file_path);
+        const { data, info } = await sharp(sourceBuffer, { failOn: "none" })
+          .resize({
+            width: safeWidth,
+            withoutEnlargement: true
+          })
+          .jpeg({
+            quality: safeQuality,
+            mozjpeg: true
+          })
+          .toBuffer({ resolveWithObject: true });
+        prepared.push({
+          input: data,
+          width: info.width,
+          height: info.height,
+          source_file_path: item.file_path
+        });
+      }
+
+      const width = Math.max(...prepared.map((item) => item.width), 1);
+      const height = prepared.reduce((sum, item) => sum + item.height, 0);
+      let top = 0;
+      const composites = prepared.map((item) => {
+        const layer = {
+          input: item.input,
+          left: 0,
+          top
+        };
+        top += item.height;
+        return layer;
+      });
+      const outputBuffer = await sharp({
+        create: {
+          width,
+          height,
+          channels: 3,
+          background: "#ffffff"
+        }
+      })
+        .composite(composites)
+        .jpeg({
+          quality: safeQuality,
+          mozjpeg: true
+        })
+        .toBuffer();
+      const outputPath = filePathForLlmSequence(basePath, llmScreenshots.length);
+      fs.writeFileSync(outputPath, outputBuffer);
+      llmScreenshots.push({
+        index: llmScreenshots.length,
+        file_path: outputPath,
+        byte_length: outputBuffer.length,
+        source_file_paths: prepared.map((item) => item.source_file_path),
+        source_page_count: prepared.length,
+        width,
+        height,
+        format: "jpeg",
+        mime_type: "image/jpeg"
+      });
+    }
+  } catch (error) {
+    return {
+      llm_file_paths: fileScreenshots.map((item) => item.file_path),
+      llm_screenshots: [],
+      llm_total_byte_length: 0,
+      llm_original_total_byte_length: fileScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+      llm_composition_error: error?.message || String(error)
+    };
+  }
+
+  return {
+    llm_file_paths: llmScreenshots.map((item) => item.file_path),
+    llm_screenshots: llmScreenshots,
+    llm_total_byte_length: llmScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+    llm_original_total_byte_length: fileScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+    llm_composition_error: null
+  };
+}
+
 export async function captureScrolledNodeScreenshots(client, nodeId, {
   filePath,
   format = "png",
@@ -222,6 +335,10 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   skipDuplicateScreenshots = false,
   optimize = false,
   resizeMaxWidth = 0,
+  composeForLlm = false,
+  llmPagesPerImage = 3,
+  llmResizeMaxWidth = 1100,
+  llmQuality = 72,
   metadata = {}
 } = {}) {
   if (!nodeId) throw new Error("captureScrolledNodeScreenshots requires nodeId");
@@ -322,6 +439,21 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     }
   }
 
+  const llmComposition = composeForLlm
+    ? await composeScreenshotsForLlm(screenshots, {
+        basePath: filePath,
+        pagesPerImage: llmPagesPerImage,
+        resizeMaxWidth: llmResizeMaxWidth,
+        quality: llmQuality
+      })
+    : {
+        llm_file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
+        llm_screenshots: [],
+        llm_total_byte_length: 0,
+        llm_original_total_byte_length: 0,
+        llm_composition_error: null
+      };
+
   return {
     schema_version: 1,
     source: "image-scroll-sequence",
@@ -335,12 +467,22 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     dropped_duplicate_count: droppedDuplicateCount,
     total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
     original_total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.original_byte_length) || 0), 0),
+    llm_file_paths: llmComposition.llm_file_paths,
+    llm_screenshot_count: llmComposition.llm_file_paths.length,
+    llm_total_byte_length: llmComposition.llm_total_byte_length,
+    llm_original_total_byte_length: llmComposition.llm_original_total_byte_length,
+    llm_composition_error: llmComposition.llm_composition_error,
+    llm_screenshots: llmComposition.llm_screenshots,
     optimization: {
       enabled: Boolean(optimize),
       resize_max_width: Math.max(0, Number(resizeMaxWidth) || 0),
       capture_viewport: Boolean(captureViewport),
       format,
-      quality: quality ?? null
+      quality: quality ?? null,
+      llm_compose_enabled: Boolean(composeForLlm),
+      llm_pages_per_image: Math.max(1, Math.min(5, Number(llmPagesPerImage) || 3)),
+      llm_resize_max_width: Math.max(0, Number(llmResizeMaxWidth) || 0),
+      llm_quality: llmQuality ?? null
     },
     file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,

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

@@ -132,8 +132,13 @@ export function summarizeImageEvidence(imageEvidence = null) {
     dropped_duplicate_count: imageEvidence.dropped_duplicate_count || 0,
     total_byte_length: imageEvidence.total_byte_length || 0,
     original_total_byte_length: imageEvidence.original_total_byte_length || 0,
+    llm_screenshot_count: imageEvidence.llm_screenshot_count || 0,
+    llm_total_byte_length: imageEvidence.llm_total_byte_length || 0,
+    llm_original_total_byte_length: imageEvidence.llm_original_total_byte_length || 0,
+    llm_composition_error: imageEvidence.llm_composition_error || null,
     optimization: imageEvidence.optimization || null,
     file_paths: imageEvidence.file_paths || [],
+    llm_file_paths: imageEvidence.llm_file_paths || [],
     first_clip: imageEvidence.screenshots?.[0]?.clip || imageEvidence.clip || null
   };
 }

package/src/core/infinite-list/index.js

@@ -1,10 +1,68 @@
 import crypto from "node:crypto";
 import {
   getNodeBox,
+  getOuterHTML,
+  querySelectorAll,
   scrollNodeIntoView,
   sleep
 } from "../browser/index.js";
 
+export const DEFAULT_BOTTOM_HINT_KEYWORDS = Object.freeze([
+  "没有更多",
+  "已显示全部",
+  "已经到底",
+  "暂无更多",
+  "推荐完了",
+  "没有更多人选",
+  "没有更多了",
+  "已到底"
+]);
+
+export const DEFAULT_LOAD_MORE_HINT_KEYWORDS = Object.freeze([
+  "滚动加载更多",
+  "下滑加载更多",
+  "继续下滑",
+  "继续滑动",
+  "滑动加载",
+  "正在加载",
+  "加载中"
+]);
+
+export const DEFAULT_BOTTOM_MARKER_SELECTORS = Object.freeze([
+  ".finished-wrap",
+  ".load-tips",
+  "div[role=\"tfoot\"] .load-tips",
+  ".no-data-refresh",
+  ".empty-tip",
+  ".empty-text",
+  ".no-data",
+  ".tip-nodata",
+  "[class*=\"finished\"]",
+  "[class*=\"load-tips\"]",
+  "[class*=\"no-more\"]",
+  "[class*=\"no_more\"]"
+]);
+
+export const DEFAULT_BOTTOM_TEXT_SCAN_SELECTORS = Object.freeze([
+  "div",
+  "span",
+  "p",
+  "li",
+  "button",
+  "a"
+]);
+
+export const DEFAULT_BOTTOM_REFRESH_SELECTORS = Object.freeze([
+  ".finished-wrap .btn-refresh",
+  ".finished-wrap .btn",
+  ".no-data-refresh .btn-refresh",
+  ".no-data-refresh .btn",
+  "[class*=\"refresh\"]",
+  "[ka*=\"refresh\"]",
+  "button",
+  "a"
+]);
+
 function nowIso() {
   return new Date().toISOString();
 }
@@ -13,6 +71,31 @@ function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
+function uniqueValues(values = []) {
+  return Array.from(new Set(values.filter(Boolean)));
+}
+
+function decodeBasicHtmlEntities(value = "") {
+  return String(value || "")
+    .replace(/ | /gi, " ")
+    .replace(/&/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&quot;/gi, "\"")
+    .replace(/&#39;|&apos;/gi, "'");
+}
+
+function plainTextFromHtml(html = "") {
+  return normalizeText(decodeBasicHtmlEntities(String(html || "")
+    .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")));
+}
+
+function isUsableBox(box) {
+  return Number(box?.rect?.width || 0) > 2 && Number(box?.rect?.height || 0) > 2;
+}
+
 function shortHash(value) {
   return crypto.createHash("sha256").update(String(value || "")).digest("hex").slice(0, 16);
 }
@@ -174,6 +257,220 @@ export function resetInfiniteListForRefreshRound(state, {
   return compactInfiniteListState(state);
 }
 
+export function classifyInfiniteListBottomMarker({
+  text = "",
+  refreshButtonVisible = false,
+  bottomKeywords = DEFAULT_BOTTOM_HINT_KEYWORDS,
+  loadMoreKeywords = DEFAULT_LOAD_MORE_HINT_KEYWORDS
+} = {}) {
+  const normalizedText = normalizeText(text);
+  const matchedBottomKeyword = bottomKeywords.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedBottomKeyword) {
+    return {
+      is_bottom: true,
+      reason: matchedBottomKeyword,
+      matched_bottom_keyword: matchedBottomKeyword,
+      matched_load_more_keyword: null
+    };
+  }
+
+  const matchedLoadMoreKeyword = loadMoreKeywords.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedLoadMoreKeyword) {
+    return {
+      is_bottom: false,
+      reason: null,
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: matchedLoadMoreKeyword
+    };
+  }
+
+  if (refreshButtonVisible) {
+    return {
+      is_bottom: true,
+      reason: "refresh_button_visible",
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: null
+    };
+  }
+
+  return {
+    is_bottom: false,
+    reason: null,
+    matched_bottom_keyword: null,
+    matched_load_more_keyword: null
+  };
+}
+
+async function safeQuerySelectorAll(client, rootNodeId, selector) {
+  try {
+    return await querySelectorAll(client, rootNodeId, selector);
+  } catch {
+    return [];
+  }
+}
+
+async function readVisibleMarkerNode(client, nodeId) {
+  let box = null;
+  try {
+    box = await getNodeBox(client, nodeId);
+  } catch {
+    return null;
+  }
+  if (!isUsableBox(box)) return null;
+  let outerHTML = "";
+  try {
+    outerHTML = await getOuterHTML(client, nodeId);
+  } catch {
+    return null;
+  }
+  return {
+    node_id: nodeId,
+    text: plainTextFromHtml(outerHTML),
+    box
+  };
+}
+
+function looksLikeRefreshLabel(text = "") {
+  const normalized = normalizeText(text).replace(/\s+/g, "");
+  return Boolean(normalized) && normalized.length <= 80 && /刷新|refresh/i.test(normalized);
+}
+
+export async function detectInfiniteListBottomMarker(client, {
+  rootNodeId,
+  markerSelectors = DEFAULT_BOTTOM_MARKER_SELECTORS,
+  textScanSelectors = DEFAULT_BOTTOM_TEXT_SCAN_SELECTORS,
+  refreshSelectors = DEFAULT_BOTTOM_REFRESH_SELECTORS,
+  bottomKeywords = DEFAULT_BOTTOM_HINT_KEYWORDS,
+  loadMoreKeywords = DEFAULT_LOAD_MORE_HINT_KEYWORDS,
+  maxMarkerNodes = 300,
+  maxTextScanNodes = 800,
+  textMaxLength = 80
+} = {}) {
+  if (!client || !rootNodeId) {
+    return {
+      found: false,
+      reason: "missing_client_or_root"
+    };
+  }
+
+  const selectorCounts = {};
+  const markerNodeIds = [];
+  for (const selector of markerSelectors || []) {
+    const nodeIds = await safeQuerySelectorAll(client, rootNodeId, selector);
+    selectorCounts[selector] = nodeIds.length;
+    markerNodeIds.push(...nodeIds);
+  }
+
+  const visibleMarkers = [];
+  const markerIds = uniqueValues(markerNodeIds).slice(0, Math.max(0, Number(maxMarkerNodes) || 0));
+  for (const nodeId of markerIds) {
+    const marker = await readVisibleMarkerNode(client, nodeId);
+    if (!marker?.text) continue;
+    const classified = classifyInfiniteListBottomMarker({
+      text: marker.text,
+      bottomKeywords,
+      loadMoreKeywords
+    });
+    const summary = {
+      node_id: marker.node_id,
+      text: marker.text.slice(0, 160),
+      y: marker.box?.rect?.y || null,
+      matched_bottom_keyword: classified.matched_bottom_keyword,
+      matched_load_more_keyword: classified.matched_load_more_keyword
+    };
+    visibleMarkers.push(summary);
+    if (classified.is_bottom) {
+      return {
+        found: true,
+        reason: classified.reason,
+        source: "marker_selector",
+        marker: summary,
+        selector_counts: selectorCounts,
+        visible_marker_count: visibleMarkers.length,
+        refresh_button_visible: false
+      };
+    }
+  }
+
+  const hasLoadMoreMarker = visibleMarkers.some((marker) => marker.matched_load_more_keyword);
+
+  const refreshNodeIds = [];
+  for (const selector of refreshSelectors || []) {
+    const nodeIds = await safeQuerySelectorAll(client, rootNodeId, selector);
+    selectorCounts[selector] = (selectorCounts[selector] || 0) + nodeIds.length;
+    refreshNodeIds.push(...nodeIds);
+  }
+  const refreshButtons = [];
+  for (const nodeId of uniqueValues(refreshNodeIds).slice(0, 300)) {
+    const marker = await readVisibleMarkerNode(client, nodeId);
+    if (!marker?.text || !looksLikeRefreshLabel(marker.text)) continue;
+    refreshButtons.push({
+      node_id: marker.node_id,
+      text: marker.text.slice(0, 120),
+      y: marker.box?.rect?.y || null
+    });
+  }
+  if (refreshButtons.length && !hasLoadMoreMarker) {
+    return {
+      found: true,
+      reason: "refresh_button_visible",
+      source: "refresh_button",
+      marker: refreshButtons[0],
+      selector_counts: selectorCounts,
+      visible_marker_count: visibleMarkers.length,
+      refresh_button_visible: true,
+      refresh_button_count: refreshButtons.length
+    };
+  }
+
+  const scanNodeIds = [];
+  for (const selector of textScanSelectors || []) {
+    const nodeIds = await safeQuerySelectorAll(client, rootNodeId, selector);
+    selectorCounts[selector] = (selectorCounts[selector] || 0) + nodeIds.length;
+    scanNodeIds.push(...nodeIds);
+  }
+  let checkedTextNodeCount = 0;
+  for (const nodeId of uniqueValues(scanNodeIds).slice(0, Math.max(0, Number(maxTextScanNodes) || 0))) {
+    const marker = await readVisibleMarkerNode(client, nodeId);
+    if (!marker?.text || marker.text.length > textMaxLength) continue;
+    checkedTextNodeCount += 1;
+    const classified = classifyInfiniteListBottomMarker({
+      text: marker.text,
+      bottomKeywords,
+      loadMoreKeywords
+    });
+    if (classified.is_bottom) {
+      return {
+        found: true,
+        reason: classified.reason,
+        source: "text_scan",
+        marker: {
+          node_id: marker.node_id,
+          text: marker.text.slice(0, 160),
+          y: marker.box?.rect?.y || null,
+          matched_bottom_keyword: classified.matched_bottom_keyword
+        },
+        selector_counts: selectorCounts,
+        visible_marker_count: visibleMarkers.length,
+        checked_text_node_count: checkedTextNodeCount,
+        refresh_button_visible: refreshButtons.length > 0,
+        refresh_button_count: refreshButtons.length
+      };
+    }
+  }
+
+  return {
+    found: false,
+    reason: hasLoadMoreMarker ? "load_more_marker_visible" : "bottom_marker_not_found",
+    selector_counts: selectorCounts,
+    visible_markers: visibleMarkers.slice(0, 20),
+    visible_marker_count: visibleMarkers.length,
+    checked_text_node_count: checkedTextNodeCount,
+    refresh_button_visible: refreshButtons.length > 0,
+    refresh_button_count: refreshButtons.length
+  };
+}
+
 export async function readVisibleInfiniteListItems({
   nodeIds = [],
   readCandidate,
@@ -333,9 +630,11 @@ export async function getNextInfiniteListCandidate({
   state,
   findNodeIds,
   readCandidate,
+  detectBottomMarker = null,
   keyForCandidate = candidateKeyFromProfile,
   maxScrolls = 20,
   stableSignatureLimit = 2,
+  minScrollsBeforeEnd = 3,
   wheelDeltaY = 850,
   settleMs = 1200,
   fallbackPoint = null
@@ -383,6 +682,54 @@ export async function getNextInfiniteListCandidate({
       return result;
     }
 
+    if (typeof detectBottomMarker === "function") {
+      let bottomMarker = null;
+      try {
+        bottomMarker = await detectBottomMarker({
+          scrollAttempt,
+          items,
+          signature,
+          state: compactInfiniteListState(state)
+        });
+      } catch (error) {
+        bottomMarker = {
+          found: false,
+          reason: "bottom_marker_probe_failed",
+          error: error?.message || String(error)
+        };
+      }
+      attempts[attempts.length - 1].bottom_marker = bottomMarker;
+      if (bottomMarker?.found) {
+        state.ledger?.push({
+          at: nowIso(),
+          event: "bottom_marker_detected",
+          reason: bottomMarker.reason || "bottom_marker",
+          source: bottomMarker.source || "",
+          marker: bottomMarker.marker || null
+        });
+        const result = {
+          ok: false,
+          end_reached: true,
+          reason: "bottom_marker",
+          bottom_marker: bottomMarker,
+          attempts,
+          state: compactInfiniteListState(state)
+        };
+        state.last_result = {
+          at: nowIso(),
+          ok: false,
+          end_reached: true,
+          reason: result.reason,
+          bottom_marker: {
+            reason: bottomMarker.reason || null,
+            source: bottomMarker.source || null,
+            marker: bottomMarker.marker || null
+          }
+        };
+        return result;
+      }
+    }
+
     if (!items.length) {
       const result = {
         ok: false,
@@ -400,7 +747,9 @@ export async function getNextInfiniteListCandidate({
       return result;
     }
 
-    if (signature.stable_signature_count >= Math.max(1, Number(stableSignatureLimit) || 1)) {
+    const stableLimit = Math.max(1, Number(stableSignatureLimit) || 1);
+    const minStableScrolls = Math.max(0, Number(minScrollsBeforeEnd) || 0);
+    if (signature.stable_signature_count >= stableLimit && scrollAttempt >= minStableScrolls) {
       const result = {
         ok: false,
         end_reached: true,
@@ -416,6 +765,10 @@ export async function getNextInfiniteListCandidate({
       };
       return result;
     }
+    if (signature.stable_signature_count >= stableLimit) {
+      attempts[attempts.length - 1].stable_end_deferred = true;
+      attempts[attempts.length - 1].min_scrolls_before_end = minStableScrolls;
+    }
 
     const scrollResult = await scrollInfiniteListByVisibleItems(client, items, {
       wheelDeltaY,

package/src/core/screening/index.js

@@ -392,11 +392,18 @@ function normalizeImagePaths({ imageEvidence = null, imagePaths = [] } = {}) {
   if (Array.isArray(imagePaths)) {
     paths.push(...imagePaths);
   }
-  if (Array.isArray(imageEvidence?.file_paths)) {
-    paths.push(...imageEvidence.file_paths);
-  }
-  if (Array.isArray(imageEvidence?.screenshots)) {
-    paths.push(...imageEvidence.screenshots.map((item) => item.file_path));
+  const evidenceLlmPaths = Array.isArray(imageEvidence?.llm_file_paths)
+    ? imageEvidence.llm_file_paths
+    : [];
+  if (evidenceLlmPaths.length) {
+    paths.push(...evidenceLlmPaths);
+  } else {
+    if (Array.isArray(imageEvidence?.file_paths)) {
+      paths.push(...imageEvidence.file_paths);
+    }
+    if (Array.isArray(imageEvidence?.screenshots)) {
+      paths.push(...imageEvidence.screenshots.map((item) => item.file_path));
+    }
   }
   return unique(paths.map((filePath) => String(filePath || "").trim()).filter(Boolean));
 }
@@ -1292,6 +1299,7 @@ export function compactScreeningLlmResult(llmResult) {
     usage: llmResult.usage || null,
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
+    attempt_count: llmResult.attempt_count || 0,
     error: llmResult.error || null,
     screened_at: llmResult.screened_at || null
   };
@@ -1324,6 +1332,7 @@ export function createFailedLlmScreeningResult(error) {
     raw_model_output: "",
     image_input_count: Number(error?.image_input_count) || 0,
     image_inputs: Array.isArray(error?.image_inputs) ? error.image_inputs : [],
+    attempt_count: Number(error?.llm_attempt_count) || 0,
     error: error?.message || String(error || "unknown"),
     screened_at: nowIso()
   };
@@ -1352,7 +1361,7 @@ export function buildScreeningLlmMessages({
     `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${safeCriteria}\n\n`
     + `候选人信息:\n${safeText || "候选人的完整简历信息在后续截图中，请按截图顺序阅读。"}\n\n`
     + (images.length
-      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。请完整阅读所有截图后再判断。\n\n`
+      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。若截图是拼接长图，请按图内从上到下顺序完整阅读；不要跳过任何一段简历内容。\n\n`
       : "")
     + "要求：\n"
     + "1) 只能依据候选人信息或截图中真实出现的内容判断。\n"
@@ -1383,6 +1392,24 @@ export function buildScreeningLlmMessages({
   ];
 }
 
+function normalizeLlmMaxRetries(value) {
+  if (value == null || value === "") return 1;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 1;
+  return Math.min(3, Math.floor(parsed));
+}
+
+function isRetryableLlmRequestError(error) {
+  const status = Number(error?.status);
+  if ([408, 409, 425, 429].includes(status) || status >= 500) return true;
+  return /(?:aborted|abort|timeout|timed out|fetch failed|socket|network|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i
+    .test(String(error?.message || error || ""));
+}
+
+function sleepMs(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+}
+
 export async function callScreeningLlm({
   candidate,
   criteria,
@@ -1425,9 +1452,13 @@ export async function callScreeningLlm({
     thinkingLevel: config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "low"
   });
 
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
+  const maxRetries = normalizeLlmMaxRetries(config.llmMaxRetries ?? config.maxRetries);
+  const maxAttempts = maxRetries + 1;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${apiKey}`
@@ -1443,7 +1474,9 @@ export async function callScreeningLlm({
     });
     const responseText = await response.text();
     if (!response.ok) {
-      throw new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
+      const error = new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
+      error.status = response.status;
+      throw error;
     }
     const json = tryParseJson(responseText);
     if (!json) {
@@ -1485,13 +1518,25 @@ export async function callScreeningLlm({
       raw_content_length: content.length,
       image_input_count: imageInputs.length,
       image_inputs: summarizeLlmImageInputs(imageInputs),
+      attempt_count: attempt,
       screened_at: nowIso()
     };
   } catch (error) {
-    error.image_input_count = imageInputs.length;
-    error.image_inputs = summarizeLlmImageInputs(imageInputs);
-    throw error;
+      lastError = error;
+      if (attempt >= maxAttempts || !isRetryableLlmRequestError(error)) {
+        error.image_input_count = imageInputs.length;
+        error.image_inputs = summarizeLlmImageInputs(imageInputs);
+        error.llm_attempt_count = attempt;
+        throw error;
+      }
+      await sleepMs(Math.min(2500, 500 * attempt));
   } finally {
     clearTimeout(timer);
   }
+  }
+  lastError = lastError || new Error("LLM request failed without response");
+  lastError.image_input_count = imageInputs.length;
+  lastError.image_inputs = summarizeLlmImageInputs(imageInputs);
+  lastError.llm_attempt_count = maxAttempts;
+  throw lastError;
 }

package/src/domains/chat/constants.js

@@ -8,6 +8,17 @@ export const CHAT_CARD_SELECTORS = Object.freeze([
   "div[role=\"listitem\"]"
 ]);
 
+export const CHAT_BOTTOM_MARKER_SELECTORS = Object.freeze([
+  "div[role=\"tfoot\"] .load-tips",
+  "p.load-tips",
+  ".load-tips",
+  ".empty-tip",
+  ".empty-text",
+  ".no-data",
+  "[class*=\"load-tips\"]",
+  "[class*=\"empty\"]"
+]);
+
 export const CHAT_JOB_LABEL_SELECTORS = Object.freeze([
   ".chat-job .chat-select-job",
   ".chat-job .dropmenu-label",

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

@@ -19,6 +19,7 @@ import {
 import {
   compactInfiniteListState,
   createInfiniteListState,
+  detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed
 } from "../../core/infinite-list/index.js";
@@ -34,7 +35,10 @@ import {
   normalizeText,
   screenCandidate
 } from "../../core/screening/index.js";
-import { CHAT_TARGET_URL } from "./constants.js";
+import {
+  CHAT_BOTTOM_MARKER_SELECTORS,
+  CHAT_TARGET_URL
+} from "./constants.js";
 import {
   chatCandidateKeyFromProfile,
   findChatCandidateNodeIdById,
@@ -98,6 +102,7 @@ function compactLlmResult(llmResult) {
     usage: llmResult.usage || null,
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
+    attempt_count: llmResult.attempt_count || 0,
     error: llmResult.error || null
   };
 }
@@ -371,9 +376,9 @@ export async function runChatWorkflow({
   llmImageDetail = "high",
   screeningMode = "llm",
   listMaxScrolls = 20,
-  listStableSignatureLimit = 2,
+  listStableSignatureLimit = 5,
   listWheelDeltaY = 850,
-  listSettleMs = 1200,
+  listSettleMs = 2200,
   listFallbackPoint = null,
   imageOutputDir = ""
 } = {}, runControl) {
@@ -630,6 +635,13 @@ export async function runChatWorkflow({
           run_candidate_index: results.length,
           visible_index: visibleIndex
         }
+      }),
+      detectBottomMarker: async ({ scrollAttempt = 0, signature = {} } = {}) => detectInfiniteListBottomMarker(client, {
+        rootNodeId: rootState?.rootNodes?.top,
+        markerSelectors: CHAT_BOTTOM_MARKER_SELECTORS,
+        refreshSelectors: [],
+        textScanSelectors: scrollAttempt > 0 || (signature?.stable_signature_count || 0) >= 2 ? undefined : [],
+        maxTextScanNodes: 500
       })
     }));
     if (!nextCandidateResult.ok) {
@@ -826,11 +838,15 @@ export async function runChatWorkflow({
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
-                duplicateStopCount: 1,
-                skipDuplicateScreenshots: true,
-                metadata: {
-                  domain: "chat",
-                  capture_mode: "scroll_sequence",
+            duplicateStopCount: 1,
+            skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
+            metadata: {
+              domain: "chat",
+              capture_mode: "scroll_sequence",
                   acquisition_reason: normalizedDetailSource === "image"
                     ? "forced_image"
                     : "network_miss_image_fallback",
@@ -1132,9 +1148,9 @@ export function createChatRunService({
     llmImageDetail = "high",
     screeningMode = "llm",
     listMaxScrolls = 20,
-    listStableSignatureLimit = 2,
+    listStableSignatureLimit = 5,
     listWheelDeltaY = 850,
-    listSettleMs = 1200,
+    listSettleMs = 2200,
     listFallbackPoint = null,
     imageOutputDir = "",
     name = "chat-domain-run"

package/src/domains/recommend/constants.js

@@ -67,6 +67,17 @@ export const RECOMMEND_END_REFRESH_SELECTOR = [
   "a"
 ].join(", ");
 
+export const RECOMMEND_BOTTOM_MARKER_SELECTORS = Object.freeze([
+  ".finished-wrap",
+  ".no-data-refresh",
+  ".load-tips",
+  ".empty-tip",
+  ".empty-text",
+  ".no-data",
+  "[class*=\"finished\"]",
+  "[class*=\"load-tips\"]"
+]);
+
 export const DETAIL_POPUP_SELECTORS = Object.freeze([
   ".dialog-wrap.active",
   ".boss-popup__wrapper",

package/src/domains/recommend/refresh.js

@@ -110,95 +110,117 @@ export async function refreshRecommendListAtEnd(client, {
     );
     attempts.push(buttonResult);
     if (buttonResult.ok) {
-      currentRootState = await getRecommendRoots(client);
-      const pageScopeResult = await selectRecommendPageScope(
-        client,
-        currentRootState.iframe.documentNodeId,
-        {
-          pageScope,
-          fallbackScope: fallbackPageScope,
-          settleMs: buttonSettleMs > 10000 ? 3000 : 1200,
-          timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+      try {
+        currentRootState = await getRecommendRoots(client);
+        const pageScopeResult = await selectRecommendPageScope(
+          client,
+          currentRootState.iframe.documentNodeId,
+          {
+            pageScope,
+            fallbackScope: fallbackPageScope,
+            settleMs: buttonSettleMs > 10000 ? 3000 : 1200,
+            timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+          }
+        );
+        if (!pageScopeResult.selected) {
+          throw new Error(`Recommend page scope was not selected after end refresh: ${pageScopeResult.reason || pageScope}`);
         }
-      );
-      if (!pageScopeResult.selected) {
-        throw new Error(`Recommend page scope was not selected after end refresh: ${pageScopeResult.reason || pageScope}`);
+        currentRootState = await getRecommendRoots(client);
+        const filterResult = await selectAndConfirmFirstSafeFilter(
+          client,
+          currentRootState.iframe.documentNodeId,
+          buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+        );
+        const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+          timeoutMs: cardTimeoutMs,
+          intervalMs: 500
+        });
+        return {
+          ok: cardNodeIds.length > 0,
+          method: "end_refresh_button",
+          attempts,
+          page_scope: pageScopeResult,
+          filter: filterResult,
+          card_count: cardNodeIds.length,
+          root_state: currentRootState,
+          forced_recent_not_view: forceRecentNotView
+        };
+      } catch (error) {
+        attempts.push({
+          ok: false,
+          method: "end_refresh_button_after_click",
+          reason: "end_refresh_reapply_failed",
+          error: error?.message || String(error)
+        });
       }
-      currentRootState = await getRecommendRoots(client);
-      const filterResult = await selectAndConfirmFirstSafeFilter(
-        client,
-        currentRootState.iframe.documentNodeId,
-        buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
-      );
-      const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
-        timeoutMs: cardTimeoutMs,
-        intervalMs: 500
-      });
-      return {
-        ok: cardNodeIds.length > 0,
-        method: "end_refresh_button",
-        attempts,
-        page_scope: pageScopeResult,
-        filter: filterResult,
-        card_count: cardNodeIds.length,
-        root_state: currentRootState,
-        forced_recent_not_view: forceRecentNotView
-      };
     }
   }
 
-  await client.Page.reload({ ignoreCache: true });
-  if (reloadSettleMs > 0) await sleep(reloadSettleMs);
-  currentRootState = await waitForRecommendRoots(client, {
-    timeoutMs: Math.max(30000, reloadSettleMs * 4),
-    intervalMs: 500
-  });
-  if (!currentRootState?.iframe?.documentNodeId) {
-    throw new Error("Recommend iframe was not ready after refresh reload");
-  }
-  let jobSelection = null;
-  if (jobLabel) {
-    jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
-      jobLabel,
-      settleMs: reloadSettleMs > 10000 ? 12000 : 6000
+  try {
+    await client.Page.reload({ ignoreCache: true });
+    if (reloadSettleMs > 0) await sleep(reloadSettleMs);
+    currentRootState = await waitForRecommendRoots(client, {
+      timeoutMs: Math.max(30000, reloadSettleMs * 4),
+      intervalMs: 500
     });
-    if (!jobSelection.selected) {
-      throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
+    if (!currentRootState?.iframe?.documentNodeId) {
+      throw new Error("Recommend iframe was not ready after refresh reload");
     }
-    currentRootState = await getRecommendRoots(client);
-  }
-  const pageScopeResult = await selectRecommendPageScope(
-    client,
-    currentRootState.iframe.documentNodeId,
-    {
-      pageScope,
-      fallbackScope: fallbackPageScope,
-      settleMs: reloadSettleMs > 10000 ? 3000 : 1200,
-      timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+    let jobSelection = null;
+    if (jobLabel) {
+      jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
+        jobLabel,
+        settleMs: reloadSettleMs > 10000 ? 12000 : 6000
+      });
+      if (!jobSelection.selected) {
+        throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
+      }
+      currentRootState = await getRecommendRoots(client);
     }
-  );
-  if (!pageScopeResult.selected) {
-    throw new Error(`Recommend page scope was not selected after refresh reload: ${pageScopeResult.reason || pageScope}`);
+    const pageScopeResult = await selectRecommendPageScope(
+      client,
+      currentRootState.iframe.documentNodeId,
+      {
+        pageScope,
+        fallbackScope: fallbackPageScope,
+        settleMs: reloadSettleMs > 10000 ? 3000 : 1200,
+        timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+      }
+    );
+    if (!pageScopeResult.selected) {
+      throw new Error(`Recommend page scope was not selected after refresh reload: ${pageScopeResult.reason || pageScope}`);
+    }
+    currentRootState = await getRecommendRoots(client);
+    const filterResult = await selectAndConfirmFirstSafeFilter(
+      client,
+      currentRootState.iframe.documentNodeId,
+      buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+    );
+    const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+      timeoutMs: cardTimeoutMs,
+      intervalMs: 500
+    });
+    return {
+      ok: cardNodeIds.length > 0,
+      method: "page_reload",
+      attempts,
+      job_selection: jobSelection,
+      page_scope: pageScopeResult,
+      filter: filterResult,
+      card_count: cardNodeIds.length,
+      root_state: currentRootState,
+      forced_recent_not_view: forceRecentNotView
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      method: "page_reload",
+      reason: "page_reload_failed",
+      error: error?.message || String(error),
+      attempts,
+      card_count: 0,
+      root_state: currentRootState,
+      forced_recent_not_view: forceRecentNotView
+    };
   }
-  currentRootState = await getRecommendRoots(client);
-  const filterResult = await selectAndConfirmFirstSafeFilter(
-    client,
-    currentRootState.iframe.documentNodeId,
-    buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
-  );
-  const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
-    timeoutMs: cardTimeoutMs,
-    intervalMs: 500
-  });
-  return {
-    ok: cardNodeIds.length > 0,
-    method: "page_reload",
-    attempts,
-    job_selection: jobSelection,
-    page_scope: pageScopeResult,
-    filter: filterResult,
-    card_count: cardNodeIds.length,
-    root_state: currentRootState,
-    forced_recent_not_view: forceRecentNotView
-  };
 }

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

@@ -21,6 +21,7 @@ import {
 import {
   compactInfiniteListState,
   createInfiniteListState,
+  detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed,
   resetInfiniteListForRefreshRound
@@ -54,6 +55,10 @@ import {
   normalizeRecommendPageScope,
   selectRecommendPageScope
 } from "./scopes.js";
+import {
+  RECOMMEND_BOTTOM_MARKER_SELECTORS,
+  RECOMMEND_END_REFRESH_SELECTOR
+} from "./constants.js";
 import {
   clickRecommendActionControl,
   normalizeRecommendPostAction,
@@ -66,6 +71,15 @@ function normalizeLabels(labels = []) {
   return labels.map((label) => String(label || "").trim()).filter(Boolean);
 }
 
+function isRefreshableListStall(reason = "") {
+  return new Set([
+    "stable_visible_signature",
+    "max_scrolls_exhausted",
+    "scroll_failed",
+    "scroll_anchor_unavailable"
+  ]).has(String(reason || ""));
+}
+
 function normalizeFilter(filter = {}) {
   const filterGroups = Array.isArray(filter.filterGroups)
     ? filter.filterGroups
@@ -364,9 +378,9 @@ export async function runRecommendWorkflow({
   imageWheelDeltaY = 650,
   cvAcquisitionMode = "unknown",
   listMaxScrolls = 20,
-  listStableSignatureLimit = 2,
+  listStableSignatureLimit = 5,
   listWheelDeltaY = 850,
-  listSettleMs = 1200,
+  listSettleMs = 2200,
   listFallbackPoint = null,
   refreshOnEnd = true,
   maxRefreshRounds = 2,
@@ -559,15 +573,22 @@ export async function runRecommendWorkflow({
           run_candidate_index: results.length,
           visible_index: visibleIndex
         }
+      }),
+      detectBottomMarker: async ({ scrollAttempt = 0, signature = {} } = {}) => detectInfiniteListBottomMarker(client, {
+        rootNodeId: rootState?.iframe?.documentNodeId,
+        markerSelectors: RECOMMEND_BOTTOM_MARKER_SELECTORS,
+        refreshSelectors: [RECOMMEND_END_REFRESH_SELECTOR],
+        textScanSelectors: scrollAttempt > 0 || (signature?.stable_signature_count || 0) >= 2 ? undefined : [],
+        maxTextScanNodes: 500
       })
     }));
     if (!nextCandidateResult.ok) {
       listEndReason = nextCandidateResult.reason || "list_exhausted";
       if (
-        nextCandidateResult.end_reached
-        && refreshOnEnd
-        && results.length < limit
-        && refreshRounds < Math.max(0, Number(maxRefreshRounds) || 0)
+          (nextCandidateResult.end_reached || isRefreshableListStall(nextCandidateResult.reason))
+          && refreshOnEnd
+          && results.length < limit
+          && refreshRounds < Math.max(0, Number(maxRefreshRounds) || 0)
       ) {
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
@@ -715,6 +736,10 @@ export async function runRecommendWorkflow({
             settleMs: 350,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
             metadata: {
               domain: "recommend",
               capture_mode: "scroll_sequence",
@@ -935,9 +960,9 @@ export function createRecommendRunService({
     imageWheelDeltaY = 650,
     cvAcquisitionMode = "unknown",
     listMaxScrolls = 20,
-    listStableSignatureLimit = 2,
+    listStableSignatureLimit = 5,
     listWheelDeltaY = 850,
-    listSettleMs = 1200,
+    listSettleMs = 2200,
     listFallbackPoint = null,
     refreshOnEnd = true,
     maxRefreshRounds = 2,

package/src/domains/recruit/constants.js

@@ -24,6 +24,29 @@ export const RECRUIT_NO_DATA_SELECTORS = Object.freeze([
   '[class*="empty"]'
 ]);
 
+export const RECRUIT_BOTTOM_MARKER_SELECTORS = Object.freeze([
+  ".finished-wrap",
+  ".load-tips",
+  ".tip-nodata",
+  ".empty-tip",
+  ".empty-text",
+  ".no-data",
+  "[class*=\"finished\"]",
+  "[class*=\"load-tips\"]",
+  "[class*=\"empty\"]"
+]);
+
+export const RECRUIT_BOTTOM_REFRESH_SELECTORS = Object.freeze([
+  ".finished-wrap .btn-refresh",
+  ".finished-wrap .btn",
+  ".no-data-refresh .btn-refresh",
+  ".no-data-refresh .btn",
+  "[class*=\"refresh\"]",
+  "[ka*=\"refresh\"]",
+  "button",
+  "a"
+]);
+
 export const RECRUIT_SEARCH_SELECTORS = Object.freeze({
   keywordInput: [
     "input.search-input",

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

@@ -19,6 +19,7 @@ import {
 import {
   compactInfiniteListState,
   createInfiniteListState,
+  detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed,
   resetInfiniteListForRefreshRound
@@ -49,6 +50,10 @@ import {
 } from "./search.js";
 import { refreshRecruitSearchAtEnd } from "./refresh.js";
 import { getRecruitRoots } from "./roots.js";
+import {
+  RECRUIT_BOTTOM_MARKER_SELECTORS,
+  RECRUIT_BOTTOM_REFRESH_SELECTORS
+} from "./constants.js";
 
 function compactScreening(screening) {
   return {
@@ -144,9 +149,9 @@ export async function runRecruitWorkflow({
   imageWheelDeltaY = 650,
   cvAcquisitionMode = "unknown",
   listMaxScrolls = 20,
-  listStableSignatureLimit = 2,
+  listStableSignatureLimit = 5,
   listWheelDeltaY = 850,
-  listSettleMs = 1200,
+  listSettleMs = 2200,
   listFallbackPoint = null,
   refreshOnEnd = true,
   maxRefreshRounds = 2,
@@ -298,6 +303,13 @@ export async function runRecruitWorkflow({
           visible_index: visibleIndex,
           search_params: normalizedSearchParams
         }
+      }),
+      detectBottomMarker: async ({ scrollAttempt = 0, signature = {} } = {}) => detectInfiniteListBottomMarker(client, {
+        rootNodeId: rootState?.iframe?.documentNodeId,
+        markerSelectors: RECRUIT_BOTTOM_MARKER_SELECTORS,
+        refreshSelectors: RECRUIT_BOTTOM_REFRESH_SELECTORS,
+        textScanSelectors: scrollAttempt > 0 || (signature?.stable_signature_count || 0) >= 2 ? undefined : [],
+        maxTextScanNodes: 500
       })
     }));
     if (!nextCandidateResult.ok) {
@@ -440,6 +452,10 @@ export async function runRecruitWorkflow({
             settleMs: 350,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
             metadata: {
               domain: "recruit",
               capture_mode: "scroll_sequence",
@@ -621,9 +637,9 @@ export function createRecruitRunService({
     imageWheelDeltaY = 650,
     cvAcquisitionMode = "unknown",
     listMaxScrolls = 20,
-    listStableSignatureLimit = 2,
+    listStableSignatureLimit = 5,
     listWheelDeltaY = 850,
-    listSettleMs = 1200,
+    listSettleMs = 2200,
     listFallbackPoint = null,
     refreshOnEnd = true,
     maxRefreshRounds = 2,