@reconcrap/boss-recommend-mcp 2.1.13 → 2.1.14

package/README.md

@@ -354,7 +354,12 @@ config/screening-config.example.json
     }
   ],
   "greetingMessage": "Hi同学，能麻烦发下简历吗？",
+  "llmScreeningStrategy": "single_pass",
   "llmThinkingLevel": "low",
+  "llmFastThinkingLevel": "current",
+  "llmVerifyThinkingLevel": "low",
+  "llmFastMaxTokens": 384,
+  "llmVerifyMaxTokens": null,
   "llmMaxRetries": 1
 }
 ```
@@ -366,9 +371,15 @@ config/screening-config.example.json
 - `greetingMessage`：chat 求简历流程发送的招呼语。兼容 `greetingText` / `greeting_text`；本次 run 显式传入的 `greeting_text` 优先级最高。
 - `debugPort`：未显式传 `port` 时，recommend / search / chat CDP-only MCP run 和健康检查默认连接这个 Chrome 调试端口。
 - `outputDir`：recommend / search / chat 完成后的最终 CSV 与 report JSON 会写入这里；run state / checkpoint 仍保留在各自状态目录，方便 pause/resume/cancel。
-- `llmThinkingLevel`：默认 `low`。可设为 `off/minimal/low/medium/high/auto/current`，用于控制 OpenAI-compatible LLM 的 thinking/reasoning 强度。
+- `llmScreeningStrategy`：默认 `single_pass`，保持旧行为并使用 `llmThinkingLevel`。设为 `fast_first_verified` 时，recommend / search / chat 会先用 `llmFastThinkingLevel` 快速判断，再只对快速通过、快速判断要求复核、或快速输出无效/缺字段的候选人用 `llmVerifyThinkingLevel` 复核；明确 `passed=false` 且 `review_required=false` 的快速淘汰不会复核。复核发生时，复核结果作为最终结果。
+- `llmFastThinkingLevel` / `llmVerifyThinkingLevel`：仅在 `llmScreeningStrategy="fast_first_verified"` 时生效；默认分别为 `current` 和 `low`，可设为 `off/minimal/low/medium/high/auto/current`。此策略会忽略 `llmThinkingLevel` 的通过选择。
+- `llmFastMaxTokens` / `llmVerifyMaxTokens`：仅在 `llmScreeningStrategy="fast_first_verified"` 时生效。快速首轮默认最多输出 `384` tokens，即使全局 `llmMaxTokens` 更大，也会使用这个快速轮上限，避免 `current` 模式输出冗长推理；可用 `llmFastMaxTokens` 覆盖。复核轮默认沿用全局 `llmMaxTokens` / `llmMaxCompletionTokens`，也可用 `llmVerifyMaxTokens` 单独覆盖。
+- `fast_first_verified` 的快速轮只有在硬性不通过证据直接、明确、且没有可见反向证据时才应返回 `review_required=false`。如果简历里存在任一可能合格的学校/学历、产品或行业、职责或指标、海外/语言证据、或需要精确计算的任期/年限证据，即使快速轮倾向 `passed=false`，也应返回 `review_required=true` 交给复核轮。
+- LLM provider 返回预算、额度、账单或鉴权类 fatal 错误（例如 `budget_exceeded`、quota exceeded、401/403）时，单次 LLM 调用最多重试 2 次；若仍失败，recommend / search / chat 会直接让本次 run 失败，不再把后续候选人记录为筛选不通过。
+- `llmThinkingLevel`：默认 `low`。可设为 `off/minimal/low/medium/high/auto/current`，用于控制 OpenAI-compatible LLM 的 thinking/reasoning 强度。recommend / search / chat 共用同一套 LLM 筛选提示词：模型会按筛选标准顺序检查硬性淘汰项，若某项已可确定不满足（包括标准要求“证据不足即不通过”的缺失证据），会直接返回不通过；只有当前淘汰项存在截图不清、信息冲突或可能被后续简历内容澄清时才继续核实。
   - `current`：不显式发送 thinking/reasoning 参数，并要求 LLM 返回 `{"passed": true/false, "summary": "少于100个中文词的筛选总结"}`；CSV 的 `判断依据(CoT)` 写入该 summary。
   - 其他值：只要求 LLM 返回 `{"passed": true/false}`；若 provider 返回 reasoning / CoT 字段，CSV 的 `判断依据(CoT)` 写入该内容。
+  - 在 `fast_first_verified` 下，快速首轮始终要求 `{"passed": true/false, "summary": "少于100个中文词的筛选总结", "review_required": true/false}`。若最终来自快速轮，CSV 的 `判断依据(CoT)` 写入快速 summary；若最终来自复核轮，CSV 优先写入复核 CoT/reasoning，复核轮为 `current` 时写入复核 summary。
 - `humanBehavior`：默认 `{ "enabled": true, "profile": "paced_with_rests", "restLevel": "low" }`。用于 recommend / search / chat 的可靠性实验，支持：
   - `profile: "baseline"`：关闭人类节奏，保持确定性行为。
   - `profile: "paced"`：启用 CDP-only Bezier 鼠标移动、较大按钮的安全 inset 点击点、分块 `Input.insertText`、列表 wheel/settle jitter，以及小的动作前后读秒。

package/config/screening-config.example.json

@@ -4,7 +4,12 @@
   "model": "gpt-4.1-mini",
   "llmModels": [],
   "greetingMessage": "Hi同学，能麻烦发下简历吗？",
+  "llmScreeningStrategy": "single_pass",
   "llmThinkingLevel": "low",
+  "llmFastThinkingLevel": "current",
+  "llmVerifyThinkingLevel": "low",
+  "llmFastMaxTokens": 384,
+  "llmVerifyMaxTokens": null,
   "llmTimeoutMs": 60000,
   "llmMaxTokens": 512,
   "llmMaxRetries": 3,

package/package.json

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

package/src/chat-runtime-config.js

@@ -12,6 +12,7 @@ const SCREEN_CONFIG_TEMPLATE_DEFAULTS = Object.freeze({
   model: "gpt-4.1-mini"
 });
 const LLM_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "auto", "current"]);
+const LLM_SCREENING_STRATEGIES = new Set(["single_pass", "fast_first_verified"]);
 
 export const TARGET_COUNT_CANONICAL_ALL = "all";
 export const TARGET_COUNT_ACCEPTED_EXAMPLES = [TARGET_COUNT_CANONICAL_ALL, -1, 20, "全部候选人"];
@@ -322,6 +323,11 @@ function normalizeLlmThinkingLevel(raw, fallback = "low") {
   return LLM_THINKING_LEVELS.has(normalized) ? normalized : fallback;
 }
 
+function normalizeLlmScreeningStrategy(raw, fallback = "single_pass") {
+  const normalized = normalizeText(raw).toLowerCase();
+  return LLM_SCREENING_STRATEGIES.has(normalized) ? normalized : fallback;
+}
+
 function firstConfiguredValue(...values) {
   for (const value of values) {
     if (value === undefined || value === null) continue;
@@ -352,6 +358,26 @@ function normalizeScreeningLlmModel(config = {}, rawEntry = {}, index = 0) {
       firstConfiguredValue(entry.llmThinkingLevel, entry.thinkingLevel, entry.reasoningEffort, config.llmThinkingLevel, config.thinkingLevel, config.reasoningEffort),
       "low"
     ),
+    llmScreeningStrategy: normalizeLlmScreeningStrategy(
+      firstConfiguredValue(entry.llmScreeningStrategy, entry.screeningStrategy, entry.screening_strategy, config.llmScreeningStrategy, config.screeningStrategy, config.screening_strategy),
+      "single_pass"
+    ),
+    llmFastThinkingLevel: normalizeLlmThinkingLevel(
+      firstConfiguredValue(entry.llmFastThinkingLevel, entry.fastThinkingLevel, entry.fast_thinking_level, config.llmFastThinkingLevel, config.fastThinkingLevel, config.fast_thinking_level),
+      "current"
+    ),
+    llmVerifyThinkingLevel: normalizeLlmThinkingLevel(
+      firstConfiguredValue(entry.llmVerifyThinkingLevel, entry.verifyThinkingLevel, entry.verify_thinking_level, config.llmVerifyThinkingLevel, config.verifyThinkingLevel, config.verify_thinking_level),
+      "low"
+    ),
+    llmFastMaxTokens: parsePositiveInteger(
+      firstConfiguredValue(entry.llmFastMaxTokens, entry.fastMaxTokens, entry.fast_max_tokens, config.llmFastMaxTokens, config.fastMaxTokens, config.fast_max_tokens),
+      null
+    ),
+    llmVerifyMaxTokens: parsePositiveInteger(
+      firstConfiguredValue(entry.llmVerifyMaxTokens, entry.verifyMaxTokens, entry.verify_max_tokens, config.llmVerifyMaxTokens, config.verifyMaxTokens, config.verify_max_tokens),
+      null
+    ),
     llmTimeoutMs: parsePositiveInteger(firstConfiguredValue(entry.llmTimeoutMs, entry.timeoutMs, config.llmTimeoutMs, config.timeoutMs), null),
     llmMaxRetries: parsePositiveInteger(firstConfiguredValue(entry.llmMaxRetries, entry.maxRetries, config.llmMaxRetries, config.maxRetries), null),
     llmMaxTokens: parsePositiveInteger(firstConfiguredValue(entry.llmMaxTokens, entry.maxTokens, config.llmMaxTokens, config.maxTokens), null),

package/src/core/reporting/legacy-csv.js

@@ -17,6 +17,10 @@ export const LEGACY_RESULT_HEADER = [
   "原始判定通过",
   "最终判定通过",
   "LLM thinking_level",
+  "LLM screening_strategy",
+  "LLM decision_source",
+  "LLM verified",
+  "LLM verification_reason",
   "错误码",
   "错误信息",
   "候选人ID",
@@ -282,7 +286,11 @@ export function legacyScreenResultRow(row = {}) {
     rawPassed,
     finalPassed,
     firstText(llm.provider?.thinking_level),
-    row.error_code || error.code || error.name || (llm.error ? "LLM_SCREENING_ERROR" : ""),
+    firstText(llm.screening_strategy),
+    firstText(llm.decision_source),
+    typeof llm.verified === "boolean" ? llm.verified : "",
+    firstText(llm.verification_reason),
+    row.error_code || error.code || error.name || llm.error_code || (llm.error ? "LLM_SCREENING_ERROR" : ""),
     row.error_message || error.message || llm.error || "",
     candidate.id || row.candidate_id || "",
     timingValue(row, "total_ms"),

package/src/core/screening/index.js

@@ -38,6 +38,9 @@ const GENDER_CODE_MAP = {
 };
 
 const LLM_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "auto", "current"]);
+const LLM_SCREENING_STRATEGIES = new Set(["single_pass", "fast_first_verified"]);
+const FAST_FIRST_DEFAULT_FAST_MAX_TOKENS = 384;
+const FATAL_LLM_PROVIDER_MAX_RETRIES = 2;
 
 function nowIso() {
   return new Date().toISOString();
@@ -48,6 +51,11 @@ function normalizeLlmThinkingLevel(value) {
   return LLM_THINKING_LEVELS.has(normalized) ? normalized : "";
 }
 
+function normalizeLlmScreeningStrategy(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  return LLM_SCREENING_STRATEGIES.has(normalized) ? normalized : "single_pass";
+}
+
 function normalizeBaseUrl(baseUrl) {
   return String(baseUrl || "").replace(/\/+$/, "");
 }
@@ -126,6 +134,65 @@ function compactLlmProviderFailure(error, providerConfig = {}, providerIndex = 0
   };
 }
 
+export function classifyFatalLlmProviderError(error) {
+  if (!error) return null;
+  if (error.llm_fatal_provider_error) {
+    return {
+      code: error.code || "LLM_FATAL_PROVIDER_ERROR",
+      reason: error.llm_fatal_reason || "fatal_provider_error"
+    };
+  }
+  const status = Number(error?.status);
+  const message = String(error?.message || error || "");
+  const providerCode = normalizeText(error?.provider_error_code).toLowerCase();
+  const providerType = normalizeText(error?.provider_error_type).toLowerCase();
+  const searchable = `${providerCode} ${providerType} ${message}`.toLowerCase();
+  if (/(?:budget[_\s-]*exceeded|budget has been exceeded|max budget|spend cap|hard limit|credit limit)/i.test(searchable)) {
+    return { code: "LLM_BUDGET_EXCEEDED", reason: "budget_exceeded" };
+  }
+  if (/(?:insufficient[_\s-]*quota|quota[_\s-]*(?:exceeded|exhausted)|(?:exceeded|exhausted).*quota|out of quota|usage quota|token quota|monthly quota|rate limit quota)/i.test(searchable)) {
+    return { code: "LLM_QUOTA_EXCEEDED", reason: "quota_exceeded" };
+  }
+  if (/(?:insufficient[_\s-]*(?:balance|credit|credits)|no credits|credit balance|billing|payment required|unpaid|account balance)/i.test(searchable)) {
+    return { code: "LLM_BILLING_REQUIRED", reason: "billing_required" };
+  }
+  if (status === 401 || /(?:unauthorized|unauthorised|invalid api key|incorrect api key|authentication failed|invalid authentication|api key invalid|no api key)/i.test(searchable)) {
+    return { code: "LLM_AUTH_FAILED", reason: "auth_failed" };
+  }
+  if (status === 403 || /(?:forbidden|permission denied|access denied|not authorized|not authorised|model access denied)/i.test(searchable)) {
+    return { code: "LLM_PERMISSION_DENIED", reason: "permission_denied" };
+  }
+  return null;
+}
+
+export function isFatalLlmProviderError(error) {
+  return Boolean(classifyFatalLlmProviderError(error));
+}
+
+export function createFatalLlmRunError(error, { domain = "", candidate = null } = {}) {
+  const classification = classifyFatalLlmProviderError(error) || {
+    code: "LLM_FATAL_PROVIDER_ERROR",
+    reason: "fatal_provider_error"
+  };
+  const attempts = Number(error?.llm_attempt_count) || 0;
+  const suffix = attempts ? ` after ${attempts} attempts` : "";
+  const fatal = new Error(`Fatal LLM provider error${suffix}: ${error?.message || String(error || "unknown")}`);
+  fatal.name = "FatalLlmProviderError";
+  fatal.code = classification.code;
+  fatal.llm_fatal_provider_error = true;
+  fatal.llm_fatal_reason = classification.reason;
+  fatal.llm_attempt_count = attempts;
+  fatal.status = Number.isFinite(Number(error?.status)) ? Number(error.status) : null;
+  fatal.provider_error_code = error?.provider_error_code || null;
+  fatal.provider_error_type = error?.provider_error_type || null;
+  fatal.provider_error_message = error?.provider_error_message || null;
+  fatal.domain = domain || null;
+  fatal.candidate_id = candidate?.id || null;
+  fatal.candidate_name = candidate?.identity?.name || null;
+  fatal.cause = error || null;
+  return fatal;
+}
+
 function isVolcengineModel(baseUrl, model) {
   return /volces|volcengine|ark\.cn|doubao|seed/i.test(`${baseUrl || ""} ${model || ""}`);
 }
@@ -168,7 +235,7 @@ function parseFiniteNumber(value, fallback = null) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
-function resolveLlmOutputTokenBudget(config = {}, thinkingLevel = "") {
+function resolveLlmOutputTokenBudget(config = {}, thinkingLevel = "", options = {}) {
   const explicit = parsePositiveNumber(
     config.llmMaxCompletionTokens
     ?? config.maxCompletionTokens
@@ -177,10 +244,16 @@ function resolveLlmOutputTokenBudget(config = {}, thinkingLevel = "") {
     null
   );
   if (explicit) return Math.max(1, Math.floor(explicit));
+  if (options.requireReviewDecision) return 384;
   const normalizedThinking = normalizeLlmThinkingLevel(thinkingLevel || "low") || "low";
   return normalizedThinking === "off" || normalizedThinking === "minimal" ? 64 : 512;
 }
 
+function parsePositiveInteger(value, fallback = null) {
+  const parsed = parsePositiveNumber(value, fallback);
+  return parsed ? Math.max(1, Math.floor(parsed)) : fallback;
+}
+
 export function normalizeText(input) {
   return String(input || "").replace(/\s+/g, " ").trim();
 }
@@ -1451,6 +1524,7 @@ export function compactScreeningLlmResult(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 || "",
@@ -1461,6 +1535,17 @@ export function compactScreeningLlmResult(llmResult) {
     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,
     screened_at: llmResult.screened_at || null
   };
@@ -1477,11 +1562,12 @@ export function llmResultToScreening(llmResult, candidate) {
 }
 
 export function isRecoverableLlmScreeningError(error) {
-  return /(?:LLM response missing boolean passed decision|LLM response missing brief summary|LLM response was not valid JSON)/i
+  return /(?:LLM response missing boolean passed decision|LLM response missing brief summary|LLM response missing boolean review_required decision|LLM response was not valid JSON)/i
     .test(String(error?.message || error || ""));
 }
 
 export function createFailedLlmScreeningResult(error) {
+  const fatalClassification = classifyFatalLlmProviderError(error);
   return {
     ok: false,
     passed: false,
@@ -1496,6 +1582,9 @@ export function createFailedLlmScreeningResult(error) {
     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_code: fatalClassification?.code || error?.code || null,
+    fatal: Boolean(fatalClassification),
+    fatal_reason: fatalClassification?.reason || "",
     error: error?.message || String(error || "unknown"),
     screened_at: nowIso()
   };
@@ -1505,6 +1594,7 @@ export function buildScreeningLlmMessages({
   candidate,
   criteria,
   thinkingLevel = "low",
+  requireReviewDecision = false,
   imageEvidence = null,
   imagePaths = [],
   imageInputs = null,
@@ -1514,7 +1604,8 @@ export function buildScreeningLlmMessages({
   const safeCriteria = normalizeText(criteria || "判断候选人是否符合本次招聘筛选标准");
   const safeText = String(candidate?.text?.raw || candidate?.text || "");
   const normalizedThinkingLevel = normalizeLlmThinkingLevel(thinkingLevel) || "low";
-  const requestSummary = normalizedThinkingLevel === "current";
+  const requestReviewDecision = Boolean(requireReviewDecision);
+  const requestSummary = requestReviewDecision || normalizedThinkingLevel === "current";
   const images = Array.isArray(imageInputs)
     ? imageInputs
     : buildScreeningLlmImageInputs({
@@ -1523,23 +1614,43 @@ export function buildScreeningLlmMessages({
       maxImages,
       detail: imageDetail
     });
-  const outputShape = requestSummary
-    ? "4) 只返回 JSON，格式为："
-      + "{\"passed\": true/false, \"summary\": \"少于100个中文词的筛选总结\"}"
-    : "4) 只返回 JSON，格式为："
-      + "{\"passed\": true/false}";
+  const outputShape = requestReviewDecision
+    ? "最后只返回 JSON，格式为："
+      + "{\"passed\": true/false, \"summary\": \"少于100个中文词的筛选总结\", \"review_required\": true/false}"
+    : requestSummary
+      ? "7) 只返回 JSON，格式为："
+        + "{\"passed\": true/false, \"summary\": \"少于100个中文词的筛选总结\"}"
+      : "7) 只返回 JSON，格式为："
+        + "{\"passed\": true/false}";
+  const failFastInstructions = [
+    "3) 按筛选标准原文顺序拆解并检查硬性淘汰项；一旦某项可确定不满足，必须立即返回 passed=false，不要继续评估后续条件。",
+    "4) 若筛选标准规定证据不足、业务线无法判断、任期无法判断、学校无法判断等情况不通过，这类缺失证据就是可确定不满足。",
+    "5) 只有当前淘汰项本身存在截图不清、信息冲突、或可能被后续可见简历内容澄清时，才继续阅读以核实该项。"
+  ].join("\n");
+  const fastReviewInstructions = requestReviewDecision
+    ? [
+      "7) review_required 必须是布尔值；当证据缺失、证据冲突、截图/文本不完整或不清晰、结论接近规则边界、或你依赖假设时设为 true；若结论明确且无需更深推理核验，设为 false。",
+      "8) 只有当某个硬性不通过条件有直接、明确、无可见反向证据的简历证据时，才可返回 review_required=false。",
+      "9) 如果简历中存在任何可能满足当前被否定条件的反向证据、边界证据或可计入经历，即使你倾向 passed=false，也必须 review_required=true。",
+      "10) 反向证据包括但不限于：可能合格的学校/学历、可能合格的产品或行业、可能合格的职责或指标、可能合格的海外/语言证据、或需要精确计算的任期/年限证据。",
+      "11) 不要因为候选人其他经历不匹配，就忽略某一段可能匹配的经历；只要任一可见经历可能满足被否定条件，就必须交给复核。",
+      "12) 当 review_required=false 时，summary 必须点明确切的决定性硬性失败，并说明没有可见反向证据或边界证据。"
+    ].join("\n")
+    : "";
   const prompt =
     `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${safeCriteria}\n\n`
     + `候选人信息:\n${safeText || "候选人的完整简历信息在后续截图中，请按截图顺序阅读。"}\n\n`
     + (images.length
-      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。若截图是拼接长图，请按图内从上到下顺序完整阅读；不要跳过任何一段简历内容。\n\n`
+      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。若截图是拼接长图，请按图内从上到下顺序阅读；若已出现明确硬性淘汰项，可停止后续评估。\n\n`
       : "")
     + "要求：\n"
     + "1) 只能依据候选人信息或截图中真实出现的内容判断。\n"
     + "2) 若证据不足或截图无法确认，必须返回 passed=false。\n"
+    + failFastInstructions + "\n"
     + (requestSummary
-      ? "3) summary 必须为少于100个中文词的简短筛选总结，可包含核心依据和主要风险；不要输出推理过程。\n"
-      : "3) 不要输出评估原因、证据列表、解释或额外文字。\n")
+      ? "6) summary 必须为少于100个中文词的简短筛选总结，可包含核心依据和主要风险；不要输出推理过程。\n"
+      : "6) 不要输出评估原因、证据列表、解释或额外文字。\n")
+    + (fastReviewInstructions ? `${fastReviewInstructions}\n` : "")
     + outputShape;
   const userContent = images.length
     ? [
@@ -1554,8 +1665,10 @@ export function buildScreeningLlmMessages({
     {
       role: "system",
       content:
-        "你是一位严谨的招聘筛选助手。必须完整阅读输入内容，严禁编造不存在的候选人经历。"
-        + (requestSummary
+        "你是一位严谨的招聘筛选助手。必须按筛选标准顺序严格阅读和判断，严禁编造不存在的候选人经历；一旦确定命中硬性淘汰项，可立即给出最终不通过结论。"
+        + (requestReviewDecision
+          ? "只能返回严格 JSON。必须包含 passed、summary 和 review_required；summary 用中文，少于100个词，只概括筛选结论、核心依据和主要风险，不要输出推理过程；review_required 只能是 true 或 false。只有在硬性失败直接明确且无可见反向证据时，review_required 才能为 false。"
+          : requestSummary
           ? "只能返回严格 JSON。必须包含 passed 和 summary；summary 用中文，少于100个词，只概括筛选结论、核心依据和主要风险，不要输出推理过程。"
           : "只能返回严格 JSON，不要输出原因、证据或额外文字。")
     },
@@ -1589,6 +1702,7 @@ async function callScreeningLlmWithProvider({
   criteria,
   config = {},
   timeoutMs = 60000,
+  requireReviewDecision = false,
   imageEvidence = null,
   imagePaths = [],
   maxImages = 8,
@@ -1611,7 +1725,7 @@ async function callScreeningLlmWithProvider({
   }
 
   const thinkingLevel = config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "low";
-  const outputTokenBudget = resolveLlmOutputTokenBudget(config, thinkingLevel);
+  const outputTokenBudget = resolveLlmOutputTokenBudget(config, thinkingLevel, { requireReviewDecision });
   const payload = {
     model,
     temperature: parseFiniteNumber(config.temperature, 0.1),
@@ -1620,6 +1734,7 @@ async function callScreeningLlmWithProvider({
       candidate,
       criteria,
       thinkingLevel,
+      requireReviewDecision,
       imageInputs
     })
   };
@@ -1642,7 +1757,10 @@ async function callScreeningLlmWithProvider({
   const maxRetries = normalizeLlmMaxRetries(config.llmMaxRetries ?? config.maxRetries);
   const maxAttempts = maxRetries + 1;
   let lastError = null;
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+  let attempt = 0;
+  let fatalProviderAttempts = 0;
+  while (true) {
+    attempt += 1;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), effectiveTimeoutMs);
     try {
@@ -1663,6 +1781,10 @@ async function callScreeningLlmWithProvider({
       if (!response.ok) {
         const error = new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
         error.status = response.status;
+        const providerError = tryParseJson(responseText)?.error || {};
+        error.provider_error_code = providerError.code || null;
+        error.provider_error_type = providerError.type || null;
+        error.provider_error_message = providerError.message || null;
         throw error;
       }
       const json = tryParseJson(responseText);
@@ -1679,13 +1801,19 @@ async function callScreeningLlmWithProvider({
       }
       const normalizedThinkingLevel = normalizeLlmThinkingLevel(thinkingLevel) || "low";
       const summary = normalizeBlockText(parsed?.summary || parsed?.screen_summary || parsed?.brief_summary);
-      if (normalizedThinkingLevel === "current" && !summary) {
-        throw new Error(`LLM response missing brief summary for current thinking level: ${content.slice(0, 240)}`);
+      if ((normalizedThinkingLevel === "current" || requireReviewDecision) && !summary) {
+        throw new Error(`LLM response missing brief summary for current thinking level or fast-first strategy: ${content.slice(0, 240)}`);
+      }
+      const reviewRequired = requireReviewDecision
+        ? parsePassedDecision(parsed?.review_required ?? parsed?.reviewRequired ?? parsed?.needs_review ?? parsed?.needsReview)
+        : null;
+      if (requireReviewDecision && reviewRequired === null) {
+        throw new Error(`LLM response missing boolean review_required decision: ${content.slice(0, 240)}`);
       }
       const evidence = Array.isArray(parsed?.evidence)
         ? parsed.evidence.map(normalizeText).filter(Boolean)
         : [];
-      const decisionCot = normalizedThinkingLevel === "current"
+      const decisionCot = (normalizedThinkingLevel === "current" || requireReviewDecision)
         ? summary
         : (firstReasoningText([
           parsed?.cot,
@@ -1712,6 +1840,7 @@ async function callScreeningLlmWithProvider({
           max_completion_tokens: payload.max_completion_tokens || null
         },
         passed,
+        review_required: reviewRequired,
         reason: "",
         evidence,
         cot: decisionCot,
@@ -1730,7 +1859,23 @@ async function callScreeningLlmWithProvider({
       return result;
     } catch (error) {
       lastError = error;
-      if (attempt >= maxAttempts || !isRetryableLlmRequestError(error)) {
+      const fatalClassification = classifyFatalLlmProviderError(error);
+      if (fatalClassification) {
+        fatalProviderAttempts += 1;
+        error.code = fatalClassification.code;
+        error.llm_fatal_provider_error = true;
+        error.llm_fatal_reason = fatalClassification.reason;
+        if (fatalProviderAttempts <= FATAL_LLM_PROVIDER_MAX_RETRIES) {
+          await sleepMs(Math.min(2500, 500 * fatalProviderAttempts));
+          continue;
+        }
+        error.image_input_count = imageInputs.length;
+        error.image_inputs = summarizeLlmImageInputs(imageInputs);
+        error.llm_attempt_count = attempt;
+        throw error;
+      }
+      const retryable = isRetryableLlmRequestError(error) || isRecoverableLlmScreeningError(error);
+      if (attempt >= maxAttempts || !retryable) {
         error.image_input_count = imageInputs.length;
         error.image_inputs = summarizeLlmImageInputs(imageInputs);
         error.llm_attempt_count = attempt;
@@ -1748,7 +1893,110 @@ async function callScreeningLlmWithProvider({
   throw lastError;
 }
 
-export async function callScreeningLlm(args = {}) {
+function compactStrategyLlmResult(result) {
+  if (!result) return null;
+  const compact = compactScreeningLlmResult(result);
+  if (compact) {
+    compact.fast_result = null;
+    compact.verify_result = null;
+  }
+  return compact;
+}
+
+function attachFastFirstScreeningMetadata(result, {
+  fastThinkingLevel = "current",
+  verifyThinkingLevel = "low",
+  verified = false,
+  verificationReason = "",
+  decisionSource = "fast",
+  fastResult = null,
+  verifyResult = null
+} = {}) {
+  return {
+    ...result,
+    screening_strategy: "fast_first_verified",
+    fast_thinking_level: fastThinkingLevel,
+    verify_thinking_level: verifyThinkingLevel,
+    verified: Boolean(verified),
+    verification_reason: verificationReason,
+    decision_source: decisionSource,
+    fast_result: compactStrategyLlmResult(fastResult),
+    verify_result: compactStrategyLlmResult(verifyResult)
+  };
+}
+
+function normalizeStrategyThinkingLevel(value, fallback) {
+  return normalizeLlmThinkingLevel(value) || normalizeLlmThinkingLevel(fallback) || fallback;
+}
+
+function resolveStrategyPassMaxTokens(entry = {}, inherited = {}, pass = "fast", fallback = null) {
+  const value = pass === "verify"
+    ? firstConfiguredValue(
+      entry.llmVerifyMaxTokens,
+      entry.verifyMaxTokens,
+      entry.verify_max_tokens,
+      inherited.llmVerifyMaxTokens,
+      inherited.verifyMaxTokens,
+      inherited.verify_max_tokens
+    )
+    : firstConfiguredValue(
+      entry.llmFastMaxTokens,
+      entry.fastMaxTokens,
+      entry.fast_max_tokens,
+      inherited.llmFastMaxTokens,
+      inherited.fastMaxTokens,
+      inherited.fast_max_tokens
+    );
+  return parsePositiveInteger(value, fallback);
+}
+
+function applyForcedOutputTokenBudget(config = {}, outputTokenBudget = null) {
+  const budget = parsePositiveInteger(outputTokenBudget, null);
+  if (!budget) return config;
+  const next = {
+    ...config,
+    llmMaxTokens: budget,
+    maxTokens: budget
+  };
+  delete next.llmMaxCompletionTokens;
+  delete next.maxCompletionTokens;
+  return next;
+}
+
+function withForcedLlmThinkingLevel(config = {}, thinkingLevel = "low", options = {}) {
+  const normalizedThinkingLevel = normalizeStrategyThinkingLevel(thinkingLevel, "low");
+  const forceEntry = (entry) => {
+    const objectEntry = typeof entry === "string" ? { model: entry } : { ...(entry || {}) };
+    const forced = {
+      ...objectEntry,
+      llmThinkingLevel: normalizedThinkingLevel,
+      thinkingLevel: normalizedThinkingLevel,
+      reasoningEffort: normalizedThinkingLevel
+    };
+    const entryBudget = options.pass
+      ? resolveStrategyPassMaxTokens(objectEntry, config, options.pass, options.defaultMaxTokens)
+      : options.outputTokenBudget;
+    return applyForcedOutputTokenBudget(forced, entryBudget);
+  };
+  const baseBudget = options.pass
+    ? resolveStrategyPassMaxTokens(config, {}, options.pass, options.defaultMaxTokens)
+    : options.outputTokenBudget;
+  const next = applyForcedOutputTokenBudget({
+    ...(config || {}),
+    llmThinkingLevel: normalizedThinkingLevel,
+    thinkingLevel: normalizedThinkingLevel,
+    reasoningEffort: normalizedThinkingLevel
+  }, baseBudget);
+  if (Array.isArray(config?.llmModels)) {
+    next.llmModels = config.llmModels.map(forceEntry);
+  }
+  if (Array.isArray(config?.models)) {
+    next.models = config.models.map(forceEntry);
+  }
+  return next;
+}
+
+async function callSinglePassScreeningLlm(args = {}) {
   const providers = normalizeLlmProviderConfigs(args.config || {});
   if (providers.length <= 1) {
     return callScreeningLlmWithProvider({
@@ -1782,6 +2030,7 @@ export async function callScreeningLlm(args = {}) {
         fallback_count: providerFailures.length
       };
     } catch (error) {
+      if (isFatalLlmProviderError(error)) throw error;
       lastError = error;
       providerFailures.push(compactLlmProviderFailure(error, providerConfig, index));
       if (index < providers.length - 1) {
@@ -1802,3 +2051,85 @@ export async function callScreeningLlm(args = {}) {
   finalError.image_inputs = lastError?.image_inputs || [];
   throw finalError;
 }
+
+async function callFastFirstVerifiedScreeningLlm(args = {}) {
+  const config = args.config || {};
+  const fastThinkingLevel = normalizeStrategyThinkingLevel(config.llmFastThinkingLevel ?? config.fastThinkingLevel, "current");
+  const verifyThinkingLevel = normalizeStrategyThinkingLevel(config.llmVerifyThinkingLevel ?? config.verifyThinkingLevel, "low");
+  const fastArgs = {
+    ...args,
+    config: withForcedLlmThinkingLevel(config, fastThinkingLevel, {
+      pass: "fast",
+      defaultMaxTokens: FAST_FIRST_DEFAULT_FAST_MAX_TOKENS
+    }),
+    requireReviewDecision: true
+  };
+  let fastResult = null;
+  let verifyReason = "";
+  try {
+    fastResult = await callSinglePassScreeningLlm(fastArgs);
+    if (fastResult.passed === true) {
+      verifyReason = fastResult.review_required === true ? "fast_passed_review_required" : "fast_passed";
+    } else if (fastResult.review_required === true) {
+      verifyReason = "fast_review_required";
+    }
+  } catch (error) {
+    if (isFatalLlmProviderError(error)) throw error;
+    fastResult = createFailedLlmScreeningResult(error);
+    verifyReason = "fast_invalid_response";
+  }
+
+  if (!verifyReason) {
+    return attachFastFirstScreeningMetadata(fastResult, {
+      fastThinkingLevel,
+      verifyThinkingLevel,
+      verified: false,
+      decisionSource: "fast",
+      fastResult
+    });
+  }
+
+  const verifyArgs = {
+    ...args,
+    config: withForcedLlmThinkingLevel(config, verifyThinkingLevel, {
+      pass: "verify"
+    }),
+    requireReviewDecision: false
+  };
+  try {
+    const verifyResult = await callSinglePassScreeningLlm(verifyArgs);
+    return attachFastFirstScreeningMetadata(verifyResult, {
+      fastThinkingLevel,
+      verifyThinkingLevel,
+      verified: true,
+      verificationReason: verifyReason,
+      decisionSource: "verify",
+      fastResult,
+      verifyResult
+    });
+  } catch (error) {
+    if (isFatalLlmProviderError(error)) throw error;
+    const failedVerifyResult = createFailedLlmScreeningResult(error);
+    return attachFastFirstScreeningMetadata(failedVerifyResult, {
+      fastThinkingLevel,
+      verifyThinkingLevel,
+      verified: true,
+      verificationReason: verifyReason,
+      decisionSource: "verify_error",
+      fastResult,
+      verifyResult: failedVerifyResult
+    });
+  }
+}
+
+export async function callScreeningLlm(args = {}) {
+  const strategy = normalizeLlmScreeningStrategy(
+    args.config?.llmScreeningStrategy
+    ?? args.config?.screeningStrategy
+    ?? args.config?.screening_strategy
+  );
+  if (strategy === "fast_first_verified") {
+    return callFastFirstVerifiedScreeningLlm(args);
+  }
+  return callSinglePassScreeningLlm(args);
+}

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

@@ -40,6 +40,8 @@ import {
 } from "../../core/run/timing.js";
 import {
   callScreeningLlm,
+  createFatalLlmRunError,
+  isFatalLlmProviderError,
   normalizeText,
   screenCandidate
 } from "../../core/screening/index.js";
@@ -108,19 +110,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 +353,9 @@ function isRecoverableLlmScreeningError(error) {
 }
 
 function createFailedLlmResult(error) {
-  return {
-    ok: false,
-    passed: false,
+  return {
+    ok: false,
+    passed: false,
     reason: "",
     evidence: [],
     cot: "",
@@ -349,12 +363,15 @@ 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()
-  };
-}
+    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();
@@ -1510,9 +1527,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 +1606,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);
+                }
               }
             }
           }

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

@@ -41,7 +41,9 @@ import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import {
   callScreeningLlm,
   compactScreeningLlmResult,
+  createFatalLlmRunError,
   createFailedLlmScreeningResult,
+  isFatalLlmProviderError,
   llmResultToScreening,
   screenCandidate
 } from "../../core/screening/index.js";
@@ -1343,9 +1345,15 @@ export async function runRecommendWorkflow({
             maxImages: llmImageLimit,
             imageDetail: llmImageDetail
           }));
-        } catch (error) {
-          llmResult = createFailedLlmScreeningResult(error);
-        }
+          } catch (error) {
+            if (isFatalLlmProviderError(error)) {
+              throw createFatalLlmRunError(error, {
+                domain: "recommend",
+                candidate: screeningCandidate
+              });
+            }
+            llmResult = createFailedLlmScreeningResult(error);
+          }
       }
       if (detailResult) detailResult.llm_result = llmResult;
     }

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

@@ -39,7 +39,9 @@ import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import {
   callScreeningLlm,
   compactScreeningLlmResult,
+  createFatalLlmRunError,
   createFailedLlmScreeningResult,
+  isFatalLlmProviderError,
   llmResultToScreening,
   screenCandidate
 } from "../../core/screening/index.js";
@@ -1022,6 +1024,12 @@ export async function runRecruitWorkflow({
             imageDetail: llmImageDetail
           }));
         } catch (error) {
+          if (isFatalLlmProviderError(error)) {
+            throw createFatalLlmRunError(error, {
+              domain: "recruit",
+              candidate: screeningCandidate
+            });
+          }
           llmResult = createFailedLlmScreeningResult(error);
         }
       }