@reconcrap/boss-recommend-mcp 1.2.1 → 1.2.3

package/package.json

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

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -13,11 +13,52 @@ const RESUME_CAPTURE_WAIT_MS = 60000;
 const RESUME_CAPTURE_MAX_ATTEMPTS = 4;
 const RESUME_CAPTURE_RETRY_DELAY_MS = 1200;
 const MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES = 10;
+const DEFAULT_VISION_MAX_IMAGE_PIXELS = 36000000;
+const DEFAULT_VISION_RETRY_MAX_IMAGE_PIXELS = 30000000;
+let visionSharpFactory = null;
 const PAGE_SCOPE_TAB_STATUS = {
   recommend: "0",
   latest: "1",
   featured: "3"
 };
+const BOTTOM_HINT_KEYWORDS = ["没有更多", "已显示全部", "已经到底", "暂无更多", "推荐完了", "没有更多人选"];
+const LOAD_MORE_HINT_KEYWORDS = ["滚动加载更多", "下滑加载更多", "继续下滑", "继续滑动", "滑动加载", "正在加载", "加载中"];
+
+function classifyFinishedWrapState(finishedWrapText, refreshButtonVisible = false) {
+  const normalizedText = normalizeText(finishedWrapText);
+  const matchedBottomKeyword = BOTTOM_HINT_KEYWORDS.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedBottomKeyword) {
+    return {
+      isBottom: true,
+      reason: matchedBottomKeyword,
+      matched_bottom_keyword: matchedBottomKeyword,
+      matched_load_more_keyword: null
+    };
+  }
+  const matchedLoadMoreKeyword = LOAD_MORE_HINT_KEYWORDS.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedLoadMoreKeyword) {
+    return {
+      isBottom: false,
+      reason: null,
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: matchedLoadMoreKeyword
+    };
+  }
+  if (refreshButtonVisible) {
+    return {
+      isBottom: true,
+      reason: "refresh_button_visible",
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: null
+    };
+  }
+  return {
+    isBottom: false,
+    reason: null,
+    matched_bottom_keyword: null,
+    matched_load_more_keyword: null
+  };
+}
 
 function getCodexHome() {
   return process.env.CODEX_HOME
@@ -65,6 +106,35 @@ function parsePositiveInteger(raw) {
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function resolveVisionPixelLimitFromEnv(envName, fallback) {
+  const parsed = parsePositiveInteger(process.env[envName]);
+  return parsed || fallback;
+}
+
+function resolveVisionRetryPixelLimit(primaryLimit) {
+  const safePrimary = parsePositiveInteger(primaryLimit) || DEFAULT_VISION_MAX_IMAGE_PIXELS;
+  const fallback = Math.max(1, Math.floor(safePrimary * 0.8));
+  const parsed = resolveVisionPixelLimitFromEnv("BOSS_RECOMMEND_VISION_RETRY_MAX_IMAGE_PIXELS", DEFAULT_VISION_RETRY_MAX_IMAGE_PIXELS);
+  const candidate = parsePositiveInteger(parsed) || fallback;
+  return Math.min(Math.max(1, candidate), Math.max(1, safePrimary - 1));
+}
+
+function loadVisionSharp() {
+  if (!visionSharpFactory) {
+    visionSharpFactory = require("sharp");
+  }
+  return visionSharpFactory;
+}
+
+function isVisionImageSizeLimitMessage(message) {
+  const text = normalizeText(message).toLowerCase();
+  if (!text) return false;
+  return (
+    /(像素|pixel|pixels|too large|image size|image dimension|too many pixels|max(?:imum)?[^a-z0-9]{0,8}(?:pixel|image)|超过|超出|上限)/i.test(text)
+    || (text.includes("image") && text.includes("limit"))
+  );
+}
+
 function normalizePostAction(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
@@ -620,6 +690,121 @@ function parseGeekIdFromUrl(url) {
   return null;
 }
 
+function collectGeekIdsFromPayload(payload, fallbackGeekId = null) {
+  if (!payload || typeof payload !== "object") return [];
+  const geekDetail = payload?.geekDetail || payload;
+  const baseInfo = geekDetail?.geekBaseInfo || {};
+  const ids = [
+    fallbackGeekId,
+    baseInfo.geekId,
+    baseInfo.encryptGeekId,
+    baseInfo.securityId,
+    geekDetail?.geekId,
+    geekDetail?.encryptGeekId,
+    geekDetail?.securityId,
+    payload?.geekId,
+    payload?.encryptGeekId,
+    payload?.securityId
+  ].map((value) => normalizeText(value)).filter(Boolean);
+  return Array.from(new Set(ids));
+}
+
+function hasResumePayloadShape(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+  const geekDetail = payload?.geekDetail && typeof payload.geekDetail === "object"
+    ? payload.geekDetail
+    : payload;
+  const baseInfo = geekDetail?.geekBaseInfo || {};
+  const hasIdentity = Boolean(
+    normalizeText(
+      baseInfo?.name
+      || geekDetail?.geekName
+      || payload?.geekName
+      || baseInfo?.geekId
+      || baseInfo?.encryptGeekId
+      || baseInfo?.securityId
+      || geekDetail?.geekId
+      || geekDetail?.encryptGeekId
+      || geekDetail?.securityId
+      || payload?.geekId
+      || payload?.encryptGeekId
+      || payload?.securityId
+      || ""
+    )
+  );
+  const hasResumeSections = [
+    geekDetail?.geekExpectList,
+    geekDetail?.geekWorkExpList,
+    geekDetail?.geekProjExpList,
+    geekDetail?.geekEduExpList,
+    geekDetail?.geekEducationList,
+    geekDetail?.geekSkillList
+  ].some((section) => Array.isArray(section) && section.length > 0);
+  const hasResumeTextFields = Boolean(
+    normalizeText(
+      geekDetail?.geekAdvantage
+      || baseInfo?.userDesc
+      || baseInfo?.userDescription
+      || ""
+    )
+  );
+  return hasIdentity && (hasResumeSections || hasResumeTextFields);
+}
+
+function findResumePayloadInObject(root, maxDepth = 4, visited = new Set()) {
+  if (root === null || root === undefined || maxDepth < 0) return null;
+  if (typeof root !== "object") return null;
+  if (visited.has(root)) return null;
+  visited.add(root);
+
+  if (hasResumePayloadShape(root)) {
+    return root;
+  }
+
+  if (maxDepth === 0) return null;
+
+  if (Array.isArray(root)) {
+    for (const item of root) {
+      const found = findResumePayloadInObject(item, maxDepth - 1, visited);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  const priorityKeys = [
+    "zpData",
+    "data",
+    "result",
+    "geekDetail",
+    "detail",
+    "info"
+  ];
+  for (const key of priorityKeys) {
+    if (!(key in root)) continue;
+    const found = findResumePayloadInObject(root[key], maxDepth - 1, visited);
+    if (found) return found;
+  }
+
+  for (const value of Object.values(root)) {
+    const found = findResumePayloadInObject(value, maxDepth - 1, visited);
+    if (found) return found;
+  }
+  return null;
+}
+
+function extractResumePayloadFromResponseBody(parsedBody) {
+  return findResumePayloadInObject(parsedBody, 4) || null;
+}
+
+function isResumeInfoRequestUrl(url) {
+  const normalizedUrl = normalizeText(url).toLowerCase();
+  if (!normalizedUrl || !normalizedUrl.includes("/wapi/")) return false;
+  if (!normalizedUrl.includes("geek") || !normalizedUrl.includes("info")) return false;
+  if (/\/boss\/[^?#]*\/geek\/info\b/.test(normalizedUrl)) return true;
+  if (/\/geek\/info\b/.test(normalizedUrl)) return true;
+  return /[?&](?:geekid|geek_id|encryptgeekid|securityid)=/.test(normalizedUrl);
+}
+
 function formatResumeApiData(data) {
   const parts = [];
   const geekDetail = data?.geekDetail || data || {};
@@ -1041,7 +1226,8 @@ const jsDetectBottom = `(() => {
   const finishedWrap = Array.from(doc.querySelectorAll('.finished-wrap')).find((el) => isVisible(el)) || null;
   const refreshButton = Array.from(doc.querySelectorAll('.finished-wrap .btn.btn-refresh, .finished-wrap .btn-refresh, .no-data-refresh .btn-refresh'))
     .find((el) => isVisible(el)) || null;
-  const keywords = ['没有更多', '已显示全部', '已经到底', '暂无更多', '推荐完了', '没有更多人选'];
+  const keywords = ${JSON.stringify(BOTTOM_HINT_KEYWORDS)};
+  const loadMoreKeywords = ${JSON.stringify(LOAD_MORE_HINT_KEYWORDS)};
   const elements = Array.from(doc.querySelectorAll('div,span,p'));
   for (const el of elements) {
     if (el.offsetParent === null) continue;
@@ -1059,12 +1245,21 @@ const jsDetectBottom = `(() => {
       }
     }
   }
+  const finishedWrapText = finishedWrap ? String(finishedWrap.textContent || '').replace(/\s+/g, ' ').trim() : '';
+  const matchedBottomKeyword = keywords.find((keyword) => finishedWrapText.includes(keyword)) || null;
+  const matchedLoadMoreKeyword = loadMoreKeywords.find((keyword) => finishedWrapText.includes(keyword)) || null;
+  const inferredBottom = matchedBottomKeyword
+    ? true
+    : (Boolean(refreshButton) && !matchedLoadMoreKeyword);
   return {
-    isBottom: Boolean(finishedWrap),
-    reason: finishedWrap ? 'finished-wrap' : null,
+    isBottom: inferredBottom,
+    reason: matchedBottomKeyword || (inferredBottom ? 'refresh_button_visible' : null),
     finished_wrap_visible: Boolean(finishedWrap),
+    finished_wrap_text: finishedWrapText || null,
     refresh_button_visible: Boolean(refreshButton),
-    refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null
+    refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null,
+    matched_bottom_keyword: matchedBottomKeyword,
+    matched_load_more_keyword: matchedLoadMoreKeyword
   };
 })()`;
 const jsWaitForDetail = `(() => {
@@ -1994,14 +2189,8 @@ class RecommendScreenCli {
     if (!payload || typeof payload !== "object") return;
     const geekDetail = payload.geekDetail || payload;
     const baseInfo = geekDetail.geekBaseInfo || {};
-    const geekId = normalizeText(
-      fallbackGeekId
-      || baseInfo.geekId
-      || baseInfo.encryptGeekId
-      || geekDetail.geekId
-      || payload.geekId
-      || ""
-    ) || null;
+    const geekIds = collectGeekIdsFromPayload(payload, fallbackGeekId);
+    const geekId = geekIds[0] || null;
     const candidateInfo = {
       name: baseInfo.name || geekDetail.geekName || payload.geekName || "",
       school: (geekDetail.geekEduExpList && geekDetail.geekEduExpList[0]?.school)
@@ -2013,17 +2202,18 @@ class RecommendScreenCli {
       company: (geekDetail.geekWorkExpList && geekDetail.geekWorkExpList[0]?.company) || "",
       position: (geekDetail.geekWorkExpList && geekDetail.geekWorkExpList[0]?.positionName) || "",
       resumeText: formatResumeApiData(payload),
-      alreadyInterested: payload.alreadyInterested === true
+      alreadyInterested: payload.alreadyInterested === true || geekDetail.alreadyInterested === true
     };
     const wrapped = {
       ts: Date.now(),
       geekId: geekId || null,
+      geekIds,
       data: payload,
       candidateInfo
     };
     this.latestResumeNetworkPayload = wrapped;
-    if (geekId) {
-      this.resumeNetworkByGeekId.set(geekId, wrapped);
+    for (const id of geekIds) {
+      this.resumeNetworkByGeekId.set(id, wrapped);
     }
   }
 
@@ -2056,7 +2246,7 @@ class RecommendScreenCli {
   handleNetworkRequestWillBeSent(params) {
     const url = normalizeText(params?.request?.url || "");
     if (!url) return;
-    if (url.includes("/wapi/zpitem/web/boss/search/geek/info")) {
+    if (isResumeInfoRequestUrl(url)) {
       const geekId = parseGeekIdFromUrl(url);
       this.resumeNetworkRequests.set(params.requestId, {
         ts: Date.now(),
@@ -2126,9 +2316,13 @@ class RecommendScreenCli {
     try {
       const responseBody = await this.Network.getResponseBody({ requestId: params.requestId });
       if (!responseBody?.body) return;
-      const parsed = JSON.parse(responseBody.body);
-      if (parsed?.zpData) {
-        this.cacheResumeNetworkPayload(parsed.zpData, requestMeta.geekId);
+      const rawBody = responseBody.base64Encoded
+        ? Buffer.from(responseBody.body, "base64").toString("utf8")
+        : responseBody.body;
+      const parsed = JSON.parse(rawBody);
+      const resumePayload = extractResumePayloadFromResponseBody(parsed);
+      if (resumePayload) {
+        this.cacheResumeNetworkPayload(resumePayload, requestMeta.geekId);
       }
     } catch {}
   }
@@ -2615,15 +2809,21 @@ class RecommendScreenCli {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
       const doc = frame.contentDocument;
-      const inner = Array.from(doc.querySelectorAll('.card-inner[data-geekid]'))
+      const recommendInner = Array.from(doc.querySelectorAll('.card-inner[data-geekid]'))
         .find((item) => (item.getAttribute('data-geekid') || '') === String(candidateKey)) || null;
-      const featuredAnchor = inner
+      const latestInner = recommendInner
+        ? null
+        : Array.from(doc.querySelectorAll('.candidate-card-wrap .card-inner[data-geek], .candidate-card-wrap [data-geek]'))
+          .find((item) => (item.getAttribute('data-geek') || '') === String(candidateKey)) || null;
+      const featuredAnchor = (recommendInner || latestInner)
         ? null
         : Array.from(doc.querySelectorAll('li.geek-info-card a[data-geekid], a[data-geekid]'))
           .find((item) => (item.getAttribute('data-geekid') || '') === String(candidateKey)) || null;
-      const card = inner
-        ? (inner.closest('li.card-item') || inner.closest('.card-item'))
-        : (featuredAnchor ? (featuredAnchor.closest('li.geek-info-card') || featuredAnchor.closest('.geek-info-card')) : null);
+      const card = recommendInner
+        ? (recommendInner.closest('li.card-item') || recommendInner.closest('.card-item'))
+        : latestInner
+          ? (latestInner.closest('.candidate-card-wrap') || latestInner.closest('li.card-item') || latestInner.closest('.card-item'))
+          : (featuredAnchor ? (featuredAnchor.closest('li.geek-info-card') || featuredAnchor.closest('.geek-info-card')) : null);
       if (!card) {
         return { ok: false, error: 'CANDIDATE_CARD_NOT_FOUND' };
       }
@@ -2716,6 +2916,130 @@ class RecommendScreenCli {
   }
 
   async callVisionModel(imagePath) {
+    const primaryLimit = resolveVisionPixelLimitFromEnv(
+      "BOSS_RECOMMEND_VISION_MAX_IMAGE_PIXELS",
+      DEFAULT_VISION_MAX_IMAGE_PIXELS
+    );
+    const retryLimit = resolveVisionRetryPixelLimit(primaryLimit);
+    const preparedPrimary = await this.prepareVisionImageForModel(imagePath, primaryLimit, "primary");
+    try {
+      return await this.requestVisionModel(preparedPrimary.imagePath);
+    } catch (error) {
+      if (!isVisionImageSizeLimitMessage(error?.message || "")) {
+        throw error;
+      }
+      log(
+        `[VISION] 检测到图片尺寸超限，准备降采样重试: ` +
+        `primary_limit=${primaryLimit} source=${preparedPrimary.source} ` +
+        `source_pixels=${preparedPrimary.sourcePixels ?? "unknown"}`
+      );
+    }
+    const preparedRetry = await this.prepareVisionImageForModel(imagePath, retryLimit, "retry");
+    try {
+      return await this.requestVisionModel(preparedRetry.imagePath);
+    } catch (retryError) {
+      if (!isVisionImageSizeLimitMessage(retryError?.message || "")) {
+        throw retryError;
+      }
+      throw this.buildError(
+        "VISION_IMAGE_SIZE_LIMIT_EXCEEDED",
+        `Vision model still rejected image after retry downscale; ` +
+          `primary_limit=${primaryLimit}; retry_limit=${retryLimit}; ` +
+          `source_pixels=${preparedRetry.sourcePixels ?? "unknown"}; ` +
+          `retry_pixels=${preparedRetry.currentPixels ?? "unknown"}; ` +
+          `last_error=${normalizeText(retryError?.message || retryError)}`
+      );
+    }
+  }
+
+  async prepareVisionImageForModel(imagePath, maxPixels, attemptTag = "primary") {
+    const resolvedMaxPixels = parsePositiveInteger(maxPixels);
+    if (!resolvedMaxPixels) {
+      return {
+        imagePath,
+        source: "no_limit",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    let sharp;
+    try {
+      sharp = loadVisionSharp();
+    } catch (error) {
+      log(`[VISION] 加载 sharp 失败，跳过预缩放: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "sharp_unavailable",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    let metadata;
+    try {
+      metadata = await sharp(imagePath).metadata();
+    } catch (error) {
+      log(`[VISION] 读取图片尺寸失败，跳过预缩放: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "metadata_error",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    const width = Number(metadata?.width || 0);
+    const height = Number(metadata?.height || 0);
+    const sourcePixels = width > 0 && height > 0 ? width * height : null;
+    if (!sourcePixels || sourcePixels <= resolvedMaxPixels) {
+      return {
+        imagePath,
+        source: "within_limit",
+        sourcePixels,
+        currentPixels: sourcePixels
+      };
+    }
+    const scale = Math.sqrt(resolvedMaxPixels / sourcePixels);
+    const targetWidth = Math.max(1, Math.floor(width * scale));
+    const targetHeight = Math.max(1, Math.floor(height * scale));
+    const parsedPath = path.parse(imagePath);
+    const resizedPath = path.join(
+      parsedPath.dir,
+      `${parsedPath.name}.${attemptTag}.max${resolvedMaxPixels}.png`
+    );
+    try {
+      await sharp(imagePath)
+        .resize({
+          width: targetWidth,
+          height: targetHeight,
+          fit: "inside",
+          withoutEnlargement: true
+        })
+        .png()
+        .toFile(resizedPath);
+      const resizedMeta = await sharp(resizedPath).metadata();
+      const resizedPixels = Number(resizedMeta?.width || 0) * Number(resizedMeta?.height || 0);
+      log(
+        `[VISION] 图片预缩放完成: ${width}x${height}(${sourcePixels}) -> ` +
+        `${resizedMeta?.width || "?"}x${resizedMeta?.height || "?"}(${resizedPixels || "?"}); ` +
+        `limit=${resolvedMaxPixels}; attempt=${attemptTag}`
+      );
+      return {
+        imagePath: resizedPath,
+        source: "resized",
+        sourcePixels,
+        currentPixels: resizedPixels || null
+      };
+    } catch (error) {
+      log(`[VISION] 预缩放失败，继续使用原图: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "resize_failed",
+        sourcePixels,
+        currentPixels: sourcePixels
+      };
+    }
+  }
+
+  async requestVisionModel(imagePath) {
     const imageBase64 = fs.readFileSync(imagePath, "base64");
     const rawBaseUrl = this.args.baseUrl;
     log(`[callVisionModel] baseUrl 原始值类型=${typeof rawBaseUrl}, 长度=${rawBaseUrl != null ? String(rawBaseUrl).length : "null/undefined"}, JSON编码=${JSON.stringify(rawBaseUrl)}`);
@@ -3247,10 +3571,11 @@ class RecommendScreenCli {
           }
 
           const isFeaturedScope = this.args.pageScope === "featured";
+          const allowImageFallback = !isFeaturedScope;
           let capture = null;
           let screening = null;
           let resumeSource = isFeaturedScope ? "network" : "image_fallback";
-          const networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(nextCandidate, 2400);
+          const networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(nextCandidate, allowImageFallback ? 4200 : 2400);
           const candidateProfile = {
             name: networkCandidateInfo?.name || nextCandidate.name || "",
             school: networkCandidateInfo?.school || nextCandidate.school || "",
@@ -3269,6 +3594,10 @@ class RecommendScreenCli {
             screening = await this.callTextModel(networkCandidateInfo.resumeText);
             resumeSource = "network";
             this.resumeSourceStats.network += 1;
+          } else if (networkCandidateInfo?.resumeText) {
+            screening = await this.callTextModel(networkCandidateInfo.resumeText);
+            resumeSource = "network";
+            this.resumeSourceStats.network += 1;
           } else {
             capture = await this.captureResumeImage(nextCandidate);
             screening = await this.callVisionModel(capture.stitchedImage);
@@ -3361,9 +3690,28 @@ class RecommendScreenCli {
           } else {
             this.resetResumeCaptureFailureStreak();
           }
-          if (["VISION_MODEL_FAILED", "TEXT_MODEL_FAILED"].includes(error.code)) {
+          if (error.code === "TEXT_MODEL_FAILED") {
             throw error;
           }
+          if (error.code === "VISION_MODEL_FAILED") {
+            if (isVisionImageSizeLimitMessage(error?.message || "")) {
+              log(
+                `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 触发视觉模型像素限制，` +
+                "已在本轮跳过并继续处理下一位。"
+              );
+            } else {
+              log(
+                `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 视觉模型调用失败，` +
+                "已在本轮跳过并继续处理下一位。"
+              );
+            }
+          }
+          if (error.code === "VISION_IMAGE_SIZE_LIMIT_EXCEEDED") {
+            log(
+              `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 触发视觉模型像素限制，` +
+              "已完成预缩放和重试，仍失败，继续处理下一位。"
+            );
+          }
         } finally {
           const closed = await this.closeDetailPage();
           if (!closed) {
@@ -3485,7 +3833,8 @@ if (require.main === module) {
       parseFavoriteActionFromKnownRequest,
       parseFavoriteActionFromActionLog,
       parseFavoriteActionFromWsPayload,
-      isRecoverablePostActionError
+      isRecoverablePostActionError,
+      classifyFinishedWrapState
     }
   };
 }

package/vendor/boss-recommend-screen-cli/test-recoverable-resume-failures.cjs

@@ -338,29 +338,28 @@ async function testFeaturedShouldUseNetworkResumeOnly() {
   assert.equal(result.result.resume_source, "network");
 }
 
-async function testRecommendShouldKeepImageCaptureEvenWhenNetworkResumeExists() {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-recommend-image-main-"));
-  const candidate = { key: "img-main-1", geek_id: "img-main-1", name: "recommend image main candidate" };
+async function testRecommendShouldPreferNetworkResumeWhenAvailable() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-recommend-network-main-"));
+  const candidate = { key: "net-main-1", geek_id: "net-main-1", name: "recommend network main candidate" };
   const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
-    candidates: [candidate],
-    captureOutcomes: new Map([
-      ["img-main-1", { stitchedImage: path.join(tempDir, "img-main-1.png") }]
-    ]),
-    screeningByKey: new Map([
-      ["img-main-1", { passed: true, reason: "image path used", summary: "image path used" }]
-    ])
+    candidates: [candidate]
   });
   cli.waitForNetworkResumeCandidateInfo = async () => ({
-    resumeText: "这段 network 文本在 recommend 页面不应被用于筛选"
+    resumeText: "这段 network 文本在 recommend 页面应优先用于筛选"
   });
-  cli.callTextModel = async () => {
-    throw new Error("text model should not be called for recommend scope");
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "network used",
+    summary: "network used"
+  });
+  cli.captureResumeImage = async () => {
+    throw new Error("capture should not be called when recommend network resume exists");
   };
 
   const result = await cli.run();
   assert.equal(result.status, "COMPLETED");
   assert.equal(result.result.passed_count, 1);
-  assert.equal(result.result.resume_source, "image_fallback");
+  assert.equal(result.result.resume_source, "network");
 }
 
 async function testNetworkMissShouldFallbackToImageCapture() {
@@ -382,6 +381,88 @@ async function testNetworkMissShouldFallbackToImageCapture() {
   assert.equal(result.result.resume_source, "image_fallback");
 }
 
+async function testLatestShouldPreferNetworkResumeWhenAvailable() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-latest-network-main-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const candidate = { key: "latest-net-1", geek_id: "latest-net-1", name: "latest network candidate" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [candidate]
+  });
+  cli.waitForNetworkResumeCandidateInfo = async () => ({
+    resumeText: "最新页 network 简历可用"
+  });
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "network used",
+    summary: "network used"
+  });
+  cli.captureResumeImage = async () => {
+    throw new Error("capture should not be called when latest network resume exists");
+  };
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.resume_source, "network");
+}
+
+async function testLatestNetworkMissShouldFallbackToImageCapture() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-latest-network-fallback-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const candidate = { key: "latest-img-1", geek_id: "latest-img-1", name: "latest image candidate" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [candidate],
+    captureOutcomes: new Map([
+      ["latest-img-1", { stitchedImage: path.join(tempDir, "latest-img-1.png") }]
+    ]),
+    screeningByKey: new Map([
+      ["latest-img-1", { passed: false, reason: "image fallback used", summary: "image fallback used" }]
+    ])
+  });
+  cli.waitForNetworkResumeCandidateInfo = async () => null;
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.resume_source, "image_fallback");
+}
+
+async function testVisionModelFailureShouldSkipCandidateAndContinue() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-vision-failure-skip-"));
+  const first = { key: "vision-fail-1", geek_id: "vision-fail-1", name: "vision-fail-1" };
+  const second = { key: "vision-pass-2", geek_id: "vision-pass-2", name: "vision-pass-2" };
+  const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
+    candidates: [first, second],
+    captureOutcomes: new Map([
+      ["vision-fail-1", { stitchedImage: path.join(tempDir, "vision-fail-1.png") }],
+      ["vision-pass-2", { stitchedImage: path.join(tempDir, "vision-pass-2.png") }]
+    ]),
+    screeningByKey: new Map([
+      ["vision-pass-2", { passed: true, reason: "ok", summary: "ok" }]
+    ])
+  });
+
+  cli.callVisionModel = async () => {
+    if (cli.lastCapturedCandidateKey === "vision-fail-1") {
+      const error = new Error("model backend timeout");
+      error.code = "VISION_MODEL_FAILED";
+      throw error;
+    }
+    return {
+      passed: true,
+      reason: "ok",
+      summary: "ok"
+    };
+  };
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.processed_count, 2);
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 1);
+}
+
 async function testFeaturedNetworkMissShouldSkipWithoutImageCapture() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-featured-network-only-"));
   const args = createArgs(tempDir);
@@ -551,6 +632,50 @@ function testFavoriteActionParserShouldOnlyTrustKnownRequestShapes() {
   assert.equal(userMark, "add");
 }
 
+function testFinishedWrapClassifierShouldNotTreatLoadMoreAsBottom() {
+  const loadMore = __testables.classifyFinishedWrapState("滚动加载更多", false);
+  const loading = __testables.classifyFinishedWrapState("正在加载数据...", false);
+  const noMore = __testables.classifyFinishedWrapState("没有更多人选", false);
+  const refreshOnly = __testables.classifyFinishedWrapState("", true);
+
+  assert.equal(loadMore.isBottom, false);
+  assert.equal(loadMore.matched_load_more_keyword, "滚动加载更多");
+  assert.equal(loading.isBottom, false);
+  assert.equal(loading.matched_load_more_keyword, "正在加载");
+  assert.equal(noMore.isBottom, true);
+  assert.equal(noMore.matched_bottom_keyword, "没有更多");
+  assert.equal(refreshOnly.isBottom, true);
+  assert.equal(refreshOnly.reason, "refresh_button_visible");
+}
+
+async function testGetCenteredCandidateClickPointShouldSupportLatestSelector() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-latest-click-locator-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const cli = new RecommendScreenCli(args);
+
+  let expressionCaptured = "";
+  cli.evaluate = async (expression) => {
+    expressionCaptured = String(expression || "");
+    return {
+      ok: true,
+      x: 100,
+      y: 100,
+      width: 120,
+      height: 64
+    };
+  };
+
+  const result = await cli.getCenteredCandidateClickPoint({
+    key: "latest-test-key",
+    geek_id: "latest-test-key"
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(expressionCaptured.includes(".candidate-card-wrap .card-inner[data-geek]"), true);
+  assert.equal(expressionCaptured.includes("getAttribute('data-geek')"), true);
+}
+
 async function testFeaturedPostActionFailureShouldStillRecordPassedCandidate() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-featured-action-failure-"));
   const args = createArgs(tempDir);
@@ -724,8 +849,11 @@ async function main() {
   await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
   await testPageExhaustedWithoutTargetShouldStillComplete();
   await testFeaturedShouldUseNetworkResumeOnly();
-  await testRecommendShouldKeepImageCaptureEvenWhenNetworkResumeExists();
+  await testRecommendShouldPreferNetworkResumeWhenAvailable();
   await testNetworkMissShouldFallbackToImageCapture();
+  await testLatestShouldPreferNetworkResumeWhenAvailable();
+  await testLatestNetworkMissShouldFallbackToImageCapture();
+  await testVisionModelFailureShouldSkipCandidateAndContinue();
   await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
   await testFeaturedFavoriteShouldNotUseDomFallback();
   await testFeaturedFavoriteShouldSkipClickWhenAlreadyInterested();
@@ -735,6 +863,8 @@ async function main() {
   testFavoriteActionParserShouldSupportFallbackRequestShape();
   testFavoriteActionParserShouldSupportWebSocketPayload();
   testFavoriteActionParserShouldOnlyTrustKnownRequestShapes();
+  testFinishedWrapClassifierShouldNotTreatLoadMoreAsBottom();
+  await testGetCenteredCandidateClickPointShouldSupportLatestSelector();
   await testFeaturedPostActionFailureShouldStillRecordPassedCandidate();
   await testStitchWithSharpShouldComposeExpectedImage();
   testStitchWithAvailablePythonShouldFallbackToPython();