@reconcrap/boss-recommend-mcp 2.0.13 → 2.0.15

package/package.json

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

package/src/domains/chat/jobs.js

@@ -223,6 +223,15 @@ function matchJobOption(option, jobLabel = "") {
   ));
 }
 
+function activeMatchingJobOption(options = [], jobLabel = "") {
+  return (options || []).find((option) => option.active && matchJobOption(option, jobLabel)) || null;
+}
+
+function selectedLabelMatches(label = "", jobLabel = "") {
+  const normalized = normalizeJobText(label);
+  return Boolean(normalized && matchJobOption({ label: normalized, value: normalized, title: normalized }, jobLabel));
+}
+
 async function clickFirstVisible(client, rootNodeId, selectors = []) {
   for (const selector of selectors) {
     const nodeIds = await safeQuerySelectorAll(client, rootNodeId, selector);
@@ -247,6 +256,62 @@ async function clickFirstVisible(client, rootNodeId, selectors = []) {
   };
 }
 
+async function waitForChatJobOptions(client, rootNodeId, {
+  timeoutMs = 12000,
+  intervalMs = 300,
+  requireVisible = false
+} = {}) {
+  const started = Date.now();
+  let latest = null;
+  while (Date.now() - started <= timeoutMs) {
+    const currentRootNodeId = await freshTopRootNodeId(client, rootNodeId);
+    latest = await readChatJobOptions(client, currentRootNodeId, {
+      timeoutMs: Math.min(intervalMs, 300),
+      intervalMs
+    });
+    const options = latest.job_options || [];
+    if (options.length && (!requireVisible || options.some((option) => option.visible))) {
+      return latest;
+    }
+    await sleep(intervalMs);
+  }
+  return latest || {
+    selector: "",
+    source: "chat-job-list",
+    selected_label: "",
+    job_options: []
+  };
+}
+
+async function waitForSelectedChatJob(client, rootNodeId, jobLabel = "", {
+  timeoutMs = 5000,
+  intervalMs = 300
+} = {}) {
+  const started = Date.now();
+  let latest = null;
+  while (Date.now() - started <= timeoutMs) {
+    const currentRootNodeId = await freshTopRootNodeId(client, rootNodeId);
+    latest = await readChatJobOptions(client, currentRootNodeId, {
+      timeoutMs: Math.min(intervalMs, 300),
+      intervalMs
+    });
+    if (
+      selectedLabelMatches(latest.selected_label, jobLabel)
+      || activeMatchingJobOption(latest.job_options || [], jobLabel)
+    ) {
+      return {
+        verified: true,
+        result: latest
+      };
+    }
+    await sleep(intervalMs);
+  }
+  return {
+    verified: false,
+    result: latest
+  };
+}
+
 export async function selectChatJob(client, rootNodeId, {
   jobLabel = "",
   timeoutMs = 12000,
@@ -267,14 +332,34 @@ export async function selectChatJob(client, rootNodeId, {
     intervalMs
   });
   let matched = (optionsResult.job_options || []).find((option) => matchJobOption(option, requested)) || null;
+  if (
+    matched
+    && (
+      matched.active
+      || selectedLabelMatches(optionsResult.selected_label, matched.label)
+      || selectedLabelMatches(optionsResult.selected_label, requested)
+    )
+  ) {
+    return {
+      selected: true,
+      verified: true,
+      already_current: true,
+      requested,
+      selected_option: matched,
+      options: optionsResult.job_options || [],
+      selected_label: optionsResult.selected_label || matched.label
+    };
+  }
+
   if (!matched || !matched.visible) {
     const triggerRootNodeId = await freshTopRootNodeId(client, currentRootNodeId);
     const trigger = await clickFirstVisible(client, triggerRootNodeId, CHAT_JOB_TRIGGER_SELECTORS);
     if (settleMs > 0) await sleep(settleMs);
     currentRootNodeId = await freshTopRootNodeId(client, triggerRootNodeId);
-    optionsResult = await readChatJobOptions(client, currentRootNodeId, {
+    optionsResult = await waitForChatJobOptions(client, currentRootNodeId, {
       timeoutMs,
-      intervalMs
+      intervalMs,
+      requireVisible: true
     });
     matched = (optionsResult.job_options || []).find((option) => matchJobOption(option, requested)) || null;
     if (!matched || !matched.visible) {
@@ -292,6 +377,7 @@ export async function selectChatJob(client, rootNodeId, {
   if (matched.active || normalizeJobText(optionsResult.selected_label).toLowerCase() === normalizeJobText(matched.label).toLowerCase()) {
     return {
       selected: true,
+      verified: true,
       already_current: true,
       requested,
       selected_option: matched,
@@ -310,22 +396,27 @@ export async function selectChatJob(client, rootNodeId, {
   if (settleMs > 0) await sleep(settleMs);
 
   const afterRootNodeId = await freshTopRootNodeId(client, currentRootNodeId);
-  const after = await readChatJobOptions(client, afterRootNodeId, {
-    timeoutMs: Math.min(timeoutMs, 3000),
+  const verification = await waitForSelectedChatJob(client, afterRootNodeId, matched.label, {
+    timeoutMs: Math.min(timeoutMs, 5000),
     intervalMs
   });
+  const after = verification.result || {
+    selected_label: "",
+    job_options: []
+  };
   const afterMatch = (after.job_options || []).find((option) => matchJobOption(option, matched.label)) || matched;
-  const selectedLabel = normalizeJobText(after.selected_label || afterMatch.label || "");
-  const verified = selectedLabel
-    ? matchJobOption({ label: selectedLabel, value: selectedLabel, title: selectedLabel }, matched.label)
-    : true;
+  const selectedLabel = normalizeJobText(after.selected_label || "");
+  const activeMatch = activeMatchingJobOption(after.job_options || [], matched.label);
+  const verified = Boolean(verification.verified || selectedLabelMatches(selectedLabel, matched.label) || activeMatch);
 
   return {
-    selected: true,
+    selected: verified,
     verified,
     already_current: false,
+    reason: verified ? "verified" : "job_selection_not_verified",
     requested,
     selected_option: afterMatch,
+    active_option: activeMatch,
     options: after.job_options || optionsResult.job_options || [],
     selected_label: selectedLabel,
     before: optionsResult,

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

@@ -203,6 +203,115 @@ function createSkippedDetailResult(cardCandidate, reason, error = null) {
   };
 }
 
+const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
+const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
+const CHAT_FULL_CV_SECTION_PATTERNS = Object.freeze([
+  /教育(?:经历|背景|经验)?/i,
+  /工作(?:经历|经验)?/i,
+  /项目(?:经历|经验)?/i,
+  /实习(?:经历|经验)?/i,
+  /科研(?:经历|经验)?/i,
+  /论文|会议|专利/i,
+  /个人(?:优势|总结|介绍|评价)/i,
+  /专业技能|技能(?:特长|标签)?/i,
+  /求职(?:期望|意向)/i,
+  /校园经历|在校经历|竞赛|证书/i
+]);
+
+function detailTextForFullCvCheck(detailResult = {}) {
+  return [
+    detailResult?.detail?.popup_text,
+    detailResult?.detail?.content_text,
+    detailResult?.detail?.resume_iframe_text
+  ].filter(Boolean).join("\n\n");
+}
+
+function resumeSectionMatchCount(text = "") {
+  const normalized = normalizeText(text);
+  if (!normalized) return 0;
+  return CHAT_FULL_CV_SECTION_PATTERNS
+    .filter((pattern) => pattern.test(normalized))
+    .length;
+}
+
+function hasResumeLikeDomText(text = "") {
+  const normalized = normalizeText(text);
+  if (normalized.length >= CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH) return true;
+  return normalized.length >= CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH
+    && resumeSectionMatchCount(normalized) >= 2;
+}
+
+function networkProfileTextLength(profileResult = {}) {
+  return normalizeText(profileResult?.profile?.text || "").length;
+}
+
+function isFullCvNetworkProfile(profileResult = {}) {
+  if (!profileResult?.ok) return false;
+  const sourceKeys = profileResult.profile?.source_keys || {};
+  const textLength = networkProfileTextLength(profileResult);
+  const sectionCount = resumeSectionMatchCount(profileResult.profile?.text || "");
+
+  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) return true;
+  if (sourceKeys.network_html_text) {
+    return textLength >= CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH
+      || sectionCount >= 2;
+  }
+  if (sourceKeys.chat_history_resume) {
+    const educationCount = Number(sourceKeys.education_count) || 0;
+    const workCount = Number(sourceKeys.work_count) || 0;
+    return (educationCount + workCount) > 0
+      && (textLength >= CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH || sectionCount >= 2);
+  }
+  return false;
+}
+
+function hasUsableImageEvidence(imageEvidence = null) {
+  if (!imageEvidence || imageEvidence.ok === false) return false;
+  return Boolean(
+    (Array.isArray(imageEvidence.llm_file_paths) && imageEvidence.llm_file_paths.length)
+    || (Array.isArray(imageEvidence.file_paths) && imageEvidence.file_paths.length)
+    || Number(imageEvidence.llm_screenshot_count) > 0
+    || Number(imageEvidence.unique_screenshot_count) > 0
+    || Number(imageEvidence.screenshot_count) > 0
+    || Number(imageEvidence.capture_count) > 0
+  );
+}
+
+export function summarizeChatFullCvEvidence({
+  detailResult = null,
+  contentWait = null,
+  imageEvidence = null
+} = {}) {
+  const parsedProfiles = (detailResult?.parsed_network_profiles || []).filter((item) => item?.ok);
+  const fullNetworkProfiles = parsedProfiles.filter(isFullCvNetworkProfile);
+  const profileOnlyCount = Math.max(0, parsedProfiles.length - fullNetworkProfiles.length);
+  const detailText = detailTextForFullCvCheck(detailResult);
+  const domTextLength = detailText.length;
+  const domSectionCount = resumeSectionMatchCount(detailText);
+  const domFullCv = Boolean(contentWait?.ok) && hasResumeLikeDomText(detailText);
+  const imageFullCv = hasUsableImageEvidence(imageEvidence);
+  const source = fullNetworkProfiles.length
+    ? "network"
+    : domFullCv
+      ? "dom"
+      : imageFullCv
+        ? "image"
+        : null;
+  return {
+    full_cv_acquired: Boolean(source),
+    source,
+    network_full_cv_count: fullNetworkProfiles.length,
+    network_profile_only_count: profileOnlyCount,
+    parsed_network_profile_count: parsedProfiles.length,
+    dom_full_cv: domFullCv,
+    dom_text_length: domTextLength,
+    dom_section_count: domSectionCount,
+    content_wait_ok: Boolean(contentWait?.ok),
+    image_full_cv: imageFullCv,
+    image_summary: summarizeImageEvidence(imageEvidence)
+  };
+}
+
 async function resolveFreshChatCardNodeId(client, {
   fallbackNodeId,
   candidate,
@@ -306,6 +415,9 @@ async function setupChatRunContext(client, {
   if (normalizeText(job) && !jobSelection.selected) {
     throw new Error(`Chat job selection failed: ${jobSelection.reason || "unknown"}`);
   }
+  if (normalizeText(job) && jobSelection.verified !== true) {
+    throw new Error(`Chat job selection was not verified: requested=${jobSelection.requested || job}; selected=${jobSelection.selected_label || "unknown"}`);
+  }
   rootState = await getChatRoots(client);
   if (ensureViewport) {
     rootState = await ensureViewport(rootState, "context_job");
@@ -770,11 +882,12 @@ export async function runChatWorkflow({
             });
             addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
             parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
-            if (parsedNetworkProfileCount > 0) {
+            const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+            if (networkEvidence.network_full_cv_count > 0) {
               contentWait = {
                 ok: true,
                 skipped: true,
-                reason: "network_profile_parsed_before_dom_wait",
+                reason: "network_full_cv_parsed_before_dom_wait",
                 elapsed_ms: 0,
                 text_length: 0
               };
@@ -816,8 +929,9 @@ export async function runChatWorkflow({
           let imageEvidence = null;
           let llmResult = null;
           const captureNodeId = captureNodeIdFromResumeState(resumeState);
+          let fullCvEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
           const shouldCaptureImage = normalizedDetailSource === "image"
-            || (normalizedDetailSource === "cascade" && parsedNetworkProfileCount < 1);
+            || (normalizedDetailSource === "cascade" && !fullCvEvidence.full_cv_acquired);
           if (shouldCaptureImage) {
             if (captureNodeId) {
               detailStep = "capture_image_fallback";
@@ -858,12 +972,20 @@ export async function runChatWorkflow({
                 }
               }));
               source = "image";
+              fullCvEvidence = summarizeChatFullCvEvidence({
+                detailResult,
+                contentWait,
+                imageEvidence
+              });
               recordCvImageFallback(cvAcquisitionState, {
+                reason: fullCvEvidence.network_profile_only_count > 0
+                  ? "profile_only_network_image_fallback"
+                  : "network_miss_image_fallback",
                 parsedNetworkProfileCount,
                 waitResult: networkWait,
                 imageEvidence
               });
-              if (callLlmOnImage) {
+              if (callLlmOnImage && fullCvEvidence.full_cv_acquired) {
                 detailStep = "llm_image_screening";
                 if (!llmConfig) {
                   llmResult = createMissingLlmConfigResult();
@@ -885,14 +1007,39 @@ export async function runChatWorkflow({
               }
             } else {
               source = "missing_capture_node";
+              fullCvEvidence = summarizeChatFullCvEvidence({
+                detailResult,
+                contentWait,
+                imageEvidence
+              });
               recordCvNetworkMiss(cvAcquisitionState, {
                 reason: "network_miss_no_capture_node",
                 parsedNetworkProfileCount,
                 waitResult: networkWait
               });
             }
-          } else if (parsedNetworkProfileCount > 0) {
+          } else if (fullCvEvidence.network_full_cv_count > 0) {
+            source = "network";
             recordCvNetworkHit(cvAcquisitionState, {
+              reason: "full_cv_network_profile",
+              parsedNetworkProfileCount,
+              waitResult: networkWait
+            });
+          } else if (fullCvEvidence.dom_full_cv) {
+            source = "dom";
+            if (normalizedDetailSource !== "dom") {
+              recordCvNetworkMiss(cvAcquisitionState, {
+                reason: parsedNetworkProfileCount > 0
+                  ? "profile_only_network_dom_fallback"
+                  : "network_miss_dom_fallback",
+                parsedNetworkProfileCount,
+                waitResult: networkWait
+              });
+            }
+          } else if (parsedNetworkProfileCount > 0) {
+            source = "profile_only_network";
+            recordCvNetworkMiss(cvAcquisitionState, {
+              reason: "profile_only_network_not_full_cv",
               parsedNetworkProfileCount,
               waitResult: networkWait
             });
@@ -906,25 +1053,29 @@ export async function runChatWorkflow({
           }
 
           if (useLlmScreening && !llmResult) {
-            detailStep = "llm_screening";
-            if (!llmConfig) {
-              llmResult = createMissingLlmConfigResult();
+            if (!fullCvEvidence.full_cv_acquired) {
+              detailUnavailableReason = "full_cv_not_acquired";
             } else {
-              try {
-                const llmTimingKey = imageEvidence?.file_paths?.length
-                  ? "vision_model_ms"
-                  : "text_model_ms";
-                llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
-                  candidate: detailResult.candidate,
-                  criteria,
-                  config: llmConfig,
-                  timeoutMs: llmTimeoutMs,
-                  imageEvidence,
-                  maxImages: llmImageLimit,
-                  imageDetail: llmImageDetail
-                }));
-              } catch (error) {
-                llmResult = createFailedLlmResult(error);
+              detailStep = "llm_screening";
+              if (!llmConfig) {
+                llmResult = createMissingLlmConfigResult();
+              } else {
+                try {
+                  const llmTimingKey = imageEvidence?.file_paths?.length
+                    ? "vision_model_ms"
+                    : "text_model_ms";
+                  llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+                    candidate: detailResult.candidate,
+                    criteria,
+                    config: llmConfig,
+                    timeoutMs: llmTimeoutMs,
+                    imageEvidence,
+                    maxImages: llmImageLimit,
+                    imageDetail: llmImageDetail
+                  }));
+                } catch (error) {
+                  llmResult = createFailedLlmResult(error);
+                }
               }
             }
           }
@@ -952,7 +1103,8 @@ export async function runChatWorkflow({
               text_length: contentWait.text_length
             },
             parsed_network_profile_count: parsedNetworkProfileCount,
-            image_evidence: summarizeImageEvidence(imageEvidence)
+            image_evidence: summarizeImageEvidence(imageEvidence),
+            full_cv_evidence: fullCvEvidence
           };
         }
       } catch (error) {
@@ -976,22 +1128,9 @@ export async function runChatWorkflow({
     runControl.setPhase("chat:screening");
     let cardOnlyLlmResult = null;
     if (useLlmScreening && !detailUnavailableReason && !detailResult?.llm_result) {
-      if (!llmConfig) {
-        cardOnlyLlmResult = createMissingLlmConfigResult();
-      } else {
-        try {
-          cardOnlyLlmResult = await measureTiming(timings, "text_model_ms", () => callScreeningLlm({
-            candidate: screeningCandidate,
-            criteria,
-            config: llmConfig,
-            timeoutMs: llmTimeoutMs,
-            maxImages: llmImageLimit,
-            imageDetail: llmImageDetail
-          }));
-        } catch (error) {
-          cardOnlyLlmResult = createFailedLlmResult(error);
-        }
-      }
+      detailUnavailableReason = detailResult
+        ? "full_cv_not_acquired"
+        : "detail_not_opened_full_cv_required";
     }
     const effectiveLlmResult = detailResult?.llm_result || cardOnlyLlmResult;
     const screening = detailUnavailableReason