@reconcrap/boss-recruit-mcp 1.0.5 → 1.0.7

package/README.md

@@ -24,9 +24,55 @@ npx @reconcrap/boss-recruit-mcp install
 
 - 安装 Codex skill 到 `$CODEX_HOME/skills/boss-recruit-pipeline`
 - 初始化用户配置到 `$CODEX_HOME/boss-recruit-mcp/screening-config.json`
+- 生成通用 MCP 配置模板到 `$CODEX_HOME/boss-recruit-mcp/agent-mcp-configs`
 - 包内自带 `boss-search-cli` 与 `boss-screen-cli` 运行时文件，无需额外目录结构
 - 不包含 `favorite-calibration.json`，首次使用前需要自行校准生成
 
+## 跨 Agent 快速接入（Cursor / Trae / Claude Code / OpenClaw）
+
+生成 MCP 配置模板：
+
+```bash
+boss-recruit-mcp mcp-config --client all
+```
+
+默认会输出到：
+
+```bash
+$CODEX_HOME/boss-recruit-mcp/agent-mcp-configs
+```
+
+包含：
+
+- `mcp.cursor.json`
+- `mcp.trae.json`
+- `mcp.claudecode.json`
+- `mcp.openclaw.json`
+- `mcp.generic.json`
+
+把对应文件里的 `mcpServers` 合并到你的 AI 客户端 MCP 配置中即可。
+
+如果你只需要某一个客户端模板：
+
+```bash
+boss-recruit-mcp mcp-config --client cursor
+boss-recruit-mcp mcp-config --client claudecode
+boss-recruit-mcp mcp-config --client trae
+boss-recruit-mcp mcp-config --client openclaw
+boss-recruit-mcp mcp-config --client generic
+```
+
+默认模板会使用：
+
+- `command: npx`
+- `args: ["-y", "@reconcrap/boss-recruit-mcp@latest", "start"]`
+
+如果你希望改成本地全局命令：
+
+```bash
+boss-recruit-mcp mcp-config --client generic --command boss-recruit-mcp --args-json "[\"start\"]"
+```
+
 ## 准备配置
 
 1. 初始化后编辑用户配置文件：
@@ -41,6 +87,7 @@ $CODEX_HOME/boss-recruit-mcp/screening-config.json
 - `debugPort` 可选，默认 `9222`
 - `calibrationFile` 可选；不填时默认使用 `$CODEX_HOME/boss-recruit-mcp/favorite-calibration.json`
 - `outputDir` 可选；不填时默认输出到用户桌面
+- 学校标签支持 `统招本科` / `双一流院校` / `985` / `211` / `qs100` / `qs500`；如果输入 `qs50`、`qs200`、`qs500` 等其他 `QS数字`，会按 `<=100 -> qs100`、`>100 -> qs500` 归一
 
 ## 运行
 
@@ -55,13 +102,13 @@ boss-recruit-mcp start
 如果当前 AI agent 无法添加新的 MCP、MCP 数量受限，或者只支持 shell/命令执行，也可以直接调用同一后端的 CLI fallback：
 
 ```bash
-boss-recruit-mcp run --instruction "在 Boss 上找做过推荐系统的人，城市杭州，本科，学校 985/211/QS100，目标 10 人"
+boss-recruit-mcp run --instruction "在 Boss 上找做过推荐系统的人，城市杭州，本科，学校 985/211/QS100，目标 10 人，过滤近14天查看过的人选"
 ```
 
 也支持通过 JSON 传确认信息与覆盖参数：
 
 ```bash
-boss-recruit-mcp run --instruction "在 Boss 上找做过推荐系统的人" --confirmation-json "{\"keyword_confirmed\":true,\"keyword_value\":\"推荐系统\",\"search_params_confirmed\":true}" --overrides-json "{\"city\":\"杭州\",\"degree\":\"本科\",\"schools\":[\"985\",\"211\",\"qs100\"],\"target_count\":10}"
+boss-recruit-mcp run --instruction "在 Boss 上找做过推荐系统的人" --confirmation-json "{\"keyword_confirmed\":true,\"keyword_value\":\"推荐系统\",\"search_params_confirmed\":true}" --overrides-json "{\"city\":\"杭州\",\"degree\":\"本科\",\"schools\":[\"985\",\"211\",\"qs100\"],\"filter_recent_viewed\":true,\"target_count\":10}"
 ```
 
 如果命令行中放长文本不方便，改用文件：
@@ -132,6 +179,7 @@ boss-recruit-mcp doctor --port <port>
     "use_default_for_missing": false
   },
   "overrides": {
+    "filter_recent_viewed": true,
     "target_count": 500
   }
 }
@@ -140,10 +188,12 @@ boss-recruit-mcp doctor --port <port>
 ## 行为说明
 
 - 若缺 `city/degree/schools/keyword/target_count`，返回 `NEED_INPUT`
-- 若 keyword 由语义自动抽取、或搜索参数仍未被用户明确确认，返回 `NEED_CONFIRMATION`
+- 若 keyword 由语义自动抽取、搜索参数仍未被用户明确确认，或用户未说明是否过滤近 14 天查看过的人选，返回 `NEED_CONFIRMATION`
 - 正式执行前应先单独做一轮参数确认，把已识别参数、待确认项、缺失项、默认值风险分开给用户确认
+- 若用户没提“是否过滤近14天查看”，会在 `pending_questions` 里返回该问题，调用方应先补问再继续
 - 用户未补齐缺失参数时，只有在明确同意默认值及其质量风险后，才允许继续
-- 确认后自动执行：搜索 CLI -> 筛选 CLI
+- `target_count` 表示“目标处理人数”，不是“目标通过人数”；状态一旦是 `COMPLETED`，就表示本轮已完成，不应因通过人数不足而自动重跑
+- 确认后自动执行：搜索 CLI -> 点击搜索 -> 勾选“过滤近14天查看”（如启用） -> 筛选 CLI
 - 返回摘要：目标数、已处理、通过数、耗时、输出 CSV
 - 执行前会先做本地依赖预检查，若目录 / 入口 / 配置文件缺失则返回 `PIPELINE_PREFLIGHT_FAILED`
 - 若缺少 `favorite-calibration.json`，会返回 `CALIBRATION_REQUIRED`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recruit-mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Unified MCP pipeline for boss-search-cli and boss-screen-cli",
   "keywords": [
     "boss",

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

@@ -12,8 +12,15 @@ npx @reconcrap/boss-recruit-mcp install
 
 - 把 skill 安装到 `$CODEX_HOME/skills/boss-recruit-pipeline`
 - 在 `$CODEX_HOME/boss-recruit-mcp/screening-config.json` 创建配置模板
+- 在 `$CODEX_HOME/boss-recruit-mcp/agent-mcp-configs` 生成 Cursor/Trae/Claude Code/OpenClaw 的 MCP 模板
 - 默认把筛选结果输出到用户桌面
 
+如果你只想导出 MCP 模板，可执行：
+
+```powershell
+boss-recruit-mcp mcp-config --client all
+```
+
 ## 前置要求
 
 - Chrome 需使用远程调试端口启动；推荐 `9222`，但也可以使用你已在运行的其他端口

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

@@ -22,6 +22,7 @@
 
 1. 先检查 MCP 是否已安装 / 可调用；若未安装，优先执行：
    - `npx @reconcrap/boss-recruit-mcp install`
+   - 若要给 Cursor / Trae / Claude Code / OpenClaw 快速接入，执行 `boss-recruit-mcp mcp-config --client all`，并把生成文件中的 `mcpServers` 合并到对应客户端配置
 2. 若用户还未确认 Chrome 调试端口，必须先询问：
    - 建议使用 `9222`
    - 但也允许用户明确提供一个已在使用的其他远程调试端口
@@ -78,6 +79,7 @@
 - Tool response 重点字段：
   - `status`
   - `required_confirmations`
+  - `pending_questions`
   - `review.extracted_search_params`
   - `review.current_search_params`
   - `review.missing_fields`
@@ -157,8 +159,9 @@
 6. 缺失项常见含义：
    - `city`: 城市，如“杭州”
    - `degree`: 学历，如“本科”“硕士及以上”
-   - `schools`: 学校标签，如“985、211、qs100”
-   - `target_count`: 目标筛选人数，如“10”
+   - `schools`: 学校标签，如“统招本科、双一流院校、985、211、qs100、qs500”
+   - `filter_recent_viewed`: 是否过滤近 14 天内查看过的人选
+   - `target_count`: 目标处理人数，如“10”；表示本轮需要处理多少位候选人，不表示必须有多少人通过
    - `keyword`: 搜索关键词，如“AI infra”“推荐系统”
 7. 若返回 `NEED_INPUT`：
    - 不要只问一次就结束；
@@ -168,8 +171,10 @@
 8. 若返回 `NEED_CONFIRMATION`：
    - 询问用户是否确认 `proposed_keyword`；
    - 同时也要让用户确认其他已提取参数里是否有误；
+   - 若 `required_confirmations` 或 `pending_questions` 里包含 `filter_recent_viewed`，必须明确补问：是否需要过滤近 14 天查看过的人选；
    - 若确认，带 `confirmation.keyword_confirmed=true` 和 `keyword_value` 再次调用；
-   - 若用户修改关键词，传用户给的新词作为 `keyword_value` 再次调用。
+   - 若用户修改关键词，传用户给的新词作为 `keyword_value` 再次调用；
+   - 对“是否过滤近 14 天查看”这个问题，需把用户选择写入 `overrides.filter_recent_viewed=true/false` 再次调用。
 9. 当仍有缺失参数但用户想直接开始时：
    - 先明确告知默认值及风险；
    - 必须得到用户明确确认“可以按默认值继续”后，才能继续执行。
@@ -178,7 +183,10 @@
    - 缺失参数已补齐，或用户已明确接受默认值；
    - `NEED_CONFIRMATION` 分支中的关键词也已确认。
 11. 若返回 `COMPLETED`：
-   - 向用户返回摘要：目标数、已处理、通过数、耗时、输出文件路径。
+   - 向用户返回摘要：目标处理人数、已处理、通过数、耗时、输出文件路径。
+   - 只要状态是 `COMPLETED`，就视为本轮任务完成；
+   - 不要因为 `passed_count < target_count` 就自动重跑；
+   - `target_count` 的含义是“处理人数目标”，不是“通过人数目标”。
 12. 若返回 `FAILED`：
    - 先提炼 `error.code`、`error.message`、`diagnostics`；
    - 如果是 `PIPELINE_PREFLIGHT_FAILED`，明确指出缺失的本地目录 / 文件；
@@ -193,6 +201,9 @@
 - 当用户提到“做过 AI infra / 推荐系统 / 搜索 / 广告 / 多模态”等经历，但没有显式写“关键词”，默认允许流水线先自动抽取，再走确认分支。
 - 当用户附带筛选要求（如“必须发表过 CCF-A 区论文”“有开源项目”“带过团队”），这些要求应该保留在 `criteria` 中，不应被误当作搜索过滤条件。
 - 若参数提取结果出现明显噪声、截断、短语串接、非标准枚举值，优先视为“识别不可靠”，要求用户确认，不要为了推进流程直接采用。
+- 若用户输入 `qs50`、`qs200`、`qs500` 等任意 `QS数字` 学校标签，统一按 `<=100 -> qs100`、`>100 -> qs500` 处理；不要把原始 `QS200` 再传到底层搜索命令。
+- 若用户没有明确提到“是否过滤近 14 天查看过的人选”，必须在参数确认阶段主动补问，不能静默默认开启或关闭。
+- 若用户说“过滤近 14 天查看”“排除最近看过的”，映射为 `filter_recent_viewed=true`；若用户说“不过滤近 14 天查看”“保留最近看过的”，映射为 `filter_recent_viewed=false`。
 - 不要把“用户没有继续回复”解释为“默认同意”；默认值只能在用户明确口头确认后使用。
 - 参数确认对话里，优先采用这种结构：
   - 已识别参数
@@ -213,7 +224,8 @@
 - `已识别参数` 只放当前看起来可信的值，例如：
   - 城市：杭州
   - 学历：本科
-  - 学校标签：985 / 211 / QS100
+  - 学校标签：统招本科 / 双一流院校 / 985 / 211 / QS100 / QS500（按实际需求选择）
+  - 过滤近14天查看：需要 / 不需要
   - 关键词：AI infra
   - 目标人数：10
 - `待确认 / 待修正` 要明确写出“识别值 -> 疑点 -> 需要用户给出的标准值”，例如：
@@ -227,7 +239,7 @@
   - 若继续会使用哪些默认值
   - 会导致搜索范围变宽、相关性下降或结果偏差增大
 - `请用户回复` 要求用户一次性回复完整，优先使用这种收口方式：
-  - 请直接按“城市 / 学历 / 学校标签 / 关键词 / 目标人数”补充或修正
+  - 请直接按“城市 / 学历 / 学校标签 / 是否过滤近14天查看 / 关键词 / 目标人数”补充或修正
   - 如果你接受默认值继续，请明确回复“确认按默认值继续”
 - 若用户补充后仍有缺失，再发第二轮确认时继续复用同一结构，只保留：
   - 已更新的参数
@@ -262,7 +274,7 @@
 
 用户：
 
-- “在 Boss 上找做过 AI infra 的候选人，必须发过 CCF-A 区论文，城市杭州，本科，学校 985/211/QS100，目标 10 人”
+- “在 Boss 上找做过 AI infra 的候选人，必须发过 CCF-A 区论文，城市杭州，本科，学校 统招本科/双一流院校/985/211/QS100/QS500 中按需选择，目标 10 人”
 
 期望行为：
 
@@ -285,5 +297,6 @@
 - 校准缺失时，直接指导用户重新校准，不要建议复制或复用任何历史 calibration 文件。
 - 若当前 agent 受 MCP 数量限制，明确告诉用户“本轮改走 CLI fallback”，但用户体验上仍保持同一套确认和状态输出。
 - 新开 Chrome 后若检测到跳转登录，先提示用户手动登录并等待确认，再继续。
+- 若返回 `COMPLETED`，不要把“通过人数不足”理解成“任务未完成”；除非用户明确要求“必须找到 N 个通过人选”，否则不要自动追加新一轮搜索。
 - 若要使用默认值，必须写明“请确认是否按默认值继续”，不能模糊带过。
 - 若运行失败，优先给用户“现在卡在哪一步 + 怎么继续”。

package/src/adapters.js

@@ -157,7 +157,7 @@ function parseSearchCount(output) {
 function parseScreenSummary(output) {
   const processed = output.match(/已处理:\s*(\d+)\s*人/);
   const passed = output.match(/通过筛选:\s*(\d+)\s*人/);
-  const target = output.match(/目标人数:\s*(\d+)\s*人/);
+  const target = output.match(/目标(?:处理)?人数:\s*(\d+)\s*人/);
   const csv = output.match(/结果已导出到:\s*(.+)/);
 
   return {
@@ -299,6 +299,10 @@ export async function runSearchCli({ workspaceRoot, searchParams }) {
     String(debugPort)
   ];
 
+  if (typeof searchParams.filter_recent_viewed === "boolean") {
+    args.push("--filter-recent-viewed", String(searchParams.filter_recent_viewed));
+  }
+
   const result = await runProcess({
     command: "node",
     args,

package/src/cli.js

@@ -21,6 +21,10 @@ const calibrationScriptPath = path.join(
   "calibrate-favorite-position-v2.cjs"
 );
 const bossUrl = "https://www.zhipin.com/web/chat/search";
+const SUPPORTED_MCP_CLIENTS = ["generic", "cursor", "trae", "claudecode", "openclaw"];
+const DEFAULT_MCP_SERVER_NAME = "boss-recruit";
+const DEFAULT_MCP_COMMAND = "npx";
+const DEFAULT_MCP_ARGS = ["-y", "@reconcrap/boss-recruit-mcp@latest", "start"];
 
 function getCodexHome() {
   return process.env.CODEX_HOME
@@ -70,6 +74,112 @@ function parseOptions(args) {
   return options;
 }
 
+function parseJsonObjectOption(value, label) {
+  if (value === undefined || value === null || value === "") {
+    return {};
+  }
+  const parsed = parseJsonOption(value, label);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
+
+function parseStringArrayOption(value, label) {
+  if (value === undefined || value === null || value === "") {
+    return [];
+  }
+  const parsed = parseJsonOption(value, label);
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+    throw new Error(`${label} must be a JSON string array`);
+  }
+  return parsed;
+}
+
+function normalizeMcpClientName(value) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return "";
+  if (raw === "claude-code") return "claudecode";
+  return raw;
+}
+
+function parseMcpClientTargets(rawValue) {
+  if (!rawValue) return SUPPORTED_MCP_CLIENTS.slice();
+  const raw = String(rawValue).trim().toLowerCase();
+  if (!raw || raw === "all") {
+    return SUPPORTED_MCP_CLIENTS.slice();
+  }
+  const candidates = raw
+    .split(",")
+    .map((item) => normalizeMcpClientName(item))
+    .filter(Boolean);
+  const unique = [...new Set(candidates)];
+  const invalid = unique.filter((item) => !SUPPORTED_MCP_CLIENTS.includes(item));
+  if (invalid.length) {
+    throw new Error(
+      `Unsupported --client value: ${invalid.join(", ")}. Supported: ${SUPPORTED_MCP_CLIENTS.join(", ")}`
+    );
+  }
+  return unique;
+}
+
+function getAgentConfigOutputDir(options = {}) {
+  if (typeof options["output-dir"] === "string" && options["output-dir"].trim()) {
+    return path.resolve(options["output-dir"]);
+  }
+  return path.join(getCodexHome(), "boss-recruit-mcp", "agent-mcp-configs");
+}
+
+function buildMcpLaunchConfig(options = {}) {
+  const command =
+    typeof options.command === "string" && options.command.trim()
+      ? options.command.trim()
+      : DEFAULT_MCP_COMMAND;
+  const args = parseStringArrayOption(options["args-json"], "args-json");
+  const env = parseJsonObjectOption(options["env-json"], "env-json");
+  const launchArgs = args.length
+    ? args
+    : command === "boss-recruit-mcp"
+      ? ["start"]
+      : DEFAULT_MCP_ARGS.slice();
+  const launchConfig = {
+    command,
+    args: launchArgs
+  };
+  if (Object.keys(env).length > 0) {
+    launchConfig.env = env;
+  }
+  return launchConfig;
+}
+
+function buildMcpConfigFileContent(options = {}) {
+  const serverName =
+    typeof options["server-name"] === "string" && options["server-name"].trim()
+      ? options["server-name"].trim()
+      : DEFAULT_MCP_SERVER_NAME;
+  return {
+    mcpServers: {
+      [serverName]: buildMcpLaunchConfig(options)
+    }
+  };
+}
+
+function writeMcpConfigFiles(options = {}) {
+  const clients = parseMcpClientTargets(options.client);
+  const outputDir = getAgentConfigOutputDir(options);
+  ensureDir(outputDir);
+  const files = [];
+
+  for (const client of clients) {
+    const filePath = path.join(outputDir, `mcp.${client}.json`);
+    const content = buildMcpConfigFileContent(options);
+    fs.writeFileSync(filePath, JSON.stringify(content, null, 2), "utf8");
+    files.push({ client, file: filePath });
+  }
+
+  return { outputDir, files };
+}
+
 function readTextFile(filePath, label) {
   const resolved = path.resolve(String(filePath));
   try {
@@ -411,6 +521,7 @@ function printHelp() {
   console.log("  boss-recruit-mcp install      Install Codex skill and initialize user config");
   console.log("  boss-recruit-mcp install-skill Install only the Codex skill");
   console.log("  boss-recruit-mcp init-config  Create ~/.codex/boss-recruit-mcp/screening-config.json if missing");
+  console.log("  boss-recruit-mcp mcp-config   Generate MCP config JSON for Cursor/Trae/Claude Code/OpenClaw");
   console.log("  boss-recruit-mcp doctor       Check config, calibration, and runtime prerequisites");
   console.log("  boss-recruit-mcp calibrate    Run favorite-button calibration and save favorite-calibration.json");
   console.log("  boss-recruit-mcp launch-chrome Launch Chrome in remote-debugging mode, open Boss search, and check login state");
@@ -419,6 +530,11 @@ function printHelp() {
   console.log("Run command:");
   console.log("  boss-recruit-mcp run --instruction \"找杭州本科做过推荐系统的人\" [--confirmation-json '{...}'] [--overrides-json '{...}']");
   console.log("  boss-recruit-mcp run --instruction-file request.txt [--confirmation-file confirmation.json] [--overrides-file overrides.json]");
+  console.log("");
+  console.log("MCP config command:");
+  console.log("  boss-recruit-mcp mcp-config --client cursor");
+  console.log("  boss-recruit-mcp mcp-config --client all --output-dir <dir>");
+  console.log("  boss-recruit-mcp mcp-config --client generic --command boss-recruit-mcp --args-json '[\"start\"]'");
 }
 
 function printPaths() {
@@ -432,23 +548,48 @@ function printPaths() {
   console.log(`desktop_output_default=${getDesktopDir()}`);
 }
 
+function printMcpConfig(options = {}) {
+  const clients = parseMcpClientTargets(options.client);
+  if (clients.length === 1 && !options["output-dir"]) {
+    const config = buildMcpConfigFileContent(options);
+    printJson(config);
+    return;
+  }
+
+  const result = writeMcpConfigFiles(options);
+  console.log(`MCP config templates exported to: ${result.outputDir}`);
+  for (const item of result.files) {
+    console.log(`- ${item.client}: ${item.file}`);
+  }
+  console.log("");
+  console.log("Tip:");
+  console.log("1. Choose the template file matching your AI client.");
+  console.log("2. Merge its mcpServers block into that client's MCP config.");
+}
+
 function installAll() {
   const skillTarget = installSkill();
   const configResult = ensureUserConfig();
+  const mcpTemplateResult = writeMcpConfigFiles({ client: "all" });
   console.log(`Skill installed to: ${skillTarget}`);
   if (configResult.created) {
     console.log(`Config template created at: ${configResult.path}`);
   } else {
     console.log(`Config already exists at: ${configResult.path}`);
   }
+  console.log(`MCP config templates exported to: ${mcpTemplateResult.outputDir}`);
+  for (const item of mcpTemplateResult.files) {
+    console.log(`- ${item.client}: ${item.file}`);
+  }
   console.log("");
   console.log("Next steps:");
   console.log("1. Fill in baseUrl/apiKey/model in the config file above.");
-  console.log("2. Choose a Chrome remote-debugging port (9222 is recommended, but you can reuse an existing port).");
-  console.log("3. Run `boss-recruit-mcp doctor --port <your-port>` to verify config, calibration, and runtime prerequisites.");
-  console.log("4. Run `boss-recruit-mcp launch-chrome --port <your-port>`; if it reports the page redirected away from search, log in to Boss manually in that Chrome window.");
-  console.log("5. Run `boss-recruit-mcp calibrate --port <your-port>` to generate favorite-calibration.json for this environment.");
-  console.log("6. Run `boss-recruit-mcp start` or configure your MCP client to launch `boss-recruit-mcp`.");
+  console.log("2. Choose a client template from the exported MCP config files and merge it into your AI client config.");
+  console.log("3. Choose a Chrome remote-debugging port (9222 is recommended, but you can reuse an existing port).");
+  console.log("4. Run `boss-recruit-mcp doctor --port <your-port>` to verify config, calibration, and runtime prerequisites.");
+  console.log("5. Run `boss-recruit-mcp launch-chrome --port <your-port>`; if it reports the page redirected away from search, log in to Boss manually in that Chrome window.");
+  console.log("6. Run `boss-recruit-mcp calibrate --port <your-port>` to generate favorite-calibration.json for this environment.");
+  console.log("7. Run `boss-recruit-mcp start` or configure your MCP client to launch the command from the generated template.");
 }
 
 async function runPipelineOnce(options) {
@@ -504,6 +645,14 @@ switch (command) {
     );
     break;
   }
+  case "mcp-config":
+    try {
+      printMcpConfig(options);
+    } catch (error) {
+      console.error(error.message || "Failed to generate MCP config template.");
+      process.exitCode = 1;
+    }
+    break;
   case "doctor":
     await printDoctor(options);
     break;

package/src/index.js

@@ -49,6 +49,7 @@ function createToolSchema() {
           properties: {
             city: { type: "string" },
             degree: { type: "string" },
+            filter_recent_viewed: { type: "boolean" },
             schools: {
               anyOf: [
                 { type: "array", items: { type: "string" } },

package/src/parser.js

@@ -1,7 +1,18 @@
 const SEARCH_SCHOOL_MAP = {
+  "统招": "统招本科",
+  "统招本科": "统招本科",
+  "统招本": "统招本科",
+  "全日制本科": "统招本科",
+  "双一流": "双一流院校",
+  "双一流院校": "双一流院校",
+  "双一流学校": "双一流院校",
   "985": "985院校",
+  "985院校": "985院校",
   "211": "211院校",
-  "qs100": "QS 100"
+  "211院校": "211院校",
+  "qs": "QS 100",
+  "qs100": "QS 100",
+  "qs500": "QS 500"
 };
 const KNOWN_SCHOOL_LABELS = new Set(Object.values(SEARCH_SCHOOL_MAP));
 const DEFAULT_PARAM_VALUES = {
@@ -39,8 +50,12 @@ function normalizeSchoolLabel(value) {
   }
 
   const compact = raw.toLowerCase().replace(/\s+/g, "");
-  if (/^qs\d+$/.test(compact)) {
-    return SEARCH_SCHOOL_MAP.qs100;
+  const qsMatch = compact.match(/^qs(\d+)$/);
+  if (qsMatch) {
+    const rank = Number.parseInt(qsMatch[1], 10);
+    if (Number.isFinite(rank)) {
+      return rank > 100 ? SEARCH_SCHOOL_MAP.qs500 : SEARCH_SCHOOL_MAP.qs100;
+    }
   }
   return SEARCH_SCHOOL_MAP[compact] || SEARCH_SCHOOL_MAP[raw] || raw;
 }
@@ -82,6 +97,7 @@ function extractCity(text) {
 function extractDegree(text) {
   if (/(博士及以上|博士)/.test(text)) return "博士";
   if (/(硕士及以上|硕士以上)/.test(text)) return "硕士及以上";
+  if (/硕士/.test(text)) return "硕士";
   if (/(本科及以上|本科以上)/.test(text)) return "本科及以上";
   if (/本科/.test(text)) return "本科";
   return null;
@@ -89,12 +105,47 @@ function extractDegree(text) {
 
 function extractSchools(text) {
   const schools = [];
+  if (/统招(?:本科)?/.test(text)) schools.push(SEARCH_SCHOOL_MAP["统招"]);
+  if (/双一流(?:院校|学校)?/.test(text)) schools.push(SEARCH_SCHOOL_MAP["双一流"]);
   if (/(^|[^0-9])985([^0-9]|$)/.test(text)) schools.push(SEARCH_SCHOOL_MAP["985"]);
   if (/(^|[^0-9])211([^0-9]|$)/.test(text)) schools.push(SEARCH_SCHOOL_MAP["211"]);
-  if (/\bqs\s*\d+\b/i.test(text)) schools.push(SEARCH_SCHOOL_MAP["qs100"]);
+  const qsMatches = text.matchAll(/\bqs\s*(\d+)\b/ig);
+  for (const match of qsMatches) {
+    const rank = Number.parseInt(match[1], 10);
+    if (Number.isFinite(rank)) {
+      schools.push(rank > 100 ? SEARCH_SCHOOL_MAP.qs500 : SEARCH_SCHOOL_MAP.qs100);
+    }
+  }
   return uniqueList(schools);
 }
 
+function extractRecentViewedFilter(text) {
+  const negativePatterns = [
+    /(?:不|别|无需|不用|不要).{0,6}(?:过滤|排除|去掉|剔除).{0,8}(?:近?14天(?:内)?查看(?:过)?)/i,
+    /(?:保留|包含).{0,8}(?:近?14天(?:内)?查看(?:过)?)/i,
+    /(?:近?14天(?:内)?查看(?:过)?).{0,8}(?:不要|不用|无需|不需要|不必).{0,4}(?:过滤|排除|去掉|剔除)/i
+  ];
+
+  for (const pattern of negativePatterns) {
+    if (pattern.test(text)) {
+      return false;
+    }
+  }
+
+  const positivePatterns = [
+    /(?:过滤|排除|去掉|剔除).{0,8}(?:近?14天(?:内)?查看(?:过)?)/i,
+    /(?:近?14天(?:内)?查看(?:过)?).{0,8}(?:过滤|排除|去掉|剔除)/i
+  ];
+
+  for (const pattern of positivePatterns) {
+    if (pattern.test(text)) {
+      return true;
+    }
+  }
+
+  return null;
+}
+
 function normalizeStringOverride(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim();
@@ -176,6 +227,10 @@ function sanitizeClause(clause) {
     .trim();
 }
 
+function isCountPlanningClause(clause) {
+  return /(?:目标(?:筛选)?(?:人数|数量)?|至少筛选|筛选\s*\d+\s*位|输出\s*\d+\s*(?:位|个|个人选|个候选人)?|最终输出\s*\d+\s*(?:位|个|个人选|个候选人)?|处理\s*\d+\s*(?:位|人)|(?:浏览|拉取|抓取).*(?:至少\s*)?\d+\s*(?:位|个|个人选|个候选人)?|最匹配.*\d+\s*(?:位|个|个人选|个候选人)?)/i.test(clause);
+}
+
 function buildScreenCriteria(text, searchParams) {
   const clauses = text
     .split(/[，,。；;\n]/)
@@ -186,8 +241,9 @@ function buildScreenCriteria(text, searchParams) {
     if (/搜索关键词|关键词|keyword/i.test(clause)) return false;
     if (/地点|城市/.test(clause)) return false;
     if (/学历|本科|硕士|博士/.test(clause) && !/论文|项目|经验/.test(clause)) return false;
-    if (/985|211|qs\s*\d+|院校/i.test(clause) && !/论文|经验|项目/.test(clause)) return false;
-    if (/至少筛选|目标人数|目标数量|筛选\d+位/.test(clause)) return false;
+    if (/985|211|qs\s*\d+|双一流|统招(?:本科)?|院校/i.test(clause) && !/论文|经验|项目/.test(clause)) return false;
+    if (/近?14天(?:内)?查看(?:过)?|过滤近14天查看/.test(clause)) return false;
+    if (isCountPlanningClause(clause)) return false;
     return true;
   });
 
@@ -345,6 +401,7 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     city: extractCity(text),
     degree: extractDegree(text),
     schools: extractSchools(text),
+    filter_recent_viewed: extractRecentViewedFilter(text),
     keyword_explicit: extractKeywordExplicit(text),
     keyword_auto: extractKeywordAuto(text),
     target_count: extractTargetCount(text)
@@ -355,11 +412,15 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     const overrideDegree = normalizeStringOverride(overrides.degree);
     const overrideSchools = normalizeSchoolsOverride(overrides.schools);
     const overrideKeyword = normalizeStringOverride(overrides.keyword);
+    const overrideRecentViewed = typeof overrides.filter_recent_viewed === "boolean"
+      ? overrides.filter_recent_viewed
+      : null;
 
     if (overrideCity) parsed.city = overrideCity;
     if (overrideDegree) parsed.degree = overrideDegree;
     if (overrideSchools && overrideSchools.length > 0) parsed.schools = overrideSchools;
     if (overrideKeyword) parsed.keyword_override = overrideKeyword;
+    if (overrideRecentViewed !== null) parsed.filter_recent_viewed = overrideRecentViewed;
 
     if (Number.isFinite(overrides.target_count) && overrides.target_count > 0) {
       parsed.target_count = Number.parseInt(String(overrides.target_count), 10);
@@ -371,6 +432,7 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     city: parsed.city,
     degree: parsed.degree,
     schools: parsed.schools,
+    filter_recent_viewed: parsed.filter_recent_viewed,
     keyword: keywordResolution.keyword
   };
 
@@ -397,6 +459,19 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     { skipKeywordDefault }
   );
   const suspicious_fields = collectSuspiciousFields(searchParams, screenParams);
+  const needs_recent_viewed_filter_confirmation = searchParams.filter_recent_viewed === null;
+  const pending_questions = needs_recent_viewed_filter_confirmation
+    ? [
+      {
+        field: "filter_recent_viewed",
+        question: "是否需要过滤近14天查看过的人选？",
+        options: [
+          { label: "需要过滤", value: true },
+          { label: "不过滤", value: false }
+        ]
+      }
+    ]
+    : [];
 
   return {
     parsed,
@@ -406,8 +481,10 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     has_unresolved_missing_fields: missingBeforeDefaults.length > 0 && !useDefaultForMissing,
     suspicious_fields,
     needs_keyword_confirmation: keywordResolution.needsConfirmation,
+    needs_recent_viewed_filter_confirmation,
     needs_search_params_confirmation: confirmation?.search_params_confirmed !== true,
     proposed_keyword: keywordResolution.proposedKeyword,
+    pending_questions,
     default_preview: defaultPreview,
     applied_defaults: appliedDefaults,
     review: {
@@ -418,6 +495,7 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
       missing_fields: missingBeforeDefaults,
       has_unresolved_missing_fields: missingBeforeDefaults.length > 0 && !useDefaultForMissing,
       suspicious_fields,
+      pending_questions,
       default_preview: defaultPreview,
       applied_defaults: appliedDefaults
     }

package/src/pipeline.js

@@ -10,6 +10,9 @@ function buildRequiredConfirmations(parsedResult) {
   if (parsedResult.needs_keyword_confirmation) {
     confirmations.push("keyword");
   }
+  if (parsedResult.needs_recent_viewed_filter_confirmation) {
+    confirmations.push("filter_recent_viewed");
+  }
   if (parsedResult.has_unresolved_missing_fields) {
     confirmations.push("missing_fields_or_defaults");
   }
@@ -25,6 +28,7 @@ function buildNeedInputResponse(parsedResult) {
     required_confirmations: buildRequiredConfirmations(parsedResult),
     search_params: parsedResult.searchParams,
     screen_params: parsedResult.screenParams,
+    pending_questions: parsedResult.pending_questions,
     review: parsedResult.review,
     error: {
       code: "MISSING_REQUIRED_FIELDS",
@@ -44,6 +48,7 @@ function buildNeedConfirmationResponse(parsedResult) {
       keyword: parsedResult.proposed_keyword || parsedResult.searchParams.keyword
     },
     screen_params: parsedResult.screenParams,
+    pending_questions: parsedResult.pending_questions,
     review: parsedResult.review
   };
 }
@@ -146,7 +151,11 @@ export async function runRecruitPipeline({
     return buildNeedInputResponse(parsed);
   }
 
-  if (parsed.needs_keyword_confirmation || parsed.needs_search_params_confirmation) {
+  if (
+    parsed.needs_keyword_confirmation
+    || parsed.needs_search_params_confirmation
+    || parsed.needs_recent_viewed_filter_confirmation
+  ) {
     return buildNeedConfirmationResponse(parsed);
   }
 
@@ -237,7 +246,10 @@ export async function runRecruitPipeline({
       processed_count: summary.processed_count ?? null,
       passed_count: summary.passed_count ?? null,
       duration_sec: durationSec,
-      output_csv: summary.output_csv
-    }
+      output_csv: summary.output_csv,
+      completion_reason: "processed_target_reached",
+      target_count_semantics: "target_count means processed candidate count, not passed candidate count"
+    },
+    message: "流水线已完成。target_count 表示处理人数目标，而不是通过人数目标；即使通过人数小于 target_count，只要已处理达到目标人数，也应视为本轮完成。"
   };
 }

package/src/test-parser.js

@@ -10,6 +10,7 @@ function testNeedInput() {
 
   assert.equal(r.needs_keyword_confirmation, true);
   assert.equal(r.needs_search_params_confirmation, true);
+  assert.equal(r.needs_recent_viewed_filter_confirmation, true);
   assert.equal(r.proposed_keyword?.toLowerCase(), "ai infra");
   assert.deepEqual(
     r.default_preview,
@@ -37,6 +38,7 @@ function testExampleExtraction() {
   assert.equal(firstPass.searchParams.city, "杭州");
   assert.equal(firstPass.searchParams.degree, "本科及以上");
   assert.deepEqual(firstPass.searchParams.schools.sort(), ["211院校", "985院校", "QS 100"].sort());
+  assert.equal(firstPass.needs_recent_viewed_filter_confirmation, true);
   assert.equal(firstPass.screenParams.target_count, 500);
 
   const confirmed = parseRecruitInstruction({
@@ -46,12 +48,16 @@ function testExampleExtraction() {
       keyword_value: "ai infra",
       search_params_confirmed: true
     },
-    overrides: null
+    overrides: {
+      filter_recent_viewed: false
+    }
   });
 
   assert.equal(confirmed.needs_keyword_confirmation, false);
   assert.equal(confirmed.needs_search_params_confirmation, false);
+  assert.equal(confirmed.needs_recent_viewed_filter_confirmation, false);
   assert.equal(confirmed.searchParams.keyword, "ai infra");
+  assert.equal(confirmed.searchParams.filter_recent_viewed, false);
   assert.equal(confirmed.missing_fields.length, 0);
 }
 
@@ -74,11 +80,14 @@ function testStructuredInputAndCriteriaCleanup() {
       keyword_value: "AI infra",
       search_params_confirmed: true
     },
-    overrides: null
+    overrides: {
+      filter_recent_viewed: false
+    }
   });
 
   assert.equal(r.searchParams.city, "杭州");
   assert.equal(r.searchParams.degree, "本科");
+  assert.equal(r.searchParams.filter_recent_viewed, false);
   assert.equal(r.screenParams.target_count, 10);
   assert.equal(
     r.screenParams.criteria,
@@ -86,9 +95,9 @@ function testStructuredInputAndCriteriaCleanup() {
   );
 }
 
-function testQsVariantsNormalizeToQs100() {
+function testSchoolAliasesAndQsBuckets() {
   const byInstruction = parseRecruitInstruction({
-    instruction: "帮我找做过推荐系统的人，城市杭州，学历本科，学校要求 qs50、985，目标人数 20 人",
+    instruction: "帮我找做过推荐系统的人，城市杭州，学历本科，学校要求 qs50、qs200、985、双一流、统招，过滤掉14天内查看过的人选，目标人数 20 人",
     confirmation: {
       keyword_confirmed: true,
       keyword_value: "推荐系统",
@@ -97,7 +106,11 @@ function testQsVariantsNormalizeToQs100() {
     overrides: null
   });
 
-  assert.deepEqual(byInstruction.searchParams.schools.sort(), ["985院校", "QS 100"].sort());
+  assert.deepEqual(
+    byInstruction.searchParams.schools.sort(),
+    ["985院校", "QS 100", "QS 500", "双一流院校", "统招本科"].sort()
+  );
+  assert.equal(byInstruction.searchParams.filter_recent_viewed, true);
 
   const byOverride = parseRecruitInstruction({
     instruction: "帮我找做过推荐系统的人，城市杭州，学历本科，目标人数 20 人",
@@ -107,11 +120,42 @@ function testQsVariantsNormalizeToQs100() {
       search_params_confirmed: true
     },
     overrides: {
-      schools: ["qs50", "qs500", "211"]
+      schools: ["qs50", "qs500", "211", "双一流学校", "统招本"],
+      filter_recent_viewed: false
     }
   });
 
-  assert.deepEqual(byOverride.searchParams.schools.sort(), ["211院校", "QS 100"].sort());
+  assert.deepEqual(
+    byOverride.searchParams.schools.sort(),
+    ["211院校", "QS 100", "QS 500", "双一流院校", "统招本科"].sort()
+  );
+  assert.equal(byOverride.searchParams.filter_recent_viewed, false);
+}
+
+function testPlanningClausesRemovedAndMasterDegreeParsed() {
+  const r = parseRecruitInstruction({
+    instruction:
+      "在 Boss 直聘上搜索候选人：城市杭州；学历硕士；学校标签：985、211、QS200；关键词：算法。请先尽可能多地浏览/拉取候选人（至少 50 个），再按硬性要求筛选：简历中明确出现 CCF-A 类会议或期刊论文。最终输出 5 个最匹配的人选。",
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "算法",
+      search_params_confirmed: true
+    },
+    overrides: {
+      schools: ["985院校", "211院校", "QS200"],
+      filter_recent_viewed: false,
+      target_count: 5
+    }
+  });
+
+  assert.equal(r.searchParams.degree, "硕士");
+  assert.deepEqual(r.searchParams.schools.sort(), ["985院校", "211院校", "QS 500"].sort());
+  assert.equal(r.searchParams.filter_recent_viewed, false);
+  assert.equal(r.screenParams.target_count, 5);
+  assert.equal(
+    r.screenParams.criteria,
+    "候选人需有算法相关经历；再按硬性要求筛选：简历中明确出现 CCF-A 类会议或期刊论文"
+  );
 }
 
 function testCitySanitizationAndConfirmationGate() {
@@ -124,6 +168,7 @@ function testCitySanitizationAndConfirmationGate() {
 
   assert.equal(r.searchParams.city, "杭州");
   assert.equal(r.needs_search_params_confirmation, true);
+  assert.equal(r.needs_recent_viewed_filter_confirmation, true);
   assert.equal(r.suspicious_fields.length, 0);
 }
 
@@ -142,6 +187,7 @@ function testDefaultsCanOnlyApplyWhenExplicitlyRequested() {
   assert.equal(r.searchParams.city, null);
   assert.equal(r.searchParams.degree, "不限");
   assert.deepEqual(r.searchParams.schools, []);
+  assert.equal(r.needs_recent_viewed_filter_confirmation, true);
   assert.equal(r.screenParams.target_count, 10);
   assert.deepEqual(r.applied_defaults, {
     city: "不限城市",
@@ -151,14 +197,53 @@ function testDefaultsCanOnlyApplyWhenExplicitlyRequested() {
   });
 }
 
+function testRecentViewedFilterPromptAndNegativeOverride() {
+  const missingChoice = parseRecruitInstruction({
+    instruction: "帮我找杭州本科做过推荐系统的人，学校 985，目标人数 10 人",
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "推荐系统",
+      search_params_confirmed: true
+    },
+    overrides: null
+  });
+
+  assert.equal(missingChoice.needs_recent_viewed_filter_confirmation, true);
+  assert.deepEqual(missingChoice.pending_questions, [
+    {
+      field: "filter_recent_viewed",
+      question: "是否需要过滤近14天查看过的人选？",
+      options: [
+        { label: "需要过滤", value: true },
+        { label: "不过滤", value: false }
+      ]
+    }
+  ]);
+
+  const explicitNo = parseRecruitInstruction({
+    instruction: "帮我找杭州本科做过推荐系统的人，学校 985，不过滤近14天查看过的人选，目标人数 10 人",
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "推荐系统",
+      search_params_confirmed: true
+    },
+    overrides: null
+  });
+
+  assert.equal(explicitNo.needs_recent_viewed_filter_confirmation, false);
+  assert.equal(explicitNo.searchParams.filter_recent_viewed, false);
+}
+
 function main() {
   testNeedInput();
   testExampleExtraction();
   testMissingFieldsBatch();
   testStructuredInputAndCriteriaCleanup();
-  testQsVariantsNormalizeToQs100();
+  testSchoolAliasesAndQsBuckets();
+  testPlanningClausesRemovedAndMasterDegreeParsed();
   testCitySanitizationAndConfirmationGate();
   testDefaultsCanOnlyApplyWhenExplicitlyRequested();
+  testRecentViewedFilterPromptAndNegativeOverride();
   // eslint-disable-next-line no-console
   console.log("parser tests passed");
 }

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

@@ -1233,7 +1233,7 @@ async function main() {
     while (processedCount < targetCount) {
         console.log('');
         console.log('----------------------------------------');
-        console.log(`处理进度: ${processedCount}/${targetCount} 已通过 ${passedCandidates.length} 人 未确认收藏 ${uncertainFavoriteCount} 人`);
+        console.log(`处理进度: 已处理 ${processedCount}/${targetCount}（目标处理人数） 已通过 ${passedCandidates.length} 人 未确认收藏 ${uncertainFavoriteCount} 人`);
 
         const processedKeysArray = Array.from(processedCardKeys);
         const findCardExpr = jsFindNextUnprocessedCard + '(' + currentCardIndex + ',' + JSON.stringify(processedKeysArray) + ')';
@@ -1606,7 +1606,7 @@ async function main() {
         }
 
         if (processedCount >= targetCount * 3) {
-            console.log('警告: 已处理超过目标数量3倍，强制结束');
+            console.log('警告: 已处理超过目标处理人数3倍，强制结束');
             break;
         }
     }
@@ -1636,7 +1636,8 @@ async function main() {
     console.log('处理结果:');
     console.log(`  已处理: ${processedCount} 人`);
     console.log(`  通过筛选: ${passedCandidates.length} 人`);
-    console.log(`  目标人数: ${targetCount} 人`);
+    console.log(`  目标处理人数: ${targetCount} 人`);
+    console.log(`  完成条件: 已处理人数达到目标处理人数；不要求通过人数达到该值`);
     console.log('');
     console.log('Done.');
 }

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

@@ -149,17 +149,24 @@ export class BossSearcher {
         const safeSchool = school.replace(/'/g, "\\'");
         const result = await this.evaluate(
           '(function() {' +
+          '  const normalizeText = function(value) {' +
+          '    return String(value || "").replace(/\\s+/g, "").trim();' +
+          '  };' +
           '  const iframe = document.querySelector("iframe");' +
           '  if (!iframe || !iframe.contentWindow) return { error: "no iframe" };' +
           '  const doc = iframe.contentWindow.document;' +
-          '  const schoolItems = doc.querySelectorAll(".school-item");' +
-          '  const targetTexts = ["统招本科", "双一流院校", "211院校", "985院校", "留学生", "QS 100", "QS 500"];' +
-          '  const targetIdx = targetTexts.indexOf("' + safeSchool + '");' +
-          '  if (targetIdx >= 0 && schoolItems[targetIdx]) {' +
-          '    const label = schoolItems[targetIdx].querySelector("label.checkbox");' +
+          '  const schoolItems = Array.from(doc.querySelectorAll(".school-item"));' +
+          '  const targetSchool = normalizeText("' + safeSchool + '");' +
+          '  const schoolItem = schoolItems.find(function(item) {' +
+          '    const textNode = item.querySelector(".checkbox-text");' +
+          '    return normalizeText(textNode ? textNode.textContent : item.textContent) === targetSchool;' +
+          '  });' +
+          '  if (schoolItem) {' +
+          '    const label = schoolItem.querySelector("label.checkbox");' +
           '    if (label) {' +
-          '      label.click();' +
-          '      const checkbox = schoolItems[targetIdx].querySelector(".checkbox-input");' +
+          '      const checkbox = schoolItem.querySelector(".checkbox-input");' +
+          '      const isChecked = label.classList.contains("checked") || Boolean(checkbox && checkbox.checked);' +
+          '      if (!isChecked) label.click();' +
           '      return { success: true, school: "' + safeSchool + '", checked: checkbox ? checkbox.checked : false };' +
           '    }' +
           '  }' +
@@ -618,6 +625,42 @@ export class BossSearcher {
     }
   }
 
+  async setRecentViewedFilter(enabled = true) {
+    console.log('🕒 设置近14天查看过滤: ' + (enabled ? '开启' : '关闭'));
+    try {
+      const result = await this.evaluate(
+        '(function() {' +
+        '  const iframe = document.querySelector("iframe");' +
+        '  if (!iframe || !iframe.contentWindow) return { error: "no iframe" };' +
+        '  const doc = iframe.contentWindow.document;' +
+        '  const normalizeText = function(value) {' +
+        '    return String(value || "").replace(/\\s+/g, "").trim();' +
+        '  };' +
+        '  const targetLabel = doc.querySelector(\'label.checkbox.high_search_checkbox[ka="search_change_view_resume"]\')' +
+        '    || Array.from(doc.querySelectorAll("label.checkbox.high_search_checkbox")).find(function(label) {' +
+        '      const textNode = label.querySelector(".checkbox-text");' +
+        '      return normalizeText(textNode ? textNode.textContent : label.textContent) === "过滤近14天查看";' +
+        '    });' +
+        '  if (!targetLabel) return { error: "recent viewed filter not found" };' +
+        '  const checkbox = targetLabel.querySelector(".checkbox-input");' +
+        '  const currentChecked = targetLabel.classList.contains("checked") || Boolean(checkbox && checkbox.checked);' +
+        '  const desiredChecked = ' + (enabled ? 'true' : 'false') + ';' +
+        '  if (currentChecked !== desiredChecked) {' +
+        '    targetLabel.click();' +
+        '  }' +
+        '  const finalChecked = targetLabel.classList.contains("checked") || Boolean(checkbox && checkbox.checked);' +
+        '  return { success: true, checked: finalChecked, changed: currentChecked !== desiredChecked };' +
+        '})()'
+      );
+      await this.sleep(1200);
+      console.log('  近14天查看过滤: ' + (result && result.checked ? '✅ 已开启' : '⬜ 未开启'));
+      return result;
+    } catch (e) {
+      console.log('  设置近14天查看过滤时出错:', e.message);
+      return { error: e.message };
+    }
+  }
+
   async getResults() {
     console.log('📋 获取搜索结果...');
     try {

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

@@ -54,6 +54,7 @@ class BossSearchCLI {
       degree: '不限',
       schools: [],
       city: null,
+      filterRecentViewed: null,
       port: 9222,
       experience: '不限',
       ageMin: null,
@@ -62,14 +63,49 @@ class BossSearchCLI {
 
     const schoolMap = {
       '211': '211院校',
+      '211院校': '211院校',
       '985': '985院校',
+      '985院校': '985院校',
+      'qs': 'QS 100',
       'qs100': 'QS 100',
       'qs500': 'QS 500',
       '双一流': '双一流院校',
+      '双一流院校': '双一流院校',
+      '双一流学校': '双一流院校',
       '留学生': '留学生',
-      '统招': '统招本科'
+      '统招': '统招本科',
+      '统招本科': '统招本科',
+      '统招本': '统招本科',
+      '全日制本科': '统招本科'
     };
 
+    function resolveQsSchool(normalizedSchool) {
+      const matched = normalizedSchool.match(/^qs(\d+)$/);
+      if (!matched) return null;
+
+      const rank = Number.parseInt(matched[1], 10);
+      if (!Number.isFinite(rank)) return null;
+
+      return rank > 100 ? 'QS 500' : 'QS 100';
+    }
+
+    function normalizeSchool(rawSchool) {
+      const raw = String(rawSchool || '').trim();
+      if (!raw) return raw;
+      const normalized = raw.toLowerCase().replace(/\s+/g, '');
+      const qsSchool = resolveQsSchool(normalized);
+      if (qsSchool) return qsSchool;
+      return schoolMap[normalized] || schoolMap[raw] || raw;
+    }
+
+    function parseBooleanArg(rawValue) {
+      const normalized = String(rawValue || '').trim().toLowerCase();
+      if (!normalized) return null;
+      if (['true', '1', 'yes', 'y', 'on', '是', '要', '需要', '过滤'].includes(normalized)) return true;
+      if (['false', '0', 'no', 'n', 'off', '否', '不要', '不需要', '不过滤'].includes(normalized)) return false;
+      return null;
+    }
+
     const argv = process.argv.slice(2);
     for (let i = 0; i < argv.length; i++) {
       const arg = argv[i];
@@ -78,13 +114,12 @@ class BossSearchCLI {
       } else if (arg === '--degree' || arg === '-d') {
         args.degree = argv[++i];
       } else if (arg === '--schools' || arg === '-s') {
-        const schools = argv[++i].split(',');
-        args.schools = schools.map(function(s) {
-          const normalized = s.trim().toLowerCase();
-          return schoolMap[normalized] || s;
-        });
+        const schools = String(argv[++i] || '').split(/[，,]/);
+        args.schools = Array.from(new Set(schools.map(normalizeSchool).filter(Boolean)));
       } else if (arg === '--city' || arg === '-c') {
         args.city = argv[++i];
+      } else if (arg === '--filter-recent-viewed') {
+        args.filterRecentViewed = parseBooleanArg(argv[++i]);
       } else if (arg === '--port' || arg === '-p') {
         const port = Number.parseInt(argv[++i], 10);
         if (Number.isFinite(port) && port > 0) {
@@ -108,6 +143,9 @@ class BossSearchCLI {
     if (config.schools.length > 0) {
       console.log('  院校要求:', config.schools.join(', '));
     }
+    if (typeof config.filterRecentViewed === 'boolean') {
+      console.log('  过滤近14天查看:', config.filterRecentViewed ? '是' : '否');
+    }
     console.log('');
 
     await this.searcher.sleep(500);
@@ -127,6 +165,11 @@ class BossSearchCLI {
     }
 
     await this.searcher.clickSearch();
+
+    if (config.filterRecentViewed) {
+      await this.searcher.setRecentViewedFilter(true);
+    }
+
     await this.searcher.sleep(2000);
     await this.searcher.getResults();