@reconcrap/boss-recommend-mcp 1.1.4 → 1.1.5

package/package.json

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

package/src/adapters.js

@@ -1392,6 +1392,221 @@ function pickBossRecommendReloadTarget(tabs = []) {
   ) || null;
 }
 
+async function evaluateCdpExpression(client, expression) {
+  const result = await client.Runtime.evaluate({
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.exception?.description || "Runtime.evaluate failed");
+  }
+  return result.result?.value;
+}
+
+function buildRecommendRefreshStateExpression() {
+  return `(() => {
+    const frame = document.querySelector('iframe[name="recommendFrame"]')
+      || document.querySelector('iframe[src*="/web/frame/recommend/"]')
+      || document.querySelector('iframe');
+    if (!frame || !frame.contentDocument) {
+      return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
+    }
+    const doc = frame.contentDocument;
+    const isVisible = (el) => {
+      if (!el) return false;
+      const win = doc.defaultView;
+      if (!win) return el.offsetParent !== null;
+      const style = win.getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity || '1') < 0.02) {
+        return false;
+      }
+      const rect = el.getBoundingClientRect();
+      return rect.width > 2 && rect.height > 2 && el.offsetParent !== null;
+    };
+    const finishedWrap = Array.from(doc.querySelectorAll('.finished-wrap')).find((el) => isVisible(el)) || null;
+    const refreshButton = Array.from(doc.querySelectorAll('.finished-wrap .btn.btn-refresh, .finished-wrap .btn-refresh, .no-data-refresh .btn-refresh'))
+      .find((el) => isVisible(el)) || null;
+    const cards = Array.from(doc.querySelectorAll('ul.card-list > li.card-item'));
+    const candidateCards = cards.filter((card) => card.querySelector('.card-inner[data-geekid]'));
+    const finishedText = finishedWrap ? String(finishedWrap.textContent || '').replace(/\\s+/g, ' ').trim() : '';
+    const buttonText = refreshButton ? String(refreshButton.textContent || '').replace(/\\s+/g, ' ').trim() : '';
+    return {
+      ok: true,
+      frame_url: (() => {
+        try { return String(frame.contentWindow.location.href || ''); } catch { return ''; }
+      })(),
+      finished_wrap_visible: Boolean(finishedWrap),
+      finished_wrap_text: finishedText || null,
+      refresh_button_visible: Boolean(refreshButton),
+      refresh_button_text: buttonText || null,
+      candidate_count: candidateCards.length,
+      total_card_count: cards.length,
+      list_ready: candidateCards.length > 0
+    };
+  })()`;
+}
+
+function buildRecommendRefreshClickExpression() {
+  return `(() => {
+    const frame = document.querySelector('iframe[name="recommendFrame"]')
+      || document.querySelector('iframe[src*="/web/frame/recommend/"]')
+      || document.querySelector('iframe');
+    if (!frame || !frame.contentDocument) {
+      return { ok: false, state: 'NO_RECOMMEND_IFRAME' };
+    }
+    const doc = frame.contentDocument;
+    const isVisible = (el) => {
+      if (!el) return false;
+      const win = doc.defaultView;
+      if (!win) return el.offsetParent !== null;
+      const style = win.getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity || '1') < 0.02) {
+        return false;
+      }
+      const rect = el.getBoundingClientRect();
+      return rect.width > 2 && rect.height > 2 && el.offsetParent !== null;
+    };
+    const refreshButton = Array.from(doc.querySelectorAll('.finished-wrap .btn.btn-refresh, .finished-wrap .btn-refresh, .no-data-refresh .btn-refresh'))
+      .find((el) => isVisible(el)) || null;
+    if (!refreshButton) {
+      return { ok: false, state: 'REFRESH_BUTTON_NOT_FOUND' };
+    }
+    try {
+      refreshButton.click();
+      return {
+        ok: true,
+        state: 'REFRESH_BUTTON_CLICKED',
+        refresh_button_text: String(refreshButton.textContent || '').replace(/\\s+/g, ' ').trim() || null
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        state: 'REFRESH_BUTTON_CLICK_FAILED',
+        message: error?.message || String(error)
+      };
+    }
+  })()`;
+}
+
+export async function refreshBossRecommendList(workspaceRoot, options = {}) {
+  const debugPort = Number.isFinite(options.port)
+    ? options.port
+    : resolveWorkspaceDebugPort(workspaceRoot);
+  const pollMs = Number.isFinite(options.pollMs) ? options.pollMs : 600;
+  const reloadTimeoutMs = Number.isFinite(options.reloadTimeoutMs) ? options.reloadTimeoutMs : 10000;
+
+  let client = null;
+  try {
+    const tabs = await listChromeTabs(debugPort);
+    const target = pickBossRecommendReloadTarget(tabs);
+    if (!target) {
+      return {
+        ok: false,
+        action: "in_page_refresh",
+        debug_port: debugPort,
+        state: "BOSS_TAB_NOT_FOUND",
+        message: "未找到可操作的 Boss recommend 标签页。",
+        before_state: null,
+        after_state: null
+      };
+    }
+
+    client = await CDP({ port: debugPort, target });
+    const { Page, Runtime } = client;
+    if (Runtime && typeof Runtime.enable === "function") {
+      await Runtime.enable();
+    }
+    if (Page && typeof Page.enable === "function") {
+      await Page.enable();
+    }
+    if (Page && typeof Page.bringToFront === "function") {
+      await Page.bringToFront();
+    }
+
+    const beforeState = await evaluateCdpExpression(client, buildRecommendRefreshStateExpression());
+    if (!beforeState?.ok) {
+      return {
+        ok: false,
+        action: "in_page_refresh",
+        debug_port: debugPort,
+        state: beforeState?.error || "NO_RECOMMEND_IFRAME",
+        message: "未能读取 recommend iframe，无法执行页内刷新。",
+        before_state: beforeState || null,
+        after_state: null
+      };
+    }
+    if (!beforeState.refresh_button_visible) {
+      return {
+        ok: false,
+        action: "in_page_refresh",
+        debug_port: debugPort,
+        state: "REFRESH_BUTTON_NOT_FOUND",
+        message: "推荐列表到底后未发现可点击的刷新按钮。",
+        before_state: beforeState,
+        after_state: beforeState
+      };
+    }
+
+    const clickResult = await evaluateCdpExpression(client, buildRecommendRefreshClickExpression());
+    if (!clickResult?.ok) {
+      return {
+        ok: false,
+        action: "in_page_refresh",
+        debug_port: debugPort,
+        state: clickResult?.state || "REFRESH_BUTTON_CLICK_FAILED",
+        message: clickResult?.message || "页内刷新按钮点击失败。",
+        before_state: beforeState,
+        after_state: null
+      };
+    }
+
+    const deadline = Date.now() + reloadTimeoutMs;
+    let lastState = beforeState;
+    while (Date.now() < deadline) {
+      await sleep(pollMs);
+      lastState = await evaluateCdpExpression(client, buildRecommendRefreshStateExpression());
+      if (lastState?.ok && lastState.finished_wrap_visible === false && lastState.list_ready === true) {
+        return {
+          ok: true,
+          action: "in_page_refresh",
+          debug_port: debugPort,
+          state: "RECOMMEND_READY",
+          message: "已点击页内刷新按钮并重新拿到候选人列表。",
+          before_state: beforeState,
+          after_state: lastState
+        };
+      }
+    }
+
+    return {
+      ok: false,
+      action: "in_page_refresh",
+      debug_port: debugPort,
+      state: "LIST_NOT_RELOADED",
+      message: "已点击页内刷新按钮，但候选人列表未在超时内重新就绪。",
+      before_state: beforeState,
+      after_state: lastState
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      action: "in_page_refresh",
+      debug_port: debugPort,
+      state: "REFRESH_BUTTON_CLICK_FAILED",
+      message: error?.message || "页内刷新失败。",
+      before_state: null,
+      after_state: null
+    };
+  } finally {
+    if (client) {
+      try {
+        await client.close();
+      } catch {}
+    }
+  }
+}
+
 export async function reloadBossRecommendPage(workspaceRoot, options = {}) {
   const debugPort = Number.isFinite(options.port)
     ? options.port

package/src/pipeline.js

@@ -4,6 +4,7 @@ import {
   attemptPipelineAutoRepair,
   ensureBossRecommendPageReady,
   listRecommendJobs,
+  refreshBossRecommendList,
   reloadBossRecommendPage,
   runPipelinePreflight,
   runRecommendSearchCli,
@@ -499,6 +500,7 @@ const defaultDependencies = {
   parseRecommendInstruction,
   ensureBossRecommendPageReady,
   listRecommendJobs,
+  refreshBossRecommendList,
   reloadBossRecommendPage,
   runPipelinePreflight,
   runRecommendSearchCli,
@@ -517,6 +519,7 @@ export async function runRecommendPipeline(
     parseRecommendInstruction: parseInstruction,
     ensureBossRecommendPageReady: ensureRecommendPageReady,
     listRecommendJobs: listJobs,
+    refreshBossRecommendList: refreshRecommendList,
     reloadBossRecommendPage: reloadRecommendPage,
     runPipelinePreflight: runPreflight,
     runRecommendSearchCli: searchCli,
@@ -946,43 +949,156 @@ export async function runRecommendPipeline(
       });
     }
     if (!screenResult.ok) {
+      const screenErrorCode = String(screenResult.error?.code || "");
       const partialScreenResult = screenResult.summary || screenResult.structured?.result || null;
       const resumeOutputCsv = normalizeText(partialScreenResult?.output_csv || currentResumeConfig.output_csv || "");
       const hasCheckpointForRecovery = Boolean(normalizeText(currentResumeConfig.checkpoint_path || ""));
-      const shouldAutoRecover = (
-        screenResult.error?.code === "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT"
-        && screenAutoRecoveryCount < MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS
-        && hasCheckpointForRecovery
-        && Boolean(resumeOutputCsv)
-      );
+      const screenPartialForRecovery = partialScreenResult
+        ? {
+            processed_count: partialScreenResult.processed_count ?? null,
+            passed_count: partialScreenResult.passed_count ?? null,
+            skipped_count: partialScreenResult.skipped_count ?? null,
+            output_csv: partialScreenResult.output_csv || currentResumeConfig.output_csv || null,
+            checkpoint_path: partialScreenResult.checkpoint_path || currentResumeConfig.checkpoint_path || null,
+            completion_reason: partialScreenResult.completion_reason || null
+          }
+        : null;
+      const isResumeCaptureRecovery = screenErrorCode === "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT";
+      const isPageExhaustedRecovery = screenErrorCode === "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED";
+      const isRecoverableScreenFailure = isResumeCaptureRecovery || isPageExhaustedRecovery;
+      const canRecoverSafely = hasCheckpointForRecovery && Boolean(resumeOutputCsv);
+      const hasRecoveryAttemptsRemaining = screenAutoRecoveryCount < MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS;
+
+      if (isRecoverableScreenFailure && !canRecoverSafely) {
+        return buildFailedResponse(
+          "SCREEN_AUTO_RECOVERY_UNSAFE",
+          "检测到 recommend 自动恢复触发，但缺少 checkpoint 或 output_csv，无法安全续跑。",
+          {
+            search_params: effectiveSearchParams,
+            screen_params: parsed.screenParams,
+            selected_job: selectedJob,
+            partial_result: partialScreenResult,
+            diagnostics: {
+              debug_port: preflight.debug_port,
+              stdout: screenResult.stdout?.slice(-1000),
+              stderr: screenResult.stderr?.slice(-1000),
+              result: screenResult.structured || null,
+              auto_recovery: {
+                trigger: screenErrorCode,
+                attempt: screenAutoRecoveryCount,
+                max_attempts: MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS,
+                original_recent_not_view: parsed.searchParams.recent_not_view,
+                effective_recent_not_view: effectiveSearchParams.recent_not_view,
+                partial_result: screenPartialForRecovery
+              }
+            }
+          }
+        );
+      }
+
+      if (isRecoverableScreenFailure && !hasRecoveryAttemptsRemaining) {
+        return buildFailedResponse(
+          screenResult.error?.code || "RECOMMEND_SCREEN_FAILED",
+          `${screenResult.error?.message || "推荐页筛选执行失败。"} 已达到自动恢复上限 ${MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS} 次。`,
+          {
+            search_params: effectiveSearchParams,
+            screen_params: parsed.screenParams,
+            selected_job: selectedJob,
+            partial_result: partialScreenResult,
+            diagnostics: {
+              debug_port: preflight.debug_port,
+              stdout: screenResult.stdout?.slice(-1000),
+              stderr: screenResult.stderr?.slice(-1000),
+              result: screenResult.structured || null,
+              auto_recovery: lastAutoRecovery
+            }
+          }
+        );
+      }
 
-      if (shouldAutoRecover) {
+      if (isRecoverableScreenFailure && canRecoverSafely && hasRecoveryAttemptsRemaining) {
         screenAutoRecoveryCount += 1;
-        effectiveSearchParams = {
-          ...effectiveSearchParams,
-          recent_not_view: FORCED_RECENT_NOT_VIEW_ON_SCREEN_RECOVERY
-        };
         lastAutoRecovery = {
-          trigger: "RESUME_CAPTURE_FAILED_CONSECUTIVE_LIMIT",
+          trigger: screenErrorCode,
           attempt: screenAutoRecoveryCount,
           max_attempts: MAX_SCREEN_AUTO_RECOVERY_ATTEMPTS,
           original_recent_not_view: parsed.searchParams.recent_not_view,
           effective_recent_not_view: effectiveSearchParams.recent_not_view,
-          partial_result: partialScreenResult
-            ? {
-                processed_count: partialScreenResult.processed_count ?? null,
-                passed_count: partialScreenResult.passed_count ?? null,
-                skipped_count: partialScreenResult.skipped_count ?? null,
-                output_csv: partialScreenResult.output_csv || currentResumeConfig.output_csv || null
-              }
-            : null
+          partial_result: screenPartialForRecovery,
+          page_exhaustion: screenResult.error?.page_exhaustion || null
         };
 
-        runtimeHooks.setStage(
-          "screen_recovery",
-          `screen 连续截图失败，开始自动恢复（第 ${screenAutoRecoveryCount} 次）：刷新 recommend 页面并重跑 search。`
-        );
-        runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
+        if (isPageExhaustedRecovery) {
+          runtimeHooks.setStage(
+            "screen_recovery",
+            `推荐列表已到底但未达目标，开始自动补货（第 ${screenAutoRecoveryCount} 次）：优先尝试页内刷新。`
+          );
+          runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
+
+          const refreshResult = typeof refreshRecommendList === "function"
+            ? await refreshRecommendList(workspaceRoot, {
+                port: preflight.debug_port
+              })
+            : {
+                ok: false,
+                action: "in_page_refresh",
+                state: "REFRESH_ADAPTER_MISSING",
+                message: "缺少页内刷新适配器。"
+              };
+          ensurePipelineNotAborted(runtimeHooks.signal);
+
+          lastAutoRecovery = {
+            ...lastAutoRecovery,
+            refresh: refreshResult
+              ? {
+                  ok: refreshResult.ok,
+                  state: refreshResult.state || null,
+                  message: refreshResult.message || null,
+                  before_state: refreshResult.before_state || null,
+                  after_state: refreshResult.after_state || null
+                }
+              : null
+          };
+
+          if (refreshResult?.ok) {
+            lastAutoRecovery = {
+              ...lastAutoRecovery,
+              action: "in_page_refresh"
+            };
+            currentResumeConfig = {
+              checkpoint_path: currentResumeConfig.checkpoint_path || null,
+              pause_control_path: currentResumeConfig.pause_control_path || null,
+              output_csv: resumeOutputCsv || null,
+              resume: true,
+              require_checkpoint: true
+            };
+            shouldRunSearch = false;
+            searchSummary = null;
+            continue;
+          }
+
+          runtimeHooks.setStage(
+            "screen_recovery",
+            `页内刷新不可用（${refreshResult?.state || "unknown"}），改为刷新 recommend 页面并重跑 search。`
+          );
+          runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
+        } else {
+          runtimeHooks.setStage(
+            "screen_recovery",
+            `screen 连续截图失败，开始自动恢复（第 ${screenAutoRecoveryCount} 次）：刷新 recommend 页面并重跑 search。`
+          );
+          runtimeHooks.heartbeat("screen_recovery", lastAutoRecovery);
+        }
+
+        effectiveSearchParams = {
+          ...effectiveSearchParams,
+          recent_not_view: FORCED_RECENT_NOT_VIEW_ON_SCREEN_RECOVERY
+        };
+        lastAutoRecovery = {
+          ...lastAutoRecovery,
+          action: "reload_page_and_rerun_search",
+          effective_recent_not_view: effectiveSearchParams.recent_not_view
+        };
 
         const reloadResult = typeof reloadRecommendPage === "function"
           ? await reloadRecommendPage(workspaceRoot, {

package/src/test-pipeline.js

@@ -354,6 +354,505 @@ async function testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWi
   assert.equal(result.search_params.recent_not_view, "近14天没有");
 }
 
+async function testPageExhaustedBeforeTargetShouldRefreshInPageAndResumeScreen() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  let reloadCalls = 0;
+  let pageReadyCalls = 0;
+  const parsed = createParsed();
+  parsed.searchParams = {
+    ...parsed.searchParams,
+    recent_not_view: "不限"
+  };
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: false,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: ""
+      }
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => {
+        pageReadyCalls += 1;
+        return { ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } };
+      },
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: true,
+          action: "in_page_refresh",
+          state: "RECOMMEND_READY",
+          before_state: {
+            finished_wrap_visible: true,
+            refresh_button_visible: true
+          },
+          after_state: {
+            finished_wrap_visible: false,
+            list_ready: true
+          }
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 9,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。",
+              page_exhaustion: {
+                reason: "bottom_reached",
+                bottom: {
+                  isBottom: true,
+                  finished_wrap_visible: true,
+                  refresh_button_visible: true
+                }
+              }
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 1);
+  assert.equal(searchCalls[0].recent_not_view, "不限");
+  assert.equal(screenCalls.length, 2);
+  assert.equal(screenCalls[0].resume, false);
+  assert.equal(screenCalls[1].resume, true);
+  assert.equal(screenCalls[1].require_checkpoint, true);
+  assert.equal(screenCalls[1].output_csv, "C:/temp/resume.csv");
+  assert.equal(refreshCalls, 1);
+  assert.equal(reloadCalls, 0);
+  assert.equal(pageReadyCalls, 1);
+  assert.equal(result.result.candidate_count, null);
+  assert.equal(result.result.completion_reason, "target_count_reached");
+  assert.equal(result.result.auto_recovery.action, "in_page_refresh");
+  assert.equal(result.result.auto_recovery.refresh.ok, true);
+  assert.equal(result.result.auto_recovery.page_exhaustion.reason, "bottom_reached");
+  assert.equal(result.search_params.recent_not_view, "不限");
+}
+
+async function testPageExhaustedBeforeTargetShouldReloadWhenRefreshButtonMissing() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  let reloadCalls = 0;
+  let pageReadyCalls = 0;
+  const parsed = createParsed();
+  parsed.searchParams = {
+    ...parsed.searchParams,
+    recent_not_view: "不限"
+  };
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: false,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: ""
+      }
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => {
+        pageReadyCalls += 1;
+        return { ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } };
+      },
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: false,
+          action: "in_page_refresh",
+          state: "REFRESH_BUTTON_NOT_FOUND",
+          message: "未找到页内刷新按钮。"
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: searchCalls.length === 1 ? 9 : 12,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。",
+              page_exhaustion: {
+                reason: "bottom_reached",
+                bottom: {
+                  isBottom: true,
+                  finished_wrap_visible: true,
+                  refresh_button_visible: false
+                }
+              }
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 2);
+  assert.equal(searchCalls[0].recent_not_view, "不限");
+  assert.equal(searchCalls[1].recent_not_view, "近14天没有");
+  assert.equal(screenCalls.length, 2);
+  assert.equal(screenCalls[0].resume, false);
+  assert.equal(screenCalls[1].resume, true);
+  assert.equal(screenCalls[1].require_checkpoint, true);
+  assert.equal(refreshCalls, 1);
+  assert.equal(reloadCalls, 1);
+  assert.equal(pageReadyCalls, 2);
+  assert.equal(result.result.candidate_count, 12);
+  assert.equal(result.result.auto_recovery.action, "reload_page_and_rerun_search");
+  assert.equal(result.result.auto_recovery.refresh.state, "REFRESH_BUTTON_NOT_FOUND");
+  assert.equal(result.result.auto_recovery.reload.ok, true);
+  assert.equal(result.search_params.recent_not_view, "近14天没有");
+}
+
+async function testPageExhaustedBeforeTargetShouldReloadWhenRefreshDoesNotRecoverList() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  let reloadCalls = 0;
+  const parsed = createParsed();
+  parsed.searchParams = {
+    ...parsed.searchParams,
+    recent_not_view: "不限"
+  };
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: false,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: ""
+      }
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } }),
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: false,
+          action: "in_page_refresh",
+          state: "LIST_NOT_RELOADED",
+          message: "点击刷新后列表没有重新就绪。"
+        };
+      },
+      reloadBossRecommendPage: async () => {
+        reloadCalls += 1;
+        return {
+          ok: true,
+          state: "RECOMMEND_READY",
+          reloaded_url: "https://www.zhipin.com/web/chat/recommend"
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: searchCalls.length === 1 ? 9 : 11,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        if (screenCalls.length === 1) {
+          return {
+            ok: false,
+            error: {
+              code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+              message: "推荐列表已到底，但尚未达到目标数。"
+            },
+            summary: {
+              processed_count: 4,
+              passed_count: 1,
+              skipped_count: 3,
+              output_csv: "C:/temp/resume.csv",
+              checkpoint_path: "C:/temp/checkpoint.json",
+              completion_reason: "page_exhausted_before_target_count"
+            }
+          };
+        }
+        return {
+          ok: true,
+          summary: {
+            processed_count: 10,
+            passed_count: 3,
+            skipped_count: 7,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "target_count_reached"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(searchCalls.length, 2);
+  assert.equal(searchCalls[1].recent_not_view, "近14天没有");
+  assert.equal(screenCalls.length, 2);
+  assert.equal(screenCalls[1].resume, true);
+  assert.equal(refreshCalls, 1);
+  assert.equal(reloadCalls, 1);
+  assert.equal(result.result.candidate_count, 11);
+  assert.equal(result.result.auto_recovery.action, "reload_page_and_rerun_search");
+  assert.equal(result.result.auto_recovery.refresh.state, "LIST_NOT_RELOADED");
+  assert.equal(result.search_params.recent_not_view, "近14天没有");
+}
+
+async function testPageExhaustedBeforeTargetShouldFailAfterFiveRecoveryAttempts() {
+  const searchCalls = [];
+  const screenCalls = [];
+  let refreshCalls = 0;
+  const parsed = createParsed();
+  parsed.searchParams = {
+    ...parsed.searchParams,
+    recent_not_view: "不限"
+  };
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      resume: {
+        resume: false,
+        output_csv: "C:/temp/resume.csv",
+        checkpoint_path: "C:/temp/checkpoint.json",
+        pause_control_path: "C:/temp/run.json",
+        previous_completion_reason: ""
+      }
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: { state: "RECOMMEND_READY" } }),
+      listRecommendJobs: async () => createJobListResult(),
+      refreshBossRecommendList: async () => {
+        refreshCalls += 1;
+        return {
+          ok: true,
+          action: "in_page_refresh",
+          state: "RECOMMEND_READY",
+          before_state: {
+            finished_wrap_visible: true,
+            refresh_button_visible: true
+          },
+          after_state: {
+            finished_wrap_visible: false,
+            list_ready: true
+          }
+        };
+      },
+      runRecommendSearchCli: async ({ searchParams }) => {
+        searchCalls.push({ ...searchParams });
+        return {
+          ok: true,
+          summary: {
+            candidate_count: 9,
+            applied_filters: searchParams,
+            page_state: { state: "RECOMMEND_READY" }
+          }
+        };
+      },
+      runRecommendScreenCli: async ({ resume }) => {
+        screenCalls.push({ ...resume });
+        return {
+          ok: false,
+          error: {
+            code: "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+            message: "推荐列表已到底，但尚未达到目标数。",
+            page_exhaustion: {
+              reason: "bottom_reached",
+              bottom: {
+                isBottom: true,
+                finished_wrap_visible: true,
+                refresh_button_visible: true
+              }
+            }
+          },
+          summary: {
+            processed_count: 4,
+            passed_count: 1,
+            skipped_count: 3,
+            output_csv: "C:/temp/resume.csv",
+            checkpoint_path: "C:/temp/checkpoint.json",
+            completion_reason: "page_exhausted_before_target_count"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(result.status, "FAILED");
+  assert.equal(result.error.code, "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED");
+  assert.match(result.error.message, /已达到自动恢复上限 5 次/);
+  assert.equal(searchCalls.length, 1);
+  assert.equal(screenCalls.length, 6);
+  assert.equal(refreshCalls, 5);
+  assert.equal(result.partial_result.output_csv, "C:/temp/resume.csv");
+  assert.equal(result.diagnostics.auto_recovery.attempt, 5);
+  assert.equal(result.diagnostics.auto_recovery.action, "in_page_refresh");
+  assert.equal(result.diagnostics.auto_recovery.partial_result.checkpoint_path, "C:/temp/checkpoint.json");
+}
+
+async function testNullTargetCountShouldKeepPageExhaustedCompletion() {
+  const parsed = createParsed();
+  parsed.screenParams = {
+    ...parsed.screenParams,
+    target_count: null
+  };
+  let receivedScreenParams = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => parsed,
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 9,
+          applied_filters: {},
+          page_state: { state: "RECOMMEND_READY" }
+        }
+      }),
+      runRecommendScreenCli: async ({ screenParams }) => {
+        receivedScreenParams = screenParams;
+        return {
+          ok: true,
+          summary: {
+            processed_count: 4,
+            passed_count: 1,
+            skipped_count: 3,
+            output_csv: "C:/temp/resume.csv",
+            completion_reason: "page_exhausted"
+          }
+        };
+      }
+    }
+  );
+
+  assert.equal(receivedScreenParams.target_count, null);
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.completion_reason, "page_exhausted");
+  assert.equal(result.result.auto_recovery, null);
+}
+
 async function testNeedConfirmationGate() {
   let preflightCalled = false;
   const result = await runRecommendPipeline(
@@ -1036,6 +1535,11 @@ async function main() {
   await testResumeFromScreenPauseShouldSkipSearch();
   await testResumeFromPausedBeforeScreenShouldRerunSearch();
   await testConsecutiveResumeCaptureFailuresShouldRefreshAndRerunSearchWithForcedRecentFilter();
+  await testPageExhaustedBeforeTargetShouldRefreshInPageAndResumeScreen();
+  await testPageExhaustedBeforeTargetShouldReloadWhenRefreshButtonMissing();
+  await testPageExhaustedBeforeTargetShouldReloadWhenRefreshDoesNotRecoverList();
+  await testPageExhaustedBeforeTargetShouldFailAfterFiveRecoveryAttempts();
+  await testNullTargetCountShouldKeepPageExhaustedCompletion();
   await testNeedConfirmationGate();
   await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();

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

@@ -450,6 +450,20 @@ const jsDetectBottom = `(() => {
     return { isBottom: false, error: 'NO_RECOMMEND_IFRAME' };
   }
   const doc = frame.contentDocument;
+  const isVisible = (el) => {
+    if (!el) return false;
+    const win = doc.defaultView;
+    if (!win) return el.offsetParent !== null;
+    const style = win.getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity || '1') < 0.02) {
+      return false;
+    }
+    const rect = el.getBoundingClientRect();
+    return rect.width > 2 && rect.height > 2 && el.offsetParent !== null;
+  };
+  const finishedWrap = Array.from(doc.querySelectorAll('.finished-wrap')).find((el) => isVisible(el)) || null;
+  const refreshButton = Array.from(doc.querySelectorAll('.finished-wrap .btn.btn-refresh, .finished-wrap .btn-refresh, .no-data-refresh .btn-refresh'))
+    .find((el) => isVisible(el)) || null;
   const keywords = ['没有更多', '已显示全部', '已经到底', '暂无更多', '推荐完了', '没有更多人选'];
   const elements = Array.from(doc.querySelectorAll('div,span,p'));
   for (const el of elements) {
@@ -458,12 +472,24 @@ const jsDetectBottom = `(() => {
     if (!text || text.length > 40) continue;
     for (const keyword of keywords) {
       if (text.includes(keyword)) {
-        return { isBottom: true, reason: keyword };
+        return {
+          isBottom: true,
+          reason: keyword,
+          finished_wrap_visible: Boolean(finishedWrap),
+          refresh_button_visible: Boolean(refreshButton),
+          refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null
+        };
       }
     }
   }
-  return { isBottom: false };
-})()`;
+  return {
+    isBottom: Boolean(finishedWrap),
+    reason: finishedWrap ? 'finished-wrap' : null,
+    finished_wrap_visible: Boolean(finishedWrap),
+    refresh_button_visible: Boolean(refreshButton),
+    refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null
+  };
+})()`;
 const jsWaitForDetail = `(() => {
   const frame = document.querySelector('iframe[name="recommendFrame"]')
     || document.querySelector('iframe[src*="/web/frame/recommend/"]')
@@ -1113,6 +1139,24 @@ class RecommendScreenCli {
     };
   }
 
+  buildProgressSnapshot(completionReason = null) {
+    const snapshot = {
+      processed_count: this.processedCount,
+      passed_count: this.passedCandidates.length,
+      skipped_count: this.skippedCount,
+      output_csv: this.args.output,
+      checkpoint_path: this.checkpointPath,
+      post_action: this.args.postAction,
+      max_greet_count: this.args.postAction === "greet" ? this.args.maxGreetCount : null,
+      greet_count: this.greetCount,
+      greet_limit_fallback_count: this.greetLimitFallbackCount
+    };
+    if (completionReason) {
+      snapshot.completion_reason = completionReason;
+    }
+    return snapshot;
+  }
+
   resetResumeCaptureFailureStreak() {
     this.consecutiveResumeCaptureFailures = 0;
     this.resumeCaptureFailureStreakKeys = [];
@@ -1916,24 +1960,14 @@ class RecommendScreenCli {
         this.sortCandidateQueue();
       }
 
+      let pageExhaustion = null;
       while (!this.args.targetCount || this.processedCount < this.args.targetCount) {
         if (this.shouldPauseAtBoundary()) {
           this.saveCsv();
           this.saveCheckpoint();
           return {
             status: "PAUSED",
-            result: {
-              processed_count: this.processedCount,
-              passed_count: this.passedCandidates.length,
-              skipped_count: this.skippedCount,
-              output_csv: this.args.output,
-              checkpoint_path: this.checkpointPath,
-              completion_reason: "paused",
-              post_action: this.args.postAction,
-              max_greet_count: this.args.postAction === "greet" ? this.args.maxGreetCount : null,
-              greet_count: this.greetCount,
-              greet_limit_fallback_count: this.greetLimitFallbackCount
-            }
+            result: this.buildProgressSnapshot("paused")
           };
         }
         const periodicDiscovery = await this.discoverCandidates();
@@ -1958,6 +1992,18 @@ class RecommendScreenCli {
           const didScroll = Number(scroll.after?.scrollTop || 0) !== Number(scroll.before?.scrollTop || 0)
             || Number(scroll.after?.scrollHeight || 0) !== Number(scroll.before?.scrollHeight || 0);
           if (scroll.bottom?.isBottom) {
+            pageExhaustion = {
+              reason: "bottom_reached",
+              bottom: scroll.bottom || null,
+              scroll: scroll.scrollResult || null,
+              before: scroll.before || null,
+              after: scroll.after || null,
+              discovery: {
+                added: discovery.added ?? 0,
+                candidate_count: discovery.candidate_count ?? null,
+                total_cards: discovery.total_cards ?? null
+              }
+            };
             break;
           }
           if (didGrow || didDiscover) {
@@ -1967,12 +2013,36 @@ class RecommendScreenCli {
           if (!didScroll) {
             this.scrollRetryCount += 1;
             if (this.scrollRetryCount >= this.maxScrollRetries) {
+              pageExhaustion = {
+                reason: "scroll_stalled",
+                bottom: scroll.bottom || null,
+                scroll: scroll.scrollResult || null,
+                before: scroll.before || null,
+                after: scroll.after || null,
+                discovery: {
+                  added: discovery.added ?? 0,
+                  candidate_count: discovery.candidate_count ?? null,
+                  total_cards: discovery.total_cards ?? null
+                }
+              };
               break;
             }
             continue;
           }
           this.scrollRetryCount += 1;
           if (this.scrollRetryCount >= this.maxScrollRetries) {
+            pageExhaustion = {
+              reason: "scroll_retry_exhausted",
+              bottom: scroll.bottom || null,
+              scroll: scroll.scrollResult || null,
+              before: scroll.before || null,
+              after: scroll.after || null,
+              discovery: {
+                added: discovery.added ?? 0,
+                candidate_count: discovery.candidate_count ?? null,
+                total_cards: discovery.total_cards ?? null
+              }
+            };
             break;
           }
           continue;
@@ -2076,6 +2146,18 @@ class RecommendScreenCli {
         }
       }
 
+      if (this.args.targetCount && this.processedCount < this.args.targetCount) {
+        throw this.buildError(
+          "TARGET_COUNT_NOT_REACHED_PAGE_EXHAUSTED",
+          `推荐列表已到底，但当前仅处理 ${this.processedCount} 位，尚未达到目标 ${this.args.targetCount} 位。`,
+          true,
+          {
+            partial_result: this.buildProgressSnapshot("page_exhausted_before_target_count"),
+            page_exhaustion: pageExhaustion
+          }
+        );
+      }
+
       this.saveCsv();
       try {
         this.saveCheckpoint();
@@ -2085,17 +2167,14 @@ class RecommendScreenCli {
       return {
         status: "COMPLETED",
         result: {
-          processed_count: this.processedCount,
-          passed_count: this.passedCandidates.length,
-          skipped_count: this.skippedCount,
-          output_csv: this.args.output,
+          ...this.buildProgressSnapshot(
+            this.args.targetCount && this.processedCount >= this.args.targetCount
+              ? "target_count_reached"
+              : "page_exhausted"
+          ),
           completion_reason: this.args.targetCount && this.processedCount >= this.args.targetCount
             ? "target_count_reached"
             : "page_exhausted",
-          post_action: this.args.postAction,
-          max_greet_count: this.args.postAction === "greet" ? this.args.maxGreetCount : null,
-          greet_count: this.greetCount,
-          greet_limit_fallback_count: this.greetLimitFallbackCount
         }
       };
     } catch (error) {
@@ -2110,12 +2189,7 @@ class RecommendScreenCli {
         log(`[保存checkpoint失败] ${checkpointError.message || checkpointError}`);
       }
       if (!error.partial_result) {
-        error.partial_result = {
-          processed_count: this.processedCount,
-          passed_count: this.passedCandidates.length,
-          skipped_count: this.skippedCount,
-          output_csv: this.args.output
-        };
+        error.partial_result = this.buildProgressSnapshot();
       }
       throw error;
     } finally {
@@ -2144,13 +2218,18 @@ async function main() {
 
 if (require.main === module) {
   main().catch((error) => {
+    const errorPayload = {
+      code: error.code || "RECOMMEND_SCREEN_FAILED",
+      message: error.message || "推荐页筛选执行失败。",
+      retryable: error.retryable !== false
+    };
+    for (const [key, value] of Object.entries(error || {})) {
+      if (["code", "message", "retryable", "partial_result", "stack"].includes(key)) continue;
+      errorPayload[key] = value;
+    }
     const payload = {
       status: "FAILED",
-      error: {
-        code: error.code || "RECOMMEND_SCREEN_FAILED",
-        message: error.message || "推荐页筛选执行失败。",
-        retryable: error.retryable !== false
-      },
+      error: errorPayload,
       result: error.partial_result || null
     };
     console.log(JSON.stringify(payload));

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

@@ -232,10 +232,83 @@ async function testConsecutiveResumeCaptureFailuresStillAbort() {
   );
 }
 
+async function testPageExhaustedBeforeTargetShouldRaiseRecoverableError() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-page-exhausted-"));
+  const args = createArgs(tempDir);
+  args.targetCount = 5;
+  const cli = new FakeRecommendScreenCli(args);
+  cli.scrollAndLoadMore = async () => ({
+    before: {
+      candidateCount: 0,
+      scrollTop: 120,
+      scrollHeight: 900
+    },
+    after: {
+      candidateCount: 0,
+      scrollTop: 900,
+      scrollHeight: 900
+    },
+    bottom: {
+      isBottom: true,
+      finished_wrap_visible: true,
+      refresh_button_visible: true,
+      refresh_button_text: "刷新"
+    }
+  });
+
+  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, 0);
+      assert.equal(error.partial_result?.output_csv, args.output);
+      assert.equal(error.partial_result?.checkpoint_path, args.checkpointPath);
+      assert.equal(error.partial_result?.completion_reason, "page_exhausted_before_target_count");
+      assert.equal(error.page_exhaustion?.reason, "bottom_reached");
+      assert.equal(error.page_exhaustion?.bottom?.finished_wrap_visible, true);
+      assert.equal(error.page_exhaustion?.bottom?.refresh_button_visible, true);
+      return true;
+    }
+  );
+}
+
+async function testPageExhaustedWithoutTargetShouldStillComplete() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-page-complete-"));
+  const cli = new FakeRecommendScreenCli(createArgs(tempDir));
+  cli.scrollAndLoadMore = async () => ({
+    before: {
+      candidateCount: 0,
+      scrollTop: 120,
+      scrollHeight: 900
+    },
+    after: {
+      candidateCount: 0,
+      scrollTop: 900,
+      scrollHeight: 900
+    },
+    bottom: {
+      isBottom: true,
+      finished_wrap_visible: true,
+      refresh_button_visible: true,
+      refresh_button_text: "刷新"
+    }
+  });
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.processed_count, 0);
+  assert.equal(result.result.output_csv, cli.args.output);
+  assert.equal(result.result.checkpoint_path, cli.args.checkpointPath);
+  assert.equal(result.result.completion_reason, "page_exhausted");
+}
+
 async function main() {
   testShouldAbortResumeProbeEarly();
   await testSingleResumeCaptureFailureIsSkipped();
   await testConsecutiveResumeCaptureFailuresStillAbort();
+  await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
+  await testPageExhaustedWithoutTargetShouldStillComplete();
   console.log("recoverable resume failure tests passed");
 }