@reconcrap/boss-recommend-mcp 2.0.6 → 2.0.8

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

@@ -1,4 +1,9 @@
 import { createRunLifecycleManager } from "../../core/run/index.js";
+import {
+  addTiming,
+  imageEvidenceFilePath,
+  measureTiming
+} from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import {
   compactCvAcquisitionState,
@@ -19,7 +24,13 @@ import {
   resetInfiniteListForRefreshRound
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
-import { screenCandidate } from "../../core/screening/index.js";
+import {
+  callScreeningLlm,
+  compactScreeningLlmResult,
+  createFailedLlmScreeningResult,
+  llmResultToScreening,
+  screenCandidate
+} from "../../core/screening/index.js";
 import {
   closeRecruitDetail,
   createRecruitDetailNetworkRecorder,
@@ -72,10 +83,22 @@ function compactDetail(detailResult) {
     parsed_network_profile_count: detailResult.parsed_network_profiles?.filter((item) => item.ok).length || 0,
     cv_acquisition: detailResult.cv_acquisition || null,
     image_evidence: summarizeImageEvidence(detailResult.image_evidence),
+    llm_screening: compactScreeningLlmResult(detailResult.llm_result),
     close_result: detailResult.close_result
   };
 }
 
+function normalizeScreeningMode(value) {
+  const normalized = String(value || "llm").trim().toLowerCase();
+  return ["deterministic", "local", "local_scorer"].includes(normalized)
+    ? "deterministic"
+    : "llm";
+}
+
+function createMissingLlmConfigResult() {
+  return createFailedLlmScreeningResult(new Error("LLM screening config is required for production search runs"));
+}
+
 function normalizeSearchParams(searchParams = {}) {
   return normalizeRecruitSearchParams(searchParams);
 }
@@ -110,7 +133,7 @@ export async function runRecruitWorkflow({
   criteria = "",
   searchParams = {},
   maxCandidates = 5,
-  detailLimit = 1,
+  detailLimit = null,
   closeDetail = true,
   delayMs = 0,
   cardTimeoutMs = 90000,
@@ -127,12 +150,20 @@ export async function runRecruitWorkflow({
   listFallbackPoint = null,
   refreshOnEnd = true,
   maxRefreshRounds = 2,
-  refreshResetSettleMs = 5000
+  refreshResetSettleMs = 5000,
+  screeningMode = "llm",
+  llmConfig = null,
+  llmTimeoutMs = 120000,
+  llmImageLimit = 8,
+  llmImageDetail = "high",
+  imageOutputDir = ""
 } = {}, runControl) {
   if (!client) throw new Error("runRecruitWorkflow requires a guarded CDP client");
   const normalizedSearchParams = normalizeSearchParams(searchParams);
+  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+  const useLlmScreening = normalizedScreeningMode !== "deterministic";
   const limit = Math.max(1, Number(maxCandidates) || 1);
-  const detailCountLimit = Math.max(0, Number(detailLimit) || 0);
+  const detailCountLimit = detailLimit == null ? limit : Math.max(0, Number(detailLimit) || 0);
   const networkRecorder = detailCountLimit > 0
     ? createRecruitDetailNetworkRecorder(client)
     : null;
@@ -222,6 +253,8 @@ export async function runRecruitWorkflow({
     screened: 0,
     detail_opened: 0,
     passed: 0,
+    screening_mode: normalizedScreeningMode,
+    llm_screened: 0,
     unique_seen: compactInfiniteListState(listState).seen_count,
     scroll_count: 0,
     refresh_rounds: 0,
@@ -231,12 +264,14 @@ export async function runRecruitWorkflow({
   });
 
   while (results.length < limit) {
+    const candidateStarted = Date.now();
+    const timings = {};
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recruit:candidate");
     rootState = await ensureRecruitViewport(rootState, "candidate_loop");
 
-    const nextCandidateResult = await getNextInfiniteListCandidate({
+    const nextCandidateResult = await measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
       client,
       state: listState,
       maxScrolls: listMaxScrolls,
@@ -264,7 +299,7 @@ export async function runRecruitWorkflow({
           search_params: normalizedSearchParams
         }
       })
-    });
+    }));
     if (!nextCandidateResult.ok) {
       listEndReason = nextCandidateResult.reason || "list_exhausted";
       if (
@@ -298,6 +333,7 @@ export async function runRecruitWorkflow({
           screened: results.length,
           detail_opened: results.filter((item) => item.detail).length,
           passed: results.filter((item) => item.screening.passed).length,
+          llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
           unique_seen: compactInfiniteListState(listState).seen_count,
           scroll_count: compactInfiniteListState(listState).scroll_count,
           refresh_rounds: refreshRounds,
@@ -345,8 +381,10 @@ export async function runRecruitWorkflow({
       rootState = await ensureRecruitViewport(rootState, "detail");
       networkRecorder.clear();
       const openedDetail = await openRecruitCardDetail(client, cardNodeId);
+      addTiming(timings, "candidate_click_ms", openedDetail.timings?.candidate_click_ms);
+      addTiming(timings, "detail_open_ms", openedDetail.timings?.detail_open_ms);
       const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-      const networkWait = await waitForCvNetworkEvents(
+      const networkWait = await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
         waitForRecruitDetailNetworkEvents,
         networkRecorder,
         {
@@ -355,7 +393,10 @@ export async function runRecruitWorkflow({
           requireLoaded: true,
           intervalMs: 120
         }
-      );
+      ));
+      if (networkWait?.elapsed_ms != null) {
+        timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+      }
       detailResult = await extractRecruitDetailCandidate(client, {
         cardCandidate,
         cardNodeId,
@@ -377,7 +418,13 @@ export async function runRecruitWorkflow({
           || openedDetail.detail_state?.resumeIframe?.node_id
           || null;
         if (captureNodeId) {
-          imageEvidence = await captureScrolledNodeScreenshots(client, captureNodeId, {
+          imageEvidence = await measureTiming(timings, "screenshot_capture_ms", () => captureScrolledNodeScreenshots(client, captureNodeId, {
+            filePath: imageEvidenceFilePath({
+              imageOutputDir,
+              domain: "recruit",
+              runId: runControl?.runId,
+              index
+            }),
             padding: 4,
             maxScreenshots: maxImagePages,
             wheelDeltaY: imageWheelDeltaY,
@@ -389,7 +436,7 @@ export async function runRecruitWorkflow({
               run_candidate_index: index,
               candidate_key: candidateKey
             }
-          });
+          }));
           source = "image";
           recordCvImageFallback(cvAcquisitionState, {
             parsedNetworkProfileCount,
@@ -408,7 +455,7 @@ export async function runRecruitWorkflow({
 
       let closeResult = null;
       if (closeDetail) {
-        closeResult = await closeRecruitDetail(client);
+        closeResult = await measureTiming(timings, "close_detail_ms", () => closeRecruitDetail(client));
       }
       detailResult.close_result = closeResult;
       detailResult.image_evidence = imageEvidence;
@@ -426,14 +473,43 @@ export async function runRecruitWorkflow({
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recruit:screening");
-    const screening = screenCandidate(screeningCandidate, { criteria });
+    let llmResult = null;
+    if (useLlmScreening) {
+      if (!llmConfig) {
+        llmResult = createMissingLlmConfigResult();
+      } else {
+        try {
+          const llmTimingKey = detailResult?.image_evidence?.file_paths?.length
+            ? "vision_model_ms"
+            : "text_model_ms";
+          llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+            candidate: screeningCandidate,
+            criteria,
+            config: llmConfig,
+            timeoutMs: llmTimeoutMs,
+            imageEvidence: detailResult?.image_evidence || null,
+            maxImages: llmImageLimit,
+            imageDetail: llmImageDetail
+          }));
+        } catch (error) {
+          llmResult = createFailedLlmScreeningResult(error);
+        }
+      }
+      if (detailResult) detailResult.llm_result = llmResult;
+    }
+    const screening = useLlmScreening
+      ? llmResultToScreening(llmResult, screeningCandidate)
+      : screenCandidate(screeningCandidate, { criteria });
+    timings.total_ms = Date.now() - candidateStarted;
     const compactResult = {
       index,
       candidate_key: candidateKey,
       card_node_id: cardNodeId,
       candidate: compactCandidate(screeningCandidate),
       detail: compactDetail(detailResult),
-      screening: compactScreening(screening)
+      llm_screening: detailResult ? null : compactScreeningLlmResult(llmResult),
+      screening: compactScreening(screening),
+      timings
     };
     results.push(compactResult);
     markInfiniteListCandidateProcessed(listState, candidateKey, {
@@ -450,6 +526,7 @@ export async function runRecruitWorkflow({
       screened: results.length,
       detail_opened: results.filter((item) => item.detail).length,
       passed: results.filter((item) => item.screening.passed).length,
+      llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
       unique_seen: compactInfiniteListState(listState).seen_count,
       scroll_count: compactInfiniteListState(listState).scroll_count,
       refresh_rounds: refreshRounds,
@@ -461,7 +538,9 @@ export async function runRecruitWorkflow({
       last_candidate_key: candidateKey,
       last_score: screening.score
     });
+    const checkpointStarted = Date.now();
     runControl.checkpoint({
+      results,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -470,12 +549,17 @@ export async function runRecruitWorkflow({
           status: screening.status,
           passed: screening.passed,
           score: screening.score
-        }
+        },
+        llm_screening: compactScreeningLlmResult(llmResult)
       }
     });
+    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
 
     if (delayMs > 0) {
+      const sleepStarted = Date.now();
       await runControl.sleep(delayMs);
+      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
+      compactResult.timings.total_ms = Date.now() - candidateStarted;
     }
   }
 
@@ -496,6 +580,7 @@ export async function runRecruitWorkflow({
     processed: results.length,
     screened: results.length,
     detail_opened: results.filter((item) => item.detail).length,
+    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
     passed: results.filter((item) => item.screening.passed).length,
     results
   };
@@ -514,7 +599,7 @@ export function createRecruitRunService({
     criteria = "",
     searchParams = {},
     maxCandidates = 5,
-    detailLimit = 1,
+    detailLimit = null,
     closeDetail = true,
     delayMs = 0,
     cardTimeoutMs = 90000,
@@ -532,10 +617,19 @@ export function createRecruitRunService({
     refreshOnEnd = true,
     maxRefreshRounds = 2,
     refreshResetSettleMs = 5000,
+    screeningMode = "llm",
+    llmConfig = null,
+    llmTimeoutMs = 120000,
+    llmImageLimit = 8,
+    llmImageDetail = "high",
+    imageOutputDir = "",
     name = "recruit-domain-run"
   } = {}) {
     if (!client) throw new Error("startRecruitRun requires a guarded CDP client");
     const normalizedSearchParams = normalizeSearchParams(searchParams);
+    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+    const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
+    const normalizedDetailLimit = detailLimit == null ? candidateLimit : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
       name,
       context: {
@@ -544,7 +638,7 @@ export function createRecruitRunService({
         criteria_present: Boolean(criteria),
         search_params: normalizedSearchParams,
         max_candidates: maxCandidates,
-        detail_limit: detailLimit,
+        detail_limit: normalizedDetailLimit,
         close_detail: closeDetail,
         reset_before_search: resetBeforeSearch,
         reset_timeout_ms: resetTimeoutMs,
@@ -559,14 +653,21 @@ export function createRecruitRunService({
         list_fallback_point: listFallbackPoint,
         refresh_on_end: refreshOnEnd,
         max_refresh_rounds: maxRefreshRounds,
-        refresh_reset_settle_ms: refreshResetSettleMs
+        refresh_reset_settle_ms: refreshResetSettleMs,
+        screening_mode: normalizedScreeningMode,
+        llm_configured: Boolean(llmConfig),
+        llm_timeout_ms: llmTimeoutMs,
+        llm_image_limit: llmImageLimit,
+        llm_image_detail: llmImageDetail,
+        image_output_dir: imageOutputDir || ""
       },
       progress: {
         card_count: 0,
-        target_count: Math.max(1, Number(maxCandidates) || 1),
+        target_count: candidateLimit,
         processed: 0,
         screened: 0,
         detail_opened: 0,
+        llm_screened: 0,
         passed: 0
       },
       checkpoint: {},
@@ -576,7 +677,7 @@ export function createRecruitRunService({
         criteria,
         searchParams: normalizedSearchParams,
         maxCandidates,
-        detailLimit,
+        detailLimit: normalizedDetailLimit,
         closeDetail,
         delayMs,
         cardTimeoutMs,
@@ -593,7 +694,13 @@ export function createRecruitRunService({
         listFallbackPoint,
         refreshOnEnd,
         maxRefreshRounds,
-        refreshResetSettleMs
+        refreshResetSettleMs,
+        screeningMode: normalizedScreeningMode,
+        llmConfig,
+        llmTimeoutMs,
+        llmImageLimit,
+        llmImageDetail,
+        imageOutputDir
       }, runControl)
     });
   }

package/src/index.js

@@ -541,11 +541,38 @@ function createRunInputSchema() {
       detail_limit: {
         type: "integer",
         minimum: 0,
-        description: "打开详情/CV 的人数上限；默认跟随 target_count/max_candidates。生产筛选不应传 0；只有 allow_card_only_screening=true 时才会接受 0 作为调试卡片-only 模式"
+        description: "打开详情/CV 的人数上限；默认跟随 target_count/max_candidates。生产筛选不应传 0；detail_limit=0 需要 debug_test_mode=true 且 allow_card_only_screening=true"
       },
       allow_card_only_screening: {
         type: "boolean",
-        description: "高级调试开关；默认 false。只有显式为 true 时，recommend 才会尊重 detail_limit=0 并只用卡片信息筛选"
+        description: "高级调试开关；默认 false。只有同时显式 debug_test_mode=true 时，recommend 才会尊重 detail_limit=0"
+      },
+      debug_test_mode: {
+        type: "boolean",
+        description: "高级测试开关；默认 false。只有显式为 true 时才允许 deterministic/local scorer、跳过筛选器、card-only、dry-run 后置动作等调试路径"
+      },
+      screening_mode: {
+        type: "string",
+        enum: ["llm", "deterministic"],
+        description: "筛选引擎；默认 llm。deterministic 仅限 debug_test_mode=true 的明确测试场景"
+      },
+      use_llm: {
+        type: "boolean",
+        description: "兼容字段；默认 true。use_llm=false 等同 deterministic，仅限 debug_test_mode=true"
+      },
+      llm_timeout_ms: {
+        type: "integer",
+        minimum: 1000,
+        description: "可选，单个候选人的 LLM 调用超时"
+      },
+      llm_image_limit: {
+        type: "integer",
+        minimum: 1,
+        description: "可选，传给 LLM 的图片简历截图页数上限"
+      },
+      llm_image_detail: {
+        type: "string",
+        description: "可选，图片输入 detail，默认 high"
       },
       delay_ms: {
         type: "integer",
@@ -577,11 +604,11 @@ function createRunInputSchema() {
       },
       no_filter: {
         type: "boolean",
-        description: "开发/live gate 专用：跳过本次筛选器点击，默认 false"
+        description: "开发/live gate 专用：跳过本次筛选器点击，默认 false；正式 run 需要 debug_test_mode=true 才允许"
       },
       filter_enabled: {
         type: "boolean",
-        description: "开发/live gate 专用：false 时跳过本次筛选器点击"
+        description: "开发/live gate 专用：false 时跳过本次筛选器点击；正式 run 需要 debug_test_mode=true 才允许"
       },
       refresh_on_end: {
         type: "boolean",
@@ -672,7 +699,16 @@ function createBossChatStartInputSchema({ requireFullInput = false } = {}) {
       },
       use_llm: {
         type: "boolean",
-        description: "可选，是否使用 screening-config.json 中的 LLM 配置筛选；求简历任务默认使用"
+        description: "可选，默认 true。use_llm=false 等同 deterministic/local scorer，仅限 debug_test_mode=true 的明确测试场景"
+      },
+      screening_mode: {
+        type: "string",
+        enum: ["llm", "deterministic"],
+        description: "筛选引擎；默认 llm。deterministic 仅限 debug_test_mode=true"
+      },
+      debug_test_mode: {
+        type: "boolean",
+        description: "高级测试开关；默认 false。只有显式为 true 时才允许 deterministic/local scorer、detail_limit=0、dry-run 求简历等调试路径"
       },
       request_cv: {
         type: "boolean",
@@ -703,6 +739,15 @@ function createBossChatStartInputSchema({ requireFullInput = false } = {}) {
         minimum: 1000,
         description: "可选，单个候选人的 LLM 调用超时"
       },
+      llm_image_limit: {
+        type: "integer",
+        minimum: 1,
+        description: "可选，传给 LLM 的图片简历截图页数上限"
+      },
+      llm_image_detail: {
+        type: "string",
+        description: "可选，图片输入 detail，默认 high"
+      },
       online_resume_button_timeout_ms: {
         type: "integer",
         minimum: 1000,

package/src/recommend-mcp.js

@@ -84,9 +84,38 @@ function parseNonNegativeInteger(raw, fallback) {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
 }
 
+function isDebugTestMode(args = {}) {
+  return args.debug_test_mode === true || args.allow_debug_test_mode === true;
+}
+
+function normalizeScreeningModeArg(args = {}) {
+  const raw = normalizeText(args.screening_mode || args.screeningMode || "");
+  if (args.use_llm === false) return "deterministic";
+  return ["deterministic", "local", "local_scorer"].includes(raw.toLowerCase())
+    ? "deterministic"
+    : "llm";
+}
+
+function collectRecommendDebugTestOptions(args = {}, normalized = {}) {
+  const reasons = [];
+  if (normalizeScreeningModeArg(args) === "deterministic") reasons.push("deterministic_screening");
+  if (args.allow_card_only_screening === true) reasons.push("allow_card_only_screening");
+  if (parseNonNegativeInteger(args.detail_limit, null) === 0) reasons.push("detail_limit=0");
+  if (args.no_filter === true) reasons.push("no_filter");
+  if (args.filter_enabled === false) reasons.push("filter_enabled=false");
+  if (args.dry_run_post_action === true) reasons.push("dry_run_post_action");
+  if (args.execute_post_action === false && normalized.postAction && normalized.postAction !== "none") {
+    reasons.push("execute_post_action=false");
+  }
+  return reasons;
+}
+
 function resolveRecommendDetailLimit(args = {}, normalized = {}) {
   const fallback = parsePositiveInteger(normalized.targetCount, 5);
   const requested = parseNonNegativeInteger(args.detail_limit, fallback);
+  if (requested === 0 && !isDebugTestMode(args)) {
+    return fallback;
+  }
   if (requested === 0 && args.allow_card_only_screening !== true) {
     return fallback;
   }
@@ -270,8 +299,15 @@ function ensureRecommendRunArtifacts(snapshot) {
   if (meta) meta.checkpointPath = artifacts.checkpoint_path;
 
   const summary = snapshot?.summary && typeof snapshot.summary === "object" ? snapshot.summary : null;
-  if (summary) {
-    const rows = Array.isArray(summary.results) ? summary.results : [];
+  const checkpointResults = Array.isArray(checkpoint.results) ? checkpoint.results : [];
+  const artifactSummary = summary || (checkpointResults.length ? {
+    domain: "recommend",
+    partial: true,
+    partial_reason: snapshot?.status || snapshot?.state || "non_terminal",
+    results: checkpointResults
+  } : null);
+  if (artifactSummary) {
+    const rows = Array.isArray(artifactSummary.results) ? artifactSummary.results : [];
     writeRecommendLegacyCsvAtomic(artifacts.output_csv, rows, snapshot, meta);
     writeJsonAtomic(artifacts.report_json, {
       run_id: snapshot.runId || snapshot.run_id,
@@ -280,7 +316,7 @@ function ensureRecommendRunArtifacts(snapshot) {
       progress: snapshot.progress || {},
       context: snapshot.context || {},
       checkpoint,
-      summary,
+      summary: artifactSummary,
       generated_at: new Date().toISOString()
     });
     if (meta) {
@@ -297,6 +333,12 @@ function buildLegacyRecommendResult(snapshot) {
   const artifacts = ensureRecommendRunArtifacts(snapshot);
   const meta = getRecommendRunMeta(snapshot.runId);
   const summary = snapshot.summary && typeof snapshot.summary === "object" ? snapshot.summary : null;
+  const checkpoint = snapshot.checkpoint && typeof snapshot.checkpoint === "object" ? snapshot.checkpoint : {};
+  const resultRows = Array.isArray(summary?.results)
+    ? summary.results
+    : Array.isArray(checkpoint.results)
+      ? checkpoint.results
+      : [];
   const progress = normalizeLegacyProgress(snapshot.progress, summary);
   const targetCount = Number.isInteger(progress.target_count)
     ? progress.target_count
@@ -341,7 +383,7 @@ function buildLegacyRecommendResult(snapshot) {
     screen_params: clonePlain(meta.parsed?.screenParams || {}, {}),
     target_count_semantics: TARGET_COUNT_SEMANTICS,
     error: snapshot.error || null,
-    results: Array.isArray(summary?.results) ? summary.results : []
+    results: resultRows
   };
 }
 
@@ -958,11 +1000,12 @@ function normalizeRecommendStartInput(args = {}, parsed, configResolution = null
     postAction: parsed.screenParams?.post_action || "none",
     maxGreetCount: Number.isInteger(parsed.screenParams?.max_greet_count)
       ? parsed.screenParams.max_greet_count
-      : null
+      : null,
+    screeningMode: normalizeScreeningModeArg(args)
   };
 }
 
-function getRunOptions(args, parsed, normalized, session) {
+function getRunOptions(args, parsed, normalized, session, configResolution = null) {
   const slowLive = args.slow_live === true;
   const executePostAction = args.dry_run_post_action === true
     ? false
@@ -998,6 +1041,14 @@ function getRunOptions(args, parsed, normalized, session) {
     actionTimeoutMs: parsePositiveInteger(args.action_timeout_ms, slowLive ? 12000 : 8000),
     actionIntervalMs: parsePositiveInteger(args.action_interval_ms, 500),
     actionAfterClickDelayMs: parseNonNegativeInteger(args.action_after_click_delay_ms, slowLive ? 1200 : 900),
+    screeningMode: normalized.screeningMode,
+    llmConfig: normalized.screeningMode === "llm" && configResolution?.ok ? {
+      ...configResolution.config
+    } : null,
+    llmTimeoutMs: parsePositiveInteger(args.llm_timeout_ms, slowLive ? 180000 : 120000),
+    llmImageLimit: parsePositiveInteger(args.llm_image_limit, 8),
+    llmImageDetail: normalizeText(args.llm_image_detail) || "high",
+    imageOutputDir: resolveBossConfiguredOutputDir("", getRunsDir()),
     name: "mcp-recommend-pipeline-run",
     parsed
   };
@@ -1054,6 +1105,30 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
   if (gate) return gate;
   const configResolution = resolveBossScreeningConfig(workspaceRoot);
   const normalized = normalizeRecommendStartInput(args, parsed, configResolution);
+  const debugTestOptions = collectRecommendDebugTestOptions(args, normalized);
+  if (debugTestOptions.length && !isDebugTestMode(args)) {
+    return {
+      status: "FAILED",
+      error: {
+        code: "DEBUG_TEST_MODE_REQUIRED",
+        message: `这些参数属于调试/测试路径，正式 live run 不会默认启用：${debugTestOptions.join(", ")}。如确需测试，请显式传 debug_test_mode=true。`,
+        retryable: false
+      },
+      debug_test_options: debugTestOptions
+    };
+  }
+  if (normalized.screeningMode === "llm" && !configResolution.ok) {
+    return {
+      status: "FAILED",
+      error: {
+        code: "SCREEN_CONFIG_ERROR",
+        message: configResolution.error?.message || "screening-config.json is required for LLM screening.",
+        retryable: true
+      },
+      config_path: configResolution.config_path || null,
+      candidate_paths: configResolution.candidate_paths || []
+    };
+  }
 
   let session;
   try {
@@ -1085,7 +1160,7 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
 
   let started;
   try {
-    started = recommendRunService.startRecommendRun(getRunOptions(args, parsed, normalized, session));
+    started = recommendRunService.startRecommendRun(getRunOptions(args, parsed, normalized, session, configResolution));
   } catch (error) {
     await session.close?.();
     return {