@reconcrap/boss-recommend-mcp 0.1.14 → 1.0.0

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天没有，有大模型平台经验，符合标准的收藏"
 ```
 
 ## 配置
@@ -77,9 +79,9 @@ node src/cli.js run --instruction "推荐页筛选985男生，近14天没有，
 配置路径优先级：
 
 1. `BOSS_RECOMMEND_SCREEN_CONFIG`
-2. `<workspace>/config/screening-config.json`
+2. `<workspace>/config/screening-config.json`（优先；在受限权限环境推荐使用）
 3. `<workspace>/boss-recommend-mcp/config/screening-config.json`
-4. `~/.boss-recommend-mcp/screening-config.json`（若可写）
+4. `~/.boss-recommend-mcp/screening-config.json`（当 workspace 不可写或无 workspace 时回退）
 5. 兼容旧路径：`$CODEX_HOME/boss-recommend-mcp/screening-config.json`
 
 注意：
@@ -127,14 +129,19 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
   "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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "0.1.14",
+  "version": "1.0.0",
   "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` 的确认是**单次运行级别**的：
 
@@ -64,17 +68,22 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 - Tool name: `run_recommend_pipeline`
 - Input:
   - `instruction` (required)
-  - `confirmation`
-    - `filters_confirmed`
-    - `school_tag_confirmed`
-    - `degree_confirmed`
-    - `gender_confirmed`
-    - `recent_not_view_confirmed`
-    - `criteria_confirmed`
+  - `confirmation`
+    - `filters_confirmed`
+    - `school_tag_confirmed`
+    - `school_tag_value`（建议回传最终确认值，避免二轮调用丢失）
+    - `degree_confirmed`
+    - `degree_value`
+    - `gender_confirmed`
+    - `gender_value`
+    - `recent_not_view_confirmed`
+    - `recent_not_view_value`
+    - `criteria_confirmed`
     - `target_count_confirmed`
     - `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 +107,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 +150,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

@@ -126,6 +126,34 @@ function resolveScreenConfigCandidates(workspaceRoot) {
   ].filter(Boolean);
 }
 
+function canWriteDirectory(targetDir) {
+  try {
+    ensureDir(targetDir);
+    fs.accessSync(targetDir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveWritableScreenConfigPath(workspaceRoot) {
+  const candidateMap = buildScreenConfigCandidateMap(workspaceRoot);
+  const workspacePreferred = candidateMap.workspace_paths?.[0] || null;
+  if (candidateMap.env_path) {
+    return candidateMap.env_path;
+  }
+  if (workspacePreferred && canWriteDirectory(path.dirname(workspacePreferred))) {
+    return workspacePreferred;
+  }
+  if (candidateMap.user_path && canWriteDirectory(path.dirname(candidateMap.user_path))) {
+    return candidateMap.user_path;
+  }
+  if (workspacePreferred) {
+    return workspacePreferred;
+  }
+  return candidateMap.user_path || candidateMap.legacy_path;
+}
+
 function resolveScreenConfigPath(workspaceRoot) {
   const candidateMap = buildScreenConfigCandidateMap(workspaceRoot);
   if (candidateMap.env_path) {
@@ -135,9 +163,9 @@ function resolveScreenConfigPath(workspaceRoot) {
   if (existingWorkspacePath) {
     return existingWorkspacePath;
   }
-  // 默认固定写入/读取 Agent 无关路径，避免落到 npx 临时目录或 .codex 旧路径。
-  if (candidateMap.user_path) {
-    return candidateMap.user_path;
+  const writablePath = resolveWritableScreenConfigPath(workspaceRoot);
+  if (writablePath) {
+    return writablePath;
   }
   return candidateMap.legacy_path;
 }
@@ -151,7 +179,7 @@ export function getScreenConfigResolution(workspaceRoot) {
     candidate_paths,
     workspace_root: path.resolve(String(workspaceRoot || process.cwd())),
     workspace_ephemeral: isEphemeralNpxWorkspaceRoot(workspaceRoot),
-    writable_path: candidateMap.user_path,
+    writable_path: resolveWritableScreenConfigPath(workspaceRoot),
     legacy_path: candidateMap.legacy_path
   };
 }
@@ -860,6 +888,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";
@@ -83,7 +85,9 @@ function dedupePaths(items) {
   const result = [];
   const seen = new Set();
   for (const item of items || []) {
-    const resolved = path.resolve(String(item || ""));
+    const raw = String(item ?? "").trim();
+    if (!raw) continue;
+    const resolved = path.resolve(raw);
     if (!resolved || seen.has(resolved)) continue;
     seen.add(resolved);
     result.push(resolved);
@@ -91,6 +95,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");
 }
@@ -149,9 +179,29 @@ function parsePositivePort(raw) {
   return Number.isFinite(port) && port > 0 ? port : null;
 }
 
+function isEphemeralWorkspaceRoot(rootPath) {
+  const normalized = path.resolve(String(rootPath || ""))
+    .replace(/\\/g, "/")
+    .toLowerCase();
+  return (
+    normalized.includes("/appdata/local/npm-cache/_npx/")
+    || normalized.includes("/node_modules/@reconcrap/boss-recommend-mcp")
+  );
+}
+
 function getWorkspaceRoot(options) {
-  const raw = options["workspace-root"] || process.env.BOSS_WORKSPACE_ROOT || process.cwd();
-  return path.resolve(String(raw));
+  const fromOption = String(options["workspace-root"] || "").trim();
+  if (fromOption) return path.resolve(fromOption);
+
+  const fromEnv = String(process.env.BOSS_WORKSPACE_ROOT || "").trim();
+  if (fromEnv) return path.resolve(fromEnv);
+
+  const cwd = path.resolve(process.cwd());
+  const initCwd = String(process.env.INIT_CWD || "").trim();
+  if (isEphemeralWorkspaceRoot(cwd) && initCwd) {
+    return path.resolve(initCwd);
+  }
+  return cwd;
 }
 
 function readTextFile(filePath, label) {
@@ -306,10 +356,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 +442,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();
@@ -449,17 +569,52 @@ function installSkill() {
   return syncSkillAssets({ force: true }).targetDir;
 }
 
-function ensureUserConfig() {
-  const targetPath = getUserConfigPath();
-  ensureDir(path.dirname(targetPath));
-  if (!fs.existsSync(targetPath)) {
-    const template = JSON.parse(fs.readFileSync(exampleConfigPath, "utf8"));
-    template.outputDir = getDesktopDir();
-    template.debugPort = 9222;
-    fs.writeFileSync(targetPath, JSON.stringify(template, null, 2), "utf8");
-    return { path: targetPath, created: true };
+function pathStartsWith(filePath, rootPath) {
+  const file = path.resolve(String(filePath || ""));
+  const root = path.resolve(String(rootPath || ""));
+  if (process.platform === "win32") {
+    return file.toLowerCase().startsWith(root.toLowerCase());
   }
-  return { path: targetPath, created: false };
+  return file.startsWith(root);
+}
+
+function resolveCliConfigTarget(options = {}) {
+  const workspaceRoot = getWorkspaceRoot(options);
+  const resolution = getScreenConfigResolution(workspaceRoot);
+  const workspacePreferred = (resolution.candidate_paths || []).find((item) => pathStartsWith(item, workspaceRoot)) || null;
+  const configPath = resolution.writable_path || resolution.resolved_path || workspacePreferred || getUserConfigPath();
+  return {
+    workspaceRoot,
+    resolution,
+    configPath,
+    workspacePreferred
+  };
+}
+
+function ensureUserConfig(options = {}) {
+  const { configPath, workspacePreferred } = resolveCliConfigTarget(options);
+  const writeTargets = dedupePaths([configPath, workspacePreferred]).filter(Boolean);
+  let lastError = null;
+  for (const targetPath of writeTargets) {
+    try {
+      ensureDir(path.dirname(targetPath));
+      if (!fs.existsSync(targetPath)) {
+        const template = JSON.parse(fs.readFileSync(exampleConfigPath, "utf8"));
+        template.outputDir = getDesktopDir();
+        template.debugPort = 9222;
+        fs.writeFileSync(targetPath, JSON.stringify(template, null, 2), "utf8");
+        return { path: targetPath, created: true };
+      }
+      const stat = fs.statSync(targetPath);
+      if (stat.isFile()) {
+        return { path: targetPath, created: false };
+      }
+      lastError = new Error(`Config target is a directory and cannot be used as file: ${targetPath}`);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError || new Error("No writable target for screening-config.json");
 }
 
 function readJsonObjectFile(filePath) {
@@ -471,24 +626,57 @@ function readJsonObjectFile(filePath) {
   return parsed;
 }
 
-function loadBestExistingUserConfig() {
-  const primary = getUserConfigPath();
-  const legacy = getLegacyUserConfigPath();
-  if (fs.existsSync(primary)) {
-    return { path: primary, config: readJsonObjectFile(primary) };
+function loadBestExistingUserConfig(options = {}) {
+  const { resolution, configPath, workspacePreferred } = resolveCliConfigTarget(options);
+  const candidates = dedupePaths([
+    ...(resolution.candidate_paths || []),
+    configPath,
+    workspacePreferred,
+    getLegacyUserConfigPath()
+  ]).filter(Boolean);
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      try {
+        const stat = fs.statSync(candidate);
+        if (!stat.isFile()) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      return { path: candidate, config: readJsonObjectFile(candidate) };
+    }
   }
-  if (fs.existsSync(legacy)) {
-    return { path: legacy, config: readJsonObjectFile(legacy) };
+  return { path: configPath, config: {} };
+}
+
+function writeConfigWithFallback(nextConfig, options = {}) {
+  const { configPath, workspacePreferred } = resolveCliConfigTarget(options);
+  const targets = dedupePaths([configPath, workspacePreferred]).filter(Boolean);
+  let lastError = null;
+  for (const target of targets) {
+    try {
+      ensureDir(path.dirname(target));
+      if (fs.existsSync(target)) {
+        const stat = fs.statSync(target);
+        if (!stat.isFile()) {
+          lastError = new Error(`Config target is a directory and cannot be used as file: ${target}`);
+          continue;
+        }
+      }
+      fs.writeFileSync(target, JSON.stringify(nextConfig, null, 2), "utf8");
+      return target;
+    } catch (error) {
+      lastError = error;
+    }
   }
-  return { path: primary, config: {} };
+  throw lastError || new Error("No writable target for screening-config.json");
 }
 
-function persistDebugPortSelection(port) {
-  const { config } = loadBestExistingUserConfig();
-  const configPath = getUserConfigPath();
+function persistDebugPortSelection(port, options = {}) {
+  const { config } = loadBestExistingUserConfig(options);
   config.debugPort = port;
-  ensureDir(path.dirname(configPath));
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+  const configPath = writeConfigWithFallback(config, options);
   return { port, configPath };
 }
 
@@ -498,7 +686,7 @@ function setDebugPort(options = {}) {
     throw new Error("Missing required --port <number> for set-port.");
   }
   process.env.BOSS_RECOMMEND_CHROME_PORT = String(selected);
-  return persistDebugPortSelection(selected);
+  return persistDebugPortSelection(selected, options);
 }
 
 function setScreeningConfig(options = {}) {
@@ -509,8 +697,7 @@ function setScreeningConfig(options = {}) {
     throw new Error("Missing required fields: --base-url, --api-key, --model");
   }
 
-  const { config: existing } = loadBestExistingUserConfig();
-  const configPath = getUserConfigPath();
+  const { config: existing } = loadBestExistingUserConfig(options);
   const nextConfig = {
     ...existing,
     baseUrl,
@@ -530,8 +717,7 @@ function setScreeningConfig(options = {}) {
   if (debugPort) {
     nextConfig.debugPort = debugPort;
   }
-  ensureDir(path.dirname(configPath));
-  fs.writeFileSync(configPath, JSON.stringify(nextConfig, null, 2), "utf8");
+  const configPath = writeConfigWithFallback(nextConfig, options);
   return { path: configPath, updated: true };
 }
 
@@ -650,16 +836,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 +927,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 +945,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`,
@@ -821,8 +1018,8 @@ function printHelp() {
   console.log("  boss-recommend-mcp run          Run the recommend pipeline once via CLI and print JSON");
   console.log("  boss-recommend-mcp install      Install skill and MCP config templates (supports --agent trae-cn/cursor/...)");
   console.log("  boss-recommend-mcp install-skill Install only the Codex skill");
-  console.log("  boss-recommend-mcp init-config  Create ~/.boss-recommend-mcp/screening-config.json if missing");
-  console.log("  boss-recommend-mcp config set   Write baseUrl/apiKey/model to ~/.boss-recommend-mcp/screening-config.json");
+  console.log("  boss-recommend-mcp init-config  Create screening-config.json if missing (prefer workspace config/, fallback ~/.boss-recommend-mcp)");
+  console.log("  boss-recommend-mcp config set   Write baseUrl/apiKey/model (prefer workspace config/, fallback ~/.boss-recommend-mcp)");
   console.log("  boss-recommend-mcp set-port     Persist preferred Chrome debug port to screening-config.json");
   console.log("  boss-recommend-mcp mcp-config   Generate MCP config JSON for Cursor/Trae(含 trae-cn)/Claude Code/OpenClaw");
   console.log("  boss-recommend-mcp doctor       Check config and runtime prerequisites (supports --agent trae-cn/cursor/...)");
@@ -890,7 +1087,7 @@ async function runPipelineOnce(options) {
   const explicitPort = parsePositivePort(options.port);
   if (explicitPort) {
     process.env.BOSS_RECOMMEND_CHROME_PORT = String(explicitPort);
-    persistDebugPortSelection(explicitPort);
+    persistDebugPortSelection(explicitPort, options);
   }
 
   const result = await runRecommendPipeline({
@@ -937,7 +1134,7 @@ switch (command) {
     console.log(`Skill installed to: ${installSkill()}`);
     break;
   case "init-config": {
-    const result = ensureUserConfig();
+    const result = ensureUserConfig(options);
     console.log(result.created ? `Config template created at: ${result.path}` : `Config already exists at: ${result.path}`);
     break;
   }

package/src/index.js

@@ -46,9 +46,51 @@ function createToolSchema() {
           properties: {
             filters_confirmed: { type: "boolean" },
             school_tag_confirmed: { type: "boolean" },
+            school_tag_value: {
+              oneOf: [
+                {
+                  type: "string",
+                  enum: ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"]
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"]
+                  },
+                  minItems: 1,
+                  uniqueItems: true
+                }
+              ]
+            },
             degree_confirmed: { type: "boolean" },
+            degree_value: {
+              oneOf: [
+                {
+                  type: "string",
+                  enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                  },
+                  minItems: 1,
+                  uniqueItems: true
+                }
+              ]
+            },
             gender_confirmed: { type: "boolean" },
+            gender_value: {
+              type: "string",
+              enum: ["不限", "男", "女"]
+            },
             recent_not_view_confirmed: { type: "boolean" },
+            recent_not_view_value: {
+              type: "string",
+              enum: ["不限", "近14天没有"]
+            },
             criteria_confirmed: { type: "boolean" },
             target_count_confirmed: { type: "boolean" },
             target_count_value: {
@@ -60,6 +102,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/parser.js

@@ -477,9 +477,13 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   const detectedDegrees = extractDegrees(text);
   const schoolTagAudit = auditSchoolTagSelections(overrides?.school_tag);
   const overrideSchoolTag = schoolTagAudit.valid.length > 0 ? schoolTagAudit.valid : null;
+  const confirmationSchoolTag = normalizeSchoolTagSelections(confirmation?.school_tag_value);
   const overrideDegrees = normalizeDegreeSelections(overrides?.degree);
+  const confirmationDegrees = normalizeDegreeSelections(confirmation?.degree_value);
   const overrideGender = normalizeGender(overrides?.gender);
+  const confirmationGender = normalizeGender(confirmation?.gender_value);
   const overrideRecentNotView = normalizeRecentNotView(overrides?.recent_not_view);
+  const confirmationRecentNotView = normalizeRecentNotView(confirmation?.recent_not_view_value);
   const overrideCriteria = overrides?.criteria;
   const jobSelectionHint = normalizeText(overrides?.job || confirmation?.job_value || "");
 
@@ -487,16 +491,18 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     ? sortSchoolTagSelections(detectedSchoolTags)
     : ["不限"];
   const searchParams = {
-    school_tag: overrideSchoolTag || inferredSchoolTag,
+    school_tag: overrideSchoolTag || confirmationSchoolTag || inferredSchoolTag,
     degree: (
       (Array.isArray(overrideDegrees) && overrideDegrees.length > 0
         ? overrideDegrees
+        : Array.isArray(confirmationDegrees) && confirmationDegrees.length > 0
+          ? confirmationDegrees
         : Array.isArray(detectedDegrees) && detectedDegrees.length > 0
           ? detectedDegrees
           : ["不限"])
     ),
-    gender: overrideGender || extractGender(text) || "不限",
-    recent_not_view: overrideRecentNotView || extractRecentNotView(text) || "不限"
+    gender: overrideGender || confirmationGender || extractGender(text) || "不限",
+    recent_not_view: overrideRecentNotView || confirmationRecentNotView || extractRecentNotView(text) || "不限"
   };
   const screenParams = {
     criteria: buildCriteria(text, overrideCriteria),
@@ -525,10 +531,42 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     invalidOverrideSchoolTags: schoolTagAudit.invalid,
     maxGreetCountResolution
   });
-  const needs_school_tag_confirmation = confirmation?.school_tag_confirmed !== true;
-  const needs_degree_confirmation = confirmation?.degree_confirmed !== true;
-  const needs_gender_confirmation = confirmation?.gender_confirmed !== true;
-  const needs_recent_not_view_confirmation = confirmation?.recent_not_view_confirmed !== true;
+  const hasSchoolTagSignal = Boolean(
+    (Array.isArray(overrideSchoolTag) && overrideSchoolTag.length > 0)
+    || (Array.isArray(confirmationSchoolTag) && confirmationSchoolTag.length > 0)
+    || (Array.isArray(detectedSchoolTags) && detectedSchoolTags.length > 0)
+  );
+  const hasDegreeSignal = Boolean(
+    (Array.isArray(overrideDegrees) && overrideDegrees.length > 0)
+    || (Array.isArray(confirmationDegrees) && confirmationDegrees.length > 0)
+    || (Array.isArray(detectedDegrees) && detectedDegrees.length > 0)
+  );
+  const hasGenderSignal = Boolean(
+    overrideGender
+    || confirmationGender
+    || extractGender(text)
+  );
+  const hasRecentNotViewSignal = Boolean(
+    overrideRecentNotView
+    || confirmationRecentNotView
+    || extractRecentNotView(text)
+  );
+  const needs_school_tag_confirmation = (
+    confirmation?.school_tag_confirmed !== true
+    || !hasSchoolTagSignal
+  );
+  const needs_degree_confirmation = (
+    confirmation?.degree_confirmed !== true
+    || !hasDegreeSignal
+  );
+  const needs_gender_confirmation = (
+    confirmation?.gender_confirmed !== true
+    || !hasGenderSignal
+  );
+  const needs_recent_not_view_confirmation = (
+    confirmation?.recent_not_view_confirmed !== true
+    || !hasRecentNotViewSignal
+  );
   const needs_filters_confirmation = (
     confirmation?.filters_confirmed !== true
     || needs_school_tag_confirmation

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-parser.js

@@ -67,6 +67,70 @@ function testConfirmedPostActionAndOverrides() {
   assert.equal(result.needs_max_greet_count_confirmation, false);
 }
 
+function testFilterConfirmedWithoutExplicitValuesShouldRequireReconfirmation() {
+  const result = parseRecommendInstruction({
+    instruction: "通过boss推荐skill帮我找人",
+    confirmation: {
+      filters_confirmed: true,
+      school_tag_confirmed: true,
+      degree_confirmed: true,
+      gender_confirmed: true,
+      recent_not_view_confirmed: true,
+      criteria_confirmed: true,
+      target_count_confirmed: true,
+      post_action_confirmed: true,
+      post_action_value: "favorite"
+    },
+    overrides: {
+      criteria: "必须有至少3年工作经验，且做过算法"
+    }
+  });
+
+  assert.deepEqual(result.searchParams.school_tag, ["不限"]);
+  assert.deepEqual(result.searchParams.degree, ["不限"]);
+  assert.equal(result.searchParams.gender, "不限");
+  assert.equal(result.searchParams.recent_not_view, "不限");
+  assert.equal(result.needs_school_tag_confirmation, true);
+  assert.equal(result.needs_degree_confirmation, true);
+  assert.equal(result.needs_gender_confirmation, true);
+  assert.equal(result.needs_recent_not_view_confirmation, true);
+  assert.equal(result.needs_filters_confirmation, true);
+}
+
+function testFilterConfirmedWithExplicitConfirmationValuesShouldNotFallbackToUnlimited() {
+  const result = parseRecommendInstruction({
+    instruction: "通过boss推荐skill帮我找人",
+    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: 3,
+      post_action_confirmed: true,
+      post_action_value: "favorite"
+    },
+    overrides: {
+      criteria: "必须有至少3年工作经验，且做过算法"
+    }
+  });
+
+  assert.deepEqual(result.searchParams.school_tag, ["985", "211"]);
+  assert.deepEqual(result.searchParams.degree, ["大专", "本科", "硕士", "博士"]);
+  assert.equal(result.searchParams.gender, "男");
+  assert.equal(result.searchParams.recent_not_view, "近14天没有");
+  assert.equal(result.needs_school_tag_confirmation, false);
+  assert.equal(result.needs_degree_confirmation, false);
+  assert.equal(result.needs_gender_confirmation, false);
+  assert.equal(result.needs_recent_not_view_confirmation, false);
+}
+
 function testMultipleSchoolTagsMarkedSuspicious() {
   const result = parseRecommendInstruction({
     instruction: "推荐页筛选985和211，有推荐系统经验",
@@ -351,6 +415,8 @@ function testMcpMentionShouldStayInCriteria() {
 function main() {
   testNeedConfirmationIncludesPostAction();
   testConfirmedPostActionAndOverrides();
+  testFilterConfirmedWithoutExplicitValuesShouldRequireReconfirmation();
+  testFilterConfirmedWithExplicitConfirmationValuesShouldNotFallbackToUnlimited();
   testMultipleSchoolTagsMarkedSuspicious();
   testDegreeCanBeExtracted();
   testDegreeAtOrAboveExpansion();

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-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 || '');