@reconcrap/boss-recommend-mcp 1.2.7 → 1.2.8

package/package.json

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

package/src/parser.js

@@ -82,9 +82,9 @@ const RECENT_NOT_VIEW_NEGATIVE_PATTERNS = [
   /保留[^。；;\n]{0,12}14天/i
 ];
 const TARGET_COUNT_PATTERNS = [
-  /目标(?:处理|筛选)?(?:人数|数量)?(?:为|是|:|：)?\s*(\d+)/i,
-  /至少(?:处理|筛选)\s*(\d+)\s*(?:位|人)/i,
-  /(?:处理|筛选)\s*(\d+)\s*(?:位|人)/i
+  /目标(?:处理|筛选|通过)?(?:人数|数量)?(?:为|是|:|：)?\s*(\d+)/i,
+  /至少(?:处理|筛选|通过)\s*(\d+)\s*(?:位|人)/i,
+  /(?:处理|筛选|通过)\s*(\d+)\s*(?:位|人)/i
 ];
 const MAX_GREET_COUNT_PATTERNS = [
   /最多(?:打招呼|沟通|联系)\s*(\d+)\s*(?:位|人|个)?/i,
@@ -95,7 +95,7 @@ const FILTER_CLAUSE_PATTERNS = [
   /学历|学位|教育|初中及以下|中专|中技|高中|大专|专科|本科|硕士|研究生|博士/i,
   /性别|男生|女生|男性|女性|男\b|女\b/i,
   /近?14天(?:内)?没有|近?14天(?:内)?没看过|近?14天(?:内)?未查看|过滤[^。；;\n]{0,12}14天|排除[^。；;\n]{0,12}14天/i,
-  /目标(?:处理|筛选)?(?:人数|数量)?|至少(?:处理|筛选)|(?:处理|筛选)\s*\d+\s*(?:位|人)/i,
+  /目标(?:处理|筛选|通过)?(?:人数|数量)?|至少(?:处理|筛选|通过)|(?:处理|筛选|通过)\s*\d+\s*(?:位|人)/i,
   /最多(?:打招呼|沟通|联系)|(?:打招呼|沟通|联系)(?:上限|最多|不超过|至多)/i,
   /收藏|打招呼|直接沟通|什么也不做|不做任何操作|不操作|仅筛选|只筛选/i
 ];
@@ -690,7 +690,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   if (needs_target_count_confirmation) {
     pending_questions.push({
       field: "target_count",
-      question: "本次目标筛选人数是多少？可留空表示不设上限。",
+      question: "本次目标通过人数是多少？可留空表示不设上限。",
       value: targetCountResolution.proposed_target_count
     });
   }

package/src/pipeline.js

@@ -18,6 +18,17 @@ const FORCED_RECENT_NOT_VIEW_ON_SCREEN_RECOVERY = "近14天没有";
 const MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS = 5;
 const MAX_SEARCH_NO_IFRAME_RETRY_ATTEMPTS = 1;
 const SEARCH_NO_IFRAME_RETRY_DELAY_MS = 1200;
+const MAX_SEARCH_FILTER_AUTO_RETRY_ATTEMPTS = 2;
+const SEARCH_FILTER_AUTO_RETRY_DELAY_MS = 1200;
+const SEARCH_FILTER_RETRY_TOKENS = [
+  "FILTER_CONFIRM_FAILED",
+  "FILTER_DOM_CLASS_VERIFY_FAILED",
+  "RECOMMEND_FILTER_PANEL_UNAVAILABLE",
+  "RECOMMEND_FILTER_PANEL_NOT_READY",
+  "FILTER_PANEL_NOT_FOUND",
+  "FILTER_TRIGGER_NOT_FOUND",
+  "FILTER_PANEL_OPEN_FAILED"
+];
 const PAGE_SCOPE_TO_TAB_STATUS = {
   recommend: "0",
   latest: "1",
@@ -46,6 +57,20 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function shouldAutoRetrySearchFilterFailure(errorCode, errorMessage) {
+  const normalizedCode = normalizeText(errorCode).toUpperCase();
+  const normalizedMessage = normalizeText(errorMessage).toUpperCase();
+  const combined = `${normalizedCode} ${normalizedMessage}`.trim();
+  if (!combined) return false;
+  if (combined.includes("LOGIN_REQUIRED") || combined.includes("NO_RECOMMEND_IFRAME")) {
+    return false;
+  }
+  if (SEARCH_FILTER_RETRY_TOKENS.some((token) => combined.includes(token))) {
+    return true;
+  }
+  return /^(RECOMMEND_)?FILTER_/.test(normalizedCode);
+}
+
 function normalizePageScope(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
@@ -336,7 +361,7 @@ function buildNeedConfirmationResponse(parsedResult) {
 function buildFinalReviewQuestion({ searchParams, screenParams, selectedJob, selectedPage }) {
   return {
     field: "final_review",
-    question: "开始执行搜索和筛选前，请最后确认全部参数（岗位/页面/筛选条件/筛选 criteria/目标人数/post_action/max_greet_count）无误。",
+    question: "开始执行搜索和筛选前，请最后确认全部参数（岗位/页面/筛选条件/筛选 criteria/目标通过人数/post_action/max_greet_count）无误。",
     value: {
       job: selectedJob?.title || selectedJob?.label || selectedJob?.value || null,
       page_scope: selectedPage || "recommend",
@@ -893,6 +918,7 @@ export async function runRecommendPipeline(
   let screenAutoRecoveryCount = 0;
   let lastAutoRecovery = null;
   let searchNoIframeRetryCount = 0;
+  let searchFilterRetryCount = 0;
   let activeTabStatus = null;
   let currentResumeConfig = {
     checkpoint_path: resume?.checkpoint_path || null,
@@ -1039,6 +1065,29 @@ export async function runRecommendPipeline(
             continue;
           }
         }
+        if (
+          shouldAutoRetrySearchFilterFailure(searchErrorCode, searchErrorMessage)
+          && searchFilterRetryCount < MAX_SEARCH_FILTER_AUTO_RETRY_ATTEMPTS
+        ) {
+          searchFilterRetryCount += 1;
+          const retryDelayMs = SEARCH_FILTER_AUTO_RETRY_DELAY_MS;
+          lastAutoRecovery = {
+            trigger: "SEARCH_FILTER_RETRY",
+            attempt: searchFilterRetryCount,
+            max_attempts: MAX_SEARCH_FILTER_AUTO_RETRY_ATTEMPTS,
+            delay_ms: retryDelayMs,
+            error_code: searchErrorCode || null,
+            error_message: searchErrorMessage || null,
+            action: "retry_search"
+          };
+          runtimeHooks.setStage(
+            "search_recovery",
+            `检测到筛选控件状态异常（${searchErrorCode || "UNKNOWN"}），等待 ${Math.round(retryDelayMs / 1000)} 秒后重试 search（第 ${searchFilterRetryCount}/${MAX_SEARCH_FILTER_AUTO_RETRY_ATTEMPTS} 次）。`
+          );
+          runtimeHooks.heartbeat("search_recovery", lastAutoRecovery);
+          await sleep(retryDelayMs);
+          continue;
+        }
         return buildFailedResponse(
           searchResult.error?.code || "RECOMMEND_SEARCH_FAILED",
           searchResult.error?.message || "推荐页筛选执行失败。",
@@ -1057,6 +1106,7 @@ export async function runRecommendPipeline(
         );
       }
 
+      searchFilterRetryCount = 0;
       searchSummary = searchResult.summary || {};
       if (isPauseRequested(runtimeHooks)) {
         return buildPausedResponse("已在 screen 阶段开始前暂停 Recommend 流水线。", {

package/src/test-pipeline.js

@@ -1432,6 +1432,7 @@ async function testCompletedPipeline() {
 }
 
 async function testSearchFailure() {
+  let searchCallCount = 0;
   const result = await runRecommendPipeline(
     {
       workspaceRoot: process.cwd(),
@@ -1444,22 +1445,80 @@ async function testSearchFailure() {
       runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
       ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
       listRecommendJobs: async () => createJobListResult(),
-      runRecommendSearchCli: async () => ({
-        ok: false,
-        stdout: "",
-        stderr: "boom",
-        structured: null,
-        error: {
-          code: "RECOMMEND_FILTER_PANEL_UNAVAILABLE",
-          message: "筛选面板不可用。"
-        }
-      }),
+      runRecommendSearchCli: async () => {
+        searchCallCount += 1;
+        return {
+          ok: false,
+          stdout: "",
+          stderr: "boom",
+          structured: null,
+          error: {
+            code: "RECOMMEND_FILTER_PANEL_UNAVAILABLE",
+            message: "筛选面板不可用。"
+          }
+        };
+      },
       runRecommendScreenCli: async () => ({ ok: true, summary: {} })
     }
   );
 
   assert.equal(result.status, "FAILED");
   assert.equal(result.error.code, "RECOMMEND_FILTER_PANEL_UNAVAILABLE");
+  assert.equal(searchCallCount, 3);
+}
+
+async function testSearchFilterFailureShouldRetryAndRecover() {
+  let searchCallCount = 0;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => {
+        searchCallCount += 1;
+        if (searchCallCount === 1) {
+          return {
+            ok: false,
+            stdout: "",
+            stderr: "FILTER_CONFIRM_FAILED",
+            structured: null,
+            error: {
+              code: "FILTER_CONFIRM_FAILED",
+              message: "FILTER_CONFIRM_FAILED"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 6,
+            applied_filters: {}
+          }
+        };
+      },
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 3,
+          passed_count: 2,
+          skipped_count: 1,
+          output_csv: "C:/temp/search-filter-retry.csv"
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCallCount, 2);
+  assert.equal(result.result.auto_recovery.trigger, "SEARCH_FILTER_RETRY");
+  assert.equal(result.result.auto_recovery.attempt, 1);
 }
 
 async function testSearchNoIframeWithLoginShouldReturnLoginRequired() {
@@ -2005,6 +2064,7 @@ async function main() {
   await testNeedFinalReviewConfirmationGate();
   await testCompletedPipeline();
   await testSearchFailure();
+  await testSearchFilterFailureShouldRetryAndRecover();
   await testSearchNoIframeWithLoginShouldReturnLoginRequired();
   await testSearchNoIframeShouldRetryOnceWhenPageRecheckReady();
   await testJobTriggerNotFoundShouldMapToLoginRequiredWhenRecheckShowsLogin();

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

@@ -15,6 +15,9 @@ 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;
+const DEFAULT_TEXT_MODEL_CHUNK_SIZE_CHARS = 24000;
+const DEFAULT_TEXT_MODEL_CHUNK_OVERLAP_CHARS = 1200;
+const DEFAULT_TEXT_MODEL_MAX_CHUNKS = 12;
 let visionSharpFactory = null;
 const PAGE_SCOPE_TAB_STATUS = {
   recommend: "0",
@@ -333,6 +336,60 @@ function isVisionImageSizeLimitMessage(message) {
   );
 }
 
+function isTextContextLimitMessage(message) {
+  const text = normalizeText(message).toLowerCase();
+  if (!text) return false;
+  return (
+    /context length|maximum context|too many tokens|max(?:imum)? token|prompt is too long|input is too long|token limit|上下文|超出.*token|超过.*token|输入过长/i.test(text)
+  );
+}
+
+function toStringArray(value, maxItems = 8) {
+  if (!Array.isArray(value)) return [];
+  const normalized = [];
+  for (const item of value) {
+    const text = normalizeText(item);
+    if (!text) continue;
+    normalized.push(text);
+    if (normalized.length >= maxItems) break;
+  }
+  return normalized;
+}
+
+function splitTextByChunks(text, chunkSize, overlap, maxChunks) {
+  const source = String(text || "");
+  if (!source) return [];
+
+  const safeChunkSize = Math.max(1000, parsePositiveInteger(chunkSize) || DEFAULT_TEXT_MODEL_CHUNK_SIZE_CHARS);
+  const safeOverlap = Math.max(0, Math.min(safeChunkSize - 1, parsePositiveInteger(overlap) || DEFAULT_TEXT_MODEL_CHUNK_OVERLAP_CHARS));
+  const safeMaxChunks = Math.max(1, parsePositiveInteger(maxChunks) || DEFAULT_TEXT_MODEL_MAX_CHUNKS);
+
+  const chunks = [];
+  let start = 0;
+  while (start < source.length && chunks.length < safeMaxChunks) {
+    const end = Math.min(source.length, start + safeChunkSize);
+    chunks.push({
+      text: source.slice(start, end),
+      start,
+      end
+    });
+    if (end >= source.length) break;
+    start = Math.max(0, end - safeOverlap);
+  }
+
+  if (chunks.length > 0) {
+    const last = chunks[chunks.length - 1];
+    if (last.end < source.length) {
+      chunks[chunks.length - 1] = {
+        text: source.slice(last.start),
+        start: last.start,
+        end: source.length
+      };
+    }
+  }
+  return chunks;
+}
+
 function normalizePostAction(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
@@ -795,7 +852,7 @@ async function promptMissingInputs(args) {
     if (args.targetCount === null) {
       const targetCount = await askWithValidation(
         ask,
-        "请输入目标筛选人数（--targetCount，可留空表示不设上限）: ",
+        "请输入目标通过人数（--targetCount，可留空表示不设上限）: ",
         (value) => parsePositiveInteger(value),
         { allowEmpty: true }
       );
@@ -3241,9 +3298,9 @@ class RecommendScreenCli {
       DEFAULT_VISION_MAX_IMAGE_PIXELS
     );
     const retryLimit = resolveVisionRetryPixelLimit(primaryLimit);
-    const preparedPrimary = await this.prepareVisionImageForModel(imagePath, primaryLimit, "primary");
+    const preparedPrimary = await this.prepareVisionImageSegmentsForModel(imagePath, primaryLimit, "primary");
     try {
-      return await this.requestVisionModel(preparedPrimary.imagePath);
+      return await this.requestVisionModel(preparedPrimary.imagePaths);
     } catch (error) {
       if (!isVisionImageSizeLimitMessage(error?.message || "")) {
         throw error;
@@ -3251,12 +3308,13 @@ class RecommendScreenCli {
       log(
         `[VISION] 检测到图片尺寸超限，准备降采样重试: ` +
         `primary_limit=${primaryLimit} source=${preparedPrimary.source} ` +
-        `source_pixels=${preparedPrimary.sourcePixels ?? "unknown"}`
+        `source_pixels=${preparedPrimary.sourcePixels ?? "unknown"} ` +
+        `segments=${preparedPrimary.imagePaths?.length || 1}`
       );
     }
-    const preparedRetry = await this.prepareVisionImageForModel(imagePath, retryLimit, "retry");
+    const preparedRetry = await this.prepareVisionImageSegmentsForModel(imagePath, retryLimit, "retry");
     try {
-      return await this.requestVisionModel(preparedRetry.imagePath);
+      return await this.requestVisionModel(preparedRetry.imagePaths);
     } catch (retryError) {
       if (!isVisionImageSizeLimitMessage(retryError?.message || "")) {
         throw retryError;
@@ -3267,11 +3325,106 @@ class RecommendScreenCli {
           `primary_limit=${primaryLimit}; retry_limit=${retryLimit}; ` +
           `source_pixels=${preparedRetry.sourcePixels ?? "unknown"}; ` +
           `retry_pixels=${preparedRetry.currentPixels ?? "unknown"}; ` +
+          `segments=${preparedRetry.imagePaths?.length || 1}; ` +
           `last_error=${normalizeText(retryError?.message || retryError)}`
       );
     }
   }
 
+  async prepareVisionImageSegmentsForModel(imagePath, maxPixels, attemptTag = "primary") {
+    const resolvedMaxPixels = parsePositiveInteger(maxPixels);
+    if (!resolvedMaxPixels) {
+      return {
+        imagePaths: [imagePath],
+        source: "no_limit",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+
+    let sharp;
+    try {
+      sharp = loadVisionSharp();
+    } catch (error) {
+      log(`[VISION] 加载 sharp 失败，回退到单图模式: ${error?.message || error}`);
+      const single = await this.prepareVisionImageForModel(imagePath, resolvedMaxPixels, attemptTag);
+      return {
+        imagePaths: [single.imagePath],
+        source: `single_${single.source}`,
+        sourcePixels: single.sourcePixels ?? null,
+        currentPixels: single.currentPixels ?? null
+      };
+    }
+
+    let metadata;
+    try {
+      metadata = await sharp(imagePath).metadata();
+    } catch (error) {
+      log(`[VISION] 读取图片尺寸失败，回退到单图模式: ${error?.message || error}`);
+      const single = await this.prepareVisionImageForModel(imagePath, resolvedMaxPixels, attemptTag);
+      return {
+        imagePaths: [single.imagePath],
+        source: `single_${single.source}`,
+        sourcePixels: single.sourcePixels ?? null,
+        currentPixels: single.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 {
+        imagePaths: [imagePath],
+        source: "within_limit",
+        sourcePixels,
+        currentPixels: sourcePixels
+      };
+    }
+
+    const maxTileHeight = Math.floor(resolvedMaxPixels / Math.max(1, width));
+    if (!Number.isFinite(maxTileHeight) || maxTileHeight < 64) {
+      const single = await this.prepareVisionImageForModel(imagePath, resolvedMaxPixels, attemptTag);
+      return {
+        imagePaths: [single.imagePath],
+        source: `single_${single.source}`,
+        sourcePixels: single.sourcePixels ?? sourcePixels,
+        currentPixels: single.currentPixels ?? sourcePixels
+      };
+    }
+
+    const parsedPath = path.parse(imagePath);
+    const imagePaths = [];
+    for (let top = 0, index = 0; top < height; top += maxTileHeight, index += 1) {
+      const segmentHeight = Math.min(maxTileHeight, height - top);
+      const segmentPath = path.join(
+        parsedPath.dir,
+        `${parsedPath.name}.${attemptTag}.seg${String(index + 1).padStart(3, "0")}.png`
+      );
+      await sharp(imagePath)
+        .extract({
+          left: 0,
+          top,
+          width,
+          height: segmentHeight
+        })
+        .png()
+        .toFile(segmentPath);
+      imagePaths.push(segmentPath);
+    }
+
+    log(
+      `[VISION] 长简历按分段输入模型: ${width}x${height}(${sourcePixels}) ` +
+      `-> segments=${imagePaths.length}, max_pixels_per_segment=${resolvedMaxPixels}, attempt=${attemptTag}`
+    );
+    return {
+      imagePaths,
+      source: "segmented",
+      sourcePixels,
+      currentPixels: resolvedMaxPixels
+    };
+  }
+
   async prepareVisionImageForModel(imagePath, maxPixels, attemptTag = "primary") {
     const resolvedMaxPixels = parsePositiveInteger(maxPixels);
     if (!resolvedMaxPixels) {
@@ -3360,7 +3513,38 @@ class RecommendScreenCli {
   }
 
   async requestVisionModel(imagePath) {
-    const imageBase64 = fs.readFileSync(imagePath, "base64");
+    const imagePaths = Array.isArray(imagePath) ? imagePath.filter(Boolean) : [imagePath].filter(Boolean);
+    if (imagePaths.length <= 0) {
+      throw this.buildError("VISION_MODEL_FAILED", "No vision image input provided.");
+    }
+    const userContent = [
+      {
+        type: "text",
+        text:
+          "请根据以下标准判断候选人是否通过筛选。\n\n" +
+          `筛选标准:\n${this.args.criteria}\n\n` +
+          "你将收到候选人完整简历的一个或多个顺序分段图片。必须完整阅读全部分段后再判断，" +
+          "严禁编造任何不存在的经历、项目、学校、公司或时间线；证据不足时必须判定为不通过。\n\n" +
+          "请返回严格 JSON: " +
+          "{\"passed\": true/false, \"reason\": \"...\", \"summary\": \"...\", \"evidence\": [\"证据原文1\", \"证据原文2\"]}"
+      }
+    ];
+    for (let index = 0; index < imagePaths.length; index += 1) {
+      const segmentPath = imagePaths[index];
+      const imageBase64 = fs.readFileSync(segmentPath, "base64");
+      if (imagePaths.length > 1) {
+        userContent.push({
+          type: "text",
+          text: `简历分段 ${index + 1}/${imagePaths.length}`
+        });
+      }
+      userContent.push({
+        type: "image_url",
+        image_url: {
+          url: `data:image/png;base64,${imageBase64}`
+        }
+      });
+    }
     const rawBaseUrl = this.args.baseUrl;
     log(`[callVisionModel] baseUrl 原始值类型=${typeof rawBaseUrl}, 长度=${rawBaseUrl != null ? String(rawBaseUrl).length : "null/undefined"}, JSON编码=${JSON.stringify(rawBaseUrl)}`);
     const baseUrl = String(rawBaseUrl || "").replace(/\/$/, "");
@@ -3370,22 +3554,13 @@ class RecommendScreenCli {
       messages: [
         {
           role: "system",
-          content: "你是一位严谨的招聘筛选助手。你只能返回 JSON，不要输出任何额外文字。"
+          content:
+            "你是一位严谨的招聘筛选助手。必须完整阅读所有输入材料，严禁臆造不存在的简历经历。" +
+            "只能返回 JSON，不要输出任何额外文字。"
         },
         {
           role: "user",
-          content: [
-            {
-              type: "text",
-              text: `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${this.args.criteria}\n\n你看到的是整份候选人简历长图。请返回严格 JSON: {\"passed\": true/false, \"reason\": \"...\", \"summary\": \"...\"}`
-            },
-            {
-              type: "image_url",
-              image_url: {
-                url: `data:image/png;base64,${imageBase64}`
-              }
-            }
-          ]
+          content: userContent
         }
       ]
     };
@@ -3410,15 +3585,79 @@ class RecommendScreenCli {
       ? json.choices[0].message.content.map((item) => item?.text || "").join("\n")
       : json?.choices?.[0]?.message?.content || "";
     const parsed = extractJsonObject(content);
+    const reason = normalizeText(parsed.reason);
+    const summary = normalizeText(parsed.summary || reason);
+    const evidence = toStringArray(parsed.evidence);
     return {
       passed: parsed.passed === true,
-      reason: normalizeText(parsed.reason),
-      summary: normalizeText(parsed.summary)
+      reason: reason || "未满足筛选标准。",
+      summary: summary || reason || "未满足筛选标准。",
+      evidence
     };
   }
 
   async callTextModel(resumeText) {
-    const safeResumeText = String(resumeText || "").slice(0, 28000);
+    const fullResumeText = String(resumeText || "");
+    if (!normalizeText(fullResumeText)) {
+      throw this.buildError("TEXT_MODEL_FAILED", "Resume text is empty.");
+    }
+    try {
+      return await this.requestTextModel(fullResumeText, {
+        chunkIndex: 1,
+        chunkTotal: 1
+      });
+    } catch (error) {
+      if (!isTextContextLimitMessage(error?.message || "")) {
+        throw error;
+      }
+      log("[TEXT_MODEL] 检测到上下文长度限制，启用分段筛选模式。");
+    }
+
+    const chunkSize = parsePositiveInteger(process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS) || DEFAULT_TEXT_MODEL_CHUNK_SIZE_CHARS;
+    const overlap = parsePositiveInteger(process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS) || DEFAULT_TEXT_MODEL_CHUNK_OVERLAP_CHARS;
+    const maxChunks = parsePositiveInteger(process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS) || DEFAULT_TEXT_MODEL_MAX_CHUNKS;
+    const chunks = splitTextByChunks(fullResumeText, chunkSize, overlap, maxChunks);
+    if (!chunks.length) {
+      throw this.buildError("TEXT_MODEL_FAILED", "Resume text is empty after chunk split.");
+    }
+
+    const chunkResults = [];
+    for (let index = 0; index < chunks.length; index += 1) {
+      const chunk = chunks[index];
+      const result = await this.requestTextModel(chunk.text, {
+        chunkIndex: index + 1,
+        chunkTotal: chunks.length
+      });
+      chunkResults.push(result);
+    }
+
+    const passedChunks = chunkResults.filter((item) => item?.passed === true);
+    if (passedChunks.length > 0) {
+      const best = passedChunks[0];
+      return {
+        passed: true,
+        reason: best.reason || `分段筛选命中（${best.chunkIndex}/${chunks.length}）。`,
+        summary: best.summary || best.reason || "分段筛选命中",
+        evidence: Array.isArray(best.evidence) ? best.evidence : []
+      };
+    }
+
+    const firstReason = chunkResults.map((item) => normalizeText(item?.reason)).find(Boolean);
+    return {
+      passed: false,
+      reason: firstReason || `分段筛选未找到满足标准的证据（共 ${chunks.length} 段）。`,
+      summary: firstReason || `分段筛选未找到满足标准的证据（共 ${chunks.length} 段）。`,
+      evidence: []
+    };
+  }
+
+  async requestTextModel(resumeText, options = {}) {
+    const safeResumeText = String(resumeText || "");
+    const chunkIndex = Number.isInteger(options.chunkIndex) && options.chunkIndex > 0 ? options.chunkIndex : 1;
+    const chunkTotal = Number.isInteger(options.chunkTotal) && options.chunkTotal > 0 ? options.chunkTotal : 1;
+    const chunkHint = chunkTotal > 1
+      ? `\n\n当前输入是简历分段 ${chunkIndex}/${chunkTotal}。请严格基于本分段文本判断；如果本分段证据不足，必须返回 passed=false。`
+      : "";
     const rawBaseUrl = this.args.baseUrl;
     log(`[callTextModel] baseUrl 原始值类型=${typeof rawBaseUrl}, 长度=${rawBaseUrl != null ? String(rawBaseUrl).length : "null/undefined"}, JSON编码=${JSON.stringify(rawBaseUrl)}`);
     const baseUrl = String(rawBaseUrl || "").replace(/\/$/, "");
@@ -3428,11 +3667,21 @@ class RecommendScreenCli {
       messages: [
         {
           role: "system",
-          content: "你是一位严谨的招聘筛选助手。你只能返回 JSON，不要输出任何额外文字。"
+          content:
+            "你是一位严谨的招聘筛选助手。必须完整阅读输入内容，严禁编造不存在的简历经历。" +
+            "只能返回 JSON，不要输出任何额外文字。"
         },
         {
           role: "user",
-          content: `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${this.args.criteria}\n\n简历内容:\n${safeResumeText}\n\n请返回严格 JSON: {"passed": true/false, "reason": "...", "summary": "..."}`
+          content:
+            `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${this.args.criteria}\n\n` +
+            `简历内容:\n${safeResumeText}${chunkHint}\n\n` +
+            "要求：\n" +
+            "1) 必须完整阅读上面的全部简历文本。\n" +
+            "2) 只能依据简历中真实出现的信息判断，严禁编造不存在的经历/项目/学历/公司。\n" +
+            "3) 若证据不足，必须返回 passed=false。\n\n" +
+            "请返回严格 JSON: " +
+            "{\"passed\": true/false, \"reason\": \"...\", \"summary\": \"...\", \"evidence\": [\"证据原文1\", \"证据原文2\"]}"
         }
       ]
     };
@@ -3457,10 +3706,28 @@ class RecommendScreenCli {
       ? json.choices[0].message.content.map((item) => item?.text || "").join("\n")
       : json?.choices?.[0]?.message?.content || "";
     const parsed = extractJsonObject(content);
+    const reason = normalizeText(parsed.reason);
+    const summary = normalizeText(parsed.summary || reason);
+    const normalizedResume = normalizeText(safeResumeText);
+    const parsedEvidence = toStringArray(parsed.evidence);
+    const evidence = parsedEvidence.filter((item) => {
+      const normalizedEvidence = normalizeText(item);
+      if (!normalizedEvidence) return false;
+      return safeResumeText.includes(item) || normalizedResume.includes(normalizedEvidence);
+    });
+    let passed = parsed.passed === true;
+    let finalReason = reason || (passed ? "满足筛选标准。" : "不满足筛选标准。");
+    if (passed && evidence.length <= 0) {
+      passed = false;
+      finalReason = `模型未给出可在简历原文中校验的证据，按安全策略判为不通过。${reason ? ` 原始原因: ${reason}` : ""}`;
+    }
     return {
-      passed: parsed.passed === true,
-      reason: normalizeText(parsed.reason),
-      summary: normalizeText(parsed.summary)
+      passed,
+      reason: finalReason,
+      summary: summary || finalReason,
+      evidence,
+      chunkIndex,
+      chunkTotal
     };
   }
 
@@ -3686,8 +3953,13 @@ class RecommendScreenCli {
     }
 
     state = await this.getDetailClosedState();
-    log(`[关闭详情] 连续 ESC 后仍未确认关闭（${state?.reason || "unknown"}），按策略视为检测误差并继续下一位。`);
-    return true;
+    const listState = await this.evaluate(jsGetListState);
+    if (listState?.ok) {
+      log(`[关闭详情] 连续 ESC 后仍未确认关闭（${state?.reason || "unknown"}），但候选人列表已可用，按就绪状态继续。`);
+      return true;
+    }
+    log(`[关闭详情] 连续 ESC 后仍未确认关闭（${state?.reason || "unknown"}），且候选人列表未恢复，判定关闭失败。`);
+    return false;
   }
 
   async waitForListReady(maxRounds = 30) {
@@ -3756,7 +4028,10 @@ class RecommendScreenCli {
 
     const restoredFromCheckpoint = this.loadCheckpointIfNeeded();
     if (restoredFromCheckpoint) {
-      log(`[恢复] 已从 checkpoint 恢复，已处理 ${this.processedCount} 位候选人。`);
+      log(
+        `[恢复] 已从 checkpoint 恢复，已处理 ${this.processedCount} 位候选人，` +
+        `其中通过 ${this.passedCandidates.length} 位。`
+      );
     }
 
     await this.connect();
@@ -3790,7 +4065,7 @@ class RecommendScreenCli {
       }
 
       let pageExhaustion = null;
-      while (!this.args.targetCount || this.processedCount < this.args.targetCount) {
+      while (!this.args.targetCount || this.passedCandidates.length < this.args.targetCount) {
         if (this.shouldPauseAtBoundary()) {
           this.saveCsv();
           this.saveCheckpoint();
@@ -4048,10 +4323,10 @@ class RecommendScreenCli {
         }
       }
 
-      if (this.args.targetCount && this.processedCount < this.args.targetCount) {
+      if (this.args.targetCount && this.passedCandidates.length < this.args.targetCount) {
         throw this.buildError(
           "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
-          `推荐列表已到底，但当前仅处理 ${this.processedCount} 位，尚未达到目标 ${this.args.targetCount} 位。`,
+          `推荐列表已到底，但当前仅通过 ${this.passedCandidates.length} 位，尚未达到目标 ${this.args.targetCount} 位。`,
           true,
           {
             partial_result: this.buildProgressSnapshot("page_exhausted_before_target_count"),
@@ -4070,11 +4345,11 @@ class RecommendScreenCli {
         status: "COMPLETED",
         result: {
           ...this.buildProgressSnapshot(
-            this.args.targetCount && this.processedCount >= this.args.targetCount
+            this.args.targetCount && this.passedCandidates.length >= this.args.targetCount
               ? "target_count_reached"
               : "page_exhausted"
           ),
-          completion_reason: this.args.targetCount && this.processedCount >= this.args.targetCount
+          completion_reason: this.args.targetCount && this.passedCandidates.length >= this.args.targetCount
             ? "target_count_reached"
             : "page_exhausted",
         }

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

@@ -124,6 +124,30 @@ class FakeRecommendScreenCli extends RecommendScreenCli {
   saveCheckpoint() {}
 }
 
+class FakeDetailCloseProbeCli extends RecommendScreenCli {
+  constructor(args, options = {}) {
+    super(args);
+    this.listReady = options.listReady === true;
+    this.evaluateCallCount = 0;
+  }
+
+  async getDetailClosedState() {
+    return { closed: false, reason: "popup visible: .boss-popup__wrapper" };
+  }
+
+  async evaluate() {
+    this.evaluateCallCount += 1;
+    if (this.evaluateCallCount >= 2) {
+      return this.listReady
+        ? { ok: true, candidate_count: 1 }
+        : { ok: false, error: "LIST_NOT_READY" };
+    }
+    return { ok: false, error: "CLOSE_ACTION_NOOP" };
+  }
+
+  async pressEsc() {}
+}
+
 function createResumeCaptureError(message = "Resume canvas not found") {
   const error = new Error(message);
   error.code = "RESUME_CAPTURE_FAILED";
@@ -306,6 +330,55 @@ async function testPageExhaustedWithoutTargetShouldStillComplete() {
   assert.equal(result.result.completion_reason, "page_exhausted");
 }
 
+async function testTargetCountShouldStopWhenPassedCountReached() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-target-pass-stop-"));
+  const args = createArgs(tempDir);
+  args.targetCount = 1;
+  const first = { key: "pass-1", geek_id: "pass-1", name: "pass-1" };
+  const second = { key: "skip-2", geek_id: "skip-2", name: "skip-2" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [first, second],
+    screeningByKey: new Map([
+      ["pass-1", { passed: true, reason: "matched", summary: "matched" }],
+      ["skip-2", { passed: false, reason: "not matched", summary: "not matched" }]
+    ])
+  });
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.processed_count, 1);
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 0);
+  assert.equal(result.result.completion_reason, "target_count_reached");
+}
+
+async function testTargetCountShouldNotTreatProcessedCountAsReached() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-target-pass-only-"));
+  const args = createArgs(tempDir);
+  args.targetCount = 1;
+  const first = { key: "skip-a", geek_id: "skip-a", name: "skip-a" };
+  const second = { key: "skip-b", geek_id: "skip-b", name: "skip-b" };
+  const cli = new FakeRecommendScreenCli(args, {
+    candidates: [first, second],
+    screeningByKey: new Map([
+      ["skip-a", { passed: false, reason: "not matched", summary: "not matched" }],
+      ["skip-b", { passed: false, reason: "not matched", summary: "not matched" }]
+    ])
+  });
+
+  await assert.rejects(
+    () => cli.run(),
+    (error) => {
+      assert.equal(error.code, "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED");
+      assert.equal(error.retryable, true);
+      assert.equal(error.partial_result?.processed_count, 2);
+      assert.equal(error.partial_result?.passed_count, 0);
+      assert.equal(error.partial_result?.completion_reason, "page_exhausted_before_target_count");
+      return true;
+    }
+  );
+}
+
 async function testFeaturedShouldUseNetworkResumeOnly() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-network-first-"));
   const candidate = { key: "net-1", geek_id: "net-1", name: "network candidate" };
@@ -842,12 +915,152 @@ function testParseArgsShouldSupportLatestPageScope() {
   assert.equal(parsed.port, 9222);
 }
 
+async function testCallTextModelShouldNotTruncateLongResume() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-text-full-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const marker = "__END_OF_RESUME_MARKER__";
+  const resumeText = `${"A".repeat(32000)}${marker}`;
+  const originalFetch = global.fetch;
+  let capturedUserContent = "";
+  global.fetch = async (_url, options = {}) => {
+    const payload = JSON.parse(String(options.body || "{}"));
+    capturedUserContent = String(payload?.messages?.[1]?.content || "");
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"A\"]}"
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    const result = await cli.callTextModel(resumeText);
+    assert.equal(result.passed, false);
+    assert.equal(capturedUserContent.includes(marker), true);
+  } finally {
+    global.fetch = originalFetch;
+  }
+}
+
+async function testCallTextModelShouldFallbackToChunkModeOnContextLimit() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-text-chunk-fallback-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const originalFetch = global.fetch;
+  const prevChunkSize = process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS;
+  const prevChunkOverlap = process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS;
+  const prevMaxChunks = process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS;
+  process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS = "80";
+  process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS = "0";
+  process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS = "6";
+
+  const passMarker = "PASS_MARKER_ABC";
+  const resumeText = `${"x".repeat(120)}${passMarker}${"y".repeat(120)}`;
+  let callCount = 0;
+  global.fetch = async (_url, options = {}) => {
+    callCount += 1;
+    if (callCount === 1) {
+      return {
+        ok: false,
+        status: 400,
+        async text() {
+          return "maximum context length exceeded";
+        }
+      };
+    }
+
+    const payload = JSON.parse(String(options.body || "{}"));
+    const userContent = String(payload?.messages?.[1]?.content || "");
+    const passed = userContent.includes(passMarker);
+    const response = passed
+      ? "{\"passed\": true, \"reason\": \"命中证据\", \"summary\": \"命中\", \"evidence\": [\"PASS_MARKER_ABC\"]}"
+      : "{\"passed\": false, \"reason\": \"本段证据不足\", \"summary\": \"不足\", \"evidence\": []}";
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: response
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    const result = await cli.callTextModel(resumeText);
+    assert.equal(result.passed, true);
+    assert.equal(callCount >= 2, true);
+    assert.equal(Array.isArray(result.evidence), true);
+  } finally {
+    global.fetch = originalFetch;
+    if (prevChunkSize === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_CHUNK_SIZE_CHARS = prevChunkSize;
+    }
+    if (prevChunkOverlap === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_CHUNK_OVERLAP_CHARS = prevChunkOverlap;
+    }
+    if (prevMaxChunks === undefined) {
+      delete process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS;
+    } else {
+      process.env.BOSS_RECOMMEND_TEXT_MAX_CHUNKS = prevMaxChunks;
+    }
+  }
+}
+
+async function testPrepareVisionImageSegmentsShouldSplitLongImage() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-vision-segments-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const imagePath = path.join(tempDir, "long.png");
+  await sharp({
+    create: { width: 400, height: 1200, channels: 3, background: { r: 240, g: 240, b: 240 } }
+  }).png().toFile(imagePath);
+
+  const prepared = await cli.prepareVisionImageSegmentsForModel(imagePath, 120000, "test");
+  assert.equal(Array.isArray(prepared.imagePaths), true);
+  assert.equal(prepared.imagePaths.length > 1, true);
+  for (const segmentPath of prepared.imagePaths) {
+    assert.equal(fs.existsSync(segmentPath), true);
+  }
+}
+
+async function testCloseDetailPageShouldFailWhenDetailStillOpenAndListNotReady() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-close-detail-fail-"));
+  const cli = new FakeDetailCloseProbeCli(createArgs(tempDir), { listReady: false });
+  const closed = await cli.closeDetailPage(1);
+  assert.equal(closed, false);
+}
+
+async function testCloseDetailPageShouldContinueWhenListReady() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-close-detail-list-ready-"));
+  const cli = new FakeDetailCloseProbeCli(createArgs(tempDir), { listReady: true });
+  const closed = await cli.closeDetailPage(1);
+  assert.equal(closed, true);
+}
+
 async function main() {
   testShouldAbortResumeProbeEarly();
   await testSingleResumeCaptureFailureIsSkipped();
   await testConsecutiveResumeCaptureFailuresStillAbort();
   await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
   await testPageExhaustedWithoutTargetShouldStillComplete();
+  await testTargetCountShouldStopWhenPassedCountReached();
+  await testTargetCountShouldNotTreatProcessedCountAsReached();
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldPreferNetworkResumeWhenAvailable();
   await testNetworkMissShouldFallbackToImageCapture();
@@ -871,6 +1084,11 @@ async function main() {
   testStitchWithAvailablePythonShouldFailWhenScriptMissing();
   testParseArgsShouldSupportFeaturedAliasesAndInlinePort();
   testParseArgsShouldSupportLatestPageScope();
+  await testCallTextModelShouldNotTruncateLongResume();
+  await testCallTextModelShouldFallbackToChunkModeOnContextLimit();
+  await testPrepareVisionImageSegmentsShouldSplitLongImage();
+  await testCloseDetailPageShouldFailWhenDetailStillOpenAndListNotReady();
+  await testCloseDetailPageShouldContinueWhenListReady();
   console.log("recoverable resume failure tests passed");
 }