@reconcrap/boss-recommend-mcp 2.1.3 → 2.1.5

package/README.md

@@ -116,9 +116,9 @@ MCP 工具：
 boss-recommend-mcp list-jobs --slow-live --port 9222
 ```
 
-返回的 `job_names` 可直接作为后续 `start_recommend_pipeline_run` 的 `confirmation.job_value` / `overrides.job`。
+返回的 `job_names` 可直接作为后续 `start_recommend_pipeline_run` 的 `overrides.job`；旧版 `confirmation.job_value` 仍兼容。
 
-Cron / 一次性定时任务设置建议先在设置阶段完成 Chrome/登录/岗位发现与全部确认：
+Cron / 一次性定时任务设置建议先在设置阶段完成 Chrome/登录/岗位发现与一次总确认；确认文件推荐只包含 `{ "final_confirmed": true }`：
 
 ```bash
 boss-recommend-mcp prepare-run --instruction-file boss-recommend-instruction.txt --overrides-file boss-recommend-overrides.json --confirmation-file boss-recommend-confirmation.json --slow-live --port 9222
@@ -158,20 +158,18 @@ boss-recommend-mcp schedule-status --schedule-id <schedule_id>
 - 学校标签支持多选语义：如“985、211”会同时勾选这两项
 - 学校标签对“混合输入”按容错处理：如“985、211、qs100”会忽略无效项 `qs100`，保留并应用有效项；仅当全部无效或用户明确“不限”时才回落到“不限”
 - 学历支持单选与多选语义：如“本科及以上”会展开为 `本科/硕士/博士`；如“大专、本科”只勾选这两项
-- 执行前会逐项确认筛选参数：学校标签 / 学历 / 性别 / 是否过滤近14天已看
-- 页面就绪（已登录且在 recommend 页）后，会先提取岗位栏全部岗位并要求用户确认本次岗位；确认后先点击岗位，再执行 search/screen
-- 在真正开始 search/screen 前，会进行最后一轮全参数总确认（岗位 + 全部筛选参数 + criteria + target_count + post_action + max_greet_count）
+- 执行前会先补齐筛选值、岗位、后置动作和休息强度，然后只做一次总确认
+- 页面就绪（已登录且在 recommend 页）后，会先提取岗位栏全部岗位，使用精确岗位名填入 run payload，再进入总确认
+- 在真正开始 search/screen 或创建 cron 前，总确认需包含岗位、全部筛选参数、criteria、target_count、post_action、可选 max_greet_count、restLevel 和定时信息（如适用）
 - npm 全局安装后会自动执行 install：生成 skill、导出 MCP 模板，并自动尝试写入已检测到的外部 agent MCP 配置（含 Trae / trae-cn / Cursor / Claude / OpenClaw）
 - 2.x installer 会迁移已存在的 legacy Boss MCP 配置：把 `boss-recommend` 指向统一 `@reconcrap/boss-recommend-mcp`，并从同一个 `mcp.json` 中移除旧 `boss-recruit-mcp` / standalone `boss-chat` / 本地 legacy Boss 路径；写入前会生成 `.boss-mcp-migration-*.bak` 备份
 - 2.x installer 会刷新外部 agent skills：`boss-recommend-pipeline`、`boss-recruit-pipeline`、`boss-chat` 都来自当前包，旧 recruit/chat skill 会被覆盖为统一 MCP 路由
 - npm / npx 安装后会自动初始化 `screening-config.json` 模板（优先写入 workspace 的 `config/`，不可写时回退到用户目录）
 - npm 安装流程会预创建运行目录（跨平台）：`~/.boss-recommend-mcp`、`~/.boss-recommend-mcp/runs`、`~/.boss-recommend-mcp/boss-chat` 及其 `logs/runs/profiles/reports/artifacts/state`
-- `post_action` 必须在每次完整运行开始时确认一次
-- `target_count` 会在每次运行开始时询问一次（可留空，不设上限）
-- 当 `post_action=greet` 时，必须在运行开始时确认 `max_greet_count`
-- 若检测到 `max_greet_count` 可能由 agent 自动默认（例如与 `target_count` 相同且原始指令未明确），会强制再次向用户确认
+- `post_action`、`target_count` 和可选 `max_greet_count` 通过同一次总确认锁定
+- 新流程中 `confirmation.final_confirmed=true` 是总确认；旧版逐字段 `*_confirmed` JSON 仍兼容但不是推荐写法
 - 一旦确认 `post_action`，本次运行内所有通过人选都统一按该动作执行
-- 若达到 `max_greet_count` 但流程仍需继续，后续通过人选会自动改为收藏
+- 若达到可选 `max_greet_count` 但流程仍需继续，后续通过人选会继续筛选但不再执行打招呼动作
 - 不会对每位候选人重复确认
 - 推荐页详情处理完成后，会强制关闭详情页并确认已关闭
 - 简历提取优先使用 Network 响应；没有可解析 Network CV 时，回退到完整滚动截图序列再交给多模态模型判断
@@ -492,27 +490,10 @@ Trae-CN / 长对话防循环建议：
 {
   "instruction": "推荐页筛选211女生，近14天没有，有 AI Agent 经验，符合标准的直接沟通",
   "confirmation": {
-    "filters_confirmed": true,
-    "school_tag_confirmed": true,
-    "school_tag_value": ["985", "211"],
-    "degree_confirmed": true,
-    "degree_value": ["本科", "硕士", "博士"],
-    "gender_confirmed": true,
-    "gender_value": "女",
-    "recent_not_view_confirmed": true,
-    "recent_not_view_value": "近14天没有",
-    "criteria_confirmed": true,
-    "target_count_confirmed": true,
-    "target_count_value": 20,
-    "post_action_confirmed": true,
-    "post_action_value": "greet",
-    "final_confirmed": true,
-    "job_confirmed": true,
-    "job_value": "算法工程师（视频/图像模型方向） _ 杭州",
-    "max_greet_count_confirmed": true,
-    "max_greet_count_value": 10
+    "final_confirmed": true
   },
   "overrides": {
+    "page_scope": "recommend",
     "school_tag": ["985", "211"],
     "degree": ["本科", "硕士", "博士"],
     "gender": "女",
@@ -520,21 +501,16 @@ Trae-CN / 长对话防循环建议：
     "criteria": "候选人需要有 AI Agent 或 MCP 工具开发经验",
     "job": "算法工程师（视频/图像模型方向） _ 杭州",
     "target_count": 20,
-    "post_action": "greet",
-    "max_greet_count": 10
+    "post_action": "greet"
   },
-  "follow_up": {
-    "chat": {
-      "criteria": "继续在聊天页处理有 AI Agent 或 MCP 项目经验的人选",
-      "start_from": "unread",
-      "target_count": 20,
-      "profile": "default",
-      "safe_pacing": true
-    }
+  "human_behavior": {
+    "restLevel": "medium"
   }
 }
 ```
 
+`confirmation.final_confirmed=true` 表示用户已经看过并确认总览。旧版 `page_confirmed`、`school_tag_confirmed`、`job_confirmed` 等逐字段布尔值仍兼容，但新流程不需要主动生成它们。
+
 ## 测试
 
 ```bash

package/package.json

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

package/skills/boss-recommend-pipeline/README.md

@@ -6,7 +6,7 @@
 
 - 先确认推荐页 filters
 - 再确认筛选 criteria
-- 再确认本次运行统一动作 `favorite` 或 `greet`
+- 再确认本次运行统一动作 `greet` 或 `none`
 - 每次运行都要让用户明确选择休息强度 `low` / `medium` / `high`，并传入 `human_behavior.restLevel`
 - 只确认一次 `post_action`，不要逐个候选人反复确认
 - 运行中临时中断请使用 `pause_recommend_pipeline_run`（按 run_id），不要靠自然语言“暂停/继续”指令

package/skills/boss-recommend-pipeline/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: "boss-recommend-pipeline"
-description: "Use when users want Boss recommend-page filtering/screening via boss-recommend-mcp. Confirm required params first, then run in two-stage confirmation with strict recommend routing."
+description: "Use when users want Boss recommend-page filtering/screening via boss-recommend-mcp. Gather required params, show one consolidated review, then run or schedule through the recommend MCP tools."
 ---
 
 # Boss Recommend Pipeline Skill
 
 ## Goal
 
-当用户要在 Boss 推荐页筛人时，必须走 `start_recommend_pipeline_run`，并按“两阶段确认 -> 页面就绪 -> 岗位确认 -> 最终确认 -> 执行”的顺序完成。2.0 CDP-only 路径不再支持 legacy recommend -> chat 自动衔接；若用户要聊天页筛选或求简历，必须在推荐页任务完成后显式改用 `boss-chat` 工具。
+当用户要在 Boss 推荐页筛人时，必须走 `start_recommend_pipeline_run`；若是稍后/cron 启动，必须走 `schedule_recommend_pipeline_run`。先补齐缺失值并读取岗位列表，然后展示一次包含岗位、筛选项、criteria、目标人数、后置动作、可选最大招呼数、休息强度和定时信息的总确认；用户确认后设置 `final_confirmed=true` 即可启动或创建定时任务。2.0 CDP-only 路径不再支持 legacy recommend -> chat 自动衔接；若用户要聊天页筛选或求简历，必须在推荐页任务完成后显式改用 `boss-chat` 工具。
 
 ## Hard Rules (Must Follow)
 
@@ -19,10 +19,11 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 
 - **确认不可代填（强制）**
   - 禁止 agent 自行“设置合理参数”并代替用户确认。
-  - 禁止在用户未明确回复前，把任意 `*_confirmed` 字段设为 `true`。
+  - 禁止在用户未明确回复前，把 `final_confirmed=true`。
+  - 旧版 `*_confirmed` 字段仍兼容，但新流程不要逐项设置；把规范化后的值写入 `overrides`，总确认后只需要 `confirmation.final_confirmed=true`。
   - 禁止在用户未明确回复前，自行填充 `page_scope/school_tag/degree/gender/recent_not_view/criteria/target_count/post_action/max_greet_count/job/rest_level`。
   - 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
-  - 若工具返回 `pending_questions`，必须逐项向用户提问并等待用户回复；不得跳过提问直接执行。
+  - 若工具返回 `pending_questions`，只追问这些缺口；若只返回 `final_review`，不要再拆成逐字段确认。
 
 - **岗位确认时机**
   - 页面未就绪前，禁止询问 `job`。
@@ -30,7 +31,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 
 - **参数确认**
   - `criteria` 必须是用户开放式自然语言；禁止“严格/宽松执行”等预设替代。
-  - `post_action=greet` 时，必须确认 `max_greet_count`；禁止自动默认为 `target_count`。
+  - `max_greet_count` 仅是可选的 `post_action=greet` 上限；禁止未告知用户就自动默认为 `target_count`。
   - 正式执行前必须 `final_confirmed=true`。
   - 真实筛选禁止传 `detail_limit: 0`；recommend 默认必须打开候选人详情/CV。只有用户明确要求“卡片-only 调试”时，才允许同时传 `detail_limit: 0` 和 `allow_card_only_screening: true`。
 
@@ -40,29 +41,29 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
   - 最终执行前逐字回显将提交的 `instruction`；若与锁定值不一致，先修正再执行。
   - 禁止在中途把用户意图拆成“recommend 已默认确认 + chat 单独执行”两条链路。
 
-## Two-Stage Confirmation
+## Single Review Confirmation
 
-### Stage A (页面就绪前，禁止问岗位)
-
-必须确认：
+先收集这些值：
 
 - `page_scope`：`recommend|latest|featured`
-- `school_tag`（多选）
-- `degree`（多选）
-- `gender`
-- `recent_not_view`
+- `school_tag`、`degree`、`gender`、`recent_not_view`
 - `criteria`（开放文本）
 - `target_count`（可空）
-- `post_action`：`favorite|greet|none`
-- `max_greet_count`（仅当 `post_action=greet`）
+- `post_action`：`greet|none`
+- `max_greet_count`（可选，仅当 `post_action=greet`）
 - `rest_level`：`low|medium|high`
+- `job`（来自 `list_recommend_jobs` / `job_options` 的精确岗位名）
+- cron/定时任务的启动时间（如适用）
 
-### Stage B (页面就绪后)
+然后只做一次总确认。用户回复“确认 / 全部确认 / 无需调整”后，下一次工具调用写入：
 
-必须确认：
+```json
+{
+  "confirmation": { "final_confirmed": true }
+}
+```
 
-- `job`（来自 `job_options`，必须全量展示）
-- `final_review`（岗位 + 全参数总确认）
+已确认值放在 `overrides` 和 `human_behavior.restLevel`。不要因为工具返回 `final_review` 就再问页面、学历、学校、性别、14天、criteria、目标人数、动作、最大招呼数等逐项确认。
 
 ## Chat Handoff
 
@@ -83,7 +84,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
   - `degree`: `不限/初中及以下/中专/中技/高中/大专/本科/硕士/博士`
   - `gender`: `不限/男/女`
   - `recent_not_view`: `不限/近14天没有`
-  - `post_action`: `favorite/greet/none`
+  - `post_action`: `greet/none`
   - `rest_level`: `low/medium/high`
 
 ## Tool Usage
@@ -105,7 +106,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 - 主工具：`start_recommend_pipeline_run`
 - 必填：`instruction`
 - 关键输入：
-  - `confirmation`：`page_confirmed/page_value/filters_confirmed/school_tag_confirmed.../job_confirmed/job_value/final_confirmed`
+  - `confirmation`：新流程只需要 `{ "final_confirmed": true }`；旧版 `page_confirmed/page_value/.../job_confirmed/job_value` 仍兼容但不要主动制造逐项确认。
   - `overrides`：`page_scope/school_tag/degree/gender/recent_not_view/criteria/job/target_count/post_action/max_greet_count`
   - `human_behavior`：必须包含本次用户确认的 `restLevel`（例如 `{ "restLevel": "medium" }`）
   - 不要传 `follow_up.chat`；该路径属于 legacy-only 行为
@@ -122,9 +123,9 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 创建 cron 时必须在设置 cron 的当下完成全部交互：
 
 1. 锁定用户原始 instruction，不改写、不摘要，criteria 放入 `overrides.criteria` 时必须逐字保留。
-2. 收集 Stage A 全部筛选项、`target_count`、`post_action`、`max_greet_count`（如需要）和本次 `rest_level`。
+2. 收集全部筛选项、`target_count`、`post_action`、可选 `max_greet_count` 和本次 `rest_level`。
 3. 调用 `list_recommend_jobs`；若 Chrome 未打开，工具会尝试自动打开本机 9222 Chrome 并进入推荐页。若返回 `BOSS_LOGIN_REQUIRED` 或页面不可用，停止 cron 创建，让用户登录/修复后重试。
-4. 用 `job_names` 中的精确岗位名完成岗位确认，并完成最终总确认，写入 `job_confirmed=true` 与 `final_confirmed=true`。
+4. 用 `job_names` 中的精确岗位名填入 `overrides.job`，展示包含启动时间的最终总确认；用户确认后写入 `final_confirmed=true`。
 5. 调用 `prepare_recommend_pipeline_run` 传入将来要执行的完整 payload；只有 `READY + cron_ready=true` 才能继续。
 6. 立即调用 `schedule_recommend_pipeline_run`，传入同一份完整 payload 和 `schedule_delay_minutes` / `schedule_run_at`。禁止让 OpenClaw 自己写 `/tmp/*.log` shell cron、自然语言提醒、或未来对话回调来代替此工具。
 7. 只有拿到 `SCHEDULED + schedule_id` 后才告诉用户定时任务已创建。回复必须包含 `schedule_id`，而不是只说“10 分钟后会启动”。
@@ -192,7 +193,7 @@ npx -y @reconcrap/boss-recommend-mcp@latest schedule-status --schedule-id <sched
 
 推荐做法：
 
-1. 将锁定的用户原文写入 instruction 文件，将已确认参数写入 `overrides` 与 `confirmation` JSON 文件。
+1. 将锁定的用户原文写入 instruction 文件，将已确认参数写入 `overrides` JSON；`confirmation` JSON 只需要 `{ "final_confirmed": true }`。
 2. 先用 `prepare-run` 校验完整 payload 已 cron-ready；未返回 `READY + cron_ready=true` 不得创建定时任务或启动 run。
 3. 若用户要“现在启动”，用 detached CLI 启动，让父命令返回启动证据，子进程继续持有 CDP 会话：
 
@@ -220,8 +221,8 @@ npx -y @reconcrap/boss-recommend-mcp@latest run --detached --instruction-file .\
 ## Response Style
 
 - 用结构化中文。
-- 第一轮确认卡片不出现 `job`。
-- 仅在 `job_options` 出现后给岗位确认卡片，且岗位选项必须全量。
+- 未读取岗位列表前不要要求用户最终确认。
+- 仅在 `job_options` 出现后选择精确岗位；最终确认卡片必须包含岗位和全部参数。
 - 封闭式问题必须带完整标签选项；开放式问题（如 `criteria`）保持自由输入。
 - 页面就绪失败提示必须包含 `debug_port`、recommend URL、以及登录 URL（若未登录）：
   - `https://www.zhipin.com/web/chat/recommend`

package/skills/boss-recruit-pipeline/SKILL.md

@@ -29,8 +29,7 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - 只有工具返回 `BOSS_LOGIN_REQUIRED` / `requires_login=true` 时，才要求用户在自动打开的 Chrome 窗口人工登录 Boss 后重试；不要把“没开 9222 Chrome”当作缺参。
 - 若本机找不到 Chrome，可提示用户设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`；非本机 debug host 不自动启动。
 - 若用户未提供岗位，必须先询问岗位。搜索页岗位选择在关键词输入框旁边；不要猜测默认岗位。
-- 若用户提供城市、学历、学校、关键词、过滤已看、人选目标数、筛选条件、post action、max greet 等参数，必须逐项传入或确认。
-- `post_action=greet` 时必须确认 `max_greet_count`；不要默认等于 `target_count`。
+- 若用户提供城市、学历、学校、关键词、过滤已看、人选目标数、筛选条件等参数，必须逐项传入或确认。
 - 搜索页和推荐页一样支持多选筛选条件；不要把多选降级成单选。
 - 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
 
@@ -48,8 +47,6 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - `degree`
 - `school_tag`
 - `recent_not_view`
-- `post_action`
-- `max_greet_count`
 - `port`
 
 启动工具时，把用户确认的休息强度写入 `human_behavior.restLevel`，例如：

package/src/domains/recommend/actions.js

@@ -22,7 +22,7 @@ import {
 import { waitForRecommendDetail } from "./detail.js";
 import { getRecommendRoots } from "./roots.js";
 
-const POST_ACTIONS = new Set(["none", "favorite", "greet"]);
+const POST_ACTIONS = new Set(["none", "greet"]);
 const GREET_EXACT_LABEL_PATTERN = /^(?:打招呼|聊一聊|立即沟通(?:[\(（]\d+\s*[/／]\s*\d+[\)）])?|沟通)$/i;
 export const RECOMMEND_DETAIL_ACTION_TEXT_SELECTORS = Object.freeze([
   "button",
@@ -94,7 +94,6 @@ function bestControl(controls, exactLabelPattern) {
 export function normalizeRecommendPostAction(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (["", "none", "skip", "no", "不执行", "无"].includes(normalized)) return "none";
-  if (["favorite", "fav", "collect", "收藏", "感兴趣"].includes(normalized)) return "favorite";
   if (["greet", "chat", "打招呼", "直接沟通", "沟通"].includes(normalized)) return "greet";
   return POST_ACTIONS.has(normalized) ? normalized : "";
 }
@@ -110,7 +109,7 @@ export function resolveRecommendPostAction({
   if (requested === "greet" && limit !== null && currentGreetCount >= limit) {
     return {
       requested,
-      effective: "favorite",
+      effective: "none",
       reason: "greet_limit_reached",
       greet_count: currentGreetCount,
       max_greet_count: limit

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

@@ -283,22 +283,22 @@ async function runRecommendPostAction({
     reason: ""
   };
 
-  if (!screening?.passed) {
-    result.reason = "screening_not_passed";
-    return result;
-  }
-  if (plan.effective === "none") {
-    result.reason = "post_action_none";
-    return result;
-  }
-
-  const summary = actionDiscovery?.summary || {};
-  const control = plan.effective === "favorite" ? summary.favorite : summary.greet;
-  if (!control?.found) {
-    result.reason = `${plan.effective}_control_not_found`;
-    return result;
-  }
-  result.control = control;
+  if (!screening?.passed) {
+    result.reason = "screening_not_passed";
+    return result;
+  }
+  if (plan.effective === "none") {
+    result.reason = plan.reason === "greet_limit_reached" ? "greet_limit_reached" : "post_action_none";
+    return result;
+  }
+
+  const summary = actionDiscovery?.summary || {};
+  const control = summary.greet;
+  if (!control?.found) {
+    result.reason = `${plan.effective}_control_not_found`;
+    return result;
+  }
+  result.control = control;
 
   if (plan.effective === "greet" && control.continue_chat) {
     result.reason = "already_connected_continue_chat";
@@ -315,15 +315,10 @@ async function runRecommendPostAction({
     result.reason = "greet_control_not_available";
     return result;
   }
-  if (plan.effective === "favorite" && control.active) {
-    result.reason = "already_favorited";
-    result.already_favorited = true;
-    return result;
-  }
-  if (control.disabled) {
-    result.reason = `${plan.effective}_control_disabled`;
-    return result;
-  }
+  if (control.disabled) {
+    result.reason = `${plan.effective}_control_disabled`;
+    return result;
+  }
   if (!executePostAction) {
     result.reason = "dry_run_post_action";
     result.would_click = true;
@@ -358,23 +353,18 @@ async function runRecommendPostAction({
       timeoutMs: 2500,
       intervalMs: 300,
       requireAny: false
-    });
-    const afterSummary = afterDiscovery?.summary || {};
-    const afterControl = plan.effective === "favorite" ? afterSummary.favorite : afterSummary.greet;
-    result.action_discovery_after = compactActionDiscovery(afterDiscovery);
-    result.control_after = afterControl || null;
-    if (plan.effective === "greet") {
-      result.verified_after_click = Boolean(
-        afterControl?.continue_chat
-        || String(afterControl?.label || "").includes("继续沟通")
-      );
-    } else if (plan.effective === "favorite") {
-      result.verified_after_click = Boolean(
-        afterControl?.active
-        || String(afterControl?.label || "").includes("已")
-      );
-    }
-  } catch (error) {
+    });
+    const afterSummary = afterDiscovery?.summary || {};
+    const afterControl = afterSummary.greet;
+    result.action_discovery_after = compactActionDiscovery(afterDiscovery);
+    result.control_after = afterControl || null;
+    if (plan.effective === "greet") {
+      result.verified_after_click = Boolean(
+        afterControl?.continue_chat
+        || String(afterControl?.label || "").includes("继续沟通")
+      );
+    }
+  } catch (error) {
     result.verify_error = {
       message: error?.message || String(error)
     };

package/src/index.js

@@ -520,6 +520,7 @@ function createRunInputSchema() {
       },
       confirmation: {
         type: "object",
+        description: "推荐页确认状态。新流程推荐只在用户看过总览后传 final_confirmed=true；逐字段 *_confirmed 为兼容旧调用保留。",
         properties: {
           page_confirmed: { type: "boolean" },
           page_value: {
@@ -580,11 +581,14 @@ function createRunInputSchema() {
             minimum: 1
           },
           post_action_confirmed: { type: "boolean" },
-          post_action_value: {
-            type: "string",
-            enum: ["favorite", "greet", "none"]
-          },
-          final_confirmed: { type: "boolean" },
+          post_action_value: {
+            type: "string",
+            enum: ["greet", "none"]
+          },
+          final_confirmed: {
+            type: "boolean",
+            description: "用户已确认包含岗位、筛选项、criteria、目标、动作、可选最大招呼数和 restLevel 的总览。"
+          },
           job_confirmed: { type: "boolean" },
           job_value: { type: "string" },
           max_greet_count_confirmed: { type: "boolean" },
@@ -648,10 +652,10 @@ function createRunInputSchema() {
           job: { type: "string" },
           target_count: { type: "integer", minimum: 1 },
           max_greet_count: { type: "integer", minimum: 1 },
-          post_action: {
-            type: "string",
-            enum: ["favorite", "greet", "none"]
-          }
+          post_action: {
+            type: "string",
+            enum: ["greet", "none"]
+          }
         },
         additionalProperties: false
       },
@@ -714,8 +718,8 @@ function createRunInputSchema() {
         type: "boolean",
         description: "可选，VPN/慢页面 live 测试模式，放宽等待时间"
       },
-      human_behavior: createHumanBehaviorInputSchema("可选，recommend 可靠性实验用节奏配置；默认 paced_with_rests/on"),
-      humanBehavior: createHumanBehaviorInputSchema("兼容字段；优先使用 human_behavior"),
+      human_behavior: createHumanBehaviorInputSchema("recommend 运行必须显式包含本次用户确认的 restLevel: low|medium|high；其他节奏配置可选"),
+      humanBehavior: createHumanBehaviorInputSchema("兼容字段；优先使用 human_behavior；recommend 运行同样必须显式包含 restLevel"),
       human_behavior_enabled: {
         type: "boolean",
         description: "兼容字段；true 等同启用 paced 默认配置，false 等同 baseline"
@@ -777,26 +781,26 @@ function createRunInputSchema() {
       },
       execute_post_action: {
         type: "boolean",
-        description: "可选，是否实际执行通过后的 recommend 后置动作 favorite/greet；默认 true"
+        description: "可选，是否实际执行通过后的 recommend 后置动作 greet；默认 true"
       },
       dry_run_post_action: {
         type: "boolean",
-        description: "可选，只验证 recommend 后置动作发现/配额/可点击路径，不实际点击 favorite/greet"
+        description: "可选，只验证 recommend 打招呼动作发现/配额/可点击路径，不实际点击"
       },
       action_timeout_ms: {
         type: "integer",
         minimum: 1000,
-        description: "可选，等待详情页 favorite/greet 控件出现的超时时间"
+        description: "可选，等待详情页 greet 控件出现的超时时间"
       },
       action_interval_ms: {
         type: "integer",
         minimum: 100,
-        description: "可选，轮询详情页 favorite/greet 控件的间隔"
+        description: "可选，轮询详情页 greet 控件的间隔"
       },
       action_after_click_delay_ms: {
         type: "integer",
         minimum: 0,
-        description: "可选，点击 favorite/greet 后等待页面状态稳定的时间"
+        description: "可选，点击 greet 后等待页面状态稳定的时间"
       },
       no_filter: {
         type: "boolean",
@@ -2433,7 +2437,7 @@ async function handleRunFeaturedCalibrationTool({ workspaceRoot, args }) {
     calibration_resolution: getFeaturedCalibrationResolution(workspaceRoot),
     guidance: {
       current_workaround: "Use an existing favorite-calibration.json if present; get_featured_calibration_status reports whether it is usable.",
-      next_development_task: "Implement CDP-only featured calibration with explicit user approval for any mutating favorite/greet action."
+      next_development_task: "Implement CDP-only featured calibration with explicit user approval for any calibration click."
     }
   };
 }

package/src/parser.js

@@ -32,9 +32,8 @@ const FILTER_CONFIRM_OPTIONS = [
   { label: "筛选项无误，继续", value: "confirm" },
   { label: "筛选项需要调整", value: "revise" }
 ];
-const POST_ACTION_OPTIONS = ["favorite", "greet", "none"];
+const POST_ACTION_OPTIONS = ["greet", "none"];
 const POST_ACTION_LABELS = {
-  favorite: "收藏",
   greet: "直接沟通",
   none: "什么也不做"
 };
@@ -306,7 +305,6 @@ function normalizeRecentNotView(value) {
 function normalizePostAction(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
-  if (["favorite", "fav", "收藏"].includes(normalized)) return "favorite";
   if (["greet", "chat", "打招呼", "直接沟通", "沟通"].includes(normalized)) return "greet";
   if (["none", "noop", "no-op", "什么也不做", "不做任何操作", "不操作", "仅筛选", "只筛选"].includes(normalized)) {
     return "none";
@@ -546,51 +544,43 @@ function buildCriteria({ instruction, rawInstruction, overrideCriteria }) {
   };
 }
 
-function resolvePostAction({ instruction, confirmation, overrides }) {
+function resolvePostAction({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.post_action_confirmed === true;
   const confirmationValue = normalizePostAction(confirmation?.post_action_value);
   const overrideValue = normalizePostAction(overrides?.post_action);
   const instructionValue =
-    /收藏/.test(instruction) && !/取消收藏/.test(instruction)
-      ? "favorite"
-      : /打招呼|直接沟通|沟通/.test(instruction)
+    /打招呼|直接沟通|沟通/.test(instruction)
         ? "greet"
         : /什么也不做|不做任何操作|不操作|仅筛选|只筛选/.test(instruction)
           ? "none"
-        : null;
+          : null;
   const proposed = overrideValue || confirmationValue || instructionValue || null;
 
-  if (confirmed && confirmationValue) {
-    return {
-      post_action: confirmationValue,
-      proposed_post_action: confirmationValue,
-      needs_post_action_confirmation: false
-    };
-  }
-
   return {
-    post_action: confirmed ? confirmationValue || proposed : null,
+    post_action: (confirmed || finalConfirmed) && proposed ? proposed : null,
     proposed_post_action: proposed,
-    needs_post_action_confirmation: true
+    needs_post_action_confirmation: !proposed
   };
 }
 
-function resolveTargetCount({ instruction, confirmation, overrides }) {
+function resolveTargetCount({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.target_count_confirmed === true;
   const overrideValue = parsePositiveIntegerValue(overrides?.target_count);
   const confirmationValue = parsePositiveIntegerValue(confirmation?.target_count_value);
   const instructionValue = extractTargetCount(instruction);
   const proposed = overrideValue || confirmationValue || instructionValue || null;
-  const resolved = overrideValue || (confirmed ? confirmationValue : null);
+  const resolved = (confirmed || finalConfirmed)
+    ? (overrideValue || confirmationValue || instructionValue || null)
+    : null;
 
   return {
     target_count: resolved,
     proposed_target_count: proposed,
-    needs_target_count_confirmation: !confirmed
+    needs_target_count_confirmation: false
   };
 }
 
-function resolveMaxGreetCount({ instruction, confirmation, overrides, postActionResolution }) {
+function resolveMaxGreetCount({ instruction, confirmation, overrides, postActionResolution, finalConfirmed = false }) {
   const actionHint = postActionResolution.post_action || postActionResolution.proposed_post_action;
   if (actionHint !== "greet") {
     return {
@@ -602,52 +592,33 @@ function resolveMaxGreetCount({ instruction, confirmation, overrides, postAction
   }
 
   const overrideValue = parsePositiveIntegerValue(overrides?.max_greet_count);
-  const confirmed = confirmation?.max_greet_count_confirmed === true;
   const confirmationValue = parsePositiveIntegerValue(confirmation?.max_greet_count_value);
   const instructionValue = extractMaxGreetCount(instruction);
-  const targetCountHint = (
-    parsePositiveIntegerValue(confirmation?.target_count_value)
-    || parsePositiveIntegerValue(overrides?.target_count)
-    || extractTargetCount(instruction)
-    || null
-  );
   const proposed = confirmationValue || overrideValue || instructionValue || null;
-  const resolved = confirmed ? (confirmationValue || overrideValue || null) : null;
-  const suspiciousAutoFill = Boolean(
-    !confirmed
-    && Number.isInteger(proposed)
-    && proposed > 0
-    && !Number.isInteger(instructionValue)
-    && Number.isInteger(targetCountHint)
-    && targetCountHint > 0
-    && proposed === targetCountHint
-  );
-  const needsConfirmation = (
-    !(Number.isInteger(resolved) && resolved > 0)
-  );
+  const resolved = confirmationValue || overrideValue || instructionValue || null;
 
   return {
-    max_greet_count: needsConfirmation ? null : resolved,
+    max_greet_count: resolved,
     proposed_max_greet_count: proposed,
-    needs_max_greet_count_confirmation: needsConfirmation,
-    suspicious_auto_fill: suspiciousAutoFill
+    needs_max_greet_count_confirmation: false,
+    suspicious_auto_fill: false
   };
 }
 
-function resolvePageScope({ instruction, confirmation, overrides }) {
+function resolvePageScope({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.page_confirmed === true;
   const confirmationValue = normalizePageScope(confirmation?.page_value);
   const overrideValue = normalizePageScope(overrides?.page_scope);
   const instructionValue = extractPageScope(instruction);
   const proposed = overrideValue || confirmationValue || instructionValue || "recommend";
   return {
-    page_scope: confirmed && confirmationValue ? confirmationValue : null,
+    page_scope: (confirmed && confirmationValue) || finalConfirmed ? proposed : null,
     proposed_page_scope: proposed,
-    needs_page_confirmation: !(confirmed && Boolean(confirmationValue))
+    needs_page_confirmation: !proposed
   };
 }
 
-function collectSuspiciousFields({ invalidOverrideSchoolTags, maxGreetCountResolution }) {
+function collectSuspiciousFields({ invalidOverrideSchoolTags }) {
   const suspicious = [];
   if (Array.isArray(invalidOverrideSchoolTags) && invalidOverrideSchoolTags.length > 0) {
     suspicious.push({
@@ -656,19 +627,13 @@ function collectSuspiciousFields({ invalidOverrideSchoolTags, maxGreetCountResol
       reason: `已忽略无效学校标签：${invalidOverrideSchoolTags.join(" / ")}；仅保留可识别选项。`
     });
   }
-  if (maxGreetCountResolution?.suspicious_auto_fill) {
-    suspicious.push({
-      field: "max_greet_count",
-      value: maxGreetCountResolution.proposed_max_greet_count,
-      reason: "检测到 max_greet_count 与 target_count 相同且原始指令未明确该值，可能是自动填充，需用户再次确认。"
-    });
-  }
   return suspicious;
 }
 
 export function parseRecommendInstruction({ instruction, confirmation, overrides }) {
   const rawInstruction = String(instruction || "");
   const text = normalizeText(rawInstruction);
+  const finalConfirmed = confirmation?.final_confirmed === true;
   const detectedSchoolTags = extractSchoolTags(text);
   const detectedDegrees = extractDegrees(text);
   const schoolTagAudit = auditSchoolTagSelections(overrides?.school_tag);
@@ -692,7 +657,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     || extractJobSelectionHint(rawInstruction)
     || ""
   );
-  const pageScopeResolution = resolvePageScope({ instruction: text, confirmation, overrides });
+  const pageScopeResolution = resolvePageScope({ instruction: text, confirmation, overrides, finalConfirmed });
 
   const inferredSchoolTag = detectedSchoolTags.length > 0
     ? sortSchoolTagSelections(detectedSchoolTags)
@@ -717,15 +682,16 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     post_action: null,
     max_greet_count: null
   };
-  const targetCountResolution = resolveTargetCount({ instruction: text, confirmation, overrides });
+  const targetCountResolution = resolveTargetCount({ instruction: text, confirmation, overrides, finalConfirmed });
   screenParams.target_count = targetCountResolution.target_count;
-  const postActionResolution = resolvePostAction({ instruction: text, confirmation, overrides });
+  const postActionResolution = resolvePostAction({ instruction: text, confirmation, overrides, finalConfirmed });
   screenParams.post_action = postActionResolution.post_action;
   const maxGreetCountResolution = resolveMaxGreetCount({
     instruction: text,
     confirmation,
     overrides,
-    postActionResolution
+    postActionResolution,
+    finalConfirmed
   });
   screenParams.max_greet_count = maxGreetCountResolution.max_greet_count;
 
@@ -735,37 +701,23 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   }
 
   const suspicious_fields = collectSuspiciousFields({
-    invalidOverrideSchoolTags: schoolTagAudit.invalid,
-    maxGreetCountResolution
+    invalidOverrideSchoolTags: schoolTagAudit.invalid
   });
-  const hasConfirmedSchoolTagValue = Array.isArray(confirmationSchoolTag) && confirmationSchoolTag.length > 0;
-  const hasConfirmedDegreeValue = Array.isArray(confirmationDegrees) && confirmationDegrees.length > 0;
-  const hasConfirmedGenderValue = Boolean(confirmationGender);
-  const hasConfirmedRecentNotViewValue = Boolean(confirmationRecentNotView);
-  const needs_school_tag_confirmation = (
-    confirmation?.school_tag_confirmed !== true
-    || !hasConfirmedSchoolTagValue
-  );
-  const needs_degree_confirmation = (
-    confirmation?.degree_confirmed !== true
-    || !hasConfirmedDegreeValue
-  );
-  const needs_gender_confirmation = (
-    confirmation?.gender_confirmed !== true
-    || !hasConfirmedGenderValue
-  );
-  const needs_recent_not_view_confirmation = (
-    confirmation?.recent_not_view_confirmed !== true
-    || !hasConfirmedRecentNotViewValue
-  );
+  const hasResolvedSchoolTagValue = Array.isArray(searchParams.school_tag) && searchParams.school_tag.length > 0;
+  const hasResolvedDegreeValue = Array.isArray(searchParams.degree) && searchParams.degree.length > 0;
+  const hasResolvedGenderValue = Boolean(searchParams.gender);
+  const hasResolvedRecentNotViewValue = Boolean(searchParams.recent_not_view);
+  const needs_school_tag_confirmation = !hasResolvedSchoolTagValue;
+  const needs_degree_confirmation = !hasResolvedDegreeValue;
+  const needs_gender_confirmation = !hasResolvedGenderValue;
+  const needs_recent_not_view_confirmation = !hasResolvedRecentNotViewValue;
   const needs_filters_confirmation = (
-    confirmation?.filters_confirmed !== true
-    || needs_school_tag_confirmation
+    needs_school_tag_confirmation
     || needs_degree_confirmation
     || needs_gender_confirmation
     || needs_recent_not_view_confirmation
   );
-  const needs_criteria_confirmation = confirmation?.criteria_confirmed !== true;
+  const needs_criteria_confirmation = !screenParams.criteria;
   const needs_target_count_confirmation = targetCountResolution.needs_target_count_confirmation;
   const needs_post_action_confirmation = postActionResolution.needs_post_action_confirmation;
   const needs_max_greet_count_confirmation = maxGreetCountResolution.needs_max_greet_count_confirmation;
@@ -861,7 +813,6 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
       question: "请确认本次运行对通过人选统一执行的动作。",
       value: postActionResolution.proposed_post_action,
       options: [
-        { label: POST_ACTION_LABELS.favorite, value: "favorite" },
         { label: POST_ACTION_LABELS.greet, value: "greet" },
         { label: POST_ACTION_LABELS.none, value: "none" }
       ]
@@ -873,7 +824,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
       field: "max_greet_count",
       question: maxGreetCountResolution.suspicious_auto_fill
         ? "检测到最大打招呼人数可能是自动默认值，请明确确认本次最多打招呼多少位候选人（必须为正整数）。"
-        : "本次选择直接沟通时，最多打招呼多少位候选人？达到上限后会自动改为收藏。",
+        : "本次选择直接沟通时，最多打招呼多少位候选人？可留空表示不单独限制打招呼人数。",
       value: maxGreetCountResolution.proposed_max_greet_count
     });
   }

package/src/recommend-mcp.js

@@ -52,10 +52,12 @@ import {
 import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
 
 const DEFAULT_RECOMMEND_HOST = "127.0.0.1";
-const DEFAULT_RECOMMEND_PORT = 9222;
-const DEFAULT_RECOMMEND_POLL_AFTER_SEC = 10;
-const TARGET_COUNT_SEMANTICS = "target_count means candidates that pass screening; scan continues until that many candidates pass or the list ends";
-const RUN_MODE_ASYNC = "async";
+const DEFAULT_RECOMMEND_PORT = 9222;
+const DEFAULT_RECOMMEND_POLL_AFTER_SEC = 10;
+const TARGET_COUNT_SEMANTICS = "target_count means candidates that pass screening; scan continues until that many candidates pass or the list ends";
+const RUN_MODE_ASYNC = "async";
+const REST_LEVEL_OPTIONS = ["low", "medium", "high"];
+const REST_LEVEL_SET = new Set(REST_LEVEL_OPTIONS);
 
 const TERMINAL_STATUSES = new Set([
   RUN_STATUS_COMPLETED,
@@ -1019,63 +1021,145 @@ async function connectRecommendChromeSession({
   };
 }
 
-function parseRecommendPipelineRequest(args = {}) {
-  return parseRecommendInstruction({
-    instruction: args.instruction,
+function parseRecommendPipelineRequest(args = {}) {
+  return parseRecommendInstruction({
+    instruction: args.instruction,
     confirmation: args.confirmation,
     overrides: args.overrides
-  });
-}
-
-function buildRequiredConfirmations(parsed, args = {}) {
-  const required = [];
-  if (parsed.needs_page_confirmation) required.push("page_scope");
+  });
+}
+
+function readOwn(source, keys = []) {
+  if (!source || typeof source !== "object" || Array.isArray(source)) return undefined;
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) return source[key];
+  }
+  return undefined;
+}
+
+function getExplicitRestLevel(args = {}) {
+  const behavior = readOwn(args, ["human_behavior", "humanBehavior"]);
+  const raw = readOwn(behavior, ["restLevel", "rest_level"]);
+  const normalized = normalizeText(raw).toLowerCase();
+  return {
+    raw: raw ?? null,
+    restLevel: REST_LEVEL_SET.has(normalized) ? normalized : null,
+    valid: REST_LEVEL_SET.has(normalized),
+    missing: raw === undefined || raw === null || normalizeText(raw) === ""
+  };
+}
+
+function buildReviewScreenParams(parsed) {
+  return {
+    ...(parsed.screenParams || {}),
+    criteria: parsed.screenParams?.criteria || null,
+    criteria_normalized: parsed.criteria_normalized || null,
+    target_count: parsed.screenParams?.target_count ?? parsed.proposed_target_count ?? null,
+    post_action: parsed.screenParams?.post_action || parsed.proposed_post_action || null,
+    max_greet_count: parsed.screenParams?.max_greet_count ?? parsed.proposed_max_greet_count ?? null
+  };
+}
+
+function buildReviewPageScope(parsed) {
+  return parsed.page_scope || parsed.proposed_page_scope || "recommend";
+}
+
+function buildReviewJob(args = {}) {
+  return normalizeText(args.confirmation?.job_value || args.overrides?.job || "") || null;
+}
+
+function buildScheduleReview(args = {}) {
+  const scheduleRunAt = normalizeText(args.schedule_run_at || args.scheduleRunAt || args.run_at || args.runAt);
+  const scheduleDelayMinutes = args.schedule_delay_minutes ?? args.scheduleDelayMinutes;
+  const scheduleDelaySeconds = args.schedule_delay_seconds ?? args.scheduleDelaySeconds;
+  if (!scheduleRunAt && scheduleDelayMinutes === undefined && scheduleDelaySeconds === undefined) return null;
+  return {
+    schedule_run_at: scheduleRunAt || null,
+    schedule_delay_minutes: scheduleDelayMinutes ?? null,
+    schedule_delay_seconds: scheduleDelaySeconds ?? null
+  };
+}
+
+function buildRequiredConfirmations(parsed, args = {}) {
+  const required = [];
+  if (parsed.needs_page_confirmation) required.push("page_scope");
   if (parsed.needs_filters_confirmation) required.push("filters");
   if (parsed.needs_school_tag_confirmation) required.push("school_tag");
   if (parsed.needs_degree_confirmation) required.push("degree");
   if (parsed.needs_gender_confirmation) required.push("gender");
   if (parsed.needs_recent_not_view_confirmation) required.push("recent_not_view");
-  if (parsed.needs_criteria_confirmation) required.push("criteria");
-  if (parsed.needs_target_count_confirmation) required.push("target_count");
-  if (parsed.needs_post_action_confirmation) required.push("post_action");
-  if (parsed.needs_max_greet_count_confirmation) required.push("max_greet_count");
-  if ((parsed.suspicious_fields || []).length) required.push("suspicious_fields");
-
-  const confirmation = args.confirmation || {};
-  const jobValue = normalizeText(confirmation.job_value || args.overrides?.job || "");
-  if (confirmation.job_confirmed !== true || !jobValue) required.push("job");
-  if (confirmation.final_confirmed !== true) required.push("final_review");
-  return Array.from(new Set(required));
-}
+  if (parsed.needs_criteria_confirmation) required.push("criteria");
+  if (parsed.needs_target_count_confirmation) required.push("target_count");
+  if (parsed.needs_post_action_confirmation) required.push("post_action");
+  if ((parsed.suspicious_fields || []).length) required.push("suspicious_fields");
+
+  const confirmation = args.confirmation || {};
+  const jobValue = normalizeText(confirmation.job_value || args.overrides?.job || "");
+  if (!jobValue) required.push("job");
+  const restLevel = getExplicitRestLevel(args);
+  if (!restLevel.valid) required.push("rest_level");
+  const blocksFinalReview = required.some((field) => field !== "rest_level");
+  if (confirmation.final_confirmed !== true && !blocksFinalReview) required.push("final_review");
+  return Array.from(new Set(required));
+}
 
-function buildJobPendingQuestion(args = {}) {
-  const value = normalizeText(args.confirmation?.job_value || args.overrides?.job || "");
+function buildJobPendingQuestion(args = {}) {
+  const value = normalizeText(args.confirmation?.job_value || args.overrides?.job || "");
   return {
     field: "job",
     question: "请确认推荐页岗位。CDP-only rewrite 会先切换到该岗位，再按所选页面范围执行筛选。",
     value: value || null
-  };
-}
-
-function buildFinalReviewQuestion(parsed) {
-  return {
-    field: "final_review",
-    question: "请最终确认本次推荐页筛选参数无误，并明确 final_confirmed=true 后再启动。",
-    value: {
-      page_scope: parsed.page_scope,
-      search_params: parsed.searchParams,
-      screen_params: parsed.screenParams
-    }
-  };
-}
-
-function buildNeedInputResponse(parsed) {
-  return {
-    status: "NEED_INPUT",
-    missing_fields: parsed.missing_fields,
-    required_confirmations: buildRequiredConfirmations(parsed),
-    search_params: parsed.searchParams,
-    screen_params: parsed.screenParams,
+  };
+}
+
+function buildRestLevelPendingQuestion(args = {}) {
+  const restLevel = getExplicitRestLevel(args);
+  return {
+    field: "rest_level",
+    question: restLevel.missing
+      ? "请确认本次运行休息强度 rest_level。"
+      : "rest_level 只能是 low / medium / high，请重新确认本次运行休息强度。",
+    value: restLevel.restLevel || restLevel.raw || null,
+    options: REST_LEVEL_OPTIONS.map((value) => ({
+      label: value,
+      value
+    }))
+  };
+}
+
+function buildSuspiciousFieldsQuestion(parsed) {
+  return {
+    field: "suspicious_fields",
+    question: "检测到需要修正或明确确认的异常字段，请先修正后再启动。",
+    value: parsed.suspicious_fields || []
+  };
+}
+
+function buildFinalReviewQuestion(parsed, args = {}) {
+  const restLevel = getExplicitRestLevel(args);
+  return {
+    field: "final_review",
+    question: "请最终确认本次推荐页筛选参数无误；确认后设置 final_confirmed=true 即可启动或创建定时任务。",
+    value: {
+      page_scope: buildReviewPageScope(parsed),
+      job: buildReviewJob(args),
+      search_params: parsed.searchParams,
+      screen_params: buildReviewScreenParams(parsed),
+      human_behavior: {
+        restLevel: restLevel.restLevel || null
+      },
+      schedule: buildScheduleReview(args)
+    }
+  };
+}
+
+function buildNeedInputResponse(parsed, args = {}) {
+  return {
+    status: "NEED_INPUT",
+    missing_fields: parsed.missing_fields,
+    required_confirmations: buildRequiredConfirmations(parsed, args),
+    search_params: parsed.searchParams,
+    screen_params: parsed.screenParams,
     pending_questions: parsed.pending_questions,
     review: parsed.review,
     error: {
@@ -1086,30 +1170,36 @@ function buildNeedInputResponse(parsed) {
   };
 }
 
-function buildNeedConfirmationResponse(parsed, args, requiredConfirmations) {
-  const pending = [...(parsed.pending_questions || [])];
-  if (requiredConfirmations.includes("job") && !pending.some((item) => item.field === "job")) {
-    pending.push(buildJobPendingQuestion(args));
-  }
-  if (requiredConfirmations.includes("final_review") && !pending.some((item) => item.field === "final_review")) {
-    pending.push(buildFinalReviewQuestion(parsed));
-  }
-  return {
-    status: "NEED_CONFIRMATION",
-    required_confirmations: requiredConfirmations,
-    page_scope: parsed.page_scope,
-    search_params: parsed.searchParams,
-    screen_params: parsed.screenParams,
-    pending_questions: pending,
-    review: {
-      ...(parsed.review || {}),
+function buildNeedConfirmationResponse(parsed, args, requiredConfirmations) {
+  const pending = [...(parsed.pending_questions || [])];
+  if (requiredConfirmations.includes("suspicious_fields") && !pending.some((item) => item.field === "suspicious_fields")) {
+    pending.push(buildSuspiciousFieldsQuestion(parsed));
+  }
+  if (requiredConfirmations.includes("job") && !pending.some((item) => item.field === "job")) {
+    pending.push(buildJobPendingQuestion(args));
+  }
+  if (requiredConfirmations.includes("rest_level") && !pending.some((item) => item.field === "rest_level")) {
+    pending.push(buildRestLevelPendingQuestion(args));
+  }
+  if (requiredConfirmations.includes("final_review") && !pending.some((item) => item.field === "final_review")) {
+    pending.push(buildFinalReviewQuestion(parsed, args));
+  }
+  return {
+    status: "NEED_CONFIRMATION",
+    required_confirmations: requiredConfirmations,
+    page_scope: buildReviewPageScope(parsed),
+    search_params: parsed.searchParams,
+    screen_params: buildReviewScreenParams(parsed),
+    pending_questions: pending,
+    review: {
+      ...(parsed.review || {}),
       required_confirmations: requiredConfirmations
     }
   };
 }
-
-function evaluateRecommendPipelineGate(parsed, args = {}) {
-  if (parsed.missing_fields?.length) return buildNeedInputResponse(parsed);
+
+function evaluateRecommendPipelineGate(parsed, args = {}) {
+  if (parsed.missing_fields?.length) return buildNeedInputResponse(parsed, args);
   const requiredConfirmations = buildRequiredConfirmations(parsed, args);
   if (requiredConfirmations.length) {
     return buildNeedConfirmationResponse(parsed, args, requiredConfirmations);