@reconcrap/boss-recommend-mcp 1.2.3 → 1.2.5

package/package.json

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

package/src/index.js

@@ -4,7 +4,11 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { runRecommendPipeline } from "./pipeline.js";
+import {
+  getFeaturedCalibrationResolution,
+  runRecommendCalibration
+} from "./adapters.js";
+import { runRecommendPipeline } from "./pipeline.js";
 import {
   RUN_MODE_ASYNC,
   RUN_STAGE_PREFLIGHT,
@@ -28,11 +32,13 @@ import {
 const require = createRequire(import.meta.url);
 const { version: SERVER_VERSION } = require("../package.json");
 
-const TOOL_START_RUN = "start_recommend_pipeline_run";
-const TOOL_GET_RUN = "get_recommend_pipeline_run";
-const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
-const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
-const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
+const TOOL_START_RUN = "start_recommend_pipeline_run";
+const TOOL_GET_RUN = "get_recommend_pipeline_run";
+const TOOL_CANCEL_RUN = "cancel_recommend_pipeline_run";
+const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
+const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
+const TOOL_RUN_FEATURED_CALIBRATION = "run_featured_calibration";
+const TOOL_GET_FEATURED_CALIBRATION_STATUS = "get_featured_calibration_status";
 
 const SERVER_NAME = "boss-recommend-mcp";
 const FRAMING_UNKNOWN = "unknown";
@@ -141,7 +147,7 @@ function createJsonRpcError(id, code, message) {
   };
 }
 
-function createRunInputSchema() {
+function createRunInputSchema() {
   return {
     type: "object",
     properties: {
@@ -290,10 +296,33 @@ function createRunInputSchema() {
     required: ["instruction"],
     additionalProperties: false
   };
-}
-
-function createToolsSchema() {
-  return [
+}
+
+function createRunFeaturedCalibrationInputSchema() {
+  return {
+    type: "object",
+    properties: {
+      port: {
+        type: "integer",
+        minimum: 1,
+        description: "可选，Boss Chrome 远程调试端口（默认读取配置或 9222）"
+      },
+      timeout_ms: {
+        type: "integer",
+        minimum: 1000,
+        description: "可选，等待收藏点击的超时时间（毫秒）"
+      },
+      output: {
+        type: "string",
+        description: "可选，校准文件输出路径（默认 favorite-calibration.json）"
+      }
+    },
+    additionalProperties: false
+  };
+}
+
+function createToolsSchema() {
+  return [
     {
       name: TOOL_START_RUN,
       description: "异步启动 Boss 推荐页流水线（含同步门禁预检）；只有在前置确认与页面就绪通过后才返回 run_id。",
@@ -335,20 +364,34 @@ function createToolsSchema() {
         additionalProperties: false
       }
     },
-    {
-      name: TOOL_RESUME_RUN,
-      description: "继续指定 run_id 的 paused 流水线；沿用原 CSV 与 checkpoint 续跑。",
-      inputSchema: {
+    {
+      name: TOOL_RESUME_RUN,
+      description: "继续指定 run_id 的 paused 流水线；沿用原 CSV 与 checkpoint 续跑。",
+      inputSchema: {
         type: "object",
         properties: {
           run_id: { type: "string" }
         },
-        required: ["run_id"],
-        additionalProperties: false
-      }
-    }
-  ];
-}
+        required: ["run_id"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: TOOL_RUN_FEATURED_CALIBRATION,
+      description: "手动执行精选页收藏按钮校准。执行前请先在 Boss 推荐页切换到精选 tab 并打开任意候选人详情页。",
+      inputSchema: createRunFeaturedCalibrationInputSchema()
+    },
+    {
+      name: TOOL_GET_FEATURED_CALIBRATION_STATUS,
+      description: "查询精选页收藏校准文件与校准脚本可用性。",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }
+    }
+  ];
+}
 
 function createToolResultResponse(id, payload, isError = false) {
   return {
@@ -367,7 +410,7 @@ function createToolResultResponse(id, payload, isError = false) {
   };
 }
 
-function validateRunArgs(args) {
+function validateRunArgs(args) {
   if (!args || typeof args !== "object") {
     return "arguments must be an object";
   }
@@ -375,9 +418,37 @@ function validateRunArgs(args) {
     return "instruction is required and must be a string";
   }
   return null;
-}
-
-function getLastOutputLine(text) {
+}
+
+function validateRunFeaturedCalibrationArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) {
+    return "arguments must be an object";
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "port")) {
+    const port = Number.parseInt(String(args.port), 10);
+    if (!Number.isFinite(port) || port <= 0) {
+      return "port must be a positive integer";
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "timeout_ms")) {
+    const timeoutMs = Number.parseInt(String(args.timeout_ms), 10);
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1000) {
+      return "timeout_ms must be an integer >= 1000";
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(args, "output")) {
+    if (typeof args.output !== "string" || !normalizeText(args.output)) {
+      return "output must be a non-empty string when provided";
+    }
+  }
+
+  return null;
+}
+
+function getLastOutputLine(text) {
   const lines = String(text || "")
     .split(/\r?\n/)
     .map((line) => normalizeText(line))
@@ -1219,8 +1290,57 @@ function handleResumeRunTool(args) {
     message: "已恢复 Recommend 流水线（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
   };
 }
-
-async function handleRequest(message, workspaceRoot) {
+
+function handleGetFeaturedCalibrationStatusTool(workspaceRoot) {
+  const resolution = getFeaturedCalibrationResolution(workspaceRoot);
+  return {
+    status: "CALIBRATION_STATUS",
+    ready: resolution.calibration_usable === true,
+    calibration_path: resolution.calibration_path,
+    calibration_exists: resolution.calibration_exists,
+    calibration_usable: resolution.calibration_usable,
+    calibration_script_path: resolution.calibration_script_path,
+    message: resolution.calibration_usable
+      ? "精选页收藏校准文件可用。"
+      : "精选页收藏校准文件不存在或无效。"
+  };
+}
+
+async function handleRunFeaturedCalibrationTool({ workspaceRoot, args }) {
+  const result = await runRecommendCalibration(workspaceRoot, {
+    port: args.port,
+    timeoutMs: args.timeout_ms,
+    output: args.output
+  });
+
+  if (!result?.ok) {
+    return {
+      status: "FAILED",
+      error: {
+        code: result?.error?.code || "CALIBRATION_REQUIRED",
+        message: result?.error?.message || "精选页收藏校准失败，请在推荐页精选 tab 打开候选人详情后点击收藏按钮再重试。",
+        retryable: true
+      },
+      calibration_path: result?.calibration_path || null,
+      calibration_script_path: result?.calibration_script_path || null,
+      debug_port: result?.debug_port || null,
+      diagnostics: {
+        stdout_last_line: getLastOutputLine(result?.stdout),
+        stderr_last_line: getLastOutputLine(result?.stderr)
+      }
+    };
+  }
+
+  return {
+    status: "CALIBRATED",
+    message: "精选页收藏按钮校准完成，可重新执行 start_recommend_pipeline_run。",
+    calibration_path: result.calibration_path,
+    calibration_script_path: result.calibration_script_path,
+    debug_port: result.debug_port
+  };
+}
+
+async function handleRequest(message, workspaceRoot) {
   if (!message || message.jsonrpc !== "2.0") {
     return createJsonRpcError(null, -32600, "Invalid JSON-RPC request");
   }
@@ -1262,34 +1382,45 @@ async function handleRequest(message, workspaceRoot) {
     const toolName = params?.name;
     const args = params?.arguments || {};
 
-    if (toolName === TOOL_START_RUN) {
-      const inputError = validateRunArgs(args);
-      if (inputError) {
-        return createJsonRpcError(id, -32602, inputError);
-      }
-    }
-
-    if ([TOOL_GET_RUN, TOOL_CANCEL_RUN, TOOL_PAUSE_RUN, TOOL_RESUME_RUN].includes(toolName)) {
-      if (!args || typeof args.run_id !== "string" || !normalizeText(args.run_id)) {
-        return createJsonRpcError(id, -32602, "run_id is required and must be a string");
-      }
+    if (toolName === TOOL_START_RUN) {
+      const inputError = validateRunArgs(args);
+      if (inputError) {
+        return createJsonRpcError(id, -32602, inputError);
+      }
+    }
+
+    if (toolName === TOOL_RUN_FEATURED_CALIBRATION) {
+      const inputError = validateRunFeaturedCalibrationArgs(args);
+      if (inputError) {
+        return createJsonRpcError(id, -32602, inputError);
+      }
+    }
+
+    if ([TOOL_GET_RUN, TOOL_CANCEL_RUN, TOOL_PAUSE_RUN, TOOL_RESUME_RUN].includes(toolName)) {
+      if (!args || typeof args.run_id !== "string" || !normalizeText(args.run_id)) {
+        return createJsonRpcError(id, -32602, "run_id is required and must be a string");
+      }
     }
 
     try {
       let payload;
-      if (toolName === TOOL_START_RUN) {
-        payload = await handleStartRunTool({ workspaceRoot, args });
-      } else if (toolName === TOOL_GET_RUN) {
-        payload = handleGetRunTool(args);
-      } else if (toolName === TOOL_CANCEL_RUN) {
-        payload = handleCancelRunTool(args);
-      } else if (toolName === TOOL_PAUSE_RUN) {
-        payload = handlePauseRunTool(args);
-      } else if (toolName === TOOL_RESUME_RUN) {
-        payload = handleResumeRunTool(args);
-      } else {
-        return createJsonRpcError(id, -32602, `Unknown tool: ${toolName || ""}`);
-      }
+      if (toolName === TOOL_START_RUN) {
+        payload = await handleStartRunTool({ workspaceRoot, args });
+      } else if (toolName === TOOL_GET_RUN) {
+        payload = handleGetRunTool(args);
+      } else if (toolName === TOOL_CANCEL_RUN) {
+        payload = handleCancelRunTool(args);
+      } else if (toolName === TOOL_PAUSE_RUN) {
+        payload = handlePauseRunTool(args);
+      } else if (toolName === TOOL_RESUME_RUN) {
+        payload = handleResumeRunTool(args);
+      } else if (toolName === TOOL_GET_FEATURED_CALIBRATION_STATUS) {
+        payload = handleGetFeaturedCalibrationStatusTool(workspaceRoot);
+      } else if (toolName === TOOL_RUN_FEATURED_CALIBRATION) {
+        payload = await handleRunFeaturedCalibrationTool({ workspaceRoot, args });
+      } else {
+        return createJsonRpcError(id, -32602, `Unknown tool: ${toolName || ""}`);
+      }
       const isError = payload?.status === "FAILED";
       return createToolResultResponse(id, payload, isError);
     } catch (error) {

package/src/pipeline.js

@@ -896,15 +896,6 @@ export async function runRecommendPipeline(
   };
 
   const ensureSelectedPageTab = async () => {
-    if (selectedPage === "recommend") {
-      activeTabStatus = selectedTabStatus;
-      return {
-        ok: true,
-        switched: false,
-        before_state: null,
-        after_state: null
-      };
-    }
     const expectedStatus = selectedTabStatus;
     let beforeState = null;
     if (typeof readTabState === "function") {
@@ -1267,11 +1258,11 @@ export async function runRecommendPipeline(
           );
           runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
         } else {
-          const recoveryFailureText = selectedPage === "featured" ? "network 简历获取失败" : "截图失败";
-          runtimeHooks.setStage(
-            "screen_recovery",
-            `screen 连续${recoveryFailureText}，开始自动恢复（第 ${screenAutoRecoveryCount} 次）：刷新 recommend 页面并重跑 search。`
-          );
+        const recoveryFailureText = "简历获取失败（network + 截图）";
+        runtimeHooks.setStage(
+          "screen_recovery",
+          `screen 连续${recoveryFailureText}，开始自动恢复（第 ${screenAutoRecoveryCount} 次）：刷新 recommend 页面并重跑 search。`
+        );
           runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
         }
 
@@ -1388,11 +1379,9 @@ export async function runRecommendPipeline(
       || tabStatusToPageScope(resolvedActiveTabStatus)
     ) || selectedPage;
     const resolvedResumeSourceRaw = normalizeText(screenSummary.resume_source || "").toLowerCase();
-    const resolvedResumeSource = resolvedResumeSourceRaw === "network"
-      ? "network"
-      : resolvedSelectedPage === "featured"
-        ? "network"
-        : "image_fallback";
+    const resolvedResumeSource = ["network", "image_fallback"].includes(resolvedResumeSourceRaw)
+      ? resolvedResumeSourceRaw
+      : "network";
     runtimeHooks.progress("finalize", {
       processed: screenSummary.processed_count ?? 0,
       passed: screenSummary.passed_count ?? 0,

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

@@ -679,13 +679,44 @@ function parseGeekIdFromUrl(url) {
   if (!raw) return null;
   try {
     const parsed = new URL(raw);
-    const keys = ["geekId", "geek_id", "gid", "encryptGeekId", "securityId"];
+    const keys = ["geekId", "geek_id", "gid", "encryptGeekId", "encryptJid", "jid", "securityId"];
     for (const key of keys) {
       const value = normalizeText(parsed.searchParams.get(key) || "");
       if (value) return value;
     }
   } catch {}
-  const matched = raw.match(/[?&](?:geekId|geek_id|gid|encryptGeekId|securityId)=([^&]+)/i);
+  const matched = raw.match(/[?&](?:geekId|geek_id|gid|encryptGeekId|encryptJid|jid|securityId)=([^&]+)/i);
+  if (matched?.[1]) return decodeURIComponent(matched[1]);
+  return null;
+}
+
+function parseGeekIdFromPostData(postData) {
+  const raw = normalizeText(postData);
+  if (!raw) return null;
+  const keys = ["geekId", "geek_id", "gid", "encryptGeekId", "encryptJid", "jid", "securityId"];
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      const queue = [parsed];
+      let depth = 0;
+      while (queue.length > 0 && depth < 5) {
+        const current = queue.shift();
+        depth += 1;
+        if (!current || typeof current !== "object") continue;
+        for (const key of keys) {
+          const value = normalizeText(current[key] || "");
+          if (value) return value;
+        }
+        for (const value of Object.values(current)) {
+          if (value && typeof value === "object") {
+            queue.push(value);
+          }
+        }
+      }
+    }
+  } catch {}
+
+  const matched = raw.match(/(?:^|[?&,\s"'])?(?:geekId|geek_id|gid|encryptGeekId|encryptJid|jid|securityId)(?:["']?\s*[:=]\s*["']?)([^&,"'\s}]+)/i);
   if (matched?.[1]) return decodeURIComponent(matched[1]);
   return null;
 }
@@ -800,9 +831,22 @@ 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 (/\/wapi\/zpjob\/view\/geek\/info\b/.test(normalizedUrl)) return true;
+  if (/\/wapi\/zpitem\/web\/boss\/[^?#]*\/geek\/info\b/.test(normalizedUrl)) return true;
   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);
+  return /[?&](?:geekid|geek_id|encryptgeekid|encryptjid|jid|securityid)=/.test(normalizedUrl);
+}
+
+function isResumeRelatedWapiUrl(url) {
+  const normalizedUrl = normalizeText(url).toLowerCase();
+  if (!normalizedUrl || !normalizedUrl.includes("/wapi/")) return false;
+  return (
+    normalizedUrl.includes("geek")
+    || normalizedUrl.includes("resume")
+    || normalizedUrl.includes("candidate")
+    || normalizedUrl.includes("friend")
+  );
 }
 
 function formatResumeApiData(data) {
@@ -2044,6 +2088,8 @@ class RecommendScreenCli {
     this.resumeCaptureFailureStreakKeys = [];
     this.currentCandidateKey = null;
     this.resumeNetworkRequests = new Map();
+    this.resumeNetworkRelatedRequests = new Map();
+    this.resumeNetworkDiagnostics = [];
     this.resumeNetworkByGeekId = new Map();
     this.latestResumeNetworkPayload = null;
     this.favoriteActionEvents = [];
@@ -2117,7 +2163,7 @@ class RecommendScreenCli {
   }
 
   buildProgressSnapshot(completionReason = null) {
-    const defaultResumeSource = this.args.pageScope === "featured" ? "network" : "image_fallback";
+    const defaultResumeSource = "network";
     const snapshot = {
       processed_count: this.processedCount,
       passed_count: this.passedCandidates.length,
@@ -2185,6 +2231,89 @@ class RecommendScreenCli {
       });
   }
 
+  recordResumeNetworkDiagnostic(entry) {
+    const normalized = {
+      ts: Number.isFinite(Number(entry?.ts)) ? Number(entry.ts) : Date.now(),
+      kind: normalizeText(entry?.kind || "unknown") || "unknown",
+      request_id: normalizeText(entry?.request_id || "") || null,
+      method: normalizeText(entry?.method || "").toUpperCase() || null,
+      url: normalizeText(entry?.url || "") || null,
+      geek_id: normalizeText(entry?.geek_id || "") || null,
+      match: normalizeText(entry?.match || "") || null,
+      reason: normalizeText(entry?.reason || "") || null,
+      error: normalizeText(entry?.error || "") || null,
+      resume_text_len: Number.isFinite(Number(entry?.resume_text_len)) ? Number(entry.resume_text_len) : null,
+      candidate_key: normalizeText(entry?.candidate_key || "") || null,
+      source: normalizeText(entry?.source || "") || null,
+      waited_ms: Number.isFinite(Number(entry?.waited_ms)) ? Number(entry.waited_ms) : null
+    };
+    this.resumeNetworkDiagnostics.push(normalized);
+    if (this.resumeNetworkDiagnostics.length > 240) {
+      this.resumeNetworkDiagnostics = this.resumeNetworkDiagnostics.slice(-240);
+    }
+  }
+
+  summarizeResumeNetworkDiagnostics(since = 0) {
+    const timestamp = Number.isFinite(since) ? since : 0;
+    return this.resumeNetworkDiagnostics
+      .filter((item) => Number(item?.ts || 0) >= timestamp)
+      .slice(-20)
+      .map((item) => {
+        const prefix = `[${item.kind}]`;
+        if (item.kind === "request") {
+          return `${prefix} ${item.method || "GET"} ${item.url || ""} match=${item.match || "none"} geek=${item.geek_id || "-"}`;
+        }
+        if (item.kind === "response_hit") {
+          return `${prefix} ${item.url || ""} geek=${item.geek_id || "-"} resume_len=${item.resume_text_len ?? "?"}`;
+        }
+        if (item.kind === "response_miss") {
+          return `${prefix} ${item.url || ""} reason=${item.reason || "payload_not_found"}`;
+        }
+        if (item.kind === "response_error") {
+          return `${prefix} ${item.url || ""} error=${item.error || "unknown"}`;
+        }
+        if (item.kind === "wait_hit") {
+          return `${prefix} candidate=${item.candidate_key || "-"} source=${item.source || "-"} waited_ms=${item.waited_ms ?? "?"} resume_len=${item.resume_text_len ?? "?"}`;
+        }
+        if (item.kind === "wait_timeout") {
+          return `${prefix} candidate=${item.candidate_key || "-"} waited_ms=${item.waited_ms ?? "?"} reason=${item.reason || "timeout"}`;
+        }
+        return `${prefix} ${item.url || item.reason || "n/a"}`;
+      });
+  }
+
+  logResumeNetworkMissDiagnostics(candidate, options = {}) {
+    const candidateKey = normalizeText(candidate?.key || candidate?.geek_id || "");
+    const candidateName = normalizeText(candidate?.name || "");
+    const waitStartedAt = Number.isFinite(options.waitStartedAt) ? options.waitStartedAt : 0;
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 0;
+    const now = Date.now();
+    const latestPayloadAgeMs = this.latestResumeNetworkPayload
+      ? Math.max(0, now - Number(this.latestResumeNetworkPayload.ts || 0))
+      : null;
+    const latestPayloadGeekIds = Array.isArray(this.latestResumeNetworkPayload?.geekIds)
+      ? this.latestResumeNetworkPayload.geekIds.slice(0, 4)
+      : [];
+    const recentLines = this.summarizeResumeNetworkDiagnostics(waitStartedAt);
+    const trackedResumeRequestCount = this.resumeNetworkRequests.size;
+    const trackedRelatedRequestCount = this.resumeNetworkRelatedRequests.size;
+
+    log(
+      `[network简历未命中] candidate=${candidateKey || candidateName || "unknown"} `
+      + `wait_ms=${timeoutMs || "n/a"} `
+      + `tracked_resume_requests=${trackedResumeRequestCount} `
+      + `tracked_related_requests=${trackedRelatedRequestCount} `
+      + `cached_by_geek=${this.resumeNetworkByGeekId.size} `
+      + `latest_payload_age_ms=${latestPayloadAgeMs ?? "none"} `
+      + `latest_payload_geek_ids=${latestPayloadGeekIds.length ? latestPayloadGeekIds.join("|") : "none"}`
+    );
+    if (recentLines.length > 0) {
+      log(`[network简历未命中][最近网络事件] ${recentLines.join(" || ")}`);
+    } else {
+      log("[network简历未命中][最近网络事件] none");
+    }
+  }
+
   cacheResumeNetworkPayload(payload, fallbackGeekId = null) {
     if (!payload || typeof payload !== "object") return;
     const geekDetail = payload.geekDetail || payload;
@@ -2232,35 +2361,81 @@ class RecommendScreenCli {
   }
 
   async waitForNetworkResumeCandidateInfo(candidate, timeoutMs = 2200) {
+    const waitStartedAt = Date.now();
+    const candidateKey = normalizeText(candidate?.key || candidate?.geek_id || "");
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       const info = this.tryExtractNetworkResumeForCandidate(candidate);
       if (info && normalizeText(info.resumeText)) {
+        const source = candidateKey && this.resumeNetworkByGeekId.has(candidateKey)
+          ? "geek_id_map"
+          : "latest_payload";
+        this.recordResumeNetworkDiagnostic({
+          kind: "wait_hit",
+          candidate_key: candidateKey,
+          source,
+          waited_ms: Date.now() - waitStartedAt,
+          resume_text_len: normalizeText(info.resumeText).length
+        });
         return info;
       }
       await sleep(120);
     }
+    this.recordResumeNetworkDiagnostic({
+      kind: "wait_timeout",
+      candidate_key: candidateKey,
+      waited_ms: Date.now() - waitStartedAt,
+      reason: "resume_text_not_ready"
+    });
     return null;
   }
 
   handleNetworkRequestWillBeSent(params) {
     const url = normalizeText(params?.request?.url || "");
+    const postData = params?.request?.postData || "";
     if (!url) return;
-    if (isResumeInfoRequestUrl(url)) {
-      const geekId = parseGeekIdFromUrl(url);
-      this.resumeNetworkRequests.set(params.requestId, {
-        ts: Date.now(),
+    const requestTs = Date.now();
+    const method = normalizeText(params?.request?.method || "").toUpperCase() || "GET";
+    const isResumeInfo = isResumeInfoRequestUrl(url);
+    const isResumeRelated = isResumeInfo || isResumeRelatedWapiUrl(url);
+    if (isResumeRelated) {
+      const geekId = parseGeekIdFromUrl(url) || parseGeekIdFromPostData(postData);
+      const meta = {
+        ts: requestTs,
         url,
-        geekId
+        geekId,
+        method,
+        isResumeInfo
+      };
+      this.resumeNetworkRelatedRequests.set(params.requestId, meta);
+      this.recordResumeNetworkDiagnostic({
+        kind: "request",
+        request_id: params.requestId,
+        method,
+        url: url.slice(0, 280),
+        geek_id: geekId,
+        match: isResumeInfo ? "resume_info_url" : "wapi_related_non_resume_info"
       });
-      return;
+      if (this.resumeNetworkRelatedRequests.size > 400) {
+        const oldest = [...this.resumeNetworkRelatedRequests.entries()]
+          .sort((a, b) => Number(a[1]?.ts || 0) - Number(b[1]?.ts || 0))
+          .slice(0, this.resumeNetworkRelatedRequests.size - 320);
+        for (const [requestId] of oldest) {
+          this.resumeNetworkRelatedRequests.delete(requestId);
+        }
+      }
+      if (isResumeInfo) {
+        this.resumeNetworkRequests.set(params.requestId, {
+          ts: requestTs,
+          url,
+          geekId
+        });
+        return;
+      }
     }
 
     if (this.favoriteClickPendingSince <= 0) return;
-    const requestTs = Date.now();
     if (requestTs < this.favoriteClickPendingSince) return;
-    const method = normalizeText(params?.request?.method || "").toUpperCase() || "GET";
-    const postData = params?.request?.postData || "";
     this.recordFavoriteNetworkTrace({
       ts: requestTs,
       kind: "http",
@@ -2310,21 +2485,60 @@ class RecommendScreenCli {
   }
 
   async handleNetworkLoadingFinished(params) {
-    const requestMeta = this.resumeNetworkRequests.get(params?.requestId);
-    if (!requestMeta) return;
-    this.resumeNetworkRequests.delete(params.requestId);
+    const requestId = params?.requestId;
+    const requestMeta = this.resumeNetworkRequests.get(requestId);
+    const relatedMeta = this.resumeNetworkRelatedRequests.get(requestId);
+    if (!requestMeta && !relatedMeta) return;
+    this.resumeNetworkRequests.delete(requestId);
+    this.resumeNetworkRelatedRequests.delete(requestId);
+    const effectiveMeta = requestMeta || relatedMeta || {};
+    const effectiveUrl = normalizeText(effectiveMeta.url || "");
+    const effectiveGeekId = normalizeText(effectiveMeta.geekId || "");
     try {
-      const responseBody = await this.Network.getResponseBody({ requestId: params.requestId });
-      if (!responseBody?.body) return;
+      const responseBody = await this.Network.getResponseBody({ requestId });
+      if (!responseBody?.body) {
+        this.recordResumeNetworkDiagnostic({
+          kind: "response_miss",
+          request_id: requestId,
+          url: effectiveUrl.slice(0, 280),
+          geek_id: effectiveGeekId,
+          reason: "empty_body"
+        });
+        return;
+      }
       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);
+        this.cacheResumeNetworkPayload(resumePayload, effectiveGeekId);
+        const formattedText = normalizeText(formatResumeApiData(resumePayload));
+        this.recordResumeNetworkDiagnostic({
+          kind: "response_hit",
+          request_id: requestId,
+          url: effectiveUrl.slice(0, 280),
+          geek_id: effectiveGeekId,
+          resume_text_len: formattedText.length
+        });
+      } else {
+        this.recordResumeNetworkDiagnostic({
+          kind: "response_miss",
+          request_id: requestId,
+          url: effectiveUrl.slice(0, 280),
+          geek_id: effectiveGeekId,
+          reason: "payload_not_found"
+        });
       }
-    } catch {}
+    } catch (error) {
+      this.recordResumeNetworkDiagnostic({
+        kind: "response_error",
+        request_id: requestId,
+        url: effectiveUrl.slice(0, 280),
+        geek_id: effectiveGeekId,
+        error: normalizeText(error?.message || String(error)).slice(0, 240)
+      });
+    }
   }
 
   resetResumeCaptureFailureStreak() {
@@ -2433,13 +2647,13 @@ class RecommendScreenCli {
     const imageFallbackCount = this.passedCandidates.filter((item) => item?.resumeSource === "image_fallback").length;
     this.resumeSourceStats = {
       network: networkCount,
-      image_fallback: this.args.pageScope === "featured" ? 0 : imageFallbackCount
+      image_fallback: imageFallbackCount
     };
     if (this.resumeSourceStats.network <= 0 && this.resumeSourceStats.image_fallback <= 0) {
       const snapshotSource = normalizeText(parsed.resume_source || "").toLowerCase();
       if (snapshotSource === "network") {
         this.resumeSourceStats.network = 1;
-      } else if (snapshotSource === "image_fallback" && this.args.pageScope !== "featured") {
+      } else if (snapshotSource === "image_fallback") {
         this.resumeSourceStats.image_fallback = 1;
       }
     }
@@ -3570,12 +3784,18 @@ class RecommendScreenCli {
             throw this.buildError("DETAIL_OPEN_FAILED", "详情页打开超时");
           }
 
-          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, allowImageFallback ? 4200 : 2400);
+          let resumeSource = "image_fallback";
+          const networkWaitMs = 4200;
+          const networkWaitStartedAt = Date.now();
+          const networkCandidateInfo = await this.waitForNetworkResumeCandidateInfo(nextCandidate, networkWaitMs);
+          if (!normalizeText(networkCandidateInfo?.resumeText) && typeof this.logResumeNetworkMissDiagnostics === "function") {
+            this.logResumeNetworkMissDiagnostics(nextCandidate, {
+              timeoutMs: networkWaitMs,
+              waitStartedAt: networkWaitStartedAt
+            });
+          }
           const candidateProfile = {
             name: networkCandidateInfo?.name || nextCandidate.name || "",
             school: networkCandidateInfo?.school || nextCandidate.school || "",
@@ -3584,17 +3804,7 @@ class RecommendScreenCli {
             position: networkCandidateInfo?.position || nextCandidate.last_position || ""
           };
 
-          if (isFeaturedScope) {
-            if (!networkCandidateInfo?.resumeText) {
-              throw this.buildError(
-                "RESUME_NETWORK_UNAVAILABLE",
-                "精选页未获取到 network 简历数据，已跳过当前候选人。"
-              );
-            }
-            screening = await this.callTextModel(networkCandidateInfo.resumeText);
-            resumeSource = "network";
-            this.resumeSourceStats.network += 1;
-          } else if (networkCandidateInfo?.resumeText) {
+          if (networkCandidateInfo?.resumeText) {
             screening = await this.callTextModel(networkCandidateInfo.resumeText);
             resumeSource = "network";
             this.resumeSourceStats.network += 1;
@@ -3667,7 +3877,9 @@ class RecommendScreenCli {
           log(`候选人处理失败: ${error.code || error.message}`);
           if (["RESUME_CAPTURE_FAILED", "RESUME_NETWORK_UNAVAILABLE"].includes(error.code)) {
             this.recordResumeCaptureFailure(nextCandidate.key);
-            const failureLabel = error.code === "RESUME_NETWORK_UNAVAILABLE" ? "简历 network 获取失败" : "简历截图失败";
+            const failureLabel = error.code === "RESUME_NETWORK_UNAVAILABLE"
+              ? "简历 network 获取失败且截图回退未完成"
+              : "简历截图失败";
             log(
               `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} ${failureLabel}，` +
               `已跳过当前候选人；连续失败 ${this.consecutiveResumeCaptureFailures}/${MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES}`
@@ -3675,7 +3887,7 @@ class RecommendScreenCli {
             if (this.consecutiveResumeCaptureFailures >= MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES) {
               shouldMarkProcessed = false;
               const rollback = this.rollbackResumeCaptureFailureStreak(nextCandidate.key);
-              const failureTypeText = this.args.pageScope === "featured" ? "简历 network 获取失败" : "简历捕获失败";
+              const failureTypeText = "简历获取失败（network + 截图）";
               throw this.buildError(
                 "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT",
                 `连续 ${MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES} 位候选人${failureTypeText}，已停止运行以避免错误跳过。` +

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

@@ -225,7 +225,7 @@ async function testConsecutiveResumeCaptureFailuresStillAbort() {
     () => cli.run(),
     (error) => {
       assert.equal(error.code, "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT");
-      assert.match(error.message, /连续 .* 位候选人简历捕获失败/);
+      assert.match(error.message, /连续 .* 位候选人简历(?:捕获失败|获取失败（network \+ 截图）)/);
       assert.equal(error.rollback?.rollback_count, maxFailures);
       assert.equal(error.partial_result?.processed_count, 0);
       assert.equal(error.partial_result?.skipped_count, 0);