@reconcrap/boss-recommend-mcp 0.1.0 → 0.1.2

package/README.md

@@ -19,7 +19,10 @@ MCP 工具名：`run_recommend_pipeline`
 ## 设计特点
 
 - 页面目标固定为 `https://www.zhipin.com/web/chat/recommend`
-- 支持推荐页原生筛选：学校标签 / 性别 / 近14天没有
+- 支持推荐页原生筛选：学校标签 / 学历 / 性别 / 近14天没有
+- 学历支持单选与多选语义：如“本科及以上”会展开为 `本科/硕士/博士`；如“大专、本科”只勾选这两项
+- 执行前会逐项确认筛选参数：学校标签 / 学历 / 性别 / 是否过滤近14天已看
+- npm 全局安装后会自动执行 install：生成 Codex skill、导出 MCP 模板，并自动尝试写入已检测到的外部 agent MCP 配置（含 Trae / trae-cn / Cursor / Claude / OpenClaw）
 - `post_action` 必须在每次完整运行开始时确认一次
 - `target_count` 会在每次运行开始时询问一次（可留空，不设上限）
 - 当 `post_action=greet` 时，必须在运行开始时确认 `max_greet_count`
@@ -41,6 +44,13 @@ npm install
 node src/cli.js start
 ```
 
+可选环境变量（用于跨 agent 自动配置）：
+
+```bash
+BOSS_RECOMMEND_MCP_CONFIG_TARGETS   # JSON 数组或系统 path 分隔路径列表，指定额外 mcp.json 目标文件
+BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS  # JSON 数组或系统 path 分隔路径列表，指定额外 skills 根目录
+```
+
 或使用 CLI fallback：
 
 ```bash
@@ -92,6 +102,10 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
   "instruction": "推荐页筛选211女生，近14天没有，有 AI Agent 经验，符合标准的直接沟通",
   "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,
     "target_count_value": 20,
@@ -102,6 +116,7 @@ node src/cli.js run --instruction-file request.txt --confirmation-file confirmat
   },
   "overrides": {
     "school_tag": "211",
+    "degree": ["本科", "硕士", "博士"],
     "gender": "女",
     "recent_not_view": "近14天没有",
     "criteria": "候选人需要有 AI Agent 或 MCP 工具开发经验",

package/package.json

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

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

@@ -22,7 +22,10 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
 
 在真正执行前，必须先确认：
 
-- 推荐页 filters 是否正确
+- 学校标签（`school_tag`）
+- 学历（`degree`）
+- 性别（`gender`）
+- 是否过滤近14天已看（`recent_not_view`）
 - screening criteria 是否正确
 - `target_count`（目标筛选人数）是否需要设置（可不设上限）
 - `post_action` 是否确定为 `favorite` 或 `greet`
@@ -41,6 +44,10 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
   - `instruction` (required)
   - `confirmation`
     - `filters_confirmed`
+    - `school_tag_confirmed`
+    - `degree_confirmed`
+    - `gender_confirmed`
+    - `recent_not_view_confirmed`
     - `criteria_confirmed`
     - `target_count_confirmed`
     - `target_count_value` (integer, optional)
@@ -50,6 +57,7 @@ description: "Use when users ask to run Boss recommend-page filtering and screen
     - `max_greet_count_value` (integer)
   - `overrides`
     - `school_tag`
+    - `degree`（可传单值或数组；如“本科及以上”应展开为 `["本科","硕士","博士"]`）
     - `gender`
     - `recent_not_view`
     - `criteria`
@@ -90,5 +98,6 @@ CLI fallback 的状态机与 MCP 保持一致：
 
 - 用结构化中文输出
 - 先给用户确认卡片，再正式执行
+- 对 `school_tag/degree/gender/recent_not_view` 必须逐项提问并逐项确认，不可合并成一句“filters已确认”
 - 不要跳过 `post_action` 的首轮确认
-- 不要把 recommend 流程说成 search 流程
+- 不要把 recommend 流程说成 search 流程

package/src/adapters.js

@@ -36,6 +36,15 @@ function parsePositiveInteger(raw) {
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function serializeDegreeSelection(value) {
+  if (Array.isArray(value)) {
+    const normalized = value.map((item) => String(item || "").trim()).filter(Boolean);
+    return normalized.length ? normalized.join(",") : "不限";
+  }
+  const normalized = String(value || "").trim();
+  return normalized || "不限";
+}
+
 function resolveScreenConfigPath(workspaceRoot) {
   const envConfigPath = process.env.BOSS_RECOMMEND_SCREEN_CONFIG
     ? path.resolve(process.env.BOSS_RECOMMEND_SCREEN_CONFIG)
@@ -506,6 +515,8 @@ export async function runRecommendSearchCli({ workspaceRoot, searchParams }) {
     cliPath,
     "--school-tag",
     searchParams.school_tag,
+    "--degree",
+    serializeDegreeSelection(searchParams.degree),
     "--gender",
     searchParams.gender,
     "--recent-not-view",

package/src/cli.js

@@ -27,6 +27,8 @@ const defaultMcpServerName = "boss-recommend";
 const defaultMcpCommand = "npx";
 const defaultMcpArgs = ["-y", "@reconcrap/boss-recommend-mcp@latest", "start"];
 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";
 
 function getPackageVersion() {
   try {
@@ -49,6 +51,39 @@ function ensureDir(targetPath) {
   fs.mkdirSync(targetPath, { recursive: true });
 }
 
+function pathExists(targetPath) {
+  try {
+    return fs.existsSync(targetPath);
+  } catch {
+    return false;
+  }
+}
+
+function readJsonObjectFileSafe(filePath) {
+  if (!pathExists(filePath)) return {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // Fallback below.
+  }
+  return {};
+}
+
+function dedupePaths(items) {
+  const result = [];
+  const seen = new Set();
+  for (const item of items || []) {
+    const resolved = path.resolve(String(item || ""));
+    if (!resolved || seen.has(resolved)) continue;
+    seen.add(resolved);
+    result.push(resolved);
+  }
+  return result;
+}
+
 function getDesktopDir() {
   return path.join(os.homedir(), "Desktop");
 }
@@ -154,6 +189,7 @@ function normalizeMcpClientName(value) {
   const raw = String(value || "").trim().toLowerCase();
   if (!raw) return "";
   if (raw === "claude-code") return "claudecode";
+  if (raw === "trae-cn") return "trae";
   return raw;
 }
 
@@ -219,6 +255,135 @@ function writeMcpConfigFiles(options = {}) {
   return { outputDir, files };
 }
 
+function parsePathListFromEnv(raw) {
+  if (!raw) return [];
+  const text = String(raw).trim();
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      return dedupePaths(parsed.filter(Boolean));
+    }
+  } catch {
+    // Fallback to delimiter split.
+  }
+  return dedupePaths(text.split(path.delimiter).map((item) => item.trim()).filter(Boolean));
+}
+
+function getKnownExternalMcpConfigPaths() {
+  const home = os.homedir();
+  const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+  return dedupePaths([
+    path.join(appData, "Cursor", "User", "mcp.json"),
+    path.join(appData, "Trae", "User", "mcp.json"),
+    path.join(appData, "Trae CN", "User", "mcp.json"),
+    path.join(home, ".trae", "mcp.json"),
+    path.join(home, ".trae-cn", "mcp.json"),
+    path.join(home, ".claude", "mcp.json"),
+    path.join(home, ".openclaw", "mcp.json")
+  ]);
+}
+
+function resolveExternalMcpConfigTargets() {
+  const fromEnv = parsePathListFromEnv(process.env[externalMcpTargetsEnv]);
+  const known = getKnownExternalMcpConfigPaths().filter((filePath) => {
+    if (pathExists(filePath)) return true;
+    return pathExists(path.dirname(filePath));
+  });
+  return dedupePaths([...fromEnv, ...known]);
+}
+
+function mergeMcpServerConfigFile(filePath, options = {}) {
+  const nextConfig = buildMcpConfigFileContent(options);
+  const serverName = Object.keys(nextConfig.mcpServers || {})[0] || defaultMcpServerName;
+  const launchConfig = nextConfig.mcpServers?.[serverName] || buildMcpLaunchConfig(options);
+  const current = readJsonObjectFileSafe(filePath);
+  const existingServers =
+    current?.mcpServers && typeof current.mcpServers === "object" && !Array.isArray(current.mcpServers)
+      ? current.mcpServers
+      : {};
+  const existingEntry = existingServers[serverName];
+  const merged = {
+    ...current,
+    mcpServers: {
+      ...existingServers,
+      [serverName]: launchConfig
+    }
+  };
+
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf8");
+  const updated = JSON.stringify(existingEntry || null) !== JSON.stringify(launchConfig);
+  return {
+    file: filePath,
+    server: serverName,
+    updated
+  };
+}
+
+function installExternalMcpConfigs(options = {}) {
+  const targets = resolveExternalMcpConfigTargets();
+  const applied = [];
+  const skipped = [];
+  for (const target of targets) {
+    try {
+      const existed = pathExists(target);
+      const merged = mergeMcpServerConfigFile(target, options);
+      applied.push({
+        file: target,
+        server: merged.server,
+        created: !existed,
+        updated: merged.updated
+      });
+    } catch (error) {
+      skipped.push({
+        file: target,
+        reason: error.message
+      });
+    }
+  }
+  return { targets, applied, skipped };
+}
+
+function getKnownExternalSkillBaseDirs() {
+  const home = os.homedir();
+  const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+  return dedupePaths([
+    path.join(home, ".cursor", "skills"),
+    path.join(home, ".trae", "skills"),
+    path.join(home, ".trae-cn", "skills"),
+    path.join(home, ".claude", "skills"),
+    path.join(home, ".openclaw", "skills"),
+    path.join(appData, "Cursor", "User", "skills"),
+    path.join(appData, "Trae", "User", "skills"),
+    path.join(appData, "Trae CN", "User", "skills"),
+    path.join(appData, "OpenClaw", "User", "skills")
+  ]);
+}
+
+function resolveExternalSkillBaseDirs() {
+  const fromEnv = parsePathListFromEnv(process.env[externalSkillDirsEnv]);
+  const known = getKnownExternalSkillBaseDirs().filter((dirPath) => pathExists(dirPath));
+  return dedupePaths([...fromEnv, ...known]);
+}
+
+function mirrorSkillToExternalDirs() {
+  const baseDirs = resolveExternalSkillBaseDirs();
+  const mirrored = [];
+  const skipped = [];
+  for (const baseDir of baseDirs) {
+    try {
+      const targetDir = path.join(baseDir, skillName);
+      ensureDir(path.dirname(targetDir));
+      fs.cpSync(skillSourceDir, targetDir, { recursive: true, force: true });
+      mirrored.push({ base_dir: baseDir, target_dir: targetDir });
+    } catch (error) {
+      skipped.push({ base_dir: baseDir, reason: error.message });
+    }
+  }
+  return { baseDirs, mirrored, skipped };
+}
+
 function syncSkillAssets(options = {}) {
   const force = options.force === true;
   const targetDir = getSkillTargetDir();
@@ -421,7 +586,7 @@ function printHelp() {
   console.log("  boss-recommend-mcp install-skill Install only the Codex skill");
   console.log("  boss-recommend-mcp init-config  Create ~/.codex/boss-recommend-mcp/screening-config.json if missing");
   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/Claude Code/OpenClaw");
+  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");
   console.log("  boss-recommend-mcp launch-chrome Launch or reuse Chrome debug instance and open Boss recommend page");
   console.log("  boss-recommend-mcp where        Print installed package, skill, and config paths");
@@ -447,12 +612,31 @@ function installAll() {
   const skillTarget = installSkill();
   const configResult = ensureUserConfig();
   const mcpTemplateResult = writeMcpConfigFiles({ client: "all" });
+  const externalMcpResult = installExternalMcpConfigs({});
+  const externalSkillResult = mirrorSkillToExternalDirs();
   console.log(`Skill installed to: ${skillTarget}`);
   console.log(configResult.created ? `Config template created at: ${configResult.path}` : `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}`);
   }
+  if (externalMcpResult.targets.length > 0) {
+    console.log(`Auto-configured external MCP files: ${externalMcpResult.applied.length}`);
+    for (const item of externalMcpResult.applied) {
+      const action = item.created ? "created" : item.updated ? "updated" : "unchanged";
+      console.log(`- ${item.file} (${action})`);
+    }
+  } else {
+    console.log("No external MCP config target detected. Set BOSS_RECOMMEND_MCP_CONFIG_TARGETS to auto-configure custom agents.");
+  }
+  if (externalSkillResult.baseDirs.length > 0) {
+    console.log(`Mirrored skill to external dirs: ${externalSkillResult.mirrored.length}`);
+    for (const item of externalSkillResult.mirrored) {
+      console.log(`- ${item.target_dir}`);
+    }
+  } else {
+    console.log("No external skill dir detected. Set BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS to mirror skill for non-Codex agents.");
+  }
 }
 
 async function runPipelineOnce(options) {

package/src/index.js

@@ -38,6 +38,10 @@ function createToolSchema() {
           type: "object",
           properties: {
             filters_confirmed: { type: "boolean" },
+            school_tag_confirmed: { type: "boolean" },
+            degree_confirmed: { type: "boolean" },
+            gender_confirmed: { type: "boolean" },
+            recent_not_view_confirmed: { type: "boolean" },
             criteria_confirmed: { type: "boolean" },
             target_count_confirmed: { type: "boolean" },
             target_count_value: {
@@ -64,6 +68,23 @@ function createToolSchema() {
               type: "string",
               enum: ["不限", "985", "211", "双一流院校", "留学", "国内外名校", "公办本科"]
             },
+            degree: {
+              oneOf: [
+                {
+                  type: "string",
+                  enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ["不限", "初中及以下", "中专/中技", "高中", "大专", "本科", "硕士", "博士"]
+                  },
+                  minItems: 1,
+                  uniqueItems: true
+                }
+              ]
+            },
             gender: {
               type: "string",
               enum: ["不限", "男", "女"]

package/src/parser.js

@@ -7,6 +7,25 @@ const SCHOOL_TAG_OPTIONS = [
   "国内外名校",
   "公办本科"
 ];
+const DEGREE_OPTIONS = [
+  "不限",
+  "初中及以下",
+  "中专/中技",
+  "高中",
+  "大专",
+  "本科",
+  "硕士",
+  "博士"
+];
+const DEGREE_ORDER = [
+  "初中及以下",
+  "中专/中技",
+  "高中",
+  "大专",
+  "本科",
+  "硕士",
+  "博士"
+];
 const GENDER_OPTIONS = ["不限", "男", "女"];
 const RECENT_NOT_VIEW_OPTIONS = ["不限", "近14天没有"];
 const POST_ACTION_OPTIONS = ["favorite", "greet"];
@@ -30,6 +49,15 @@ const SCHOOL_TAG_PATTERNS = [
   { label: "国内外名校", pattern: /国内外名校|名校/i },
   { label: "公办本科", pattern: /公办本科/i }
 ];
+const DEGREE_PATTERNS = [
+  { label: "初中及以下", pattern: /初中及以下|初中以下/i },
+  { label: "中专/中技", pattern: /中专\s*\/\s*中技|中专中技|中专|中技/i },
+  { label: "高中", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}高中/i },
+  { label: "大专", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:大专|专科)/i },
+  { label: "本科", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:本科|学士)/i },
+  { label: "硕士", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}(?:硕士|研究生)/i },
+  { label: "博士", pattern: /(?:学历|教育|要求)?[^。；;\n]{0,8}博士/i }
+];
 const GENDER_PATTERNS = [
   { label: "男", pattern: /(?:性别|候选人|人选)?[^。；;\n]{0,8}(?:男生|男性|男)/i },
   { label: "女", pattern: /(?:性别|候选人|人选)?[^。；;\n]{0,8}(?:女生|女性|女)/i }
@@ -57,6 +85,7 @@ const MAX_GREET_COUNT_PATTERNS = [
 ];
 const FILTER_CLAUSE_PATTERNS = [
   /学校标签|院校标签|985|211|双一流|留学|国内外名校|公办本科/i,
+  /学历|学位|教育|初中及以下|中专|中技|高中|大专|专科|本科|硕士|研究生|博士/i,
   /性别|男生|女生|男性|女性|男\b|女\b/i,
   /近?14天(?:内)?没有|近?14天(?:内)?没看过|近?14天(?:内)?未查看|过滤[^。；;\n]{0,12}14天|排除[^。；;\n]{0,12}14天/i,
   /目标(?:处理|筛选)?(?:人数|数量)?|至少(?:处理|筛选)|(?:处理|筛选)\s*\d+\s*(?:位|人)/i,
@@ -89,6 +118,75 @@ function normalizeSchoolTag(value) {
   return null;
 }
 
+function normalizeDegree(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) return null;
+  if (normalized === "专科") return "大专";
+  if (normalized === "研究生") return "硕士";
+  if (normalized === "中专" || normalized === "中技" || normalized === "中专中技") return "中专/中技";
+  return DEGREE_OPTIONS.includes(normalized) ? normalized : null;
+}
+
+function sortDegreeSelections(values) {
+  return uniqueList(values).sort((left, right) => {
+    const leftIndex = DEGREE_ORDER.indexOf(left);
+    const rightIndex = DEGREE_ORDER.indexOf(right);
+    return leftIndex - rightIndex;
+  });
+}
+
+function expandDegreeAtOrAbove(value) {
+  const normalized = normalizeDegree(value);
+  if (!normalized || normalized === "不限") return [];
+  const startIndex = DEGREE_ORDER.indexOf(normalized);
+  if (startIndex === -1) return [];
+  return DEGREE_ORDER.slice(startIndex);
+}
+
+function parseDegreeSelectionsFromText(text) {
+  const normalizedText = normalizeText(text);
+  if (!normalizedText) return [];
+  if (/(?:学历|学位|教育)[^。；;\n]{0,6}不限|不限[^。；;\n]{0,6}(?:学历|学位|教育)/i.test(normalizedText)) {
+    return ["不限"];
+  }
+
+  const selected = [];
+  const atOrAbovePattern = /(初中及以下|中专\/中技|中专中技|中专|中技|高中|大专|专科|本科|硕士|研究生|博士)\s*(?:及|或)?以上/g;
+  let match;
+  while ((match = atOrAbovePattern.exec(normalizedText)) !== null) {
+    selected.push(...expandDegreeAtOrAbove(match[1]));
+  }
+
+  for (const { label, pattern } of DEGREE_PATTERNS) {
+    if (pattern.test(normalizedText)) {
+      selected.push(label);
+    }
+  }
+  return sortDegreeSelections(selected);
+}
+
+function normalizeDegreeSelections(input) {
+  if (Array.isArray(input)) {
+    const normalized = sortDegreeSelections(input.map((item) => normalizeDegree(item)).filter(Boolean));
+    if (!normalized.length) return null;
+    return normalized.includes("不限") ? ["不限"] : normalized;
+  }
+
+  const text = normalizeText(input);
+  if (!text) return null;
+  if (text.includes("以上")) {
+    const fromText = parseDegreeSelectionsFromText(text);
+    if (fromText.length) return fromText;
+  }
+  const parts = text.split(/[，,、/|]/).map((item) => normalizeDegree(item)).filter(Boolean);
+  if (parts.length) {
+    const normalized = sortDegreeSelections(parts);
+    return normalized.includes("不限") ? ["不限"] : normalized;
+  }
+  const single = normalizeDegree(text);
+  return single ? [single] : null;
+}
+
 function normalizeGender(value) {
   const normalized = normalizeText(value);
   if (!normalized) return null;
@@ -142,6 +240,10 @@ function extractGender(text) {
   return null;
 }
 
+function extractDegrees(text) {
+  return parseDegreeSelectionsFromText(text);
+}
+
 function extractRecentNotView(text) {
   for (const pattern of RECENT_NOT_VIEW_NEGATIVE_PATTERNS) {
     if (pattern.test(text)) {
@@ -298,13 +400,22 @@ function collectSuspiciousFields({ detectedSchoolTags }) {
 export function parseRecommendInstruction({ instruction, confirmation, overrides }) {
   const text = normalizeText(instruction);
   const detectedSchoolTags = extractSchoolTags(text);
+  const detectedDegrees = extractDegrees(text);
   const overrideSchoolTag = normalizeSchoolTag(overrides?.school_tag);
+  const overrideDegrees = normalizeDegreeSelections(overrides?.degree);
   const overrideGender = normalizeGender(overrides?.gender);
   const overrideRecentNotView = normalizeRecentNotView(overrides?.recent_not_view);
   const overrideCriteria = overrides?.criteria;
 
   const searchParams = {
     school_tag: overrideSchoolTag || detectedSchoolTags[0] || "不限",
+    degree: (
+      (Array.isArray(overrideDegrees) && overrideDegrees.length > 0
+        ? overrideDegrees
+        : Array.isArray(detectedDegrees) && detectedDegrees.length > 0
+          ? detectedDegrees
+          : ["不限"])
+    ),
     gender: overrideGender || extractGender(text) || "不限",
     recent_not_view: overrideRecentNotView || extractRecentNotView(text) || "不限"
   };
@@ -332,17 +443,63 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   }
 
   const suspicious_fields = collectSuspiciousFields({ detectedSchoolTags });
-  const needs_filters_confirmation = confirmation?.filters_confirmed !== true;
+  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 needs_filters_confirmation = (
+    confirmation?.filters_confirmed !== true
+    || needs_school_tag_confirmation
+    || needs_degree_confirmation
+    || needs_gender_confirmation
+    || needs_recent_not_view_confirmation
+  );
   const needs_criteria_confirmation = confirmation?.criteria_confirmed !== true;
   const needs_target_count_confirmation = targetCountResolution.needs_target_count_confirmation;
   const needs_post_action_confirmation = postActionResolution.needs_post_action_confirmation;
   const needs_max_greet_count_confirmation = maxGreetCountResolution.needs_max_greet_count_confirmation;
   const pending_questions = [];
 
-  if (needs_filters_confirmation) {
+  if (needs_school_tag_confirmation) {
+    pending_questions.push({
+      field: "school_tag",
+      question: "请确认学校标签筛选。",
+      value: searchParams.school_tag,
+      options: SCHOOL_TAG_OPTIONS
+    });
+  }
+
+  if (needs_degree_confirmation) {
+    pending_questions.push({
+      field: "degree",
+      question: "请确认学历筛选（可多选）。",
+      value: searchParams.degree,
+      options: DEGREE_OPTIONS
+    });
+  }
+
+  if (needs_gender_confirmation) {
+    pending_questions.push({
+      field: "gender",
+      question: "请确认性别筛选。",
+      value: searchParams.gender,
+      options: GENDER_OPTIONS
+    });
+  }
+
+  if (needs_recent_not_view_confirmation) {
+    pending_questions.push({
+      field: "recent_not_view",
+      question: "请确认是否过滤近14天内已看过的人选。",
+      value: searchParams.recent_not_view,
+      options: RECENT_NOT_VIEW_OPTIONS
+    });
+  }
+
+  if (needs_filters_confirmation && pending_questions.every((item) => item.field !== "filters")) {
     pending_questions.push({
       field: "filters",
-      question: "请确认推荐页筛选项是否正确。",
+      question: "请确认以上推荐页筛选项整体无误。",
       value: searchParams
     });
   }
@@ -389,6 +546,10 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     missing_fields,
     suspicious_fields,
     needs_filters_confirmation,
+    needs_school_tag_confirmation,
+    needs_degree_confirmation,
+    needs_gender_confirmation,
+    needs_recent_not_view_confirmation,
     needs_criteria_confirmation,
     needs_target_count_confirmation,
     needs_post_action_confirmation,
@@ -415,6 +576,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
 }
 
 export {
+  DEGREE_OPTIONS,
   GENDER_OPTIONS,
   POST_ACTION_LABELS,
   POST_ACTION_OPTIONS,

package/src/pipeline.js

@@ -9,6 +9,10 @@ import {
 function buildRequiredConfirmations(parsedResult) {
   const confirmations = [];
   if (parsedResult.needs_filters_confirmation) confirmations.push("filters");
+  if (parsedResult.needs_school_tag_confirmation) confirmations.push("school_tag");
+  if (parsedResult.needs_degree_confirmation) confirmations.push("degree");
+  if (parsedResult.needs_gender_confirmation) confirmations.push("gender");
+  if (parsedResult.needs_recent_not_view_confirmation) confirmations.push("recent_not_view");
   if (parsedResult.needs_criteria_confirmation) confirmations.push("criteria");
   if (parsedResult.needs_target_count_confirmation) confirmations.push("target_count");
   if (parsedResult.needs_post_action_confirmation) confirmations.push("post_action");
@@ -89,6 +93,10 @@ export async function runRecommendPipeline(
 
   if (
     parsed.needs_filters_confirmation
+    || parsed.needs_school_tag_confirmation
+    || parsed.needs_degree_confirmation
+    || parsed.needs_gender_confirmation
+    || parsed.needs_recent_not_view_confirmation
     || parsed.needs_criteria_confirmation
     || parsed.needs_target_count_confirmation
     || parsed.needs_post_action_confirmation