@reconcrap/boss-recommend-mcp 2.0.12 → 2.0.14

package/package.json

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

package/src/chat-mcp.js

@@ -71,6 +71,43 @@ const TERMINAL_STATUSES = new Set([
   RUN_STATUS_CANCELED
 ]);
 
+const ARTIFACT_STATUSES = new Set([
+  RUN_STATUS_COMPLETED,
+  RUN_STATUS_FAILED,
+  RUN_STATUS_CANCELED,
+  RUN_STATUS_PAUSED
+]);
+
+const STALE_PROCESS_STATUSES = new Set([
+  "queued",
+  "running",
+  RUN_STATUS_CANCELING
+]);
+
+const CHAT_REQUEST_RESUME_ACTIONS = new Set([
+  "request_cv",
+  "ask_cv",
+  "request_resume",
+  "求简历",
+  "索要简历"
+]);
+
+const CHAT_DISABLE_REQUEST_RESUME_ACTIONS = new Set([
+  "none",
+  "no",
+  "false",
+  "off",
+  "skip",
+  "do_nothing",
+  "nothing",
+  "不做",
+  "什么都不做",
+  "无",
+  "不用",
+  "不求简历",
+  "不请求简历"
+]);
+
 let chatWorkflowImpl = runChatWorkflow;
 let chatConnectorImpl = connectChatChromeSession;
 let chatJobReaderImpl = readChatJobOptionsFromSession;
@@ -156,8 +193,13 @@ function readJsonFile(filePath) {
   }
 }
 
-function selectedChatJobForCsv(meta = {}) {
-  const job = normalizeText(meta.normalized?.job || meta.args?.job || "");
+function selectedChatJobForCsv(meta = {}, snapshot = {}) {
+  const job = normalizeText(
+    meta.normalized?.job
+    || meta.args?.job
+    || snapshot.context?.job
+    || ""
+  );
   return {
     value: job,
     title: job,
@@ -167,31 +209,32 @@ function selectedChatJobForCsv(meta = {}) {
 
 function buildChatCsvInputRows(snapshot = {}, meta = {}) {
   const normalized = meta.normalized || {};
-  const postAction = shouldRequestChatResume(meta.args)
+  const context = snapshot.context || {};
+  const postAction = shouldRequestChatResume(meta.args, context)
     ? "request_cv"
     : normalizeText(meta.args?.post_action || meta.args?.action || "") || "none";
   const searchParams = {
-    job: normalized.job || meta.args?.job || "",
-    start_from: normalized.startFrom || meta.args?.start_from || "",
+    job: normalized.job || meta.args?.job || context.job || "",
+    start_from: normalized.startFrom || meta.args?.start_from || context.start_from || "",
     target_count: normalized.publicTargetCount ?? normalized.targetCount ?? snapshot.progress?.target_count ?? "",
-    detail_source: meta.args?.detail_source || snapshot.summary?.detail_source || snapshot.context?.detail_source || ""
+    detail_source: meta.args?.detail_source || snapshot.summary?.detail_source || context.detail_source || ""
   };
   return buildLegacyScreenInputRows({
     instruction: meta.args?.instruction || "启动boss聊天任务",
     selectedPage: "chat",
-    selectedJob: selectedChatJobForCsv(meta),
+    selectedJob: selectedChatJobForCsv(meta, snapshot),
     userSearchParams: cloneReportInput(searchParams, {}),
     effectiveSearchParams: cloneReportInput(searchParams, {}),
     screenParams: {
-      criteria: normalized.criteria || meta.args?.criteria || "",
+      criteria: normalized.criteria || meta.args?.criteria || context.criteria || "",
       target_count: searchParams.target_count,
       post_action: postAction,
       max_greet_count: meta.args?.max_greet_count ?? ""
     },
     followUp: meta.args?.follow_up || null,
     extraRows: [
-      ["chat_params.greeting_text", normalized.greetingText || meta.args?.greeting_text || meta.args?.greetingText || DEFAULT_CHAT_GREETING_TEXT],
-      ["chat_params.profile", normalized.profile || meta.args?.profile || "default"]
+      ["chat_params.greeting_text", normalized.greetingText || meta.args?.greeting_text || meta.args?.greetingText || context.greeting_text || DEFAULT_CHAT_GREETING_TEXT],
+      ["chat_params.profile", normalized.profile || meta.args?.profile || context.profile || "default"]
     ]
   });
 }
@@ -314,6 +357,12 @@ function ensureChatRunArtifacts(snapshot) {
     partial: true,
     partial_reason: snapshot?.status || snapshot?.state || "non_terminal",
     results: checkpointResults
+  } : ARTIFACT_STATUSES.has(snapshot?.status || snapshot?.state) ? {
+    domain: "chat",
+    partial: (snapshot?.status || snapshot?.state) !== RUN_STATUS_COMPLETED,
+    partial_reason: snapshot?.status || snapshot?.state || "unknown",
+    completion_reason: completionReason(snapshot?.status || snapshot?.state),
+    results: []
   } : null);
   if (artifactSummary) {
     const rows = Array.isArray(artifactSummary.results) ? artifactSummary.results : [];
@@ -337,6 +386,143 @@ function ensureChatRunArtifacts(snapshot) {
   return artifacts;
 }
 
+function isPidAlive(pid) {
+  const numericPid = Number(pid);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return false;
+  if (numericPid === process.pid) return true;
+  try {
+    process.kill(numericPid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+function snapshotFromPersistedChatRun(persisted = {}) {
+  return {
+    runId: persisted.run_id || persisted.runId,
+    name: persisted.name || persisted.run_id || persisted.runId,
+    status: persisted.status || persisted.state,
+    phase: persisted.stage || persisted.phase,
+    progress: persisted.progress || {},
+    context: persisted.context || {},
+    checkpoint: persisted.checkpoint || {},
+    startedAt: persisted.started_at || persisted.startedAt,
+    updatedAt: persisted.updated_at || persisted.updatedAt,
+    completedAt: persisted.completed_at || persisted.completedAt || null,
+    error: persisted.error || null,
+    summary: persisted.summary || null
+  };
+}
+
+function persistDiskChatRun(runId, payload) {
+  const artifacts = getChatRunArtifacts(runId);
+  if (!artifacts) return payload;
+  writeJsonAtomic(artifacts.run_state_path, payload);
+  return payload;
+}
+
+function attachLegacyArtifactsToPersistedChatRun(persisted = {}) {
+  const runId = normalizeRunId(persisted.run_id || persisted.runId);
+  if (!runId) return persisted;
+  const snapshot = snapshotFromPersistedChatRun(persisted);
+  const result = buildLegacyChatResult(snapshot);
+  const artifacts = getChatRunArtifacts(runId);
+  const next = {
+    ...persisted,
+    result,
+    resume: {
+      ...(persisted.resume || {}),
+      checkpoint_path: result?.checkpoint_path || persisted.resume?.checkpoint_path || artifacts?.checkpoint_path || null,
+      output_csv: result?.output_csv || persisted.resume?.output_csv || artifacts?.output_csv || null
+    },
+    artifacts: artifacts || persisted.artifacts || null
+  };
+  return persistDiskChatRun(runId, next);
+}
+
+function finalizePersistedChatRun(persisted = {}, {
+  status = RUN_STATUS_FAILED,
+  error = null,
+  message = ""
+} = {}) {
+  const runId = normalizeRunId(persisted.run_id || persisted.runId);
+  if (!runId) return persisted;
+  const now = new Date().toISOString();
+  const normalizedError = status === RUN_STATUS_FAILED
+    ? {
+        name: error?.name || "Error",
+        code: error?.code || "STALE_RUN_PROCESS_EXITED",
+        message: error?.message || message || "Boss chat run process exited before it wrote a terminal state."
+      }
+    : null;
+  const next = {
+    ...persisted,
+    run_id: runId,
+    state: status,
+    status,
+    stage: persisted.stage || persisted.phase || "chat:stale",
+    updated_at: now,
+    heartbeat_at: now,
+    completed_at: persisted.completed_at || now,
+    last_message: normalizedError?.message || message || status,
+    control: {
+      ...(persisted.control || {}),
+      cancel_requested: false
+    },
+    error: normalizedError,
+    summary: persisted.summary || null
+  };
+  return attachLegacyArtifactsToPersistedChatRun(next);
+}
+
+function persistedChatRunArtifactMissing(persisted = {}) {
+  const runId = normalizeRunId(persisted.run_id || persisted.runId);
+  const artifacts = getChatRunArtifacts(runId);
+  const outputCsv = persisted.result?.output_csv
+    || persisted.resume?.output_csv
+    || persisted.artifacts?.output_csv
+    || artifacts?.output_csv;
+  const reportJson = persisted.result?.report_json
+    || persisted.artifacts?.report_json
+    || artifacts?.report_json;
+  return Boolean(
+    !outputCsv
+    || !reportJson
+    || !fs.existsSync(outputCsv)
+    || !fs.existsSync(reportJson)
+  );
+}
+
+function reconcilePersistedChatRun(persisted = {}, { cancelStale = false } = {}) {
+  const status = persisted.status || persisted.state;
+  if (STALE_PROCESS_STATUSES.has(status) && !isPidAlive(persisted.pid)) {
+    const shouldCancel = cancelStale || status === RUN_STATUS_CANCELING || persisted.control?.cancel_requested === true;
+    return {
+      run: finalizePersistedChatRun(persisted, {
+        status: shouldCancel ? RUN_STATUS_CANCELED : RUN_STATUS_FAILED,
+        error: shouldCancel ? null : {
+          code: "STALE_RUN_PROCESS_EXITED",
+          message: `Boss chat run process is no longer alive for pid=${persisted.pid || "unknown"}.`
+        },
+        message: shouldCancel
+          ? "Boss chat run was canceled after its worker process was no longer active."
+          : `Boss chat run process is no longer alive for pid=${persisted.pid || "unknown"}.`
+      }),
+      stale_finalized: true
+    };
+  }
+  if (ARTIFACT_STATUSES.has(status) && persistedChatRunArtifactMissing(persisted)) {
+    return {
+      run: attachLegacyArtifactsToPersistedChatRun(persisted),
+      artifacts_repaired: true
+    };
+  }
+  return {
+    run: persisted
+  };
+}
+
 function buildLegacyChatResult(snapshot) {
   if (!snapshot) return null;
   const artifacts = ensureChatRunArtifacts(snapshot);
@@ -791,14 +977,32 @@ async function buildNeedInputResponse({ args, missingFields, normalized }) {
   };
 }
 
-function shouldRequestChatResume(args = {}) {
-  return (
+function shouldRequestChatResume(args = {}, context = {}) {
+  const action = normalizeText(args.post_action || args.action).toLowerCase();
+  if (
+    args.request_cv === false
+    || args.request_resume === false
+    || args.ask_cv === false
+    || args.execute_post_action === false
+    || args.no_request_cv === true
+    || args.no_request_resume === true
+    || CHAT_DISABLE_REQUEST_RESUME_ACTIONS.has(action)
+  ) {
+    return false;
+  }
+  if (
     args.request_cv === true
     || args.request_resume === true
     || args.ask_cv === true
     || args.execute_post_action === true
-    || ["request_cv", "ask_cv", "request_resume", "求简历", "索要简历"].includes(normalizeText(args.post_action || args.action))
-  );
+    || CHAT_REQUEST_RESUME_ACTIONS.has(action)
+  ) {
+    return true;
+  }
+  if (typeof context.request_resume_for_passed === "boolean") {
+    return context.request_resume_for_passed;
+  }
+  return true;
 }
 
 function isDebugTestMode(args = {}) {
@@ -1300,12 +1504,15 @@ export function getBossChatRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readChatRunState(runId);
     if (persisted) {
+      const reconciled = reconcilePersistedChatRun(persisted);
       return {
         status: "RUN_STATUS",
-        run: persisted,
+        run: reconciled.run,
         persistence: {
           source: "disk",
-          active_control_available: false
+          active_control_available: false,
+          stale_finalized: reconciled.stale_finalized === true,
+          artifacts_repaired: reconciled.artifacts_repaired === true
         },
         runtime_evaluate_used: false,
         method_summary: {},
@@ -1354,9 +1561,10 @@ export function pauseBossChatRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readChatRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      const reconciled = reconcilePersistedChatRun(persisted);
       return {
         status: "PAUSE_IGNORED",
-        run: persisted,
+        run: reconciled.run,
         message: "目标任务已结束，无需暂停。",
         runtime_evaluate_used: false,
         method_summary: {},
@@ -1412,19 +1620,23 @@ export function resumeBossChatRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readChatRunState(runId);
     if (persisted) {
+      const reconciled = reconcilePersistedChatRun(persisted);
+      const reconciledStatus = reconciled.run?.status || reconciled.run?.state;
       return {
         status: "FAILED",
         error: {
-          code: TERMINAL_STATUSES.has(persisted.state) ? "RUN_ALREADY_TERMINATED" : "RUN_NOT_ACTIVE",
-          message: TERMINAL_STATUSES.has(persisted.state)
+          code: TERMINAL_STATUSES.has(reconciledStatus) ? "RUN_ALREADY_TERMINATED" : "RUN_NOT_ACTIVE",
+          message: TERMINAL_STATUSES.has(reconciledStatus)
             ? "目标任务已结束，无法继续。"
             : "该 run 只有磁盘快照，没有当前进程内的活动 CDP 会话，无法安全继续。",
-          retryable: !TERMINAL_STATUSES.has(persisted.state)
+          retryable: !TERMINAL_STATUSES.has(reconciledStatus)
         },
-        run: persisted,
+        run: reconciled.run,
         persistence: {
           source: "disk",
-          active_control_available: false
+          active_control_available: false,
+          stale_finalized: reconciled.stale_finalized === true,
+          artifacts_repaired: reconciled.artifacts_repaired === true
         },
         runtime_evaluate_used: false,
         method_summary: {},
@@ -1458,9 +1670,10 @@ export function cancelBossChatRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readChatRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      const reconciled = reconcilePersistedChatRun(persisted);
       return {
         status: "CANCEL_IGNORED",
-        run: persisted,
+        run: reconciled.run,
         message: "目标任务已结束，无需取消。",
         runtime_evaluate_used: false,
         method_summary: {},
@@ -1468,6 +1681,26 @@ export function cancelBossChatRunTool({ args = {} } = {}) {
         chrome: null
       };
     }
+    if (persisted) {
+      const reconciled = reconcilePersistedChatRun(persisted, { cancelStale: true });
+      if (reconciled.stale_finalized) {
+        return {
+          status: "CANCEL_REQUESTED",
+          run: reconciled.run,
+          message: "该 run 的后台进程已经不在，已将磁盘状态安全标记为 canceled 并生成结果文件。",
+          persistence: {
+            source: "disk",
+            active_control_available: false,
+            stale_finalized: true,
+            artifacts_repaired: reconciled.artifacts_repaired === true
+          },
+          runtime_evaluate_used: false,
+          method_summary: {},
+          method_log: [],
+          chrome: null
+        };
+      }
+    }
     return getBossChatRunTool({ args });
   }
 }

package/src/cli.js

@@ -7,6 +7,7 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import {
   assertNoForbiddenCdpCalls,
+  buildBossChromeLaunchArgs,
   bringPageToFront,
   connectToChromeTarget,
   enableDomains,
@@ -1994,14 +1995,7 @@ async function launchChrome(options = {}) {
   }
 
   const userDataDir = getChromeUserDataDir(port);
-  const args = [
-    `--remote-debugging-port=${port}`,
-    `--user-data-dir=${userDataDir}`,
-    "--no-first-run",
-    "--no-default-browser-check",
-    "--new-window",
-    bossUrl
-  ];
+  const args = buildBossChromeLaunchArgs({ port, userDataDir, url: bossUrl });
   const child = spawn(chromePath, args, {
     detached: true,
     stdio: "ignore",

package/src/core/browser/index.js

@@ -7,6 +7,12 @@ import CDP from "chrome-remote-interface";
 export const DEFAULT_CHROME_HOST = "127.0.0.1";
 export const DEFAULT_CHROME_PORT = 9222;
 export const BOSS_LOGIN_URL = "https://www.zhipin.com/web/user/?ka=bticket";
+export const LID_CLOSED_SAFE_CHROME_ARGS = [
+  "--disable-backgrounding-occluded-windows",
+  "--disable-background-timer-throttling",
+  "--disable-renderer-backgrounding",
+  "--disable-features=CalculateNativeWinOcclusion"
+];
 
 export const ALLOWED_CDP_DOMAINS = new Set([
   "Accessibility",
@@ -208,6 +214,33 @@ export function getBossChromeUserDataDir(port = DEFAULT_CHROME_PORT) {
   return sharedPath;
 }
 
+function parseExtraChromeArgs(value = "") {
+  return String(value || "")
+    .split(/\s+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function buildBossChromeLaunchArgs({
+  port = DEFAULT_CHROME_PORT,
+  userDataDir = "",
+  url = "about:blank",
+  extraArgs = []
+} = {}) {
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    ...LID_CLOSED_SAFE_CHROME_ARGS,
+    ...parseExtraChromeArgs(process.env.BOSS_MCP_EXTRA_CHROME_ARGS),
+    ...extraArgs,
+    "--new-window",
+    url
+  ];
+  return Array.from(new Set(args.filter(Boolean)));
+}
+
 export async function waitForChromeDebugPort({
   host = DEFAULT_CHROME_HOST,
   port = DEFAULT_CHROME_PORT,
@@ -250,14 +283,7 @@ export async function launchChromeDebugInstance({
     throw new Error("Chrome executable not found. Set BOSS_MCP_CHROME_PATH or BOSS_RECOMMEND_CHROME_PATH.");
   }
   const userDataDir = getBossChromeUserDataDir(port);
-  const args = [
-    `--remote-debugging-port=${port}`,
-    `--user-data-dir=${userDataDir}`,
-    "--no-first-run",
-    "--no-default-browser-check",
-    "--new-window",
-    url
-  ];
+  const args = buildBossChromeLaunchArgs({ port, userDataDir, url });
   const child = spawn(chromePath, args, {
     detached: true,
     stdio: "ignore",
@@ -277,6 +303,7 @@ export async function launchChromeDebugInstance({
     launched: true,
     chrome_path: chromePath,
     user_data_dir: userDataDir,
+    launch_args: args,
     port,
     url,
     readiness: {

package/src/core/capture/index.js

@@ -6,6 +6,7 @@ import {
   getAttributesMap,
   getNodeBox,
   getOuterHTML,
+  querySelectorAll,
   sleep
 } from "../browser/index.js";
 import {
@@ -158,6 +159,185 @@ function screenshotHash(buffer) {
   return crypto.createHash("sha256").update(buffer).digest("hex");
 }
 
+function createCaptureTimeoutError(label, timeoutMs) {
+  const error = new Error(`Image fallback capture timed out during ${label} after ${timeoutMs}ms`);
+  error.code = "IMAGE_CAPTURE_TIMEOUT";
+  error.capture_step = label;
+  error.timeout_ms = timeoutMs;
+  return error;
+}
+
+async function withCaptureTimeout(promise, {
+  label = "capture_step",
+  timeoutMs = 0
+} = {}) {
+  const safeTimeout = Math.max(0, Number(timeoutMs) || 0);
+  if (!safeTimeout) return promise;
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(createCaptureTimeoutError(label, safeTimeout)), safeTimeout);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function assertCaptureTotalBudget(started, totalTimeoutMs, label) {
+  const safeTimeout = Math.max(0, Number(totalTimeoutMs) || 0);
+  if (!safeTimeout) return;
+  const elapsed = Date.now() - started;
+  if (elapsed <= safeTimeout) return;
+  const error = createCaptureTimeoutError(label, safeTimeout);
+  error.elapsed_ms = elapsed;
+  error.code = "IMAGE_CAPTURE_TOTAL_TIMEOUT";
+  throw error;
+}
+
+const DEFAULT_SCROLL_ANCHOR_SELECTOR = [
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "p",
+  "li",
+  "section",
+  "article",
+  "table",
+  "tr",
+  "dl",
+  "dt",
+  "dd",
+  "[class*='resume']",
+  "[class*='work']",
+  "[class*='project']",
+  "[class*='education']",
+  "[class*='experience']",
+  "[class*='item']",
+  "div"
+].join(",");
+
+function normalizeScrollMethod(value = "dom-anchor-fallback-input") {
+  const normalized = normalizeText(value).toLowerCase();
+  if (["dom", "dom-anchor", "dom_anchor", "anchor"].includes(normalized)) return "dom-anchor";
+  if (["dom-anchor-fallback-input", "dom_anchor_fallback_input", "dom-fallback-input"].includes(normalized)) {
+    return "dom-anchor-fallback-input";
+  }
+  return "input";
+}
+
+function uniqueNumbers(values = []) {
+  return Array.from(new Set(values.map((value) => Number(value) || 0).filter(Boolean)));
+}
+
+function pickEvenly(items = [], limit = 1) {
+  const safeLimit = Math.max(1, Number(limit) || 1);
+  if (items.length <= safeLimit) return items;
+  const picked = [];
+  const last = items.length - 1;
+  for (let index = 0; index < safeLimit; index += 1) {
+    const sourceIndex = Math.round((index * last) / Math.max(1, safeLimit - 1));
+    picked.push(items[sourceIndex]);
+  }
+  return Array.from(new Map(picked.map((item) => [item.node_id, item])).values());
+}
+
+async function collectDomScrollAnchors(client, rootNodeId, {
+  selector = DEFAULT_SCROLL_ANCHOR_SELECTOR,
+  maxScreenshots = 6,
+  maxProbeNodes = 260,
+  minAnchorGap = 180,
+  stepTimeoutMs = 45000
+} = {}) {
+  const started = Date.now();
+  let nodeIds = [];
+  try {
+    nodeIds = uniqueNumbers(await querySelectorAll(client, rootNodeId, selector));
+  } catch (error) {
+    return {
+      ok: false,
+      method: "dom-anchor",
+      reason: "query_selector_all_failed",
+      error: error?.message || String(error)
+    };
+  }
+  if (!nodeIds.length) {
+    return {
+      ok: false,
+      method: "dom-anchor",
+      reason: "no_anchor_nodes"
+    };
+  }
+
+  const probeLimit = Math.max(1, Number(maxProbeNodes) || 260);
+  const perNodeTimeoutMs = Math.min(1200, Math.max(250, Math.floor((Number(stepTimeoutMs) || 45000) / 30)));
+  const measured = [];
+  for (const nodeId of nodeIds.slice(0, probeLimit)) {
+    try {
+      const box = await withCaptureTimeout(getNodeBox(client, nodeId), {
+        label: `anchor_box_${nodeId}`,
+        timeoutMs: perNodeTimeoutMs
+      });
+      const rect = box?.rect || {};
+      if ((Number(rect.width) || 0) < 80 || (Number(rect.height) || 0) < 8) continue;
+      measured.push({
+        node_id: nodeId,
+        y: Math.round(Number(rect.y) || 0),
+        height: Math.round(Number(rect.height) || 0)
+      });
+    } catch {}
+  }
+
+  let anchors = [];
+  if (measured.length) {
+    const sorted = measured.sort((a, b) => a.y - b.y);
+    for (const item of sorted) {
+      const last = anchors[anchors.length - 1];
+      if (!last || Math.abs(item.y - last.y) >= Math.max(40, Number(minAnchorGap) || 180)) {
+        anchors.push(item);
+      }
+    }
+  }
+
+  if (anchors.length < 2) {
+    anchors = nodeIds.slice(0, probeLimit).map((nodeId, index) => ({
+      node_id: nodeId,
+      y: null,
+      height: null,
+      document_order: index
+    }));
+  }
+
+  anchors = pickEvenly(anchors, Math.max(1, Number(maxScreenshots) || 1));
+  return {
+    ok: anchors.length > 0,
+    method: "dom-anchor",
+    elapsed_ms: Date.now() - started,
+    selector,
+    discovered_node_count: nodeIds.length,
+    measured_node_count: measured.length,
+    anchor_count: anchors.length,
+    anchors
+  };
+}
+
+async function scrollDomAnchorIntoView(client, nodeId, {
+  timeoutMs = 10000,
+  label = "dom_scroll_anchor"
+} = {}) {
+  if (client.DOM && typeof client.DOM.scrollIntoViewIfNeeded === "function") {
+    return withCaptureTimeout(client.DOM.scrollIntoViewIfNeeded({ nodeId }), { label, timeoutMs });
+  }
+  if (typeof client.send === "function") {
+    return withCaptureTimeout(client.send("DOM.scrollIntoViewIfNeeded", { nodeId }), { label, timeoutMs });
+  }
+  throw new Error("CDP client does not expose DOM.scrollIntoViewIfNeeded");
+}
+
 async function optimizeScreenshotBuffer(buffer, {
   enabled = false,
   format = "png",
@@ -339,20 +519,83 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   llmPagesPerImage = 3,
   llmResizeMaxWidth = 1100,
   llmQuality = 72,
+  stepTimeoutMs = 45000,
+  totalTimeoutMs = 90000,
+  scrollMethod = "dom-anchor-fallback-input",
+  scrollAnchorSelector = DEFAULT_SCROLL_ANCHOR_SELECTOR,
+  scrollAnchorMaxProbeNodes = 260,
+  scrollAnchorMinGap = 180,
   metadata = {}
 } = {}) {
   if (!nodeId) throw new Error("captureScrolledNodeScreenshots requires nodeId");
   const sequenceStarted = Date.now();
+  const normalizedScrollMethod = normalizeScrollMethod(scrollMethod);
+  const maxScreenshotCount = Math.max(1, Number(maxScreenshots) || 1);
+  const anchorPlan = normalizedScrollMethod !== "input"
+    ? await collectDomScrollAnchors(client, nodeId, {
+        selector: scrollAnchorSelector,
+        maxScreenshots: maxScreenshotCount,
+        maxProbeNodes: scrollAnchorMaxProbeNodes,
+        minAnchorGap: scrollAnchorMinGap,
+        stepTimeoutMs
+      })
+    : null;
   const screenshots = [];
   let consecutiveDuplicates = 0;
   let previousHash = "";
   let captureCount = 0;
   let droppedDuplicateCount = 0;
+  let currentScrollMetadata = {
+    before_capture: "initial",
+    method: normalizedScrollMethod,
+    anchor_plan: anchorPlan
+      ? {
+          ok: Boolean(anchorPlan.ok),
+          reason: anchorPlan.reason || null,
+          discovered_node_count: anchorPlan.discovered_node_count || 0,
+          measured_node_count: anchorPlan.measured_node_count || 0,
+          anchor_count: anchorPlan.anchor_count || 0,
+          elapsed_ms: anchorPlan.elapsed_ms || 0
+        }
+      : null
+  };
 
-  for (let index = 0; index < Math.max(1, Number(maxScreenshots) || 1); index += 1) {
+  if (anchorPlan?.anchors?.[0]?.node_id && normalizedScrollMethod !== "input") {
+    try {
+      await scrollDomAnchorIntoView(client, anchorPlan.anchors[0].node_id, {
+        label: "scroll_dom_anchor_initial",
+        timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
+      });
+      currentScrollMetadata = {
+        before_capture: "dom_anchor_initial",
+        method: "DOM.scrollIntoViewIfNeeded",
+        anchor_node_id: anchorPlan.anchors[0].node_id,
+        anchor_y: anchorPlan.anchors[0].y,
+        anchor_height: anchorPlan.anchors[0].height,
+        anchor_plan: currentScrollMetadata.anchor_plan
+      };
+    } catch (error) {
+      if (normalizedScrollMethod === "dom-anchor") {
+        throw error;
+      }
+      currentScrollMetadata = {
+        before_capture: "dom_anchor_initial_failed",
+        method: "DOM.scrollIntoViewIfNeeded",
+        anchor_node_id: anchorPlan.anchors[0].node_id,
+        error: error?.message || String(error),
+        anchor_plan: currentScrollMetadata.anchor_plan
+      };
+    }
+  }
+
+  for (let index = 0; index < maxScreenshotCount; index += 1) {
+    assertCaptureTotalBudget(sequenceStarted, totalTimeoutMs, `capture_page_${index + 1}`);
     captureCount += 1;
     const captureStarted = Date.now();
-    const box = await getNodeBox(client, nodeId);
+    const box = await withCaptureTimeout(getNodeBox(client, nodeId), {
+      label: `get_box_${index + 1}`,
+      timeoutMs: stepTimeoutMs
+    });
     const clip = withPadding(box.rect, padding);
     const captureOptions = captureViewport ? {
       format,
@@ -367,13 +610,19 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     if (quality != null) {
       captureOptions.quality = quality;
     }
-    const screenshot = await client.Page.captureScreenshot(captureOptions);
+    const screenshot = await withCaptureTimeout(client.Page.captureScreenshot(captureOptions), {
+      label: `capture_screenshot_${index + 1}`,
+      timeoutMs: stepTimeoutMs
+    });
     const originalBuffer = Buffer.from(screenshot.data || "", "base64");
-    const optimized = await optimizeScreenshotBuffer(originalBuffer, {
+    const optimized = await withCaptureTimeout(optimizeScreenshotBuffer(originalBuffer, {
       enabled: optimize,
       format,
       quality,
       resizeMaxWidth
+    }), {
+      label: `optimize_screenshot_${index + 1}`,
+      timeoutMs: stepTimeoutMs
     });
     const buffer = optimized.buffer;
     const hash = screenshotHash(buffer);
@@ -412,9 +661,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
         clip,
         capture_viewport: Boolean(captureViewport),
         node_rect: box.rect,
-        scroll: index === 0
-          ? { before_capture: "initial" }
-          : { before_capture: `wheel_down_${index}` },
+        scroll: currentScrollMetadata,
         metadata
       });
     }
@@ -424,27 +671,75 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       break;
     }
 
-    if (index < Math.max(1, Number(maxScreenshots) || 1) - 1) {
-      const x = box.center.x;
-      const y = box.center.y;
-      await client.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" });
-      await client.Input.dispatchMouseEvent({
-        type: "mouseWheel",
-        x,
-        y,
-        deltaX: 0,
-        deltaY: Math.max(1, Number(wheelDeltaY) || 650)
-      });
+    if (index < maxScreenshotCount - 1) {
+      assertCaptureTotalBudget(sequenceStarted, totalTimeoutMs, `scroll_after_page_${index + 1}`);
+      let scrolledByDomAnchor = false;
+      const nextAnchor = anchorPlan?.anchors?.[index + 1] || null;
+      if (nextAnchor?.node_id && normalizedScrollMethod !== "input") {
+        try {
+          await scrollDomAnchorIntoView(client, nextAnchor.node_id, {
+            label: `scroll_dom_anchor_${index + 1}`,
+            timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
+          });
+          scrolledByDomAnchor = true;
+          currentScrollMetadata = {
+            before_capture: `dom_anchor_${index + 1}`,
+            method: "DOM.scrollIntoViewIfNeeded",
+            anchor_node_id: nextAnchor.node_id,
+            anchor_y: nextAnchor.y,
+            anchor_height: nextAnchor.height
+          };
+        } catch (error) {
+          if (normalizedScrollMethod === "dom-anchor") {
+            throw error;
+          }
+          currentScrollMetadata = {
+            before_capture: `dom_anchor_${index + 1}_failed`,
+            method: "DOM.scrollIntoViewIfNeeded",
+            anchor_node_id: nextAnchor.node_id,
+            error: error?.message || String(error)
+          };
+        }
+      } else if (normalizedScrollMethod === "dom-anchor") {
+        break;
+      }
+
+      if (!scrolledByDomAnchor && normalizedScrollMethod !== "dom-anchor") {
+        const x = box.center.x;
+        const y = box.center.y;
+        await withCaptureTimeout(client.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }), {
+          label: `scroll_mouse_move_${index + 1}`,
+          timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
+        });
+        await withCaptureTimeout(client.Input.dispatchMouseEvent({
+          type: "mouseWheel",
+          x,
+          y,
+          deltaX: 0,
+          deltaY: Math.max(1, Number(wheelDeltaY) || 650)
+        }), {
+          label: `scroll_wheel_${index + 1}`,
+          timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
+        });
+        currentScrollMetadata = {
+          before_capture: `wheel_down_${index + 1}`,
+          method: "Input.dispatchMouseEvent",
+          fallback_from_dom_anchor: Boolean(anchorPlan && normalizedScrollMethod === "dom-anchor-fallback-input")
+        };
+      }
       if (settleMs > 0) await sleep(settleMs);
     }
   }
 
   const llmComposition = composeForLlm
-    ? await composeScreenshotsForLlm(screenshots, {
+    ? await withCaptureTimeout(composeScreenshotsForLlm(screenshots, {
         basePath: filePath,
         pagesPerImage: llmPagesPerImage,
         resizeMaxWidth: llmResizeMaxWidth,
         quality: llmQuality
+      }), {
+        label: "compose_llm_screenshots",
+        timeoutMs: stepTimeoutMs
       })
     : {
         llm_file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
@@ -456,6 +751,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
 
   return {
     schema_version: 1,
+    ok: true,
     source: "image-scroll-sequence",
     captured_at: nowIso(),
     node_id: nodeId,
@@ -482,8 +778,15 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       llm_compose_enabled: Boolean(composeForLlm),
       llm_pages_per_image: Math.max(1, Math.min(5, Number(llmPagesPerImage) || 3)),
       llm_resize_max_width: Math.max(0, Number(llmResizeMaxWidth) || 0),
-      llm_quality: llmQuality ?? null
+      llm_quality: llmQuality ?? null,
+      step_timeout_ms: Math.max(0, Number(stepTimeoutMs) || 0),
+      total_timeout_ms: Math.max(0, Number(totalTimeoutMs) || 0),
+      scroll_method: normalizedScrollMethod,
+      scroll_anchor_selector: scrollAnchorSelector,
+      scroll_anchor_max_probe_nodes: Math.max(1, Number(scrollAnchorMaxProbeNodes) || 260),
+      scroll_anchor_min_gap: Math.max(0, Number(scrollAnchorMinGap) || 0)
     },
+    scroll_anchor_plan: anchorPlan,
     file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,
     metadata

package/src/core/cv-acquisition/index.js

@@ -124,6 +124,7 @@ export function hasParsedNetworkProfile(detailResult = {}) {
 export function summarizeImageEvidence(imageEvidence = null) {
   if (!imageEvidence) return null;
   return {
+    ok: imageEvidence.ok !== false,
     source: imageEvidence.source || "",
     elapsed_ms: imageEvidence.elapsed_ms || 0,
     capture_count: imageEvidence.capture_count || imageEvidence.screenshot_count || 0,
@@ -137,6 +138,8 @@ export function summarizeImageEvidence(imageEvidence = null) {
     llm_original_total_byte_length: imageEvidence.llm_original_total_byte_length || 0,
     llm_composition_error: imageEvidence.llm_composition_error || null,
     optimization: imageEvidence.optimization || null,
+    error_code: imageEvidence.error_code || imageEvidence.code || null,
+    error: imageEvidence.error || null,
     file_paths: imageEvidence.file_paths || [],
     llm_file_paths: imageEvidence.llm_file_paths || [],
     first_clip: imageEvidence.screenshots?.[0]?.clip || imageEvidence.clip || null

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

@@ -306,6 +306,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");
@@ -838,6 +841,9 @@ export async function runChatWorkflow({
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
+                scrollMethod: "dom-anchor-fallback-input",
+                stepTimeoutMs: 45000,
+                totalTimeoutMs: 90000,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
             composeForLlm: true,
@@ -1174,6 +1180,8 @@ export function createChatRunService({
         detail_limit: normalizedDetailLimit,
         detail_source: normalizedDetailSource,
         close_resume: closeResume,
+        request_resume_for_passed: Boolean(requestResumeForPassed),
+        dry_run_request_cv: Boolean(dryRunRequestCv),
         cv_acquisition_mode: cvAcquisitionMode,
         call_llm_on_image: Boolean(callLlmOnImage),
         screening_mode: normalizedScreeningMode,

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

@@ -361,6 +361,18 @@ function compactRefreshAttempt(refreshAttempt) {
   };
 }
 
+function countPassedResults(results = []) {
+  return results.filter((item) => item?.screening?.passed).length;
+}
+
+function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
+  if (!error) return null;
+  return {
+    code: error.code || fallbackCode,
+    message: error.message || String(error)
+  };
+}
+
 export async function runRecommendWorkflow({
   client,
   targetUrl = "",
@@ -407,9 +419,9 @@ export async function runRecommendWorkflow({
   const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
   const useLlmScreening = normalizedScreeningMode !== "deterministic";
   const postActionEnabled = normalizedPostAction !== "none";
-  const limit = Math.max(1, Number(maxCandidates) || 1);
-  const detailCountLimit = detailLimit == null ? limit : Math.max(0, Number(detailLimit) || 0);
-  const effectiveDetailLimit = postActionEnabled ? limit : detailCountLimit;
+  const targetPassCount = Math.max(1, Number(maxCandidates) || 1);
+  const detailCountLimit = detailLimit == null ? Number.POSITIVE_INFINITY : Math.max(0, Number(detailLimit) || 0);
+  const effectiveDetailLimit = postActionEnabled ? Number.POSITIVE_INFINITY : detailCountLimit;
   const networkRecorder = effectiveDetailLimit > 0
     ? createRecommendDetailNetworkRecorder(client)
     : null;
@@ -522,7 +534,8 @@ export async function runRecommendWorkflow({
 
   runControl.updateProgress({
     card_count: cardNodeIds.length,
-    target_count: limit,
+    target_count: targetPassCount,
+    target_count_semantics: "passed_candidates",
     processed: 0,
     screened: 0,
     detail_opened: 0,
@@ -539,7 +552,7 @@ export async function runRecommendWorkflow({
     viewport_recoveries: viewportGuard.getStats().recoveries
   });
 
-  while (results.length < limit) {
+  while (countPassedResults(results) < targetPassCount) {
     const candidateStarted = Date.now();
     const timings = {};
     await runControl.waitIfPaused();
@@ -587,7 +600,7 @@ export async function runRecommendWorkflow({
       if (
           (nextCandidateResult.end_reached || isRefreshableListStall(nextCandidateResult.reason))
           && refreshOnEnd
-          && results.length < limit
+          && countPassedResults(results) < targetPassCount
           && refreshRounds < Math.max(0, Number(maxRefreshRounds) || 0)
       ) {
         await runControl.waitIfPaused();
@@ -613,7 +626,8 @@ export async function runRecommendWorkflow({
         });
         runControl.updateProgress({
           card_count: refreshResult.card_count || cardNodeIds.length,
-          target_count: limit,
+          target_count: targetPassCount,
+          target_count_semantics: "passed_candidates",
           processed: results.length,
           screened: results.length,
           detail_opened: results.filter((item) => item.detail).length,
@@ -734,6 +748,9 @@ export async function runRecommendWorkflow({
             maxScreenshots: maxImagePages,
             wheelDeltaY: imageWheelDeltaY,
             settleMs: 350,
+            scrollMethod: "dom-anchor-fallback-input",
+            stepTimeoutMs: 45000,
+            totalTimeoutMs: 90000,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
             composeForLlm: true,
@@ -859,7 +876,8 @@ export async function runRecommendWorkflow({
 
     runControl.updateProgress({
       card_count: cardNodeIds.length,
-      target_count: limit,
+      target_count: targetPassCount,
+      target_count_semantics: "passed_candidates",
       processed: results.length,
       screened: results.length,
       detail_opened: results.filter((item) => item.detail).length,
@@ -989,7 +1007,7 @@ export function createRecommendRunService({
     const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
     const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
     const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
-    const normalizedDetailLimit = detailLimit == null ? candidateLimit : Math.max(0, Number(detailLimit) || 0);
+    const normalizedDetailLimit = detailLimit == null ? null : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
       name,
       context: {
@@ -1001,6 +1019,7 @@ export function createRecommendRunService({
         fallback_page_scope: normalizedFallbackPageScope,
         filter: normalizedFilter,
         max_candidates: maxCandidates,
+        max_candidates_semantics: "passed_candidates",
         detail_limit: normalizedDetailLimit,
         close_detail: closeDetail,
         cv_acquisition_mode: cvAcquisitionMode,
@@ -1029,6 +1048,7 @@ export function createRecommendRunService({
       progress: {
         card_count: 0,
         target_count: candidateLimit,
+        target_count_semantics: "passed_candidates",
         processed: 0,
         screened: 0,
         detail_opened: 0,

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

@@ -450,6 +450,9 @@ export async function runRecruitWorkflow({
             maxScreenshots: maxImagePages,
             wheelDeltaY: imageWheelDeltaY,
             settleMs: 350,
+            scrollMethod: "dom-anchor-fallback-input",
+            stepTimeoutMs: 45000,
+            totalTimeoutMs: 90000,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
             composeForLlm: true,