@reconcrap/boss-recommend-mcp 2.1.13 → 2.1.15

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

@@ -1,4 +1,7 @@
-import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
+import {
+  captureScrolledNodeScreenshots,
+  captureViewportScreenshot
+} from "../../core/capture/index.js";
 import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
 import {
   clickPoint,
@@ -32,7 +35,10 @@ import {
   resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
-import { createRunLifecycleManager } from "../../core/run/index.js";
+import {
+  createRunLifecycleManager,
+  RunCanceledError
+} from "../../core/run/index.js";
 import {
   addTiming,
   imageEvidenceFilePath,
@@ -40,6 +46,8 @@ import {
 } from "../../core/run/timing.js";
 import {
   callScreeningLlm,
+  createFatalLlmRunError,
+  isFatalLlmProviderError,
   normalizeText,
   screenCandidate
 } from "../../core/screening/index.js";
@@ -59,12 +67,14 @@ import {
   closeChatBlockingPanels,
   closeChatResumeModal,
   createChatProfileNetworkRecorder,
-  extractChatProfileCandidate,
-  isUnsafeChatOnlineResumeLinkError,
-  openChatOnlineResume,
-  quickChatResumeModalOpenProbe,
-  readChatConversationReadyState,
-  requestChatResumeForPassedCandidate,
+  extractChatProfileCandidate,
+  isChatOnlineResumeModalOpenFailureError,
+  isUnsafeChatOnlineResumeLinkError,
+  openChatOnlineResume,
+  quickChatResumeModalOpenProbe,
+  readChatActiveCandidateState,
+  readChatConversationReadyState,
+  requestChatResumeForPassedCandidate,
   selectChatMessageFilter,
   selectChatPrimaryLabel,
   waitForChatOnlineResumeButton,
@@ -108,19 +118,31 @@ function compactLlmResult(llmResult) {
     ok: Boolean(llmResult.ok),
     provider: llmResult.provider || null,
     passed: llmResult.passed,
+    review_required: typeof llmResult.review_required === "boolean" ? llmResult.review_required : null,
     cot: llmResult.cot || llmResult.decision_cot || "",
-    reasoning_content: llmResult.reasoning_content || "",
-    raw_model_output: llmResult.raw_model_output || "",
-    evidence_count: llmResult.evidence?.length || 0,
-    usage: llmResult.usage || null,
+    reasoning_content: llmResult.reasoning_content || "",
+    raw_model_output: llmResult.raw_model_output || "",
+    evidence_count: llmResult.evidence?.length || 0,
+    usage: llmResult.usage || null,
     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
-  };
-}
+    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 : [],
+    screening_strategy: llmResult.screening_strategy || "",
+    fast_thinking_level: llmResult.fast_thinking_level || "",
+    verify_thinking_level: llmResult.verify_thinking_level || "",
+    verified: typeof llmResult.verified === "boolean" ? llmResult.verified : null,
+    verification_reason: llmResult.verification_reason || "",
+    decision_source: llmResult.decision_source || "",
+    fast_result: llmResult.fast_result || null,
+    verify_result: llmResult.verify_result || null,
+    error_code: llmResult.error_code || null,
+    fatal: Boolean(llmResult.fatal),
+    fatal_reason: llmResult.fatal_reason || "",
+    error: llmResult.error || null
+  };
+}
 
 function compactCandidate(candidate) {
   return {
@@ -339,9 +361,9 @@ function isRecoverableLlmScreeningError(error) {
 }
 
 function createFailedLlmResult(error) {
-  return {
-    ok: false,
-    passed: false,
+  return {
+    ok: false,
+    passed: false,
     reason: "",
     evidence: [],
     cot: "",
@@ -349,19 +371,110 @@ function createFailedLlmResult(error) {
     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()
-  };
-}
-
-function normalizeScreeningMode(value) {
-  const normalized = String(value || "llm").trim().toLowerCase();
-  return ["deterministic", "local", "local_scorer"].includes(normalized)
-    ? "deterministic"
-    : "llm";
-}
+    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_code: error?.code || null,
+    fatal: Boolean(isFatalLlmProviderError(error)),
+    fatal_reason: error?.llm_fatal_reason || "",
+    error: error?.message || String(error || "unknown"),
+    screened_at: new Date().toISOString()
+  };
+}
+
+function normalizeScreeningMode(value) {
+  const normalized = String(value || "llm").trim().toLowerCase();
+  if (["collect_cv", "collect-cv", "cv_collection", "request_cv", "request_resume"].includes(normalized)) {
+    return "collect_cv";
+  }
+  return ["deterministic", "local", "local_scorer"].includes(normalized)
+    ? "deterministic"
+    : "llm";
+}
+
+function isCvAcquiredOrAvailable(detailResult = null, preActionState = null) {
+  return Boolean(
+    preActionState?.attachment_resume_enabled
+    || detailResult?.cv_acquisition?.full_cv_evidence?.full_cv_acquired
+  );
+}
+
+function isChatResumeRequestAvailable(preActionState = null) {
+  return Boolean(preActionState?.ask_resume?.node_id && !preActionState.ask_resume.disabled);
+}
+
+function shouldSkipCvCollectionForDetailReason(reason = "") {
+  const normalized = normalizeText(reason);
+  return [
+    "active_candidate_mismatch",
+    "forbidden_top_level_resume_navigation",
+    "online_resume_modal_did_not_open",
+    "unsafe_online_resume_navigation_link"
+  ].includes(normalized)
+    || normalized.startsWith("recoverable_cdp_node_stale:")
+    || normalized.startsWith("resume_modal_close_failed:");
+}
+
+export function createCvCollectionScreening(screeningCandidate, {
+  detailResult = null,
+  detailUnavailableReason = "",
+  preActionState = null
+} = {}) {
+  if (preActionState?.already_requested_resume) {
+    return {
+      status: "skip",
+      passed: false,
+      score: 0,
+      reasons: ["resume_request_already_pending"],
+      candidate: screeningCandidate
+    };
+  }
+  if (isCvAcquiredOrAvailable(detailResult, preActionState)) {
+    const reason = preActionState?.attachment_resume_enabled
+      ? "attachment_resume_already_available"
+      : "online_cv_already_available";
+    return {
+      status: "skip",
+      passed: false,
+      score: 0,
+      reasons: [reason],
+      candidate: screeningCandidate
+    };
+  }
+  if (isChatResumeRequestAvailable(preActionState)) {
+    const reason = detailUnavailableReason || "request_cv_available";
+    return {
+      status: "pass",
+      passed: true,
+      score: 100,
+      reasons: [`collect_cv:${reason}`],
+      candidate: screeningCandidate
+    };
+  }
+  if (shouldSkipCvCollectionForDetailReason(detailUnavailableReason)) {
+    return {
+      status: "skip",
+      passed: false,
+      score: 0,
+      reasons: [detailUnavailableReason],
+      candidate: screeningCandidate
+    };
+  }
+  const reason = detailUnavailableReason || "cv_collection_missing_online_cv";
+  return {
+    status: "pass",
+    passed: true,
+    score: 100,
+    reasons: [`collect_cv:${reason}`],
+    candidate: screeningCandidate
+  };
+}
+
+export function shouldOpenOnlineResumeForChatDetail({
+  collectCvOnly = false,
+  detailResult = null
+} = {}) {
+  return !collectCvOnly && !detailResult;
+}
 
 function createMissingLlmConfigResult() {
   return createFailedLlmResult(new Error("LLM screening config is required for production chat runs"));
@@ -383,17 +496,81 @@ function createSkippedDetailResult(cardCandidate, reason, error = null) {
   };
 }
 
-function compactChatRuntimeError(error) {
-  if (!error) return null;
-  return {
-    name: error.name || "Error",
-    code: error.code || null,
-    message: error.message || String(error),
-    close_result: error.close_result || null,
-    selection_ready_state: error.selection_ready_state || null,
-    page_state: error.page_state || null
-  };
-}
+function compactChatRuntimeError(error) {
+  if (!error) return null;
+  return {
+    name: error.name || "Error",
+    code: error.code || null,
+    message: error.message || String(error),
+    retryable: typeof error.retryable === "boolean" ? error.retryable : null,
+    attempts: Array.isArray(error.attempts) ? error.attempts : null,
+    close_result: error.close_result || null,
+    selection_ready_state: error.selection_ready_state || null,
+    page_state: error.page_state || null
+  };
+}
+
+async function captureChatFinalFailureArtifact(client, {
+  runControl,
+  imageOutputDir = "",
+  error = null
+} = {}) {
+  if (!client || !imageOutputDir || !runControl?.runId) return null;
+  const artifact = {
+    schema_version: 1,
+    kind: "chat_final_failure_page",
+    captured_at: new Date().toISOString(),
+    run_id: runControl.runId,
+    error: compactChatRuntimeError(error),
+    page_state: null,
+    active_candidate_state: null,
+    conversation_ready_state: null,
+    screenshot: null,
+    screenshot_error: null
+  };
+  try {
+    artifact.page_state = await getChatTopLevelState(client);
+  } catch (pageError) {
+    artifact.page_state = {
+      error: pageError?.message || String(pageError)
+    };
+  }
+  try {
+    artifact.active_candidate_state = await readChatActiveCandidateState(client);
+  } catch (activeCandidateError) {
+    artifact.active_candidate_state = {
+      error: activeCandidateError?.message || String(activeCandidateError)
+    };
+  }
+  try {
+    artifact.conversation_ready_state = await readChatConversationReadyState(client);
+  } catch (conversationError) {
+    artifact.conversation_ready_state = {
+      error: conversationError?.message || String(conversationError)
+    };
+  }
+  try {
+    artifact.screenshot = await captureViewportScreenshot(client, {
+      filePath: imageEvidenceFilePath({
+        imageOutputDir,
+        domain: "chat-final-failure",
+        runId: runControl.runId,
+        index: 0,
+        extension: "jpg"
+      }),
+      format: "jpeg",
+      quality: 72,
+      metadata: {
+        domain: "chat",
+        run_id: runControl.runId,
+        reason: "final_failure"
+      }
+    });
+  } catch (screenshotError) {
+    artifact.screenshot_error = screenshotError?.message || String(screenshotError);
+  }
+  return artifact;
+}
 
 const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
 const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
@@ -561,14 +738,15 @@ async function resolveFreshChatCardNodeId(client, {
   return freshNodeId || fallbackNodeId;
 }
 
-async function selectFreshChatCandidate(client, {
-  cardNodeId,
-  candidate,
-  timeoutMs,
-  settleMs = 1200
-} = {}) {
-  let lastError = null;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
+async function selectFreshChatCandidate(client, {
+  cardNodeId,
+  candidate,
+  timeoutMs,
+  settleMs = 1200,
+  onlineResumeProbe = true
+} = {}) {
+  let lastError = null;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
     const modalGuard = await ensureNoOpenChatResumeModalBeforeCandidateClick(client);
     const rootState = await getChatRoots(client);
     const freshNodeId = await resolveFreshChatCardNodeId(client, {
@@ -579,16 +757,18 @@ async function selectFreshChatCandidate(client, {
     try {
       await scrollNodeIntoView(client, freshNodeId);
       await sleep(250);
-      const box = await getNodeBox(client, freshNodeId);
-      await clickPoint(client, box.center.x, box.center.y);
-      if (settleMs > 0) await sleep(settleMs);
-      const ready = await waitForChatOnlineResumeButton(client, {
-        timeoutMs,
-        expectedCandidateId: candidate?.id || ""
-      });
-      return {
-        card_box: box,
-        ready,
+      const box = await getNodeBox(client, freshNodeId);
+      await clickPoint(client, box.center.x, box.center.y);
+      if (settleMs > 0) await sleep(settleMs);
+      const ready = onlineResumeProbe
+        ? await waitForChatOnlineResumeButton(client, {
+            timeoutMs,
+            expectedCandidateId: candidate?.id || ""
+          })
+        : await readSelectedChatCandidateState(client, candidate);
+      return {
+        card_box: box,
+        ready,
         card_node_id: freshNodeId,
         refreshed_node: freshNodeId !== cardNodeId,
         modal_guard: modalGuard,
@@ -600,8 +780,35 @@ async function selectFreshChatCandidate(client, {
       await sleep(350);
     }
   }
-  throw lastError || new Error("Chat candidate selection failed");
-}
+  throw lastError || new Error("Chat candidate selection failed");
+}
+
+async function readSelectedChatCandidateState(client, candidate = null) {
+  const topLevelState = await getChatTopLevelState(client);
+  if (topLevelState.is_forbidden_resume_top_level) {
+    return {
+      forbidden_top_level_navigation: true,
+      top_level_state: topLevelState
+    };
+  }
+  const activeState = await readChatActiveCandidateState(client);
+  const expectedId = normalizeText(candidate?.id || "");
+  const activeCandidateId = normalizeText(activeState?.active_candidate?.candidate_id || "");
+  const candidateSelectionVerified = expectedId
+    ? activeCandidateId === expectedId
+    : undefined;
+  return {
+    ok: !expectedId || candidateSelectionVerified === true,
+    reason: expectedId && candidateSelectionVerified !== true
+      ? "active_candidate_mismatch"
+      : "online_resume_probe_skipped",
+    roots: activeState.roots,
+    activeCandidate: activeState.active_candidate,
+    expected_candidate_id: expectedId || null,
+    active_candidate_id: activeCandidateId || null,
+    candidate_selection_verified: candidateSelectionVerified
+  };
+}
 
 function selectedDetailNetworkEvents(detailSource, selectionEvents, resumeEvents) {
   if (detailSource !== "network" && detailSource !== "cascade") return [];
@@ -743,15 +950,16 @@ export async function runChatWorkflow({
     safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
     actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
   });
-  const humanRestController = createHumanRestController({
-    enabled: effectiveHumanRestEnabled,
-    shortRestEnabled: effectiveHumanBehavior.shortRest,
-    batchRestEnabled: effectiveHumanBehavior.batchRest,
-    restLevel: effectiveHumanBehavior.restLevel
-  });
-  const normalizedDetailSource = normalizeDetailSource(detailSource);
-  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
-  const useLlmScreening = normalizedScreeningMode !== "deterministic";
+  const humanRestController = createHumanRestController({
+    enabled: effectiveHumanRestEnabled,
+    shortRestEnabled: effectiveHumanBehavior.shortRest,
+    batchRestEnabled: effectiveHumanBehavior.batchRest,
+    restLevel: effectiveHumanBehavior.restLevel
+  });
+  const normalizedDetailSource = normalizeDetailSource(detailSource);
+  const normalizedScreeningMode = normalizeText(criteria) ? normalizeScreeningMode(screeningMode) : "collect_cv";
+  const collectCvOnly = normalizedScreeningMode === "collect_cv" || !normalizeText(criteria);
+  const useLlmScreening = normalizedScreeningMode === "llm" && !collectCvOnly;
   const processedLimit = Math.max(1, Number(maxCandidates) || 1);
   const passTarget = Number.isFinite(Number(targetPassCount)) && Number(targetPassCount) > 0
     ? Number(targetPassCount)
@@ -1197,11 +1405,12 @@ export async function runChatWorkflow({
         detailStep = "select_candidate";
         networkRecorder.clear();
         await maybeHumanActionCooldown("before_detail_open", timings);
-        const selected = await measureTiming(timings, "candidate_click_ms", () => selectFreshChatCandidate(client, {
-          cardNodeId,
-          candidate: cardCandidate,
-          timeoutMs: onlineResumeButtonTimeoutMs
-        }));
+        const selected = await measureTiming(timings, "candidate_click_ms", () => selectFreshChatCandidate(client, {
+          cardNodeId,
+          candidate: cardCandidate,
+          timeoutMs: onlineResumeButtonTimeoutMs,
+          onlineResumeProbe: !collectCvOnly
+        }));
         if (selected.ready?.forbidden_top_level_navigation) {
           throw makeForbiddenChatResumeNavigationError(selected.ready.top_level_state);
         }
@@ -1221,11 +1430,11 @@ export async function runChatWorkflow({
           detailResult.cv_acquisition.pre_detail_state = preActionState;
           detailResult.cv_acquisition.selection_ready_state = selected.ready;
         }
-        if (!selected.ready?.ok) {
-          if (detailResult) {
-            // Already classified by the pre-detail conversation state.
-          } else if (selected.ready?.reason === "active_candidate_mismatch") {
-            throw makeChatCandidateSelectionMismatchError(selected, cardCandidate);
+        if (!selected.ready?.ok) {
+          if (detailResult) {
+            // Already classified by the pre-detail conversation state.
+          } else if (selected.ready?.reason === "active_candidate_mismatch") {
+            throw makeChatCandidateSelectionMismatchError(selected, cardCandidate);
           } else {
             detailStep = "read_conversation_ready_state";
             if (preActionState.attachment_resume_enabled) {
@@ -1235,13 +1444,18 @@ export async function runChatWorkflow({
             } else {
               detailUnavailableReason = "online_resume_button_unavailable";
               detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason);
-              detailResult.cv_acquisition.pre_detail_state = preActionState;
-            }
-          }
-        }
-
-        if (!detailResult) {
-          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
+              detailResult.cv_acquisition.pre_detail_state = preActionState;
+            }
+          }
+        }
+        if (collectCvOnly && !detailResult) {
+          detailUnavailableReason = preActionState?.has_online_resume
+            ? "collect_cv_request_candidate"
+            : "collect_cv_missing_online_resume";
+        }
+
+        if (shouldOpenOnlineResumeForChatDetail({ collectCvOnly, detailResult })) {
+          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
           let networkWait = null;
           let contentWait = {
             ok: false,
@@ -1510,9 +1724,15 @@ export async function runChatWorkflow({
                       maxImages: llmImageLimit,
                       imageDetail: llmImageDetail
                     }));
-                  } catch (error) {
-                    llmResult = createFailedLlmResult(error);
-                  }
+                  } catch (error) {
+                    if (isFatalLlmProviderError(error)) {
+                      throw createFatalLlmRunError(error, {
+                        domain: "chat",
+                        candidate: detailResult.candidate
+                      });
+                    }
+                    llmResult = createFailedLlmResult(error);
+                  }
                 }
               }
             } else {
@@ -1583,9 +1803,15 @@ export async function runChatWorkflow({
                     maxImages: llmImageLimit,
                     imageDetail: llmImageDetail
                   }));
-                } catch (error) {
-                  llmResult = createFailedLlmResult(error);
-                }
+                } catch (error) {
+                  if (isFatalLlmProviderError(error)) {
+                    throw createFatalLlmRunError(error, {
+                      domain: "chat",
+                      candidate: detailResult.candidate
+                    });
+                  }
+                  llmResult = createFailedLlmResult(error);
+                }
               }
             }
           }
@@ -1659,11 +1885,11 @@ export async function runChatWorkflow({
             recovery
           });
           continue;
-        } else if (isChatCandidateSelectionMismatchError(error)) {
-          const retryCount = candidateRecoveryCounts.get(candidateKey) || 0;
-          if (retryCount < 1) {
-            candidateRecoveryCounts.set(candidateKey, retryCount + 1);
-            const recovery = await recoverAndReapplyChatContext(
+        } else if (isChatCandidateSelectionMismatchError(error)) {
+          const retryCount = candidateRecoveryCounts.get(candidateKey) || 0;
+          if (retryCount < 1) {
+            candidateRecoveryCounts.set(candidateKey, retryCount + 1);
+            const recovery = await recoverAndReapplyChatContext(
               "active_candidate_mismatch",
               error,
               { forceRefresh: true }
@@ -1675,15 +1901,35 @@ export async function runChatWorkflow({
             continue;
           }
           detailUnavailableReason = "active_candidate_mismatch";
-          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
-          detailResult.cv_acquisition.selection_ready_state = error.selection_ready_state || null;
-          detailResult.cv_acquisition.recovery_attempted = true;
-          detailResult.cv_acquisition.recovery_attempt_count = retryCount;
-        } else if (isUnsafeChatOnlineResumeLinkError(error)) {
-          detailUnavailableReason = "unsafe_online_resume_navigation_link";
-          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
-          detailResult.cv_acquisition.blocked_pre_click = true;
-          detailResult.cv_acquisition.button_href = error.href || null;
+          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
+          detailResult.cv_acquisition.selection_ready_state = error.selection_ready_state || null;
+          detailResult.cv_acquisition.recovery_attempted = true;
+          detailResult.cv_acquisition.recovery_attempt_count = retryCount;
+        } else if (isChatOnlineResumeModalOpenFailureError(error)) {
+          const retryCount = candidateRecoveryCounts.get(candidateKey) || 0;
+          if (retryCount < 1) {
+            candidateRecoveryCounts.set(candidateKey, retryCount + 1);
+            const recovery = await recoverAndReapplyChatContext(
+              "online_resume_modal_did_not_open",
+              error,
+              { forceRefresh: true }
+            );
+            checkpointInProgressCandidate({
+              event: "retry_after_online_resume_modal_open_failure",
+              recovery
+            });
+            continue;
+          }
+          detailUnavailableReason = "online_resume_modal_did_not_open";
+          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
+          detailResult.cv_acquisition.attempts = error.attempts || null;
+          detailResult.cv_acquisition.recovery_attempted = true;
+          detailResult.cv_acquisition.recovery_attempt_count = retryCount;
+        } else if (isUnsafeChatOnlineResumeLinkError(error)) {
+          detailUnavailableReason = "unsafe_online_resume_navigation_link";
+          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
+          detailResult.cv_acquisition.blocked_pre_click = true;
+          detailResult.cv_acquisition.button_href = error.href || null;
           detailResult.cv_acquisition.button_selector = error.button_selector || null;
           detailResult.cv_acquisition.attempts = error.attempts || null;
         } else {
@@ -1694,37 +1940,43 @@ export async function runChatWorkflow({
           await closeChatBlockingPanels(client, { attemptsLimit: 2 });
         }
       }
-      screeningCandidate = detailResult.candidate;
-    }
+      screeningCandidate = detailResult?.candidate || cardCandidate;
+    }
 
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("chat:screening");
     let cardOnlyLlmResult = null;
-    if (useLlmScreening && !detailUnavailableReason && !detailResult?.llm_result) {
-      detailUnavailableReason = detailResult
-        ? "full_cv_not_acquired"
-        : "detail_not_opened_full_cv_required";
-    }
-    const effectiveLlmResult = detailResult?.llm_result || cardOnlyLlmResult;
-    const screening = detailUnavailableReason
-      ? {
-          status: "skip",
-          passed: false,
-          score: 0,
-          reasons: [detailUnavailableReason],
-          candidate: screeningCandidate
-        }
-      : useLlmScreening
-        ? llmToScreening(effectiveLlmResult, screeningCandidate)
-        : screenCandidate(screeningCandidate, { criteria });
+    if (useLlmScreening && !detailUnavailableReason && !detailResult?.llm_result) {
+      detailUnavailableReason = detailResult
+        ? "full_cv_not_acquired"
+        : "detail_not_opened_full_cv_required";
+    }
+    const effectiveLlmResult = detailResult?.llm_result || cardOnlyLlmResult;
+    const screening = collectCvOnly
+      ? createCvCollectionScreening(screeningCandidate, {
+          detailResult,
+          detailUnavailableReason,
+          preActionState
+        })
+      : detailUnavailableReason
+        ? {
+            status: "skip",
+            passed: false,
+            score: 0,
+            reasons: [detailUnavailableReason],
+            candidate: screeningCandidate
+          }
+        : useLlmScreening
+          ? llmToScreening(effectiveLlmResult, screeningCandidate)
+          : screenCandidate(screeningCandidate, { criteria });
     let postAction = null;
     if (requestResumeForPassed && screening.passed) {
       await maybeHumanActionCooldown("before_post_action", timings);
-      postAction = await measureTiming(timings, "post_action_ms", () => requestChatResumeForPassedCandidate(client, {
-        greetingText,
-        dryRun: dryRunRequestCv
-      }));
+      postAction = await measureTiming(timings, "post_action_ms", () => requestChatResumeForPassedCandidate(client, {
+        greetingText,
+        dryRun: dryRunRequestCv
+      }));
       if (postAction?.requested) requestSatisfiedCount += 1;
       if (postAction?.skipped) requestSkippedCount += 1;
       if (postAction?.requested && !postAction?.skipped) requestedCount += 1;
@@ -1921,8 +2173,8 @@ export function createChatRunService({
     name = "chat-domain-run"
   } = {}) {
     if (!client) throw new Error("startChatRun requires a guarded CDP client");
-    const normalizedDetailSource = normalizeDetailSource(detailSource);
-    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+    const normalizedDetailSource = normalizeDetailSource(detailSource);
+    const normalizedScreeningMode = normalizeText(criteria) ? normalizeScreeningMode(screeningMode) : "collect_cv";
     const processedLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? processedLimit : Math.max(0, Number(detailLimit) || 0);
     const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
@@ -1948,9 +2200,10 @@ export function createChatRunService({
         dry_run_request_cv: Boolean(dryRunRequestCv),
         greeting_text: greetingText,
         cv_acquisition_mode: cvAcquisitionMode,
-        call_llm_on_image: Boolean(callLlmOnImage),
-        screening_mode: normalizedScreeningMode,
-        llm_configured: Boolean(llmConfig),
+        call_llm_on_image: Boolean(callLlmOnImage),
+        screening_mode: normalizedScreeningMode,
+        cv_collection_mode: normalizedScreeningMode === "collect_cv",
+        llm_configured: Boolean(llmConfig),
         llm_timeout_ms: llmTimeoutMs,
         llm_image_limit: llmImageLimit,
         llm_image_detail: llmImageDetail,
@@ -1965,10 +2218,11 @@ export function createChatRunService({
         image_output_dir: imageOutputDir || "",
         human_behavior_enabled: effectiveHumanBehavior.enabled,
         human_behavior_profile: effectiveHumanBehavior.profile,
-        human_behavior: effectiveHumanBehavior,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled
-      },
+        human_behavior: effectiveHumanBehavior,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled,
+        cv_collection_mode: normalizedScreeningMode === "collect_cv"
+      },
       progress: {
         card_count: 0,
         target_count: targetPassCount || (processUntilListEnd ? "all" : processedLimit),
@@ -1992,47 +2246,64 @@ export function createChatRunService({
         human_rest_ms: 0,
         last_human_event: null
       },
-      checkpoint: {},
-      task: (runControl) => workflow({
-        client,
-        targetUrl,
-        job,
-        startFrom,
-        criteria,
-        maxCandidates,
-        targetPassCount,
-        processUntilListEnd,
-        detailLimit: normalizedDetailLimit,
-        detailSource: normalizedDetailSource,
-        closeResume,
-        requestResumeForPassed,
-        dryRunRequestCv,
-        greetingText,
-        delayMs,
-        cardTimeoutMs,
-        readyTimeoutMs,
-        onlineResumeButtonTimeoutMs,
-        resumeDomTimeoutMs,
-        maxImagePages,
-        imageWheelDeltaY,
-        cvAcquisitionMode,
-        callLlmOnImage,
-        llmConfig,
-        llmTimeoutMs,
-        llmImageLimit,
-        llmImageDetail,
-        screeningMode: normalizedScreeningMode,
-        listMaxScrolls,
-        listStableSignatureLimit,
-        listWheelDeltaY,
-        listSettleMs,
-        listFallbackPoint,
-        imageOutputDir,
-        humanRestEnabled: effectiveHumanRestEnabled,
-        humanBehavior: effectiveHumanBehavior
-      }, runControl)
-    });
-  }
+      checkpoint: {},
+      task: async (runControl) => {
+        try {
+          return await workflow({
+            client,
+            targetUrl,
+            job,
+            startFrom,
+            criteria,
+            maxCandidates,
+            targetPassCount,
+            processUntilListEnd,
+            detailLimit: normalizedDetailLimit,
+            detailSource: normalizedDetailSource,
+            closeResume,
+            requestResumeForPassed,
+            dryRunRequestCv,
+            greetingText,
+            delayMs,
+            cardTimeoutMs,
+            readyTimeoutMs,
+            onlineResumeButtonTimeoutMs,
+            resumeDomTimeoutMs,
+            maxImagePages,
+            imageWheelDeltaY,
+            cvAcquisitionMode,
+            callLlmOnImage,
+            llmConfig,
+            llmTimeoutMs,
+            llmImageLimit,
+            llmImageDetail,
+            screeningMode: normalizedScreeningMode,
+            listMaxScrolls,
+            listStableSignatureLimit,
+            listWheelDeltaY,
+            listSettleMs,
+            listFallbackPoint,
+            imageOutputDir,
+            humanRestEnabled: effectiveHumanRestEnabled,
+            humanBehavior: effectiveHumanBehavior
+          }, runControl);
+        } catch (error) {
+          if (error instanceof RunCanceledError) throw error;
+          const finalFailureArtifact = await captureChatFinalFailureArtifact(client, {
+            runControl,
+            imageOutputDir,
+            error
+          });
+          if (finalFailureArtifact) {
+            runControl.checkpoint({
+              final_failure_artifact: finalFailureArtifact
+            });
+          }
+          throw error;
+        }
+      }
+    });
+  }
 
   return {
     startChatRun,