@reconcrap/boss-recommend-mcp 0.1.1 → 0.1.2

package/README.md

@@ -19,9 +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`
@@ -43,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
@@ -94,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "0.1.1",
+  "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)
@@ -91,5 +98,6 @@ CLI fallback 的状态机与 MCP 保持一致：
 
 - 用结构化中文输出
 - 先给用户确认卡片，再正式执行
+- 对 `school_tag/degree/gender/recent_not_view` 必须逐项提问并逐项确认，不可合并成一句“filters已确认”
 - 不要跳过 `post_action` 的首轮确认
-- 不要把 recommend 流程说成 search 流程
+- 不要把 recommend 流程说成 search 流程

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: {

package/src/parser.js

@@ -443,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
     });
   }
@@ -500,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,

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

package/src/test-parser.js

@@ -15,6 +15,10 @@ function testNeedConfirmationIncludesPostAction() {
   assert.equal(result.screenParams.criteria, "有大模型平台经验");
   assert.equal(result.proposed_post_action, "favorite");
   assert.equal(result.needs_filters_confirmation, true);
+  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_criteria_confirmation, true);
   assert.equal(result.needs_post_action_confirmation, true);
 }
@@ -24,6 +28,10 @@ function testConfirmedPostActionAndOverrides() {
     instruction: "推荐页筛选女生，有多模态经历",
     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: 12,
@@ -49,6 +57,10 @@ function testConfirmedPostActionAndOverrides() {
   assert.equal(result.screenParams.post_action, "greet");
   assert.equal(result.screenParams.max_greet_count, 8);
   assert.equal(result.needs_filters_confirmation, false);
+  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);
   assert.equal(result.needs_criteria_confirmation, false);
   assert.equal(result.needs_target_count_confirmation, false);
   assert.equal(result.needs_post_action_confirmation, false);
@@ -60,6 +72,10 @@ function testMultipleSchoolTagsMarkedSuspicious() {
     instruction: "推荐页筛选985和211，有推荐系统经验",
     confirmation: {
       filters_confirmed: true,
+      school_tag_confirmed: true,
+      degree_confirmed: true,
+      gender_confirmed: true,
+      recent_not_view_confirmed: true,
       criteria_confirmed: true,
       post_action_confirmed: true,
       post_action_value: "favorite"
@@ -120,6 +136,10 @@ function testCriteriaCanBeProvidedViaOverrides() {
     instruction: "推荐页筛选211女生",
     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,
@@ -139,6 +159,10 @@ function testMissingCriteriaTriggersNeedInput() {
     instruction: "推荐页筛选985男生",
     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,
@@ -155,6 +179,10 @@ function testGreetNeedsMaxGreetCountConfirmation() {
     instruction: "推荐页筛选985男生，有大模型工程经验，符合标准直接沟通",
     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,
@@ -174,6 +202,10 @@ function testGreetMaxGreetCountCanComeFromOverrides() {
     instruction: "推荐页筛选985男生，有大模型工程经验，符合标准直接沟通",
     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,
@@ -194,6 +226,10 @@ function testTargetCountNeedsConfirmationEvenWhenOptional() {
     instruction: "推荐页筛选985男生，有大模型平台经验，符合标准收藏",
     confirmation: {
       filters_confirmed: true,
+      school_tag_confirmed: true,
+      degree_confirmed: true,
+      gender_confirmed: true,
+      recent_not_view_confirmed: true,
       criteria_confirmed: true,
       post_action_confirmed: true,
       post_action_value: "favorite"
@@ -210,6 +246,10 @@ function testTargetCountCanBeSkippedAfterConfirmation() {
     instruction: "推荐页筛选985男生，有大模型平台经验，符合标准收藏",
     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,

package/src/test-pipeline.js

@@ -18,6 +18,10 @@ function createParsed(overrides = {}) {
     missing_fields: [],
     suspicious_fields: [],
     needs_filters_confirmation: false,
+    needs_school_tag_confirmation: false,
+    needs_degree_confirmation: false,
+    needs_gender_confirmation: false,
+    needs_recent_not_view_confirmation: false,
     needs_criteria_confirmation: false,
     needs_target_count_confirmation: false,
     needs_post_action_confirmation: false,
@@ -84,6 +88,35 @@ async function testNeedTargetCountConfirmationGate() {
   assert.equal(preflightCalled, false);
 }
 
+async function testNeedSchoolTagConfirmationGate() {
+  let preflightCalled = false;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: {},
+      overrides: {}
+    },
+    {
+      parseRecommendInstruction: () => createParsed({
+        needs_school_tag_confirmation: true,
+        pending_questions: [{ field: "school_tag" }]
+      }),
+      runPipelinePreflight: () => {
+        preflightCalled = true;
+        return { ok: true, checks: [], debug_port: 9222 };
+      },
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      runRecommendSearchCli: async () => ({ ok: true, summary: {} }),
+      runRecommendScreenCli: async () => ({ ok: true, summary: {} })
+    }
+  );
+
+  assert.equal(result.status, "NEED_CONFIRMATION");
+  assert.equal(result.required_confirmations.includes("school_tag"), true);
+  assert.equal(preflightCalled, false);
+}
+
 async function testNeedMaxGreetCountConfirmationGate() {
   const result = await runRecommendPipeline(
     {
@@ -218,6 +251,7 @@ async function testSearchFailure() {
 
 async function main() {
   await testNeedConfirmationGate();
+  await testNeedSchoolTagConfirmationGate();
   await testNeedTargetCountConfirmationGate();
   await testNeedMaxGreetCountConfirmationGate();
   await testNeedInputGate();