@reconcrap/boss-recommend-mcp 1.3.14 → 1.3.16

package/package.json

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

package/src/parser.js

@@ -86,26 +86,33 @@ const RECENT_NOT_VIEW_NEGATIVE_PATTERNS = [
   /保留[^。；;\n]{0,12}14天/i
 ];
 const TARGET_COUNT_PATTERNS = [
+  /目标筛选数(?:量)?(?:为|是|:|：)?\s*(\d+)/i,
+  /目标通过数(?:量)?(?:为|是|:|：)?\s*(\d+)/i,
   /目标(?:处理|筛选|通过)?(?:人数|数量)?(?:为|是|:|：)?\s*(\d+)/i,
   /至少(?:处理|筛选|通过)\s*(\d+)\s*(?:位|人)/i,
   /(?:处理|筛选|通过)\s*(\d+)\s*(?:位|人)/i
 ];
 const MAX_GREET_COUNT_PATTERNS = [
+  /最大招呼数(?:量)?(?:为|是|:|：)?\s*(\d+)/i,
+  /最大(?:打招呼|招呼|沟通|联系)(?:人数|数量|数)?(?:为|是|:|：)?\s*(\d+)/i,
   /最多(?:打招呼|沟通|联系)\s*(\d+)\s*(?:位|人|个)?/i,
   /(?:打招呼|沟通|联系)(?:上限|最多|不超过|至多)(?:为|是|:|：)?\s*(\d+)/i
 ];
-const FILTER_CLAUSE_PATTERNS = [
-  /学校标签|院校标签|985|211|双一流|留学|国内外名校|公办本科/i,
-  /学历|学位|教育|初中及以下|中专|中技|高中|大专|专科|本科|硕士|研究生|博士/i,
-  /性别|男生|女生|男性|女性|男\b|女\b/i,
-  /近?14天(?:内)?没有|近?14天(?:内)?没看过|近?14天(?:内)?未查看|过滤[^。；;\n]{0,12}14天|排除[^。；;\n]{0,12}14天/i,
-  /目标(?:处理|筛选|通过)?(?:人数|数量)?|至少(?:处理|筛选|通过)|(?:处理|筛选|通过)\s*\d+\s*(?:位|人)/i,
-  /最多(?:打招呼|沟通|联系)|(?:打招呼|沟通|联系)(?:上限|最多|不超过|至多)/i,
-  /收藏|打招呼|直接沟通|什么也不做|不做任何操作|不操作|仅筛选|只筛选/i
+const CRITERIA_EXPLICIT_MARKER_PATTERN = /筛选条件\s*[：:]/i;
+const CRITERIA_EXPLICIT_STOP_PATTERN = /(?:^|[\n；;])\s*(?:页面选择|学校标签|院校标签|学历|学位|性别|是否过滤近14天看过|目标筛选数|目标通过人数|通过筛选后动作|最大招呼数|最大打招呼数|岗位)\s*[：:]/i;
+const CRITERIA_META_FIELD_PREFIX_PATTERNS = [
+  /^(?:页面选择|学校标签|院校标签|学历|学位|性别|是否过滤近14天看过|目标筛选数|目标通过人数|通过筛选后动作|最大招呼数|最大打招呼数|岗位)\s*(?:[:：]|$)/i,
+  /^(?:近?14天(?:内)?(?:没有|没看过|未查看)|(?:不过滤|保留|过滤|排除)[^。；;\n]{0,12}14天)\s*(?:[:：]|$)?/i,
+  /^(?:目标(?:处理|筛选|通过)?(?:人数|数量)?|至少(?:处理|筛选|通过)|(?:处理|筛选|通过)\s*\d+\s*(?:位|人))(?:[:：\s]|$)/i,
+  /^(?:最多(?:打招呼|沟通|联系)|(?:打招呼|沟通|联系)(?:上限|最多|不超过|至多))(?:[:：\s]|$)/i,
+  /^(?:(?:通过筛选后)?动作|post[_\s-]?action|max[_\s-]?greet[_\s-]?count|target[_\s-]?count)\s*(?:[:：]|$)/i
 ];
 const META_CLAUSE_PATTERNS = [
-  /推荐页|推荐页面|boss推荐/i,
-  /帮我|请|运行|skill/i
+  /^推荐页|^推荐页面|^boss推荐/i,
+  /^帮我|^请|^运行|^使用.*skill/i,
+  /^启动boss推荐任务/i,
+  /^条件如下(?:[:：]|$)/i,
+  /^(?:符合标准(?:的人选)?(?:都)?(?:的)?(?:动作)?[:：]?\s*)?(?:收藏|打招呼|直接沟通|什么也不做|不做任何操作|不操作|仅筛选|只筛选)(?:[:：]|$)/i
 ];
 const FEATURED_SCOPE_PATTERN = /(?:精选牛人|精选页|精选页面|精选tab|精选标签|tab[^。；;\n]{0,6}精选|精选)/i;
 const LATEST_SCOPE_PATTERN = /(?:最新页|最新页面|最新tab|最新标签|tab[^。；;\n]{0,6}最新|最新)/i;
@@ -394,6 +401,13 @@ function extractMaxGreetCount(text) {
   return null;
 }
 
+function extractJobSelectionHint(text) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n");
+  const match = normalized.match(/(?:^|[\n；;])\s*(?:岗位|职位|job)\s*[：:]\s*([^\n；;]+)/i);
+  if (!match?.[1]) return null;
+  return normalizeText(String(match[1] || "").replace(/[。；;]+$/, "").trim());
+}
+
 function sanitizeClause(clause) {
   let current = normalizeText(clause);
   for (const pattern of LEADING_NOISE_PATTERNS) {
@@ -408,25 +422,128 @@ function sanitizeClause(clause) {
   return current;
 }
 
-function buildCriteria(text, overrideCriteria) {
-  const normalizedOverride = normalizeText(overrideCriteria);
-  if (normalizedOverride) {
-    return normalizedOverride;
+function isMetaClause(clause) {
+  const normalized = sanitizeClause(clause);
+  if (!normalized) return true;
+  const withoutNumbering = normalized.replace(/^\d+\s*[)）]\s*/, "").trim();
+  if (!withoutNumbering) return true;
+  if (CRITERIA_META_FIELD_PREFIX_PATTERNS.some((pattern) => pattern.test(withoutNumbering))) return true;
+  if (META_CLAUSE_PATTERNS.some((pattern) => pattern.test(withoutNumbering))) return true;
+  return false;
+}
+
+function splitRawCriteriaClauses(text) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n").trim();
+  if (!normalized) return [];
+  const firstNumberedIndex = normalized.search(/\d+\s*[)）]/);
+  if (firstNumberedIndex === -1) {
+    return normalized
+      .split(/[；;\n]+/)
+      .map((item) => String(item || "").trim())
+      .filter(Boolean);
   }
 
+  const prefix = normalized
+    .slice(0, firstNumberedIndex)
+    .replace(/[；;，,。]+$/, "")
+    .trim();
+  const numberedClauses = normalized
+    .slice(firstNumberedIndex)
+    .split(/(?=\d+\s*[)）])/)
+    .map((item) => String(item || "").trim())
+    .filter(Boolean);
+
+  return prefix ? [prefix, ...numberedClauses] : numberedClauses;
+}
+
+function normalizeRawCriteriaClauses(clauses = []) {
+  const filtered = clauses
+    .map((item) => String(item || "").replace(/^[；;，,。]+/, "").replace(/[；;，,。]+$/, "").trim())
+    .filter(Boolean)
+    .filter((item) => !isMetaClause(item));
+  const unique = uniqueList(filtered);
+  if (!unique.length) return null;
+  return unique.reduce((acc, clause) => {
+    if (!acc) return clause;
+    if (/[：:]$/.test(acc) && /^\d+\s*[)）]/.test(clause)) {
+      return `${acc}${clause}`;
+    }
+    return `${acc}；${clause}`;
+  }, "");
+}
+
+function normalizeCriteriaClauses(clauses = []) {
+  const filtered = clauses
+    .map((item) => sanitizeClause(item))
+    .map((item) => item.replace(/^[；;，,。]+/, "").replace(/[；;，,。]+$/, "").trim())
+    .filter(Boolean)
+    .filter((item) => !isMetaClause(item));
+  const unique = uniqueList(filtered.map((item) => normalizeText(item)));
+  if (!unique.length) return null;
+  return unique.reduce((acc, clause) => {
+    if (!acc) return clause;
+    if (/[：:]$/.test(acc) && /^\d+\s*[)）]/.test(clause)) {
+      return `${acc}${clause}`;
+    }
+    return `${acc}；${clause}`;
+  }, "");
+}
+
+function extractExplicitCriteriaBlock(text) {
+  const normalizedText = String(text || "").replace(/\r\n/g, "\n");
+  const markerMatch = normalizedText.match(CRITERIA_EXPLICIT_MARKER_PATTERN);
+  if (!markerMatch) return {
+    raw: null,
+    normalized: null
+  };
+
+  let block = normalizedText.slice(markerMatch.index + markerMatch[0].length);
+  const stopMatch = block.match(CRITERIA_EXPLICIT_STOP_PATTERN);
+  if (stopMatch && stopMatch.index > 0) {
+    block = block.slice(0, stopMatch.index);
+  }
+  const rawClauses = splitRawCriteriaClauses(block);
+  return {
+    raw: normalizeRawCriteriaClauses(rawClauses),
+    normalized: normalizeCriteriaClauses(rawClauses)
+  };
+}
+
+function buildFallbackCriteria(text) {
   const clauses = sanitizeInstruction(text)
     .split(/[，,。；;\n]/)
-    .map((item) => sanitizeClause(item))
+    .map((item) => String(item || "").trim())
     .filter(Boolean);
+  return {
+    raw: normalizeRawCriteriaClauses(clauses),
+    normalized: normalizeCriteriaClauses(clauses)
+  };
+}
 
-  const filtered = clauses.filter((clause) => {
-    if (FILTER_CLAUSE_PATTERNS.some((pattern) => pattern.test(clause))) return false;
-    if (META_CLAUSE_PATTERNS.some((pattern) => pattern.test(clause))) return false;
-    return true;
-  });
+function buildCriteria({ instruction, rawInstruction, overrideCriteria }) {
+  const rawOverride = String(overrideCriteria || "").trim();
+  const normalizedOverride = normalizeText(rawOverride);
+  if (normalizedOverride) {
+    return {
+      raw: rawOverride || normalizedOverride,
+      normalized: normalizedOverride,
+      source: "override"
+    };
+  }
 
-  const result = uniqueList(filtered.map(normalizeText)).join("；");
-  return result || null;
+  const explicitCriteria = extractExplicitCriteriaBlock(rawInstruction || instruction);
+  if (explicitCriteria.raw) {
+    return {
+      ...explicitCriteria,
+      source: "explicit"
+    };
+  }
+
+  const fallbackCriteria = buildFallbackCriteria(rawInstruction || instruction);
+  return {
+    ...fallbackCriteria,
+    source: fallbackCriteria.raw ? "fallback" : null
+  };
 }
 
 function resolvePostAction({ instruction, confirmation, overrides }) {
@@ -550,7 +667,8 @@ function collectSuspiciousFields({ invalidOverrideSchoolTags, maxGreetCountResol
 }
 
 export function parseRecommendInstruction({ instruction, confirmation, overrides }) {
-  const text = normalizeText(instruction);
+  const rawInstruction = String(instruction || "");
+  const text = normalizeText(rawInstruction);
   const detectedSchoolTags = extractSchoolTags(text);
   const detectedDegrees = extractDegrees(text);
   const schoolTagAudit = auditSchoolTagSelections(overrides?.school_tag);
@@ -563,7 +681,17 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   const overrideRecentNotView = normalizeRecentNotView(overrides?.recent_not_view);
   const confirmationRecentNotView = normalizeRecentNotView(confirmation?.recent_not_view_value);
   const overrideCriteria = overrides?.criteria;
-  const jobSelectionHint = normalizeText(overrides?.job || confirmation?.job_value || "");
+  const criteriaResolution = buildCriteria({
+    instruction: text,
+    rawInstruction,
+    overrideCriteria
+  });
+  const jobSelectionHint = normalizeText(
+    overrides?.job
+    || confirmation?.job_value
+    || extractJobSelectionHint(rawInstruction)
+    || ""
+  );
   const pageScopeResolution = resolvePageScope({ instruction: text, confirmation, overrides });
 
   const inferredSchoolTag = detectedSchoolTags.length > 0
@@ -584,7 +712,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     recent_not_view: overrideRecentNotView || confirmationRecentNotView || extractRecentNotView(text) || "不限"
   };
   const screenParams = {
-    criteria: buildCriteria(text, overrideCriteria),
+    criteria: criteriaResolution.raw || criteriaResolution.normalized || null,
     target_count: null,
     post_action: null,
     max_greet_count: null
@@ -765,6 +893,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     needs_post_action_confirmation,
     needs_max_greet_count_confirmation,
     needs_page_confirmation,
+    criteria_normalized: criteriaResolution.normalized,
     proposed_target_count: targetCountResolution.proposed_target_count,
     proposed_post_action: postActionResolution.proposed_post_action,
     proposed_max_greet_count: maxGreetCountResolution.proposed_max_greet_count,
@@ -777,13 +906,17 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
       extracted_search_params: searchParams,
       extracted_screen_params: {
         criteria: screenParams.criteria,
+        criteria_normalized: criteriaResolution.normalized,
         target_count: targetCountResolution.proposed_target_count,
         post_action: postActionResolution.proposed_post_action,
         max_greet_count: maxGreetCountResolution.proposed_max_greet_count
       },
       current_page_scope: pageScopeResolution.page_scope,
       current_search_params: searchParams,
-      current_screen_params: screenParams,
+      current_screen_params: {
+        ...screenParams,
+        criteria_normalized: criteriaResolution.normalized
+      },
       missing_fields,
       suspicious_fields,
       pending_questions

package/src/test-parser.js

@@ -1,6 +1,19 @@
 import assert from "node:assert/strict";
 import { parseRecommendInstruction } from "./parser.js";
 
+const REPRODUCTION_INSTRUCTION = `启动boss推荐任务。条件如下：
+
+页面选择：推荐；
+学校标签：985/211/国内外名校；
+学历：本科及以上；
+性别：不限；
+是否过滤近14天看过：近14天没有；
+目标筛选数：152；
+通过筛选后动作：打招呼；
+最大招呼数：152；
+岗位：研发工程师（AI应用方向）-2026届校招 _ 杭州；
+筛选条件：需同时满足全部条件：1）如果有本科学历，本科学历必须为 211 及以上或 QS 前 500 海外院校；2）至少一段学历为 985、QS 前 100 海外院校或中科院；3）具备大模型 / AI / 图形学 / 计算机视觉 / 3D相关的算法或工程经验（实习、项目、科研均可）。学校是否是985、211、qs排名等判断如果简历内没有明确标明，需要通过学校名称来判断；4）必须是25年应届生或者26年应届生或者27年应届生，除了标签以外需要通过人选最高学历的求学年份判断（比如：本科简历里写了2021 - 2025，应该理解为25年毕业，属于25年应届生）；5）年龄必须35岁以内。`;
+
 function testNeedConfirmationIncludesPostAction() {
   const result = parseRecommendInstruction({
     instruction: "推荐页上筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏",
@@ -606,6 +619,85 @@ function testPageScopeOverrideShouldNotBypassConfirmation() {
   assert.equal(result.pending_questions.some((item) => item.field === "page_scope"), true);
 }
 
+function testExplicitCriteriaBlockShouldKeepAllCoreRulesAndExcludeMetaFields() {
+  const result = parseRecommendInstruction({
+    instruction: REPRODUCTION_INSTRUCTION,
+    confirmation: null,
+    overrides: null
+  });
+  const criteria = result.screenParams.criteria || "";
+
+  assert.equal(criteria.includes("需同时满足全部条件"), true);
+  assert.equal(criteria.includes("1）如果有本科学历，本科学历必须为 211 及以上或 QS 前 500 海外院校"), true);
+  assert.equal(criteria.includes("2）至少一段学历为 985、QS 前 100 海外院校或中科院"), true);
+  assert.equal(criteria.includes("3）具备大模型 / AI / 图形学 / 计算机视觉 / 3D相关的算法或工程经验"), true);
+  assert.equal(criteria.includes("4）必须是25年应届生或者26年应届生或者27年应届生"), true);
+  assert.equal(criteria.includes("5）年龄必须35岁以内"), true);
+
+  assert.equal(criteria.includes("页面选择"), false);
+  assert.equal(criteria.includes("目标筛选数"), false);
+  assert.equal(criteria.includes("通过筛选后动作"), false);
+  assert.equal(criteria.includes("最大招呼数"), false);
+  assert.equal(criteria.includes("岗位"), false);
+}
+
+function testFallbackCriteriaShouldStillWorkWithoutExplicitMarker() {
+  const result = parseRecommendInstruction({
+    instruction: "页面选择：推荐；学校标签：985/211；岗位：算法工程师；候选人需满足至少两段 AI 项目经验；最大招呼数：20；",
+    confirmation: null,
+    overrides: null
+  });
+  const criteria = result.screenParams.criteria || "";
+
+  assert.equal(criteria.includes("至少两段 AI 项目经验"), true);
+  assert.equal(criteria.includes("页面选择"), false);
+  assert.equal(criteria.includes("岗位"), false);
+  assert.equal(criteria.includes("最大招呼数"), false);
+}
+
+function testOverrideCriteriaShouldHaveHighestPriorityOverExplicitCriteriaBlock() {
+  const result = parseRecommendInstruction({
+    instruction: REPRODUCTION_INSTRUCTION,
+    confirmation: null,
+    overrides: {
+      criteria: "只看有开源 Agent 项目经验的人选"
+    }
+  });
+
+  assert.equal(result.screenParams.criteria, "只看有开源 Agent 项目经验的人选");
+}
+
+function testFallbackCriteriaShouldNotDropReal985211QsRules() {
+  const result = parseRecommendInstruction({
+    instruction: "页面选择：推荐；目标筛选数：10；至少一段学历为985或QS前100海外院校；如果有本科学历，本科必须211或QS前500；岗位：算法工程师；",
+    confirmation: null,
+    overrides: null
+  });
+  const criteria = result.screenParams.criteria || "";
+
+  assert.equal(criteria.includes("985"), true);
+  assert.equal(criteria.includes("QS前100"), true);
+  assert.equal(criteria.includes("211"), true);
+  assert.equal(criteria.includes("QS前500"), true);
+}
+
+function testMetaHintsShouldBeProposedFromInstruction() {
+  const result = parseRecommendInstruction({
+    instruction: `页面选择：推荐；目标筛选数：5；通过筛选后动作：打招呼；最大招呼数：3；岗位：研发工程师（AI应用方向）-2026届校招 _ 杭州；筛选条件：需同时满足全部条件：1）具备AI经验；`,
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.equal(result.proposed_page_scope, "recommend");
+  assert.equal(result.proposed_target_count, 5);
+  assert.equal(result.proposed_post_action, "greet");
+  assert.equal(result.proposed_max_greet_count, 3);
+  assert.equal(result.job_selection_hint, "研发工程师（AI应用方向）-2026届校招 _ 杭州");
+  assert.equal(result.screenParams.target_count, null);
+  assert.equal(result.screenParams.post_action, null);
+  assert.equal(result.screenParams.max_greet_count, null);
+}
+
 function main() {
   testNeedConfirmationIncludesPostAction();
   testConfirmedPostActionAndOverrides();
@@ -639,6 +731,11 @@ function main() {
   testLatestKeywordShouldProposeLatestPageScope();
   testConfirmedPageScopeShouldBeResolved();
   testPageScopeOverrideShouldNotBypassConfirmation();
+  testExplicitCriteriaBlockShouldKeepAllCoreRulesAndExcludeMetaFields();
+  testFallbackCriteriaShouldStillWorkWithoutExplicitMarker();
+  testOverrideCriteriaShouldHaveHighestPriorityOverExplicitCriteriaBlock();
+  testFallbackCriteriaShouldNotDropReal985211QsRules();
+  testMetaHintsShouldBeProposedFromInstruction();
   console.log("parser tests passed");
 }
 

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

@@ -3305,6 +3305,60 @@ class RecommendScreenCli {
     return info;
   }
 
+  async resolveDomResumeFallback(candidate, cardProfile) {
+    let domCandidateInfo = await this.extractResumeTextFromDom(candidate);
+    let networkCandidateInfo = null;
+    if (domCandidateInfo && !isDomProfileConsistentWithCard(cardProfile, domCandidateInfo)) {
+      this.recordResumeNetworkDiagnostic({
+        kind: "dom_profile_mismatch",
+        candidate_key: normalizeText(candidate?.key || candidate?.geek_id || ""),
+        card_name: normalizeText(cardProfile?.name || ""),
+        dom_name: normalizeText(domCandidateInfo?.name || ""),
+        card_school: normalizeText(cardProfile?.school || ""),
+        dom_school: normalizeText(domCandidateInfo?.school || "")
+      });
+      log(
+        `[DOM简历疑似错位] candidate=${candidate?.key || candidate?.geek_id || "unknown"} ` +
+        `card=${normalizeText(cardProfile?.name || "-")} dom=${normalizeText(domCandidateInfo?.name || "-")}，尝试重试一次点击+监听。`
+      );
+      try {
+        const retryCaptureStartedAt = Date.now();
+        await this.clickCandidate(candidate);
+        const retryDetailOpen = await this.ensureDetailOpen();
+        if (retryDetailOpen) {
+          networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(
+            candidate,
+            NETWORK_RESUME_RETRY_WAIT_MS,
+            { minTs: retryCaptureStartedAt }
+          );
+          if (!normalizeText(networkCandidateInfo?.resumeText)) {
+            const retryDomCandidateInfo = await this.extractResumeTextFromDom(candidate);
+            if (retryDomCandidateInfo && isDomProfileConsistentWithCard(cardProfile, retryDomCandidateInfo)) {
+              domCandidateInfo = retryDomCandidateInfo;
+            } else {
+              domCandidateInfo = null;
+            }
+          } else {
+            domCandidateInfo = null;
+          }
+        } else {
+          domCandidateInfo = null;
+        }
+      } catch (retryError) {
+        domCandidateInfo = null;
+        this.recordResumeNetworkDiagnostic({
+          kind: "dom_profile_mismatch_retry_failed",
+          candidate_key: normalizeText(candidate?.key || candidate?.geek_id || ""),
+          error: normalizeText(retryError?.message || retryError)
+        });
+      }
+    }
+    return {
+      domCandidateInfo,
+      networkCandidateInfo
+    };
+  }
+
   handleNetworkRequestWillBeSent(params) {
     const url = normalizeText(params?.request?.url || "");
     const postData = params?.request?.postData || "";
@@ -5222,82 +5276,69 @@ class RecommendScreenCli {
               }
             );
           }
-          if (!normalizeText(networkCandidateInfo?.resumeText)) {
-            domCandidateInfo = await this.extractResumeTextFromDom(nextCandidate);
-            if (domCandidateInfo && !isDomProfileConsistentWithCard(cardProfile, domCandidateInfo)) {
-              this.recordResumeNetworkDiagnostic({
-                kind: "dom_profile_mismatch",
-                candidate_key: normalizeText(nextCandidate?.key || nextCandidate?.geek_id || ""),
-                card_name: normalizeText(cardProfile?.name || ""),
-                dom_name: normalizeText(domCandidateInfo?.name || ""),
-                card_school: normalizeText(cardProfile?.school || ""),
-                dom_school: normalizeText(domCandidateInfo?.school || "")
-              });
-              log(
-                `[DOM简历疑似错位] candidate=${nextCandidate?.key || nextCandidate?.geek_id || "unknown"} ` +
-                `card=${normalizeText(cardProfile?.name || "-")} dom=${normalizeText(domCandidateInfo?.name || "-")}，尝试重试一次点击+监听。`
-              );
-              try {
-                const retryCaptureStartedAt = Date.now();
-                await this.clickCandidate(nextCandidate);
-                const retryDetailOpen = await this.ensureDetailOpen();
-                if (retryDetailOpen) {
-                  networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(
-                    nextCandidate,
-                    NETWORK_RESUME_RETRY_WAIT_MS,
-                    { minTs: retryCaptureStartedAt }
-                  );
-                  if (!normalizeText(networkCandidateInfo?.resumeText)) {
-                    const retryDomCandidateInfo = await this.extractResumeTextFromDom(nextCandidate);
-                    if (retryDomCandidateInfo && isDomProfileConsistentWithCard(cardProfile, retryDomCandidateInfo)) {
-                      domCandidateInfo = retryDomCandidateInfo;
-                    } else {
-                      domCandidateInfo = null;
-                    }
-                  } else {
-                    domCandidateInfo = null;
-                  }
-                } else {
-                  domCandidateInfo = null;
-                }
-              } catch (retryError) {
-                domCandidateInfo = null;
-                this.recordResumeNetworkDiagnostic({
-                  kind: "dom_profile_mismatch_retry_failed",
-                  candidate_key: normalizeText(nextCandidate?.key || nextCandidate?.geek_id || ""),
-                  error: normalizeText(retryError?.message || retryError)
-                });
-              }
-            }
-          }
-          const resumeCandidateInfo = networkCandidateInfo?.resumeText ? networkCandidateInfo : domCandidateInfo;
-          candidateProfile = mergeCandidateProfiles(
-            resumeCandidateInfo || null,
-            cardProfile || null,
-            {
-              name: nextCandidate.name || "",
-              school: nextCandidate.school || "",
-              major: nextCandidate.major || "",
-              company: nextCandidate.last_company || "",
-              position: nextCandidate.last_position || ""
-            }
-          );
 
           if (networkCandidateInfo?.resumeText) {
             screening = await this.callTextModel(networkCandidateInfo.resumeText);
             resumeSource = "network";
             resumeTextLength = normalizeText(networkCandidateInfo.resumeText).length;
             this.resumeSourceStats.network += 1;
-          } else if (domCandidateInfo?.resumeText) {
-            screening = await this.callTextModel(domCandidateInfo.resumeText);
-            resumeSource = "dom_fallback";
-            resumeTextLength = normalizeText(domCandidateInfo.resumeText).length;
-            this.resumeSourceStats.dom_fallback += 1;
+            candidateProfile = mergeCandidateProfiles(
+              networkCandidateInfo || null,
+              cardProfile || null,
+              {
+                name: nextCandidate.name || "",
+                school: nextCandidate.school || "",
+                major: nextCandidate.major || "",
+                company: nextCandidate.last_company || "",
+                position: nextCandidate.last_position || ""
+              }
+            );
           } else {
-            resumeSource = "image_fallback";
-            capture = await this.captureResumeImage(nextCandidate);
-            screening = await this.callVisionModel(capture.stitchedImage);
-            this.resumeSourceStats.image_fallback += 1;
+            try {
+              resumeSource = "image_fallback";
+              capture = await this.captureResumeImage(nextCandidate);
+              screening = await this.callVisionModel(capture.stitchedImage);
+              this.resumeSourceStats.image_fallback += 1;
+            } catch (imageFallbackError) {
+              const domFallback = await this.resolveDomResumeFallback(nextCandidate, cardProfile || null);
+              if (domFallback?.networkCandidateInfo?.resumeText) {
+                networkCandidateInfo = domFallback.networkCandidateInfo;
+                screening = await this.callTextModel(networkCandidateInfo.resumeText);
+                resumeSource = "network";
+                resumeTextLength = normalizeText(networkCandidateInfo.resumeText).length;
+                this.resumeSourceStats.network += 1;
+                candidateProfile = mergeCandidateProfiles(
+                  networkCandidateInfo || null,
+                  cardProfile || null,
+                  {
+                    name: nextCandidate.name || "",
+                    school: nextCandidate.school || "",
+                    major: nextCandidate.major || "",
+                    company: nextCandidate.last_company || "",
+                    position: nextCandidate.last_position || ""
+                  }
+                );
+              } else if (domFallback?.domCandidateInfo?.resumeText) {
+                domCandidateInfo = domFallback.domCandidateInfo;
+                screening = await this.callTextModel(domCandidateInfo.resumeText);
+                resumeSource = "dom_fallback";
+                resumeTextLength = normalizeText(domCandidateInfo.resumeText).length;
+                this.resumeSourceStats.dom_fallback += 1;
+                candidateProfile = mergeCandidateProfiles(
+                  domCandidateInfo || null,
+                  cardProfile || null,
+                  {
+                    name: nextCandidate.name || "",
+                    school: nextCandidate.school || "",
+                    major: nextCandidate.major || "",
+                    company: nextCandidate.last_company || "",
+                    position: nextCandidate.last_position || ""
+                  }
+                );
+              } else {
+                throw imageFallbackError;
+              }
+            }
           }
           this.resetResumeCaptureFailureStreak();
           log(`筛选结果: ${screening.passed ? "通过" : "不通过"}`);

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

@@ -467,7 +467,7 @@ async function testRecommendShouldPreferNetworkResumeWhenAvailable() {
   assert.equal(result.result.resume_source, "network");
 }
 
-async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
+async function testNetworkMissShouldFallbackToImageThenDom() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-network-dom-fallback-"));
   const candidate = { key: "dom-1", geek_id: "dom-1", name: "dom candidate" };
   const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
@@ -485,13 +485,15 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   });
 
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
   cli.callTextModel = async (resumeText) => ({
     passed: true,
     reason: resumeText.includes("华中科技大学") ? "dom fallback used" : "unexpected",
     summary: "dom fallback used"
   });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called when dom fallback resume exists");
+    captureAttempted = true;
+    throw new Error("capture failed, should fallback to dom");
   };
 
   const result = await cli.run();
@@ -501,6 +503,7 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   assert.equal(cli.passedCandidates.length, 1);
   assert.equal(cli.passedCandidates[0].school, "华中科技大学");
   assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
+  assert.equal(captureAttempted, true);
 }
 
 async function testNetworkMissShouldFallbackToImageCapture() {
@@ -600,7 +603,7 @@ function testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing() {
     key: "",
     geek_id: ""
   });
-  assert.equal(extracted?.resumeText, "recent resume payload");
+  assert.equal(extracted?.candidateInfo?.resumeText, "recent resume payload");
 }
 
 async function testVisionModelFailureShouldSkipCandidateAndContinue() {
@@ -638,25 +641,44 @@ async function testVisionModelFailureShouldSkipCandidateAndContinue() {
   assert.equal(result.result.skipped_count, 1);
 }
 
-async function testFeaturedNetworkMissShouldSkipWithoutImageCapture() {
+async function testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-featured-network-only-"));
   const args = createArgs(tempDir);
   args.pageScope = "featured";
   const candidate = { key: "featured-no-network", geek_id: "featured-no-network", name: "featured no network" };
   const cli = new FakeRecommendScreenCli(args, {
-    candidates: [candidate]
+    candidates: [candidate],
+    domResumeByKey: new Map([
+      ["featured-no-network", {
+        name: "featured no network",
+        school: "华中科技大学",
+        major: "软件工程",
+        company: "测试公司",
+        position: "后端工程师",
+        resumeText: "featured network miss 后应在截图失败后走 DOM 兜底。"
+      }]
+    ])
   });
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "dom fallback used",
+    summary: "dom fallback used"
+  });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called for featured scope");
+    captureAttempted = true;
+    throw new Error("capture failed for featured scope");
   };
 
   const result = await cli.run();
   assert.equal(result.status, "COMPLETED");
   assert.equal(result.result.processed_count, 1);
-  assert.equal(result.result.passed_count, 0);
-  assert.equal(result.result.skipped_count, 1);
-  assert.equal(result.result.resume_source, "network");
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 0);
+  assert.equal(result.result.resume_source, "dom_fallback");
+  assert.equal(captureAttempted, true);
+  assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
 }
 
 async function testFeaturedFavoriteShouldNotUseDomFallback() {
@@ -1461,14 +1483,14 @@ async function main() {
   await testTargetCountShouldNotTreatProcessedCountAsReached();
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldPreferNetworkResumeWhenAvailable();
-  await testNetworkMissShouldFallbackToDomBeforeImageCapture();
+  await testNetworkMissShouldFallbackToImageThenDom();
   await testNetworkMissShouldFallbackToImageCapture();
   await testLatestShouldPreferNetworkResumeWhenAvailable();
   await testLatestNetworkMissShouldFallbackToImageCapture();
   testLatestPayloadShouldNotLeakAcrossCandidates();
   testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing();
   await testVisionModelFailureShouldSkipCandidateAndContinue();
-  await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
+  await testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure();
   await testFeaturedFavoriteShouldNotUseDomFallback();
   await testFeaturedFavoriteShouldSkipClickWhenAlreadyInterested();
   await testFeaturedFavoriteShouldRecognizeAlreadyFavoritedByDelThenAdd();