@reconcrap/boss-recommend-mcp 2.0.14 → 2.0.16

package/package.json

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

package/src/domains/chat/detail.js

@@ -39,13 +39,65 @@ import {
 import {
   assertChatShellNotResumeTopLevel,
   getChatTopLevelState,
+  isForbiddenChatResumeTopLevelUrl,
   makeForbiddenChatResumeNavigationError
 } from "./page-guard.js";
 
+export const CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE = "CHAT_UNSAFE_ONLINE_RESUME_LINK";
+
 export function matchesChatProfileNetwork(url) {
   return CHAT_PROFILE_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
+function looksLikeForbiddenChatResumePath(value = "") {
+  const normalized = String(value || "");
+  return isForbiddenChatResumeTopLevelUrl(normalized)
+    || /(?:^|["'\s=])(?:https?:\/\/[^"'\s>]*zhipin\.com)?\/web\/frame\/c-resume(?:[/?#"' >]|$)/i
+      .test(normalized);
+}
+
+function extractFirstHtmlAttribute(html = "", names = []) {
+  const source = String(html || "");
+  for (const name of names) {
+    const escaped = String(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`${escaped}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+    const match = source.match(regex);
+    if (match) return match[1] ?? match[2] ?? match[3] ?? "";
+  }
+  return "";
+}
+
+export function isUnsafeChatOnlineResumeTarget(target = {}, buttonHTML = "") {
+  const attributes = target?.attributes || {};
+  const href = attributes.href
+    || attributes["data-href"]
+    || attributes["data-url"]
+    || attributes.url
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"]);
+  return looksLikeForbiddenChatResumePath(href)
+    || looksLikeForbiddenChatResumePath(buttonHTML);
+}
+
+export function makeUnsafeChatOnlineResumeLinkError(target = {}, buttonHTML = "") {
+  const href = target?.attributes?.href
+    || target?.attributes?.["data-href"]
+    || target?.attributes?.["data-url"]
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"])
+    || null;
+  const error = new Error("CHAT_UNSAFE_ONLINE_RESUME_LINK: refusing to click an online resume link that can navigate the chat tab to /web/frame/c-resume/");
+  error.code = CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE;
+  error.href = href;
+  error.button_selector = target?.selector || null;
+  error.button_text = htmlToText(buttonHTML).slice(0, 120);
+  error.button_html_length = String(buttonHTML || "").length;
+  return error;
+}
+
+export function isUnsafeChatOnlineResumeLinkError(error) {
+  return error?.code === CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE
+    || /CHAT_UNSAFE_ONLINE_RESUME_LINK/i.test(String(error?.message || error || ""));
+}
+
 export function createChatProfileNetworkRecorder(client) {
   const events = [];
   client.Network.responseReceived((event) => {
@@ -673,6 +725,22 @@ export async function openChatOnlineResume(client, {
       buttonHTML = await getOuterHTML(client, buttonState.target.node_id);
     } catch {}
 
+    if (isUnsafeChatOnlineResumeTarget(buttonState.target, buttonHTML)) {
+      const error = makeUnsafeChatOnlineResumeLinkError(buttonState.target, buttonHTML);
+      attempts.push({
+        attempt: index + 1,
+        ok: false,
+        error: error.code,
+        blocked_pre_click: true,
+        button_selector: buttonState.target.selector,
+        button_text: error.button_text,
+        button_href: error.href,
+        button_html_length: buttonHTML.length
+      });
+      error.attempts = attempts;
+      throw error;
+    }
+
     try {
       if (buttonState.target.center) {
         await clickPoint(client, buttonState.target.center.x, buttonState.target.center.y);

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

@@ -49,6 +49,7 @@ import {
   closeChatResumeModal,
   createChatProfileNetworkRecorder,
   extractChatProfileCandidate,
+  isUnsafeChatOnlineResumeLinkError,
   openChatOnlineResume,
   readChatConversationReadyState,
   requestChatResumeForPassedCandidate,
@@ -203,6 +204,132 @@ function createSkippedDetailResult(cardCandidate, reason, error = null) {
   };
 }
 
+const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
+const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
+const CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH = 650;
+const CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT = 3;
+const CHAT_FULL_CV_SECTION_PATTERNS = Object.freeze([
+  /教育(?:经历|背景|经验)?/i,
+  /工作(?:经历|经验)?/i,
+  /项目(?:经历|经验)?/i,
+  /实习(?:经历|经验)?/i,
+  /科研(?:经历|经验)?/i,
+  /论文|会议|专利/i,
+  /个人(?:优势|总结|介绍|评价)/i,
+  /专业技能|技能(?:特长|标签)?/i,
+  /求职(?:期望|意向)/i,
+  /校园经历|在校经历|竞赛|证书/i
+]);
+
+function detailTextForFullCvCheck(detailResult = {}) {
+  return [
+    detailResult?.detail?.popup_text,
+    detailResult?.detail?.content_text,
+    detailResult?.detail?.resume_iframe_text
+  ].filter(Boolean).join("\n\n");
+}
+
+function resumeSectionMatchCount(text = "") {
+  const normalized = normalizeText(text);
+  if (!normalized) return 0;
+  return CHAT_FULL_CV_SECTION_PATTERNS
+    .filter((pattern) => pattern.test(normalized))
+    .length;
+}
+
+function hasResumeLikeDomText(text = "") {
+  const normalized = normalizeText(text);
+  if (normalized.length >= CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH) return true;
+  return normalized.length >= CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH
+    && resumeSectionMatchCount(normalized) >= 2;
+}
+
+function networkProfileTextLength(profileResult = {}) {
+  return normalizeText(profileResult?.profile?.text || "").length;
+}
+
+function isFullCvNetworkProfile(profileResult = {}) {
+  if (!profileResult?.ok) return false;
+  const sourceKeys = profileResult.profile?.source_keys || {};
+  const textLength = networkProfileTextLength(profileResult);
+  const sectionCount = resumeSectionMatchCount(profileResult.profile?.text || "");
+  const richItemCount = [
+    "education_count",
+    "work_count",
+    "project_count",
+    "expectation_count",
+    "certification_count"
+  ].reduce((sum, key) => sum + (Number(sourceKeys[key]) || 0), 0);
+  const hasResumeSections = sectionCount >= 3 || (sectionCount >= 2 && richItemCount >= 2);
+  const hasEnoughNetworkText = textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH;
+
+  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) {
+    return hasEnoughNetworkText && (
+      hasResumeSections
+      || richItemCount >= CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT
+    );
+  }
+  if (sourceKeys.network_html_text) {
+    return textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
+  }
+  if (sourceKeys.chat_history_resume) {
+    const educationCount = Number(sourceKeys.education_count) || 0;
+    const workCount = Number(sourceKeys.work_count) || 0;
+    return (educationCount + workCount) >= 2
+      && textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
+  }
+  return false;
+}
+
+function hasUsableImageEvidence(imageEvidence = null) {
+  if (!imageEvidence || imageEvidence.ok === false) return false;
+  return Boolean(
+    (Array.isArray(imageEvidence.llm_file_paths) && imageEvidence.llm_file_paths.length)
+    || (Array.isArray(imageEvidence.file_paths) && imageEvidence.file_paths.length)
+    || Number(imageEvidence.llm_screenshot_count) > 0
+    || Number(imageEvidence.unique_screenshot_count) > 0
+    || Number(imageEvidence.screenshot_count) > 0
+    || Number(imageEvidence.capture_count) > 0
+  );
+}
+
+export function summarizeChatFullCvEvidence({
+  detailResult = null,
+  contentWait = null,
+  imageEvidence = null
+} = {}) {
+  const parsedProfiles = (detailResult?.parsed_network_profiles || []).filter((item) => item?.ok);
+  const fullNetworkProfiles = parsedProfiles.filter(isFullCvNetworkProfile);
+  const profileOnlyCount = Math.max(0, parsedProfiles.length - fullNetworkProfiles.length);
+  const detailText = detailTextForFullCvCheck(detailResult);
+  const domTextLength = detailText.length;
+  const domSectionCount = resumeSectionMatchCount(detailText);
+  const domFullCv = Boolean(contentWait?.ok) && hasResumeLikeDomText(detailText);
+  const imageFullCv = hasUsableImageEvidence(imageEvidence);
+  const source = fullNetworkProfiles.length
+    ? "network"
+    : domFullCv
+      ? "dom"
+      : imageFullCv
+        ? "image"
+        : null;
+  return {
+    full_cv_acquired: Boolean(source),
+    source,
+    network_full_cv_count: fullNetworkProfiles.length,
+    network_profile_only_count: profileOnlyCount,
+    parsed_network_profile_count: parsedProfiles.length,
+    dom_full_cv: domFullCv,
+    dom_text_length: domTextLength,
+    dom_section_count: domSectionCount,
+    content_wait_ok: Boolean(contentWait?.ok),
+    image_full_cv: imageFullCv,
+    image_summary: summarizeImageEvidence(imageEvidence)
+  };
+}
+
 async function resolveFreshChatCardNodeId(client, {
   fallbackNodeId,
   candidate,
@@ -717,28 +844,8 @@ export async function runChatWorkflow({
         }
 
         if (!detailResult) {
-          detailStep = "open_online_resume";
-          networkRecorder.clear();
-          const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
-            timeoutMs: readyTimeoutMs
-          }));
           const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-          detailStep = "wait_network";
-          const networkWait = ["network", "cascade"].includes(normalizedDetailSource)
-            ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
-                waitForChatProfileNetworkEvents,
-                networkRecorder,
-                {
-                  waitPlan,
-                  minCount: 1,
-                  requireLoaded: true,
-                  intervalMs: 200
-                }
-              ))
-            : null;
-          if (networkWait?.elapsed_ms != null) {
-            timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
-          }
+          let networkWait = null;
           let contentWait = {
             ok: false,
             skipped: false,
@@ -746,38 +853,44 @@ export async function runChatWorkflow({
             elapsed_ms: 0,
             text_length: 0
           };
-          let resumeState = openedResume.resume_state;
+          let resumeState = null;
           let resumeHtml = null;
-          let resumeNetworkEvents = networkRecorder.events.slice();
+          let resumeNetworkEvents = [];
           let parsedNetworkProfileCount = 0;
 
           if (
             ["network", "cascade"].includes(normalizedDetailSource)
-            && networkWait?.count > 0
+            && selectionNetworkEvents.length > 0
           ) {
-            detailStep = "extract_network_profile";
+            detailStep = "extract_selection_network_profile";
             detailResult = await extractChatProfileCandidate(client, {
               cardCandidate,
               cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
+              resumeState: null,
+              resumeHtml: null,
+              networkEvents: selectionNetworkEvents,
               targetUrl,
               closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
+              networkParseRetryMs: waitPlan.mode_before === "image" ? 250 : 900,
+              networkParseIntervalMs: 150
             });
             addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
             parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
-            if (parsedNetworkProfileCount > 0) {
+            const selectionNetworkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+            if (selectionNetworkEvidence.network_full_cv_count > 0) {
+              networkWait = {
+                ok: true,
+                skipped: true,
+                reason: "selection_network_full_cv_before_online_resume_click",
+                elapsed_ms: detailResult.network_parse_retry_elapsed_ms,
+                count: selectionNetworkEvents.length,
+                total_event_count: selectionNetworkEvents.length,
+                wait_plan: waitPlan
+              };
               contentWait = {
                 ok: true,
                 skipped: true,
-                reason: "network_profile_parsed_before_dom_wait",
+                reason: "selection_network_full_cv_before_online_resume_click",
                 elapsed_ms: 0,
                 text_length: 0
               };
@@ -787,40 +900,103 @@ export async function runChatWorkflow({
           }
 
           if (!detailResult) {
-            detailStep = "wait_resume_content";
-            contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
-              timeoutMs: resumeDomTimeoutMs,
-              intervalMs: 300
+            detailStep = "open_online_resume";
+            networkRecorder.clear();
+            const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
+              timeoutMs: readyTimeoutMs
             }));
-            resumeState = contentWait.resume_state || openedResume.resume_state;
-            resumeHtml = contentWait.resume_html || null;
+            resumeState = openedResume.resume_state;
+            detailStep = "wait_network";
+            networkWait = ["network", "cascade"].includes(normalizedDetailSource)
+              ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
+                  waitForChatProfileNetworkEvents,
+                  networkRecorder,
+                  {
+                    waitPlan,
+                    minCount: 1,
+                    requireLoaded: true,
+                    intervalMs: 200
+                  }
+                ))
+              : null;
+            if (networkWait?.elapsed_ms != null) {
+              timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+            }
             resumeNetworkEvents = networkRecorder.events.slice();
-            detailStep = "extract_resume_content";
-            detailResult = await extractChatProfileCandidate(client, {
-              cardCandidate,
-              cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
-              targetUrl,
-              closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
-            });
-            addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
-            parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+
+            if (
+              ["network", "cascade"].includes(normalizedDetailSource)
+              && networkWait?.count > 0
+            ) {
+              detailStep = "extract_network_profile";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+              const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+              if (networkEvidence.network_full_cv_count > 0) {
+                contentWait = {
+                  ok: true,
+                  skipped: true,
+                  reason: "network_full_cv_parsed_before_dom_wait",
+                  elapsed_ms: 0,
+                  text_length: 0
+                };
+              } else {
+                detailResult = null;
+              }
+            }
+
+            if (!detailResult) {
+              detailStep = "wait_resume_content";
+              contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
+                timeoutMs: resumeDomTimeoutMs,
+                intervalMs: 300
+              }));
+              resumeState = contentWait.resume_state || openedResume.resume_state;
+              resumeHtml = contentWait.resume_html || null;
+              resumeNetworkEvents = networkRecorder.events.slice();
+              detailStep = "extract_resume_content";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+            }
           }
 
           let source = normalizedDetailSource === "dom" ? "dom" : "network";
           let imageEvidence = null;
           let llmResult = null;
           const captureNodeId = captureNodeIdFromResumeState(resumeState);
+          let fullCvEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
           const shouldCaptureImage = normalizedDetailSource === "image"
-            || (normalizedDetailSource === "cascade" && parsedNetworkProfileCount < 1);
+            || (normalizedDetailSource === "cascade" && !fullCvEvidence.full_cv_acquired);
           if (shouldCaptureImage) {
             if (captureNodeId) {
               detailStep = "capture_image_fallback";
@@ -861,12 +1037,20 @@ export async function runChatWorkflow({
                 }
               }));
               source = "image";
+              fullCvEvidence = summarizeChatFullCvEvidence({
+                detailResult,
+                contentWait,
+                imageEvidence
+              });
               recordCvImageFallback(cvAcquisitionState, {
+                reason: fullCvEvidence.network_profile_only_count > 0
+                  ? "profile_only_network_image_fallback"
+                  : "network_miss_image_fallback",
                 parsedNetworkProfileCount,
                 waitResult: networkWait,
                 imageEvidence
               });
-              if (callLlmOnImage) {
+              if (callLlmOnImage && fullCvEvidence.full_cv_acquired) {
                 detailStep = "llm_image_screening";
                 if (!llmConfig) {
                   llmResult = createMissingLlmConfigResult();
@@ -888,14 +1072,39 @@ export async function runChatWorkflow({
               }
             } else {
               source = "missing_capture_node";
+              fullCvEvidence = summarizeChatFullCvEvidence({
+                detailResult,
+                contentWait,
+                imageEvidence
+              });
               recordCvNetworkMiss(cvAcquisitionState, {
                 reason: "network_miss_no_capture_node",
                 parsedNetworkProfileCount,
                 waitResult: networkWait
               });
             }
-          } else if (parsedNetworkProfileCount > 0) {
+          } else if (fullCvEvidence.network_full_cv_count > 0) {
+            source = "network";
             recordCvNetworkHit(cvAcquisitionState, {
+              reason: "full_cv_network_profile",
+              parsedNetworkProfileCount,
+              waitResult: networkWait
+            });
+          } else if (fullCvEvidence.dom_full_cv) {
+            source = "dom";
+            if (normalizedDetailSource !== "dom") {
+              recordCvNetworkMiss(cvAcquisitionState, {
+                reason: parsedNetworkProfileCount > 0
+                  ? "profile_only_network_dom_fallback"
+                  : "network_miss_dom_fallback",
+                parsedNetworkProfileCount,
+                waitResult: networkWait
+              });
+            }
+          } else if (parsedNetworkProfileCount > 0) {
+            source = "profile_only_network";
+            recordCvNetworkMiss(cvAcquisitionState, {
+              reason: "profile_only_network_not_full_cv",
               parsedNetworkProfileCount,
               waitResult: networkWait
             });
@@ -909,25 +1118,29 @@ export async function runChatWorkflow({
           }
 
           if (useLlmScreening && !llmResult) {
-            detailStep = "llm_screening";
-            if (!llmConfig) {
-              llmResult = createMissingLlmConfigResult();
+            if (!fullCvEvidence.full_cv_acquired) {
+              detailUnavailableReason = "full_cv_not_acquired";
             } else {
-              try {
-                const llmTimingKey = imageEvidence?.file_paths?.length
-                  ? "vision_model_ms"
-                  : "text_model_ms";
-                llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
-                  candidate: detailResult.candidate,
-                  criteria,
-                  config: llmConfig,
-                  timeoutMs: llmTimeoutMs,
-                  imageEvidence,
-                  maxImages: llmImageLimit,
-                  imageDetail: llmImageDetail
-                }));
-              } catch (error) {
-                llmResult = createFailedLlmResult(error);
+              detailStep = "llm_screening";
+              if (!llmConfig) {
+                llmResult = createMissingLlmConfigResult();
+              } else {
+                try {
+                  const llmTimingKey = imageEvidence?.file_paths?.length
+                    ? "vision_model_ms"
+                    : "text_model_ms";
+                  llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+                    candidate: detailResult.candidate,
+                    criteria,
+                    config: llmConfig,
+                    timeoutMs: llmTimeoutMs,
+                    imageEvidence,
+                    maxImages: llmImageLimit,
+                    imageDetail: llmImageDetail
+                  }));
+                } catch (error) {
+                  llmResult = createFailedLlmResult(error);
+                }
               }
             }
           }
@@ -955,7 +1168,8 @@ export async function runChatWorkflow({
               text_length: contentWait.text_length
             },
             parsed_network_profile_count: parsedNetworkProfileCount,
-            image_evidence: summarizeImageEvidence(imageEvidence)
+            image_evidence: summarizeImageEvidence(imageEvidence),
+            full_cv_evidence: fullCvEvidence
           };
         }
       } catch (error) {
@@ -964,6 +1178,13 @@ export async function runChatWorkflow({
           const recovery = await recoverAndReapplyChatContext(detailUnavailableReason, error);
           detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
           detailResult.cv_acquisition.recovery = recovery;
+        } 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 {
           if (!isRecoverableCdpNodeError(error)) throw error;
           detailUnavailableReason = `recoverable_cdp_node_stale:${detailStep}`;
@@ -979,22 +1200,9 @@ export async function runChatWorkflow({
     runControl.setPhase("chat:screening");
     let cardOnlyLlmResult = null;
     if (useLlmScreening && !detailUnavailableReason && !detailResult?.llm_result) {
-      if (!llmConfig) {
-        cardOnlyLlmResult = createMissingLlmConfigResult();
-      } else {
-        try {
-          cardOnlyLlmResult = await measureTiming(timings, "text_model_ms", () => callScreeningLlm({
-            candidate: screeningCandidate,
-            criteria,
-            config: llmConfig,
-            timeoutMs: llmTimeoutMs,
-            maxImages: llmImageLimit,
-            imageDetail: llmImageDetail
-          }));
-        } catch (error) {
-          cardOnlyLlmResult = createFailedLlmResult(error);
-        }
-      }
+      detailUnavailableReason = detailResult
+        ? "full_cv_not_acquired"
+        : "detail_not_opened_full_cv_required";
     }
     const effectiveLlmResult = detailResult?.llm_result || cardOnlyLlmResult;
     const screening = detailUnavailableReason