@reconcrap/boss-recommend-mcp 0.1.13 → 0.1.15

package/README.md

@@ -25,6 +25,7 @@ MCP 工具名：`run_recommend_pipeline`
 - 学历支持单选与多选语义：如“本科及以上”会展开为 `本科/硕士/博士`；如“大专、本科”只勾选这两项
 - 执行前会逐项确认筛选参数：学校标签 / 学历 / 性别 / 是否过滤近14天已看
 - 页面就绪（已登录且在 recommend 页）后，会先提取岗位栏全部岗位并要求用户确认本次岗位；确认后先点击岗位，再执行 search/screen
+- 在真正开始 search/screen 前，会进行最后一轮全参数总确认（岗位 + 全部筛选参数 + criteria + target_count + post_action + max_greet_count）
 - npm 全局安装后会自动执行 install：生成 skill、导出 MCP 模板，并自动尝试写入已检测到的外部 agent MCP 配置（含 Trae / trae-cn / Cursor / Claude / OpenClaw）
 - `post_action` 必须在每次完整运行开始时确认一次
 - `target_count` 会在每次运行开始时询问一次（可留空，不设上限）
@@ -64,6 +65,7 @@ BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS  # JSON 数组或系统 path 分隔路径列
 
 ```bash
 node src/cli.js run --instruction "推荐页筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏"
+npx -y @reconcrap/boss-recommend-mcp@latest run --instruction "推荐页筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏"
 ```
 
 ## 配置
@@ -135,6 +137,7 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
     "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,

package/package.json

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

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

@@ -51,7 +51,11 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
   - 严禁在未询问用户的情况下自动把 `max_greet_count` 设为 `target_count` 或其他默认值
 - 岗位（`job`）是否确定
   - 必须先列出 recommend 页岗位栏里识别到的全部岗位，让用户明确选择
+  - 即使前序步骤已提取到 `job` 参数，执行前也必须再次展示岗位列表并让用户二次确认
   - 用户确认后必须先点击该岗位，再开始 search 和 screen
+- 正式开始 search/screen 前，必须做最后一轮“全参数总确认”
+  - 需要向用户复述并确认：岗位、school_tag、degree、gender、recent_not_view、criteria、target_count、post_action、max_greet_count
+  - 只有用户明确最终确认后才允许执行
 
 `post_action` 的确认是**单次运行级别**的：
 
@@ -75,6 +79,7 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
     - `target_count_value` (integer, optional)
     - `post_action_confirmed`
     - `post_action_value` (`favorite|greet`)
+    - `final_confirmed`
     - `job_confirmed`
     - `job_value` (string)
     - `max_greet_count_confirmed`
@@ -98,11 +103,17 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 - recommend-screen-cli 负责滚动推荐列表、打开详情、提取完整简历图、调用多模态模型判断，并按单次确认的 `post_action` 执行收藏或打招呼。
 - 详情页处理完成后必须关闭详情页并确认已关闭。
 
-## Fallback
-
-如果 MCP 不可用，改用：
-
-`boss-recommend-mcp run --instruction "..." [--confirmation-json '{...}'] [--overrides-json '{...}']`
+## Fallback
+
+如果 MCP 不可用，改用：
+
+`npx -y @reconcrap/boss-recommend-mcp@latest run --instruction "..." [--confirmation-json '{...}'] [--overrides-json '{...}']`
+
+禁止错误回退：
+
+- 不能把 recommend 请求回退到 `boss-recruit-mcp` / `run_recruit_pipeline`
+- 不能执行 `boss-recruit-mcp doctor` 作为 recommend 流程的环境检查
+- 若检测到当前环境只有 recruit MCP，应先修复 recommend MCP 配置，再继续
 
 CLI fallback 的状态机与 MCP 保持一致：
 
@@ -135,6 +146,8 @@ CLI fallback 的状态机与 MCP 保持一致：
 当工具返回 `status=FAILED` 且 `error.code=PIPELINE_PREFLIGHT_FAILED` 时：
 
 1. 若 `diagnostics.checks` 中 `screen_config` 失败，优先引导用户填写 `screening-config.json` 的 `baseUrl/apiKey/model`（必须让用户提供真实值，不可保留模板值）。
+   - 禁止 agent 自行代填或猜测示例值（如 `test-key` / `mock-key` / `https://example.com` / `gpt-4` 占位等）
+   - 必须逐项向用户确认 `baseUrl`、`apiKey`、`model` 后再写入
 2. 优先查看 `diagnostics.auto_repair`，若有自动修复动作则先基于其结果继续执行或给出最小化补救提示。
 3. 若自动修复后仍失败，再读取 `diagnostics.recovery.agent_prompt`，直接把这段提示词交给 AI agent 执行环境修复。
 4. 若 `diagnostics.recovery.agent_prompt` 不存在，使用下面的兜底提示词（严格顺序，不可跳步）：

package/src/adapters.js

@@ -860,6 +860,19 @@ export async function inspectBossRecommendPageState(port, options = {}) {
         (tab) => typeof tab?.url === "string" && tab.url.includes("/web/chat/recommend")
       );
       if (exactTab) {
+        if (isBossLoginTab(exactTab)) {
+          return buildBossPageState({
+            ok: false,
+            state: "LOGIN_REQUIRED",
+            path: exactTab.url || bossLoginUrl,
+            current_url: exactTab.url || bossLoginUrl,
+            title: exactTab.title || null,
+            requires_login: true,
+            expected_url: expectedUrl,
+            login_url: bossLoginUrl,
+            message: "当前标签页虽在 recommend 路径，但检测到登录态页面特征，请先完成 Boss 登录。"
+          });
+        }
         return buildBossPageState({
           ok: true,
           state: "RECOMMEND_READY",

package/src/cli.js

@@ -27,6 +27,8 @@ const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "opencla
 const defaultMcpServerName = "boss-recommend";
 const defaultMcpCommand = "npx";
 const defaultMcpArgs = ["-y", "@reconcrap/boss-recommend-mcp@latest", "start"];
+const recommendMcpPackageName = "@reconcrap/boss-recommend-mcp";
+const recommendMcpBinaryName = "boss-recommend-mcp";
 const autoSyncSkipCommands = new Set(["install", "install-skill", "where", "help", "--help", "-h"]);
 const externalMcpTargetsEnv = "BOSS_RECOMMEND_MCP_CONFIG_TARGETS";
 const externalSkillDirsEnv = "BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS";
@@ -91,6 +93,32 @@ function dedupePaths(items) {
   return result;
 }
 
+function dedupeLower(values = []) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const normalized = String(value || "").trim();
+    if (!normalized) continue;
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(normalized);
+  }
+  return result;
+}
+
+function discoverAppDataDirsByPattern(baseDir, pattern) {
+  try {
+    if (!pathExists(baseDir)) return [];
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isDirectory() && pattern.test(entry.name))
+      .map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+
 function getDesktopDir() {
   return path.join(os.homedir(), "Desktop");
 }
@@ -306,10 +334,19 @@ function parseAgentTargets(rawValue) {
 function getKnownExternalMcpConfigPathsByAgent() {
   const home = os.homedir();
   const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+  const traeDirNames = dedupeLower([
+    "Trae",
+    "Trae CN",
+    "TraeCN",
+    "trae-cn",
+    "trae_cn",
+    ...discoverAppDataDirsByPattern(appData, /^trae(?:[\s\-_]?cn)?$/i)
+  ]);
+  const traeConfigPaths = traeDirNames.map((dir) => path.join(appData, dir, "User", "mcp.json"));
   return {
     cursor: [path.join(appData, "Cursor", "User", "mcp.json"), path.join(home, ".cursor", "mcp.json")],
-    trae: [path.join(appData, "Trae", "User", "mcp.json"), path.join(home, ".trae", "mcp.json")],
-    "trae-cn": [path.join(appData, "Trae CN", "User", "mcp.json"), path.join(home, ".trae-cn", "mcp.json")],
+    trae: [...traeConfigPaths, path.join(home, ".trae", "mcp.json"), path.join(home, ".trae-cn", "mcp.json")],
+    "trae-cn": [...traeConfigPaths, path.join(home, ".trae-cn", "mcp.json"), path.join(home, ".trae", "mcp.json")],
     claude: [path.join(home, ".claude", "mcp.json")],
     openclaw: [path.join(home, ".openclaw", "mcp.json")]
   };
@@ -383,15 +420,76 @@ function installExternalMcpConfigs(options = {}) {
 function getKnownExternalSkillBaseDirsByAgent() {
   const home = os.homedir();
   const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+  const traeDirNames = dedupeLower([
+    "Trae",
+    "Trae CN",
+    "TraeCN",
+    "trae-cn",
+    "trae_cn",
+    ...discoverAppDataDirsByPattern(appData, /^trae(?:[\s\-_]?cn)?$/i)
+  ]);
+  const traeSkillDirs = traeDirNames.map((dir) => path.join(appData, dir, "User", "skills"));
   return {
     cursor: [path.join(home, ".cursor", "skills"), path.join(appData, "Cursor", "User", "skills")],
-    trae: [path.join(home, ".trae", "skills"), path.join(appData, "Trae", "User", "skills")],
-    "trae-cn": [path.join(home, ".trae-cn", "skills"), path.join(appData, "Trae CN", "User", "skills")],
+    trae: [path.join(home, ".trae", "skills"), path.join(home, ".trae-cn", "skills"), ...traeSkillDirs],
+    "trae-cn": [path.join(home, ".trae-cn", "skills"), path.join(home, ".trae", "skills"), ...traeSkillDirs],
     claude: [path.join(home, ".claude", "skills")],
     openclaw: [path.join(home, ".openclaw", "skills"), path.join(appData, "OpenClaw", "User", "skills")]
   };
 }
 
+function isRecommendMcpLaunchConfig(launchConfig) {
+  if (!launchConfig || typeof launchConfig !== "object") return false;
+  const command = String(launchConfig.command || "").toLowerCase();
+  const args = Array.isArray(launchConfig.args) ? launchConfig.args : [];
+  const joined = `${command} ${args.map((item) => String(item || "")).join(" ")}`.toLowerCase();
+  return (
+    joined.includes(recommendMcpPackageName.toLowerCase())
+    || joined.includes(`${recommendMcpBinaryName} start`)
+    || (command.endsWith(recommendMcpBinaryName) && args.includes("start"))
+    || command === recommendMcpBinaryName
+  );
+}
+
+function inspectMcpServerEntries(filePath) {
+  if (!pathExists(filePath)) {
+    return {
+      exists: false,
+      has_boss_recommend: false,
+      has_boss_recruit: false,
+      recommend_server_names: [],
+      recruit_server_names: []
+    };
+  }
+  const parsed = readJsonObjectFileSafe(filePath);
+  const servers = parsed?.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers)
+    ? parsed.mcpServers
+    : {};
+  const recommendNames = [];
+  const recruitNames = [];
+  for (const [name, config] of Object.entries(servers)) {
+    const lowerName = String(name || "").toLowerCase();
+    if (isRecommendMcpLaunchConfig(config) || lowerName.includes("boss-recommend")) {
+      recommendNames.push(name);
+    }
+    const serialized = JSON.stringify(config || {}).toLowerCase();
+    if (
+      lowerName.includes("boss-recruit")
+      || serialized.includes("@reconcrap/boss-recruit-mcp")
+      || serialized.includes("boss-recruit-mcp")
+    ) {
+      recruitNames.push(name);
+    }
+  }
+  return {
+    exists: true,
+    has_boss_recommend: recommendNames.length > 0,
+    has_boss_recruit: recruitNames.length > 0,
+    recommend_server_names: recommendNames,
+    recruit_server_names: recruitNames
+  };
+}
+
 function resolveExternalSkillBaseDirs(options = {}) {
   const fromEnv = parsePathListFromEnv(process.env[externalSkillDirsEnv]);
   const pathMap = getKnownExternalSkillBaseDirsByAgent();
@@ -650,16 +748,21 @@ function inspectAgentIntegration(agentRaw) {
 
   const mcpPathMap = getKnownExternalMcpConfigPathsByAgent();
   const skillPathMap = getKnownExternalSkillBaseDirsByAgent();
-  const mcp_paths = dedupePaths(mcpPathMap[agent] || []);
-  const skill_bases = dedupePaths(skillPathMap[agent] || []);
+  const mcp_paths = dedupePaths([
+    ...(mcpPathMap[agent] || []),
+    ...parsePathListFromEnv(process.env[externalMcpTargetsEnv])
+  ]);
+  const skill_bases = dedupePaths([
+    ...(skillPathMap[agent] || []),
+    ...parsePathListFromEnv(process.env[externalSkillDirsEnv])
+  ]);
 
   const mcp_checks = mcp_paths.map((mcpPath) => {
-    if (!pathExists(mcpPath)) {
-      return { path: mcpPath, exists: false, has_boss_recommend: false };
-    }
-    const parsed = readJsonObjectFileSafe(mcpPath);
-    const has = Boolean(parsed?.mcpServers && parsed.mcpServers["boss-recommend"]);
-    return { path: mcpPath, exists: true, has_boss_recommend: has };
+    const detail = inspectMcpServerEntries(mcpPath);
+    return {
+      path: mcpPath,
+      ...detail
+    };
   });
 
   const hasRecommendIntent = (content) => /(recommend|推荐页|boss recommend|recommend page)/i.test(content);
@@ -736,6 +839,10 @@ async function printDoctor(options = {}) {
   if (typeof options.agent === "string" && options.agent.trim()) {
     agentIntegration = inspectAgentIntegration(options.agent.trim());
     const agentMcpOk = agentIntegration.mcp_checks.some((item) => item.has_boss_recommend);
+    const agentRecruitOnly = (
+      !agentMcpOk
+      && agentIntegration.mcp_checks.some((item) => item.has_boss_recruit)
+    );
     const agentSkillOk = agentIntegration.skill_checks.some((item) => item.exists);
     const agentRecruitRouteGuardOk = agentIntegration.skill_checks.every(
       (item) => !item.recruit_skill_exists || item.recruit_route_guard
@@ -750,7 +857,9 @@ async function printDoctor(options = {}) {
       path: agentIntegration.mcp_checks.map((item) => item.path).join(" | "),
       message: agentMcpOk
         ? "目标 Agent MCP 配置已检测到 boss-recommend。"
-        : "目标 Agent MCP 配置未检测到 boss-recommend。"
+        : agentRecruitOnly
+          ? "目标 Agent MCP 配置未检测到 boss-recommend，但检测到 boss-recruit（可能导致错误调用 recruit pipeline）。"
+          : "目标 Agent MCP 配置未检测到 boss-recommend。"
     });
     checks.push({
       key: `agent_${agentIntegration.agent}_skill`,

package/src/index.js

@@ -60,6 +60,7 @@ function createToolSchema() {
               type: "string",
               enum: ["favorite", "greet"]
             },
+            final_confirmed: { type: "boolean" },
             job_confirmed: { type: "boolean" },
             job_value: { type: "string" },
             max_greet_count_confirmed: { type: "boolean" },

package/src/pipeline.js

@@ -19,13 +19,14 @@ function normalizeText(value) {
 function normalizeJobTitle(value) {
   const text = normalizeText(value);
   if (!text) return "";
-  const strippedRange = text
+  const byGap = text.split(/\s{2,}/).map((item) => item.trim()).filter(Boolean)[0] || text;
+  const strippedRange = byGap
     .replace(/\s+\d+(?:\.\d+)?\s*(?:-|~|—|至)\s*\d+(?:\.\d+)?\s*(?:k|K|千|万|元\/天|元\/月|元\/年|K\/月|k\/月|万\/月|万\/年)?$/u, "")
     .trim();
   const strippedSingle = strippedRange
     .replace(/\s+\d+(?:\.\d+)?\s*(?:k|K|千|万|元\/天|元\/月|元\/年|K\/月|k\/月|万\/月|万\/年)$/u, "")
     .trim();
-  return strippedSingle || text;
+  return strippedSingle || byGap;
 }
 
 function normalizeJobOptions(jobOptions = []) {
@@ -299,8 +300,8 @@ function buildNeedInputResponse(parsedResult) {
   };
 }
 
-function buildNeedConfirmationResponse(parsedResult) {
-  return {
+function buildNeedConfirmationResponse(parsedResult) {
+  return {
     status: "NEED_CONFIRMATION",
     required_confirmations: buildRequiredConfirmations(parsedResult),
     search_params: parsedResult.searchParams,
@@ -311,10 +312,22 @@ function buildNeedConfirmationResponse(parsedResult) {
       max_greet_count: parsedResult.proposed_max_greet_count || parsedResult.screenParams.max_greet_count
     },
     pending_questions: parsedResult.pending_questions,
-    review: parsedResult.review
-  };
-}
-
+    review: parsedResult.review
+  };
+}
+
+function buildFinalReviewQuestion({ searchParams, screenParams, selectedJob }) {
+  return {
+    field: "final_review",
+    question: "开始执行搜索和筛选前，请最后确认全部参数（岗位/筛选条件/筛选 criteria/目标人数/post_action/max_greet_count）无误。",
+    value: {
+      job: selectedJob?.title || selectedJob?.label || selectedJob?.value || null,
+      search_params: searchParams,
+      screen_params: screenParams
+    }
+  };
+}
+
 function buildFailedResponse(code, message, extra = {}) {
   return {
     status: "FAILED",
@@ -445,7 +458,7 @@ export async function runRecommendPipeline(
                 "2) apiKey",
                 "3) model",
                 `配置文件路径：${screenConfigCheck.path}`,
-                "注意：不要使用模板占位符（例如 replace-with-openai-api-key）。填写完成后重试。"
+                "注意：不要使用模板占位符（例如 replace-with-openai-api-key），也不要由 agent 自行猜测或代填示例值。必须向用户逐项确认真实可用值后再重试。"
               ].join("\n")
             }
           : undefined,
@@ -559,6 +572,34 @@ export async function runRecommendPipeline(
   }
   const selectedJob = selectedJobResolution.job;
   const selectedJobToken = selectedJob.value || selectedJob.title || selectedJob.label;
+  if (confirmation?.final_confirmed !== true) {
+    const pendingQuestions = (parsed.pending_questions || []).filter((item) => item?.field !== "final_review");
+    pendingQuestions.push(buildFinalReviewQuestion({
+      searchParams: parsed.searchParams,
+      screenParams: {
+        ...parsed.screenParams,
+        target_count: parsed.proposed_target_count ?? parsed.screenParams.target_count,
+        post_action: parsed.proposed_post_action || parsed.screenParams.post_action,
+        max_greet_count: parsed.proposed_max_greet_count || parsed.screenParams.max_greet_count
+      },
+      selectedJob
+    }));
+    return {
+      status: "NEED_CONFIRMATION",
+      required_confirmations: dedupe([...buildRequiredConfirmations(parsed), "final_review"]),
+      search_params: parsed.searchParams,
+      screen_params: {
+        ...parsed.screenParams,
+        target_count: parsed.proposed_target_count ?? parsed.screenParams.target_count,
+        post_action: parsed.proposed_post_action || parsed.screenParams.post_action,
+        max_greet_count: parsed.proposed_max_greet_count || parsed.screenParams.max_greet_count
+      },
+      selected_job: selectedJob,
+      pending_questions: pendingQuestions,
+      review: parsed.review,
+      job_options: jobOptions
+    };
+  }
 
   const searchResult = await searchCli({
     workspaceRoot,

package/src/test-pipeline.js

@@ -30,6 +30,14 @@ function createJobListResult() {
 }
 
 function createJobConfirmedConfirmation() {
+  return {
+    job_confirmed: true,
+    job_value: "数据分析实习生 _ 杭州",
+    final_confirmed: true
+  };
+}
+
+function createJobConfirmedWithoutFinalConfirmation() {
   return {
     job_confirmed: true,
     job_value: "数据分析实习生 _ 杭州"
@@ -318,6 +326,29 @@ async function testNeedJobConfirmationGate() {
   assert.equal(result.job_options.length, 2);
 }
 
+async function testNeedFinalReviewConfirmationGate() {
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedWithoutFinalConfirmation(),
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9222 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => ({ ok: true, summary: {} }),
+      runRecommendScreenCli: async () => ({ ok: true, summary: {} })
+    }
+  );
+
+  assert.equal(result.status, "NEED_CONFIRMATION");
+  assert.equal(result.required_confirmations.includes("final_review"), true);
+  assert.equal(result.pending_questions.some((item) => item.field === "final_review"), true);
+}
+
 async function testLoginRequiredShouldReturnGuidance() {
   const result = await runRecommendPipeline(
     {
@@ -587,6 +618,7 @@ async function main() {
   await testNeedMaxGreetCountConfirmationGate();
   await testNeedInputGate();
   await testNeedJobConfirmationGate();
+  await testNeedFinalReviewConfirmationGate();
   await testCompletedPipeline();
   await testSearchFailure();
   await testLoginRequiredShouldReturnGuidance();

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -1407,14 +1407,26 @@ class RecommendScreenCli {
       }
     }
 
+    const isListReadyNow = async () => {
+      const detailState = await this.getDetailClosedState();
+      if (!detailState?.closed) return false;
+      const listState = await this.evaluate(jsGetListState);
+      return Boolean(listState?.ok);
+    };
+
     let know = null;
     for (let index = 0; index < 10; index += 1) {
       await sleep(humanDelay(260, 80));
       know = await this.evaluate(jsGetKnowButtonState);
       if (know?.ok) break;
+      if (await isListReadyNow()) {
+        log("[打招呼] 未检测到“知道了”弹窗，页面已自动返回列表，继续下一位候选人。");
+        return { actionTaken: "greet", ackMode: "auto_return_no_popup" };
+      }
     }
     if (!know?.ok) {
-      throw this.buildError("ACK_BUTTON_FAILED", know?.error || "未出现知道了确认按钮");
+      log(`[打招呼] 未检测到“知道了”弹窗（${know?.error || "ACK_BUTTON_NOT_FOUND"}），按无弹窗流程继续。`);
+      return { actionTaken: "greet", ackMode: "no_popup_detected" };
     }
 
     try {
@@ -1422,7 +1434,12 @@ class RecommendScreenCli {
     } catch {
       const fallback = await this.evaluate(jsClickKnowFallback);
       if (!fallback?.ok) {
-        throw this.buildError("ACK_BUTTON_FAILED", fallback?.error || "知道了按钮点击失败");
+        if (await isListReadyNow()) {
+          log("[打招呼] “知道了”点击兜底失败，但页面已回列表，继续下一位候选人。");
+          return { actionTaken: "greet", ackMode: "ack_click_failed_but_list_ready" };
+        }
+        log(`[打招呼] “知道了”按钮点击失败（${fallback?.error || "unknown"}），后续由详情关闭流程兜底。`);
+        return { actionTaken: "greet", ackMode: "ack_click_failed" };
       }
     }
 
@@ -1430,11 +1447,18 @@ class RecommendScreenCli {
       await sleep(humanDelay(220, 60));
       const state = await this.evaluate(jsGetKnowButtonState);
       if (!state?.ok) {
-        return { actionTaken: "greet" };
+        return { actionTaken: "greet", ackMode: "ack_closed" };
+      }
+      if (await isListReadyNow()) {
+        return { actionTaken: "greet", ackMode: "auto_return_after_ack" };
       }
     }
 
-    throw this.buildError("ACK_BUTTON_FAILED", "知道了弹窗未成功关闭。");
+    if (await isListReadyNow()) {
+      return { actionTaken: "greet", ackMode: "ack_still_visible_but_list_ready" };
+    }
+    log("[打招呼] “知道了”弹窗关闭未确认，后续由详情关闭流程兜底。");
+    return { actionTaken: "greet", ackMode: "ack_close_unconfirmed" };
   }
 
   async closeDetailPage(maxRetries = 3) {

package/vendor/boss-recommend-search-cli/src/cli.js

@@ -19,13 +19,14 @@ function normalizeText(value) {
 function normalizeJobTitle(value) {
   const text = normalizeText(value);
   if (!text) return "";
-  const strippedRange = text
+  const byGap = text.split(/\s{2,}/).map((item) => item.trim()).filter(Boolean)[0] || text;
+  const strippedRange = byGap
     .replace(/\s+\d+(?:\.\d+)?\s*(?:-|~|—|至)\s*\d+(?:\.\d+)?\s*(?:k|K|千|万|元\/天|元\/月|元\/年|K\/月|k\/月|万\/月|万\/年)?$/u, "")
     .trim();
   const strippedSingle = strippedRange
     .replace(/\s+\d+(?:\.\d+)?\s*(?:k|K|千|万|元\/天|元\/月|元\/年|K\/月|k\/月|万\/月|万\/年)$/u, "")
     .trim();
-  return strippedSingle || text;
+  return strippedSingle || byGap;
 }
 
 function parsePositiveInteger(raw) {
@@ -419,13 +420,14 @@ class RecommendSearchCli {
       const normalizeTitle = (value) => {
         const text = normalize(value);
         if (!text) return '';
-        const strippedRange = text
+        const byGap = text.split(/\\s{2,}/).map((item) => item.trim()).filter(Boolean)[0] || text;
+        const strippedRange = byGap
           .replace(/\\s+\\d+(?:\\.\\d+)?\\s*(?:-|~|—|至)\\s*\\d+(?:\\.\\d+)?\\s*(?:k|K|千|万|元\\/天|元\\/月|元\\/年|K\\/月|k\\/月|万\\/月|万\\/年)?$/u, '')
           .trim();
         const strippedSingle = strippedRange
           .replace(/\\s+\\d+(?:\\.\\d+)?\\s*(?:k|K|千|万|元\\/天|元\\/月|元\\/年|K\\/月|k\\/月|万\\/月|万\\/年)$/u, '')
           .trim();
-        return strippedSingle || text;
+        return strippedSingle || byGap;
       };
       const isVisible = (el) => {
         if (!el) return false;
@@ -437,9 +439,13 @@ class RecommendSearchCli {
         return rect.width > 2 && rect.height > 2;
       };
 
-      const items = Array.from(
-        doc.querySelectorAll('.ui-dropmenu-list .job-list .job-item, .job-selecter-options .job-list .job-item, .job-list .job-item')
-      );
+      const items = Array.from(doc.querySelectorAll([
+        '.ui-dropmenu-list .job-list .job-item',
+        '.job-selecter-options .job-list .job-item',
+        '.job-selector-options .job-list .job-item',
+        '.dropmenu-list .job-list .job-item',
+        '.job-list .job-item'
+      ].join(',')));
       const jobs = [];
       const seen = new Set();
       for (const item of items) {
@@ -481,9 +487,13 @@ class RecommendSearchCli {
       const doc = frame.contentDocument;
       const selectors = [
         '.chat-job-select',
+        '.chat-job-selector',
         '.job-selecter',
+        '.job-selector',
         '.job-select-wrap',
         '.job-select',
+        '.job-select-box',
+        '.job-wrap',
         '.chat-job-name',
         '.top-chat-search'
       ];
@@ -564,17 +574,22 @@ class RecommendSearchCli {
       const normalizeTitle = (value) => {
         const text = normalize(value);
         if (!text) return '';
-        const strippedRange = text
+        const byGap = text.split(/\\s{2,}/).map((item) => item.trim()).filter(Boolean)[0] || text;
+        const strippedRange = byGap
           .replace(/\\s+\\d+(?:\\.\\d+)?\\s*(?:-|~|—|至)\\s*\\d+(?:\\.\\d+)?\\s*(?:k|K|千|万|元\\/天|元\\/月|元\\/年|K\\/月|k\\/月|万\\/月|万\\/年)?$/u, '')
           .trim();
         const strippedSingle = strippedRange
           .replace(/\\s+\\d+(?:\\.\\d+)?\\s*(?:k|K|千|万|元\\/天|元\\/月|元\\/年|K\\/月|k\\/月|万\\/月|万\\/年)$/u, '')
           .trim();
-        return strippedSingle || text;
+        return strippedSingle || byGap;
       };
-      const items = Array.from(
-        doc.querySelectorAll('.ui-dropmenu-list .job-list .job-item, .job-selecter-options .job-list .job-item, .job-list .job-item')
-      );
+      const items = Array.from(doc.querySelectorAll([
+        '.ui-dropmenu-list .job-list .job-item',
+        '.job-selecter-options .job-list .job-item',
+        '.job-selector-options .job-list .job-item',
+        '.dropmenu-list .job-list .job-item',
+        '.job-list .job-item'
+      ].join(',')));
       const target = items.find((item) => {
         const value = normalize(item.getAttribute('value') || item.dataset?.value || '');
         const label = normalize(item.querySelector('.label')?.textContent || item.textContent || '');