@reconcrap/boss-recommend-mcp 2.0.30 → 2.0.32

package/src/core/screening/index.js

@@ -58,6 +58,74 @@ function buildChatCompletionsUrl(baseUrl) {
   return `${normalized}/chat/completions`;
 }
 
+function redactBaseUrl(baseUrl) {
+  const normalized = normalizeBaseUrl(baseUrl);
+  return normalized ? normalized.replace(/\/\/[^/]+/, "//[redacted-host]") : "";
+}
+
+function firstConfiguredValue(...values) {
+  for (const value of values) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === "string" && !value.trim()) continue;
+    return value;
+  }
+  return "";
+}
+
+function normalizeLlmProviderEntry(rawEntry, inherited = {}, index = 0) {
+  const entry = typeof rawEntry === "string"
+    ? { model: rawEntry }
+    : (rawEntry && typeof rawEntry === "object" && !Array.isArray(rawEntry) ? rawEntry : {});
+  const providerName = firstConfiguredValue(
+    entry.name,
+    entry.label,
+    entry.id,
+    entry.providerName,
+    entry.provider,
+    ""
+  );
+  const next = {
+    ...inherited,
+    ...entry,
+    baseUrl: firstConfiguredValue(entry.baseUrl, entry.base_url, inherited.baseUrl, inherited.base_url),
+    apiKey: firstConfiguredValue(entry.apiKey, entry.api_key, inherited.apiKey, inherited.api_key),
+    model: firstConfiguredValue(entry.model, entry.modelName, entry.model_name, typeof rawEntry === "string" ? rawEntry : "", inherited.model),
+    openaiOrganization: firstConfiguredValue(entry.openaiOrganization, entry.organization, inherited.openaiOrganization, inherited.organization),
+    openaiProject: firstConfiguredValue(entry.openaiProject, entry.project, inherited.openaiProject, inherited.project),
+    topP: firstConfiguredValue(entry.topP, entry.top_p, inherited.topP, inherited.top_p),
+    llmProviderName: normalizeText(providerName),
+    llmProviderIndex: index
+  };
+  delete next.llmModels;
+  delete next.models;
+  return next;
+}
+
+function normalizeLlmProviderConfigs(config = {}) {
+  if (Array.isArray(config)) {
+    return config.map((entry, index) => normalizeLlmProviderEntry(entry, {}, index));
+  }
+  const inherited = config && typeof config === "object" && !Array.isArray(config) ? { ...config } : {};
+  const rawProviders = Array.isArray(inherited.llmModels) && inherited.llmModels.length > 0
+    ? inherited.llmModels
+    : (Array.isArray(inherited.models) && inherited.models.length > 0 ? inherited.models : [inherited]);
+  delete inherited.llmModels;
+  delete inherited.models;
+  return rawProviders.map((entry, index) => normalizeLlmProviderEntry(entry, inherited, index));
+}
+
+function compactLlmProviderFailure(error, providerConfig = {}, providerIndex = 0) {
+  return {
+    index: providerIndex + 1,
+    name: normalizeText(providerConfig.llmProviderName || providerConfig.name || providerConfig.label || providerConfig.id) || null,
+    baseUrl: redactBaseUrl(providerConfig.baseUrl),
+    model: normalizeText(providerConfig.model) || null,
+    status: Number.isFinite(Number(error?.status)) ? Number(error.status) : null,
+    attempts: Number(error?.llm_attempt_count) || 0,
+    message: String(error?.message || error || "").slice(0, 500)
+  };
+}
+
 function isVolcengineModel(baseUrl, model) {
   return /volces|volcengine|ark\.cn|doubao|seed/i.test(`${baseUrl || ""} ${model || ""}`);
 }
@@ -1325,6 +1393,8 @@ export function compactScreeningLlmResult(llmResult) {
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
     attempt_count: llmResult.attempt_count || 0,
+    fallback_count: llmResult.fallback_count || 0,
+    llm_model_failures: Array.isArray(llmResult.llm_model_failures) ? llmResult.llm_model_failures : [],
     error: llmResult.error || null,
     screened_at: llmResult.screened_at || null
   };
@@ -1358,6 +1428,8 @@ export function createFailedLlmScreeningResult(error) {
     image_input_count: Number(error?.image_input_count) || 0,
     image_inputs: Array.isArray(error?.image_inputs) ? error.image_inputs : [],
     attempt_count: Number(error?.llm_attempt_count) || 0,
+    fallback_count: Array.isArray(error?.llm_model_failures) ? error.llm_model_failures.length : 0,
+    llm_model_failures: Array.isArray(error?.llm_model_failures) ? error.llm_model_failures : [],
     error: error?.message || String(error || "unknown"),
     screened_at: nowIso()
   };
@@ -1435,7 +1507,7 @@ function sleepMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
 }
 
-export async function callScreeningLlm({
+async function callScreeningLlmWithProvider({
   candidate,
   criteria,
   config = {},
@@ -1488,81 +1560,89 @@ export async function callScreeningLlm({
     thinkingLevel
   });
 
+  const effectiveTimeoutMs = parsePositiveNumber(config.llmTimeoutMs ?? config.timeoutMs, timeoutMs) || timeoutMs;
   const maxRetries = normalizeLlmMaxRetries(config.llmMaxRetries ?? config.maxRetries);
   const maxAttempts = maxRetries + 1;
   let lastError = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const timer = setTimeout(() => controller.abort(), effectiveTimeoutMs);
     try {
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    if (config.openaiOrganization) headers["OpenAI-Organization"] = config.openaiOrganization;
-    if (config.openaiProject) headers["OpenAI-Project"] = config.openaiProject;
-
-    const response = await fetch(buildChatCompletionsUrl(baseUrl), {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-      signal: controller.signal
-    });
-    const responseText = await response.text();
-    if (!response.ok) {
-      const error = new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
-      error.status = response.status;
-      throw error;
-    }
-    const json = tryParseJson(responseText);
-    if (!json) {
-      throw new Error("LLM response was not valid JSON");
-    }
-    const choice = json?.choices?.[0] || {};
-    const content = flattenChatMessageContent(choice?.message?.content);
-    const reasoningContent = collectLlmReasoningText(choice);
-    const parsed = tryExtractJsonObject(content) || tryExtractJsonObject(reasoningContent);
-    const passed = parsePassedDecision(parsed?.passed);
-    if (passed === null) {
-      throw new Error(`LLM response missing boolean passed decision: ${content.slice(0, 240)}`);
-    }
-    const evidence = Array.isArray(parsed?.evidence)
-      ? parsed.evidence.map(normalizeText).filter(Boolean)
-      : [];
-    const decisionCot = firstUsefulLine([
-      parsed?.cot,
-      parsed?.decision_cot,
-      parsed?.reasoning,
-      parsed?.chain_of_thought,
-      reasoningContent
-    ].map(normalizeBlockText).filter(Boolean)) || reasoningContent;
-    return {
-      ok: true,
-      provider: {
-        baseUrl: baseUrl.replace(/\/\/[^/]+/, "//[redacted-host]"),
-        model,
-        thinking_level: normalizeLlmThinkingLevel(thinkingLevel) || "low",
-        thinking: payload.thinking || null,
-        reasoning_effort: payload.reasoning_effort || null,
-        max_tokens: payload.max_tokens,
-        max_completion_tokens: payload.max_completion_tokens || null
-      },
-      passed,
-      reason: "",
-      evidence,
-      cot: decisionCot,
-      decision_cot: decisionCot,
-      reasoning_content: reasoningContent,
-      raw_model_output: content,
-      usage: json.usage || null,
-      finish_reason: choice.finish_reason || null,
-      raw_content_length: content.length,
-      image_input_count: imageInputs.length,
-      image_inputs: summarizeLlmImageInputs(imageInputs),
-      attempt_count: attempt,
-      screened_at: nowIso()
-    };
-  } catch (error) {
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      };
+      if (config.openaiOrganization) headers["OpenAI-Organization"] = config.openaiOrganization;
+      if (config.openaiProject) headers["OpenAI-Project"] = config.openaiProject;
+
+      const response = await fetch(buildChatCompletionsUrl(baseUrl), {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      const responseText = await response.text();
+      if (!response.ok) {
+        const error = new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
+        error.status = response.status;
+        throw error;
+      }
+      const json = tryParseJson(responseText);
+      if (!json) {
+        throw new Error("LLM response was not valid JSON");
+      }
+      const choice = json?.choices?.[0] || {};
+      const content = flattenChatMessageContent(choice?.message?.content);
+      const reasoningContent = collectLlmReasoningText(choice);
+      const parsed = tryExtractJsonObject(content) || tryExtractJsonObject(reasoningContent);
+      const passed = parsePassedDecision(parsed?.passed);
+      if (passed === null) {
+        throw new Error(`LLM response missing boolean passed decision: ${content.slice(0, 240)}`);
+      }
+      const evidence = Array.isArray(parsed?.evidence)
+        ? parsed.evidence.map(normalizeText).filter(Boolean)
+        : [];
+      const decisionCot = firstUsefulLine([
+        parsed?.cot,
+        parsed?.decision_cot,
+        parsed?.reasoning,
+        parsed?.chain_of_thought,
+        reasoningContent
+      ].map(normalizeBlockText).filter(Boolean)) || reasoningContent;
+      const providerName = normalizeText(config.llmProviderName || config.name || config.label || config.id);
+      const providerIndex = Number.isFinite(Number(config.llmProviderIndex)) ? Number(config.llmProviderIndex) : 0;
+      const providerCount = Number.isFinite(Number(config.llmProviderCount)) ? Number(config.llmProviderCount) : 1;
+      return {
+        ok: true,
+        provider: {
+          baseUrl: redactBaseUrl(baseUrl),
+          model,
+          name: providerName || null,
+          index: providerIndex + 1,
+          total: providerCount,
+          thinking_level: normalizeLlmThinkingLevel(thinkingLevel) || "low",
+          thinking: payload.thinking || null,
+          reasoning_effort: payload.reasoning_effort || null,
+          max_tokens: payload.max_tokens,
+          max_completion_tokens: payload.max_completion_tokens || null
+        },
+        passed,
+        reason: "",
+        evidence,
+        cot: decisionCot,
+        decision_cot: decisionCot,
+        reasoning_content: reasoningContent,
+        raw_model_output: content,
+        usage: json.usage || null,
+        finish_reason: choice.finish_reason || null,
+        raw_content_length: content.length,
+        image_input_count: imageInputs.length,
+        image_inputs: summarizeLlmImageInputs(imageInputs),
+        attempt_count: attempt,
+        provider_attempt_count: attempt,
+        screened_at: nowIso()
+      };
+    } catch (error) {
       lastError = error;
       if (attempt >= maxAttempts || !isRetryableLlmRequestError(error)) {
         error.image_input_count = imageInputs.length;
@@ -1571,9 +1651,9 @@ export async function callScreeningLlm({
         throw error;
       }
       await sleepMs(Math.min(2500, 500 * attempt));
-  } finally {
-    clearTimeout(timer);
-  }
+    } finally {
+      clearTimeout(timer);
+    }
   }
   lastError = lastError || new Error("LLM request failed without response");
   lastError.image_input_count = imageInputs.length;
@@ -1581,3 +1661,58 @@ export async function callScreeningLlm({
   lastError.llm_attempt_count = maxAttempts;
   throw lastError;
 }
+
+export async function callScreeningLlm(args = {}) {
+  const providers = normalizeLlmProviderConfigs(args.config || {});
+  if (providers.length <= 1) {
+    return callScreeningLlmWithProvider({
+      ...args,
+      config: {
+        ...(providers[0] || args.config || {}),
+        llmProviderCount: 1
+      }
+    });
+  }
+
+  const providerFailures = [];
+  let lastError = null;
+  for (let index = 0; index < providers.length; index += 1) {
+    const providerConfig = {
+      ...providers[index],
+      llmProviderIndex: index,
+      llmProviderCount: providers.length
+    };
+    try {
+      const previousAttempts = providerFailures.reduce((sum, item) => sum + (Number(item.attempts) || 0), 0);
+      const result = await callScreeningLlmWithProvider({
+        ...args,
+        config: providerConfig
+      });
+      const providerAttempts = Number(result.provider_attempt_count ?? result.attempt_count) || 0;
+      return {
+        ...result,
+        attempt_count: previousAttempts + providerAttempts,
+        llm_model_failures: providerFailures,
+        fallback_count: providerFailures.length
+      };
+    } catch (error) {
+      lastError = error;
+      providerFailures.push(compactLlmProviderFailure(error, providerConfig, index));
+      if (index < providers.length - 1) {
+        await sleepMs(Math.min(1500, 250 * (index + 1)));
+      }
+    }
+  }
+
+  const totalAttempts = providerFailures.reduce((sum, item) => sum + (Number(item.attempts) || 0), 0);
+  const finalError = new Error(
+    `All configured LLM models failed (${providers.length}); last error: ${lastError?.message || "unknown error"}`
+  );
+  finalError.cause = lastError || null;
+  finalError.llm_provider_failures = providerFailures;
+  finalError.llm_model_failures = providerFailures;
+  finalError.llm_attempt_count = totalAttempts;
+  finalError.image_input_count = lastError?.image_input_count || 0;
+  finalError.image_inputs = lastError?.image_inputs || [];
+  throw finalError;
+}

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

@@ -1,4 +1,5 @@
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
+import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
 import {
   clickPoint,
   getNodeBox,
@@ -9,6 +10,7 @@ import {
   compactCvAcquisitionState,
   countParsedNetworkProfiles,
   createCvAcquisitionState,
+  DEFAULT_MAX_IMAGE_PAGES,
   getCvNetworkWaitPlan,
   recordCvImageFallback,
   recordCvNetworkHit,
@@ -109,6 +111,8 @@ function compactLlmResult(llmResult) {
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
     attempt_count: llmResult.attempt_count || 0,
+    fallback_count: llmResult.fallback_count || 0,
+    llm_model_failures: Array.isArray(llmResult.llm_model_failures) ? llmResult.llm_model_failures : [],
     error: llmResult.error || null
   };
 }
@@ -203,9 +207,9 @@ function llmToScreening(llmResult, candidate) {
 }
 
 export function captureNodeIdFromResumeState(resumeState) {
-  return resumeState?.popup?.node_id
-    || resumeState?.content?.node_id
+  return resumeState?.content?.node_id
     || resumeState?.resumeIframe?.node_id
+    || resumeState?.popup?.node_id
     || null;
 }
 
@@ -287,6 +291,9 @@ function createFailedLlmResult(error) {
     decision_cot: "",
     reasoning_content: "",
     raw_model_output: "",
+    attempt_count: Number(error?.llm_attempt_count) || 0,
+    fallback_count: Array.isArray(error?.llm_model_failures) ? error.llm_model_failures.length : 0,
+    llm_model_failures: Array.isArray(error?.llm_model_failures) ? error.llm_model_failures : [],
     error: error?.message || String(error || "unknown"),
     screened_at: new Date().toISOString()
   };
@@ -636,7 +643,7 @@ export async function runChatWorkflow({
   readyTimeoutMs = 60000,
   onlineResumeButtonTimeoutMs = 30000,
   resumeDomTimeoutMs = 60000,
-  maxImagePages = 8,
+  maxImagePages = DEFAULT_MAX_IMAGE_PAGES,
   imageWheelDeltaY = 650,
   cvAcquisitionMode = "unknown",
   callLlmOnImage = false,
@@ -1226,11 +1233,19 @@ export async function runChatWorkflow({
           let source = normalizedDetailSource === "dom" ? "dom" : "network";
           let imageEvidence = null;
           let llmResult = null;
-          const captureNodeId = captureNodeIdFromResumeState(resumeState);
+          let captureTarget = null;
+          let captureTargetWait = null;
           let fullCvEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
           const shouldCaptureImage = normalizedDetailSource === "image"
             || (normalizedDetailSource === "cascade" && !fullCvEvidence.full_cv_acquired);
           if (shouldCaptureImage) {
+            captureTargetWait = await waitForCvCaptureTarget(client, resumeState, {
+              domain: "chat",
+              timeoutMs: 6000,
+              intervalMs: 250
+            });
+            captureTarget = captureTargetWait.target || null;
+            const captureNodeId = captureTarget?.node_id || null;
             if (captureNodeId) {
               detailStep = "capture_image_fallback";
               imageEvidence = await measureTiming(timings, "screenshot_capture_ms", () => captureScrolledNodeScreenshots(client, captureNodeId, {
@@ -1272,7 +1287,9 @@ export async function runChatWorkflow({
                     ? "forced_image"
                     : "network_miss_image_fallback",
                   run_candidate_index: index,
-                  candidate_key: candidateKey
+                  candidate_key: candidateKey,
+                  capture_target: captureTarget,
+                  capture_target_wait: captureTargetWait
                 }
               }));
               source = "image";
@@ -1416,6 +1433,8 @@ export async function runChatWorkflow({
             },
             parsed_network_profile_count: parsedNetworkProfileCount,
             image_evidence: summarizeImageEvidence(imageEvidence),
+            capture_target: captureTarget || null,
+            capture_target_wait: captureTargetWait,
             full_cv_evidence: fullCvEvidence
           };
         }
@@ -1600,7 +1619,7 @@ export function createChatRunService({
     readyTimeoutMs = 60000,
     onlineResumeButtonTimeoutMs = 30000,
     resumeDomTimeoutMs = 60000,
-    maxImagePages = 8,
+    maxImagePages = DEFAULT_MAX_IMAGE_PAGES,
     imageWheelDeltaY = 650,
     cvAcquisitionMode = "unknown",
     callLlmOnImage = false,
@@ -1638,6 +1657,7 @@ export function createChatRunService({
         close_resume: closeResume,
         request_resume_for_passed: Boolean(requestResumeForPassed),
         dry_run_request_cv: Boolean(dryRunRequestCv),
+        greeting_text: greetingText,
         cv_acquisition_mode: cvAcquisitionMode,
         call_llm_on_image: Boolean(callLlmOnImage),
         screening_mode: normalizedScreeningMode,

package/src/domains/recommend/detail.js

@@ -20,8 +20,7 @@ import {
   DETAIL_RESUME_IFRAME_SELECTORS
 } from "./constants.js";
 import {
-  getRecommendRoots,
-  queryFirstAcrossRoots
+  getRecommendRoots
 } from "./roots.js";
 import {
   findRecommendCardNodeIds,
@@ -133,8 +132,8 @@ export async function waitForRecommendDetail(client, {
   let lastState = null;
   while (Date.now() - started <= timeoutMs) {
     const rootState = await getRecommendRoots(client);
-    const popup = await queryFirstAcrossRoots(client, rootState.roots, DETAIL_POPUP_SELECTORS);
-    const resumeIframe = await queryFirstAcrossRoots(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
+    const popup = await findVisibleDetailTarget(client, rootState.roots, DETAIL_POPUP_SELECTORS);
+    const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, DETAIL_RESUME_IFRAME_SELECTORS);
     lastState = {
       iframe: rootState.iframe,
       roots: rootState.roots,
@@ -147,6 +146,31 @@ export async function waitForRecommendDetail(client, {
   return lastState;
 }
 
+async function findVisibleDetailTarget(client, roots, selectors) {
+  for (const root of roots) {
+    if (!root?.nodeId) continue;
+    for (const selector of selectors) {
+      const nodeIds = await querySelectorAll(client, root.nodeId, selector);
+      for (const nodeId of nodeIds) {
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box.rect.width > 2 && box.rect.height > 2) {
+            return {
+              root: root.name,
+              root_node_id: root.nodeId,
+              selector,
+              node_id: nodeId,
+              center: box.center,
+              rect: box.rect
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+  return null;
+}
+
 export async function readRecommendDetailHtml(client, detailState) {
   let popupHTML = "";
   let resumeHTML = "";

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

@@ -7,12 +7,14 @@ import {
   measureTiming
 } from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
+import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
 import { sleep } from "../../core/browser/index.js";
 import { GREET_CREDITS_EXHAUSTED_CODE } from "../../core/greet-quota/index.js";
 import {
   compactCvAcquisitionState,
   countParsedNetworkProfiles,
   createCvAcquisitionState,
+  DEFAULT_MAX_IMAGE_PAGES,
   getCvNetworkWaitPlan,
   recordCvImageFallback,
   recordCvNetworkHit,
@@ -404,7 +406,7 @@ export function createRecoverableImageCaptureEvidence(error, {
   elapsedMs = 0,
   filePath = "",
   extension = "jpg",
-  maxScreenshots = 8
+  maxScreenshots = DEFAULT_MAX_IMAGE_PAGES
 } = {}) {
   const filePaths = collectPartialImageEvidencePaths(filePath, extension, maxScreenshots);
   return {
@@ -474,7 +476,7 @@ export async function runRecommendWorkflow({
   closeDetail = true,
   delayMs = 0,
   cardTimeoutMs = 10000,
-  maxImagePages = 8,
+  maxImagePages = DEFAULT_MAX_IMAGE_PAGES,
   imageWheelDeltaY = 650,
   cvAcquisitionMode = "unknown",
   listMaxScrolls = 20,
@@ -820,15 +822,21 @@ export async function runRecommendWorkflow({
         const parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
         let source = "network";
         let imageEvidence = null;
+        let captureTarget = null;
+        let captureTargetWait = null;
         if (parsedNetworkProfileCount > 0) {
           recordCvNetworkHit(cvAcquisitionState, {
             parsedNetworkProfileCount,
             waitResult: networkWait
           });
         } else {
-          const captureNodeId = openedDetail.detail_state?.popup?.node_id
-            || openedDetail.detail_state?.resumeIframe?.node_id
-            || null;
+          captureTargetWait = await waitForCvCaptureTarget(client, openedDetail.detail_state, {
+            domain: "recommend",
+            timeoutMs: 6000,
+            intervalMs: 250
+          });
+          captureTarget = captureTargetWait.target || null;
+          const captureNodeId = captureTarget?.node_id || null;
           if (captureNodeId) {
             const imageEvidencePath = imageEvidenceFilePath({
               imageOutputDir,
@@ -844,8 +852,8 @@ export async function runRecommendWorkflow({
                 quality: 72,
                 optimize: true,
                 resizeMaxWidth: 1100,
-                captureViewport: true,
-                padding: 4,
+                captureViewport: false,
+                padding: 0,
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
@@ -863,7 +871,9 @@ export async function runRecommendWorkflow({
                   capture_mode: "scroll_sequence",
                   acquisition_reason: "network_miss_image_fallback",
                   run_candidate_index: index,
-                  candidate_key: candidateKey
+                  candidate_key: candidateKey,
+                  capture_target: captureTarget,
+                  capture_target_wait: captureTargetWait
                 }
               }));
               source = "image";
@@ -902,7 +912,9 @@ export async function runRecommendWorkflow({
           wait_plan: waitPlan,
           network_wait: networkWait,
           parsed_network_profile_count: parsedNetworkProfileCount,
-          image_evidence: summarizeImageEvidence(imageEvidence)
+          image_evidence: summarizeImageEvidence(imageEvidence),
+          capture_target: captureTarget || null,
+          capture_target_wait: captureTargetWait
         };
         screeningCandidate = detailResult.candidate;
       } catch (error) {
@@ -1120,7 +1132,7 @@ export function createRecommendRunService({
     closeDetail = true,
     delayMs = 0,
     cardTimeoutMs = 10000,
-    maxImagePages = 8,
+    maxImagePages = DEFAULT_MAX_IMAGE_PAGES,
     imageWheelDeltaY = 650,
     cvAcquisitionMode = "unknown",
     listMaxScrolls = 20,

package/src/domains/recruit/detail.js

@@ -19,8 +19,7 @@ import {
   RECRUIT_DETAIL_RESUME_IFRAME_SELECTORS
 } from "./constants.js";
 import {
-  getRecruitRoots,
-  queryFirstAcrossRoots
+  getRecruitRoots
 } from "./roots.js";
 
 export function matchesRecruitDetailNetwork(url) {
@@ -128,8 +127,8 @@ export async function waitForRecruitDetail(client, {
   let lastState = null;
   while (Date.now() - started <= timeoutMs) {
     const rootState = await getRecruitRoots(client);
-    const popup = await queryFirstAcrossRoots(client, rootState.roots, RECRUIT_DETAIL_POPUP_SELECTORS);
-    const resumeIframe = await queryFirstAcrossRoots(client, rootState.roots, RECRUIT_DETAIL_RESUME_IFRAME_SELECTORS);
+    const popup = await findVisibleDetailTarget(client, rootState.roots, RECRUIT_DETAIL_POPUP_SELECTORS);
+    const resumeIframe = await findVisibleDetailTarget(client, rootState.roots, RECRUIT_DETAIL_RESUME_IFRAME_SELECTORS);
     lastState = {
       iframe: rootState.iframe,
       roots: rootState.roots,
@@ -142,6 +141,31 @@ export async function waitForRecruitDetail(client, {
   return lastState;
 }
 
+async function findVisibleDetailTarget(client, roots, selectors) {
+  for (const root of roots) {
+    if (!root?.nodeId) continue;
+    for (const selector of selectors) {
+      const nodeIds = await querySelectorAll(client, root.nodeId, selector);
+      for (const nodeId of nodeIds) {
+        try {
+          const box = await getNodeBox(client, nodeId);
+          if (box.rect.width > 2 && box.rect.height > 2) {
+            return {
+              root: root.name,
+              root_node_id: root.nodeId,
+              selector,
+              node_id: nodeId,
+              center: box.center,
+              rect: box.rect
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+  return null;
+}
+
 export async function readRecruitDetailHtml(client, detailState) {
   let popupHTML = "";
   let resumeHTML = "";