@reconcrap/boss-recommend-mcp 2.1.10 → 2.1.12

package/README.md

@@ -100,6 +100,7 @@ MCP 工具：
 - `resume_recruit_pipeline_run`
 - `cancel_recruit_pipeline_run`
 - `boss_chat_health_check`
+- `list_boss_chat_jobs`（只读读取聊天页岗位列表；chat-only 获取 `job_options` 的首选别名，不会启动任务）
 - `prepare_boss_chat_run`
 - `start_boss_chat_run`
 - `get_boss_chat_run`
@@ -224,8 +225,9 @@ node src/cli.js start
 如果检测到 legacy Boss server entries，installer 会：
 
 - 保留非 Boss MCP server。
-- 默认写入统一 server：`boss-recommend -> npx -y @reconcrap/boss-recommend-mcp@<installed-version> start`
-- 如果传入 `--mcp-launch global-wrapper`，写入升级稳定入口：`boss-recommend -> ~/.boss-recommend-mcp/bin/boss-recommend-mcp-mcp-server`。该 wrapper 会加载 `~/.nvm/nvm.sh` 并执行当前全局 `boss-recommend-mcp start`，适合 macOS 上通过 `npm -g i @reconcrap/boss-recommend-mcp@latest` 持续升级。
+- Trae/Trae-CN 默认写入三个小 toolset server：`boss-recommend`（`BOSS_RECOMMEND_MCP_TOOLSET=recommend`）、`boss-chat`（`chat`）、`boss-recruit`（`recruit`）。这样 recommend/chat/search 的 tool list 不会互相挤占 agent 可见工具预算。
+- 其它宿主默认仍写入兼容统一 server：`boss-recommend -> npx -y @reconcrap/boss-recommend-mcp@<installed-version> start`。
+- 如果传入 `--mcp-launch global-wrapper`，Trae/Trae-CN 同样会写入三个 toolset server，但 command 指向升级稳定 wrapper。该 wrapper 会加载 `~/.nvm/nvm.sh` 并执行当前全局 `boss-recommend-mcp start`，适合 macOS 上通过 `npm -g i @reconcrap/boss-recommend-mcp@latest` 持续升级。
 - 从同一个 `mcp.json` 删除旧 `boss-recruit-mcp`、standalone `boss-chat`、旧本地 Boss repo 路径，避免 agent 继续调用 legacy 包。
 - 在原文件旁生成 `mcp.json.boss-mcp-migration-*.bak`。
 - 同步外部 skills 目录里的 `boss-recommend-pipeline`、`boss-recruit-pipeline`、`boss-chat`。
@@ -262,6 +264,7 @@ BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS="/path/to/skills" boss-recommend-mcp install
 BOSS_RECOMMEND_HOME               # 统一状态目录，默认 ~/.boss-recommend-mcp
 BOSS_CHAT_HOME                    # 覆盖 boss-chat 运行态目录；默认 ~/.boss-recommend-mcp/boss-chat
 BOSS_RECOMMEND_SCREEN_CONFIG      # 显式指定 screening-config.json 路径（最高优先级）
+BOSS_RECOMMEND_MCP_TOOLSET        # 可选收窄 MCP 工具：all|recommend|chat|recruit；Trae/Trae-CN installer 会自动设置
 BOSS_RECOMMEND_MCP_CONFIG_TARGETS   # JSON 数组或系统 path 分隔路径列表，指定额外 mcp.json 目标文件
 BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS  # JSON 数组或系统 path 分隔路径列表，指定额外 skills 根目录
 ```
@@ -424,7 +427,7 @@ node src/cli.js chat prepare-run --slow-live --port 9222
 - `baseUrl` / `apiKey` / `model` 不再单独传入，固定复用 recommend 的 `screening-config.json`
 - `greeting_text` 默认优先级：本次显式值 > `screening-config.json.greetingMessage` > 内置默认招呼语（`Hi同学，能麻烦发下简历吗？`）
 - 若缺少 `follow_up.chat` 必填项，pipeline 会返回 `NEED_INPUT`
-- 如需聊天页筛选，请调用 `prepare_boss_chat_run` 获取岗位列表，再调用 `start_boss_chat_run`。
+- 如需聊天页筛选，请调用 `list_boss_chat_jobs` 或 `prepare_boss_chat_run` 获取岗位列表，再调用 `start_boss_chat_run`。chat-only、未读、全部聊天、求简历任务不要调用 `list_recommend_jobs` / `run_recommend` / `start_recommend_pipeline_run`；这些 recommend 工具会对明确的 chat/search 误路由 fail closed。
 - `boss-chat` 状态统一写入 `~/.boss-recommend-mcp/boss-chat`（或 `BOSS_CHAT_HOME` 指定目录），不再依赖工作区 `cwd`
 
 ## Chat-only
@@ -438,6 +441,7 @@ node src/cli.js chat prepare-run --slow-live --port 9222
   - `boss-recommend-mcp chat get-run|pause-run|resume-run|cancel-run`
 - MCP：
   - `boss_chat_health_check`
+  - `list_boss_chat_jobs`
   - `prepare_boss_chat_run`
   - `start_boss_chat_run`
   - `get_boss_chat_run`
@@ -450,14 +454,15 @@ node src/cli.js chat prepare-run --slow-live --port 9222
 
 chat-only 交互建议：
 
-- 先调用一次 `prepare_boss_chat_run`（可不带参数），服务会先导航到 `https://www.zhipin.com/web/chat/index` 并返回 `NEED_INPUT`，其中包含岗位 `job_options` 与待补字段。
+- 先调用一次 `list_boss_chat_jobs` 或 `prepare_boss_chat_run`（可不带参数），服务会先导航到 `https://www.zhipin.com/web/chat/index` 并返回 `NEED_INPUT`，其中包含岗位 `job_options` 与待补字段。
 - 然后基于 `job_options` 让用户选择 `job`，并补齐 `start_from`、`target_count`、`criteria` 后调用 `start_boss_chat_run` 启动任务。
 - `greeting_text` 可选；未传时使用 `screening-config.json.greetingMessage`，若未配置则使用默认招呼语（`Hi同学，能麻烦发下简历吗？`）。
 - `target_count` 支持正整数、`all`、`-1`；若用户给出 `全部候选人` / `所有候选人`，会自动按不限（扫到底）处理。
 
 Trae-CN / 长对话防循环建议：
 
-- 固定流程：`boss_chat_health_check` -> `prepare_boss_chat_run(空参可)` -> 一次性补齐 `job/start_from/target_count/criteria` -> `start_boss_chat_run`。
+- 固定流程：`boss_chat_health_check` -> `list_boss_chat_jobs(空参可)` / `prepare_boss_chat_run(空参可)` -> 一次性补齐 `job/start_from/target_count/criteria` -> `start_boss_chat_run`。
+- chat-only 场景严禁调用 `list_recommend_jobs`、`run_recommend` 或 `start_recommend_pipeline_run`。
 - `start_boss_chat_run` 的工具 schema 已把 `job/start_from/target_count/criteria` 标记为必填；不要用它获取岗位列表。
 - 若 `pending_questions` / UI 选项里出现“扫到底（必须传 `target_count="all"`）”，下一次工具调用请直接照抄 `"target_count": "all"`，不要只保留“扫到底”这层自然语言语义。
 - `start_boss_chat_run` 返回 `ACCEPTED` 后直接结束当前回合，不要自动轮询。

package/package.json

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

package/skills/boss-chat/README.md

@@ -16,7 +16,7 @@ Please run a Boss chat-only task (do not switch to recommend flow).
 
 Execution order:
 1) Call boss_chat_health_check.
-2) Call prepare_boss_chat_run once (empty params allowed) to fetch job_options and missing fields.
+2) Call list_boss_chat_jobs once (empty params allowed), or prepare_boss_chat_run once, to fetch job_options and missing fields.
 3) Ask for these required fields in one shot: job, start_from (unread/all), target_count, criteria, rest_level (low/medium/high).
 4) After user reply, call start_boss_chat_run exactly once to start the run.
 5) If ACCEPTED, reply only with run_id and "task started"; no auto polling.
@@ -24,6 +24,8 @@ Execution order:
 Anti-loop rules:
 - Do not repeat the same sentence across turns.
 - On validation errors, list all missing/invalid fields once.
+- Do not call list_recommend_jobs for chat-only tasks; it is recommend-page only and will switch the browser to /web/chat/recommend.
+- Do not call run_recommend or start_recommend_pipeline_run for chat-only tasks; use start_boss_chat_run.
 - Do not use start_boss_chat_run for preflight. It is only for the final start call and must include job/start_from/target_count/criteria.
 - Do not call start_boss_chat_run repeatedly in one turn.
 - Do not call get_boss_chat_run unless user explicitly asks for progress.

package/skills/boss-chat/SKILL.md

@@ -13,7 +13,10 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 
 ## Tool Routing
 
+Trae/Trae-CN split-server config exposes these under the `boss-chat` MCP server. Chat-only tasks should call `boss-chat/<tool>` when the host shows server-qualified tool names.
+
 - 健康检查：`boss_chat_health_check`
+- 只读获取聊天页岗位列表：`list_boss_chat_jobs`
 - 预备并获取岗位列表：`prepare_boss_chat_run`
 - 启动异步任务：`start_boss_chat_run`
 - 查询进度：`get_boss_chat_run`
@@ -69,6 +72,8 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - 若本机找不到 Chrome，可提示用户设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`；非本机 debug host 不自动启动。
 - `job` / `start_from` / `criteria` 缺一不可；缺参时只补缺口。
 - `target_count` 在 chat-only 启动前也是必填项，不能默认省略。
+- chat-only 岗位列表只能通过 `list_boss_chat_jobs` 或 `prepare_boss_chat_run` 获取；严禁调用 `list_recommend_jobs`，因为它会切到推荐页。
+- chat-only 启动只能调用 `start_boss_chat_run`；严禁调用 `run_recommend` 或 `start_recommend_pipeline_run`。
 - 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
 - 当用户说“全部候选人/所有候选人”时，必须按“扫到底（unlimited）”处理，不要再追问正整数。
 - 参数名必须写 `target_count`（不要写“目标数量”等中文键名）。
@@ -77,7 +82,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - 若工具或提问选项里出现“扫到底（必须传 `target_count=\"all\"`）”之类字样，下一次工具调用时必须直接照抄这个字面量，不要只保留“扫到底”语义。
 - 禁止 agent 自行补全 `job/start_from/criteria` 并直接执行，必须由用户明确给出或确认。
 - chat-only 启动流程必须先进入聊天页并拉取岗位列表，再让用户从列表中选择 `job`。
-- 必须先用空参调用 `prepare_boss_chat_run` 获取 `job_options`；不要用 `start_boss_chat_run` 做预备调用。
+- 必须先用空参调用 `list_boss_chat_jobs` 或 `prepare_boss_chat_run` 获取 `job_options`；不要用 `start_boss_chat_run` 做预备调用。
 - `start_boss_chat_run` 只能用于真正启动，必须一次性传齐 `job` / `start_from` / `target_count` / `criteria`。
 - 若 `start_boss_chat_run` 返回 `NEED_INPUT` 且 `missing_fields` 包含 `target_count`，说明你没有把用户选择写入工具参数；下一次调用必须照 `next_call_example` 原样补上 `"target_count": "all"` 或正整数，不要重复空调用。
 - 默认不自动轮询；只有用户要求查进度时才调用 `get_boss_chat_run`。
@@ -96,6 +101,6 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 ## Response Style
 
 - 用结构化中文。
-- 首轮建议先调用一次 `prepare_boss_chat_run`（可空参）获取 `job_options` 与 `pending_questions`。
+- 首轮建议先调用一次 `list_boss_chat_jobs`（可空参）或 `prepare_boss_chat_run`（可空参）获取 `job_options` 与 `pending_questions`。
 - 缺参时必须逐项确认：`job`（来自岗位列表）、`start_from`（`unread|all`）、`target_count`、`criteria`、`rest_level`。
 - 若健康检查失败，明确提示共享配置文件 `screening-config.json` 不可用。

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

@@ -97,6 +97,8 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 
 ## Tool Usage
 
+Trae/Trae-CN split-server config exposes these under the `boss-recommend` MCP server. 推荐页任务应调用 `boss-recommend/<tool>`；不要切到 `boss-chat` 或 `boss-recruit`。
+
 - 岗位发现工具：`list_recommend_jobs`
   - 用途：当用户需要为 cron / 一次性自动任务提前填写完整参数时，先用它读取推荐页岗位下拉框的全部可用岗位名；默认会复用/自动打开本机 9222 Chrome 并导航到推荐页。
   - 输出：优先把 `job_names` 里的值作为后续 `overrides.job` / `confirmation.job_value`。

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

@@ -11,6 +11,8 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 
 ## Tool Routing
 
+Trae/Trae-CN split-server config exposes these under the `boss-recruit` MCP server. Search/recruit tasks should call `boss-recruit/<tool>` when the host shows server-qualified tool names.
+
 - 同步启动：`run_recruit_pipeline`
 - 异步启动：`start_recruit_pipeline_run`
 - 查询进度：`get_recruit_pipeline_run`

package/src/cli.js

@@ -57,12 +57,15 @@ const bossLoginUrl = "https://www.zhipin.com/web/user/?ka=bticket";
 const chromeOnboardingUrlPattern = /^chrome:\/\/(welcome|intro|newtab|signin|history-sync|settings\/syncSetup)/i;
 const bossLoginUrlPattern = /(?:zhipin\.com\/web\/user(?:\/|\?|$)|passport\.zhipin\.com)/i;
 const bossLoginTitlePattern = /登录|signin|扫码登录|BOSS直聘登录/i;
-const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "openclaw", "qclaw"];
+const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "openclaw", "qclaw"];
 const defaultMcpServerName = "boss-recommend";
+const bossChatMcpServerName = "boss-chat";
+const bossRecruitMcpServerName = "boss-recruit";
 const defaultMcpCommand = "npx";
 const recommendMcpPackageName = "@reconcrap/boss-recommend-mcp";
 const recommendMcpBinaryName = "boss-recommend-mcp";
 const globalMcpWrapperFileName = "boss-recommend-mcp-mcp-server";
+const mcpToolsetEnv = "BOSS_RECOMMEND_MCP_TOOLSET";
 const supportedMcpLaunchModes = ["npx", "global-wrapper"];
 const autoSyncSkipCommands = new Set(["install", "install-skill", "where", "help", "--help", "-h", "list-jobs", "jobs", "recommend-jobs"]);
 const externalMcpTargetsEnv = "BOSS_RECOMMEND_MCP_CONFIG_TARGETS";
@@ -807,12 +810,35 @@ function shouldDefaultRecommendDetachedMcpEnv(options = {}) {
   return client === "openclaw"
     || client === "qclaw"
     || agent === "openclaw"
-    || agent === "qclaw";
-}
-
-function getDefaultMcpEnv(options = {}) {
-  return shouldDefaultRecommendDetachedMcpEnv(options)
-    ? { ...detachedRecommendMcpEnv }
+    || agent === "qclaw";
+}
+
+function normalizeMcpToolsetOption(value) {
+  const raw = String(value || "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (!raw || raw === "all") return "";
+  if (raw === "boss-recommend" || raw === "recommend-page") return "recommend";
+  if (raw === "boss-chat" || raw === "chat-only" || raw === "chat-page") return "chat";
+  if (raw === "boss-recruit" || raw === "search" || raw === "search-page" || raw === "recruit-page") return "recruit";
+  if (["recommend", "chat", "recruit"].includes(raw)) return raw;
+  throw new Error(`Unsupported --toolset value: ${raw}. Supported: recommend, chat, recruit, all`);
+}
+
+function getMcpToolsetEnv(options = {}) {
+  const toolset = normalizeMcpToolsetOption(options.toolset || options["toolset"]);
+  return toolset ? { [mcpToolsetEnv]: toolset } : {};
+}
+
+function shouldUseSplitBossMcpServers(options = {}) {
+  if (options["server-name"] || options.serverName || options.toolset || options["toolset"]) return false;
+  if (options.split === true || options["split-tools"] === true || options.splitTools === true) return true;
+  const client = normalizeMcpClientName(options.client);
+  const agent = normalizeAgentName(options.agent);
+  return client === "trae" || agent === "trae" || agent === "trae-cn";
+}
+
+function getDefaultMcpEnv(options = {}) {
+  return shouldDefaultRecommendDetachedMcpEnv(options)
+    ? { ...detachedRecommendMcpEnv }
     : {};
 }
 
@@ -834,6 +860,7 @@ function buildMcpLaunchConfig(options = {}) {
     };
     const mergedEnv = {
       ...getDefaultMcpEnv(options),
+      ...getMcpToolsetEnv(options),
       ...(isPlainObject(env) ? env : {})
     };
     if (Object.keys(mergedEnv).length > 0) {
@@ -853,19 +880,36 @@ function buildMcpLaunchConfig(options = {}) {
       ? ["start"]
       : buildDefaultMcpArgs(options);
   const launchConfig = { command, args: launchArgs };
-  const mergedEnv = {
-    ...getDefaultMcpEnv(options),
-    ...(isPlainObject(env) ? env : {})
-  };
+  const mergedEnv = {
+    ...getDefaultMcpEnv(options),
+    ...getMcpToolsetEnv(options),
+    ...(isPlainObject(env) ? env : {})
+  };
   if (Object.keys(mergedEnv).length > 0) {
     launchConfig.env = mergedEnv;
   }
   return launchConfig;
-}
-
-function mergeExistingMcpEntryEnv(existingEntry, launchConfig) {
-  if (!isPlainObject(existingEntry?.env) || !isPlainObject(launchConfig)) {
-    return launchConfig;
+}
+
+function buildBossMcpServerEntries(options = {}) {
+  if (shouldUseSplitBossMcpServers(options)) {
+    return {
+      [defaultMcpServerName]: buildMcpLaunchConfig({ ...options, toolset: "recommend" }),
+      [bossChatMcpServerName]: buildMcpLaunchConfig({ ...options, toolset: "chat" }),
+      [bossRecruitMcpServerName]: buildMcpLaunchConfig({ ...options, toolset: "recruit" })
+    };
+  }
+  const serverName = typeof options["server-name"] === "string" && options["server-name"].trim()
+    ? options["server-name"].trim()
+    : defaultMcpServerName;
+  return {
+    [serverName]: buildMcpLaunchConfig(options)
+  };
+}
+
+function mergeExistingMcpEntryEnv(existingEntry, launchConfig) {
+  if (!isPlainObject(existingEntry?.env) || !isPlainObject(launchConfig)) {
+    return launchConfig;
   }
   return {
     ...launchConfig,
@@ -874,28 +918,21 @@ function mergeExistingMcpEntryEnv(existingEntry, launchConfig) {
       ...(isPlainObject(launchConfig.env) ? launchConfig.env : {})
     }
   };
-}
-
-function buildMcpConfigFileContent(options = {}) {
-  const serverName = typeof options["server-name"] === "string" && options["server-name"].trim()
-    ? options["server-name"].trim()
-    : defaultMcpServerName;
-  const launchConfig = buildMcpLaunchConfig(options);
-  if (normalizeMcpClientName(options.client) === "qclaw") {
-    return {
-      mcp: {
-        servers: {
-          [serverName]: launchConfig
-        }
-      }
-    };
-  }
-  return {
-    mcpServers: {
-      [serverName]: launchConfig
-    }
-  };
-}
+}
+
+function buildMcpConfigFileContent(options = {}) {
+  const servers = buildBossMcpServerEntries(options);
+  if (normalizeMcpClientName(options.client) === "qclaw") {
+    return {
+      mcp: {
+        servers
+      }
+    };
+  }
+  return {
+    mcpServers: servers
+  };
+}
 
 function writeMcpConfigFiles(options = {}) {
   const clients = parseMcpClientTargets(options.client);
@@ -1039,25 +1076,28 @@ function getMcpServersFromConfig(config = {}, useQClawShape = false) {
   return {};
 }
 
-function mergeMcpServerConfigFile(filePath, options = {}) {
-  const current = readJsonObjectFileSafe(filePath);
-  const useQClawShape = isQClawMcpConfigTarget(filePath, options, current);
-  const nextConfig = buildMcpConfigFileContent({ ...options, client: useQClawShape ? "qclaw" : options.client });
-  const nextServers = useQClawShape ? nextConfig.mcp?.servers : nextConfig.mcpServers;
-  const serverName = Object.keys(nextServers || {})[0] || defaultMcpServerName;
-  const existingServers = getMcpServersFromConfig(current, useQClawShape);
-  const existingEntry = existingServers[serverName];
-  const launchConfig = mergeExistingMcpEntryEnv(
-    existingEntry,
-    nextServers?.[serverName] || buildMcpLaunchConfig(options)
-  );
-  const retainedServers = {};
-  const migratedLegacyServers = [];
-  for (const [name, config] of Object.entries(existingServers)) {
-    if (name === serverName) continue;
-    if (isBossMcpServerEntry(name, config)) {
-      migratedLegacyServers.push(name);
-      continue;
+function mergeMcpServerConfigFile(filePath, options = {}) {
+  const current = readJsonObjectFileSafe(filePath);
+  const useQClawShape = isQClawMcpConfigTarget(filePath, options, current);
+  const nextConfig = buildMcpConfigFileContent({ ...options, client: useQClawShape ? "qclaw" : options.client });
+  const nextServers = useQClawShape ? nextConfig.mcp?.servers : nextConfig.mcpServers;
+  const serverNames = Object.keys(nextServers || {});
+  const nextBossServerNames = new Set(serverNames);
+  const existingServers = getMcpServersFromConfig(current, useQClawShape);
+  const mergedBossServers = {};
+  for (const serverName of serverNames) {
+    mergedBossServers[serverName] = mergeExistingMcpEntryEnv(
+      existingServers[serverName],
+      nextServers?.[serverName] || buildMcpLaunchConfig(options)
+    );
+  }
+  const retainedServers = {};
+  const migratedLegacyServers = [];
+  for (const [name, config] of Object.entries(existingServers)) {
+    if (nextBossServerNames.has(name)) continue;
+    if (isBossMcpServerEntry(name, config)) {
+      migratedLegacyServers.push(name);
+      continue;
     }
     retainedServers[name] = config;
   }
@@ -1065,20 +1105,20 @@ function mergeMcpServerConfigFile(filePath, options = {}) {
     ? {
         ...current,
         mcp: {
-          ...(current?.mcp && typeof current.mcp === "object" && !Array.isArray(current.mcp) ? current.mcp : {}),
-          servers: {
-            ...retainedServers,
-            [serverName]: launchConfig
-          }
-        }
-      }
-    : {
-        ...current,
-        mcpServers: {
-          ...retainedServers,
-          [serverName]: launchConfig
-        }
-      };
+          ...(current?.mcp && typeof current.mcp === "object" && !Array.isArray(current.mcp) ? current.mcp : {}),
+          servers: {
+            ...retainedServers,
+            ...mergedBossServers
+          }
+        }
+      }
+    : {
+        ...current,
+        mcpServers: {
+          ...retainedServers,
+          ...mergedBossServers
+        }
+      };
 
   ensureDir(path.dirname(filePath));
   const before = pathExists(filePath) ? fs.readFileSync(filePath, "utf8") : "";
@@ -1088,14 +1128,15 @@ function mergeMcpServerConfigFile(filePath, options = {}) {
     backupFile = `${filePath}.boss-mcp-migration-${new Date().toISOString().replace(/[:.]/g, "-")}.bak`;
     fs.writeFileSync(backupFile, before, "utf8");
   }
-  fs.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf8");
-  const updated = before.trim() !== next.trim() || JSON.stringify(existingEntry || null) !== JSON.stringify(launchConfig);
-  return {
-    file: filePath,
-    server: serverName,
-    config_shape: useQClawShape ? "qclaw" : "mcpServers",
-    updated,
-    migrated_legacy_servers: migratedLegacyServers,
+  fs.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf8");
+  const updated = before.trim() !== next.trim();
+  return {
+    file: filePath,
+    server: serverNames[0] || defaultMcpServerName,
+    servers: serverNames,
+    config_shape: useQClawShape ? "qclaw" : "mcpServers",
+    updated,
+    migrated_legacy_servers: migratedLegacyServers,
     backup_file: backupFile
   };
 }
@@ -1108,12 +1149,13 @@ function installExternalMcpConfigs(options = {}) {
     try {
       const existed = pathExists(target);
       const merged = mergeMcpServerConfigFile(target, options);
-      applied.push({
-        file: target,
-        server: merged.server,
-        created: !existed,
-        updated: merged.updated,
-        migrated_legacy_servers: merged.migrated_legacy_servers,
+      applied.push({
+        file: target,
+        server: merged.server,
+        servers: merged.servers,
+        created: !existed,
+        updated: merged.updated,
+        migrated_legacy_servers: merged.migrated_legacy_servers,
         backup_file: merged.backup_file
       });
     } catch (error) {
@@ -2718,6 +2760,7 @@ function printHelp() {
   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");
   console.log("  boss-recommend-mcp install --mcp-launch global-wrapper  Use ~/.boss-recommend-mcp/bin wrapper so npm global upgrades affect MCP hosts");
+  console.log("  boss-recommend-mcp start --toolset recommend  Start a narrowed MCP server (all|recommend|chat|recruit)");
   console.log("");
   console.log("Run command:");
   console.log("  boss-recommend-mcp prepare-run --instruction \"...\" --overrides-file overrides.json --confirmation-file confirmation.json --rest-level medium");
@@ -3397,6 +3440,7 @@ export const __testables = {
   buildBossChatCliInput,
   buildDefaultMcpArgs,
   buildMcpLaunchConfig,
+  buildMcpConfigFileContent,
   ensureGlobalMcpWrapper,
   getGlobalMcpWrapperPath,
   collectRuntimeDirectories,

package/src/index.js

@@ -110,6 +110,7 @@ const TOOL_RUN_FEATURED_CALIBRATION = "run_featured_calibration";
 const TOOL_GET_FEATURED_CALIBRATION_STATUS = "get_featured_calibration_status";
 const TOOL_RUN_RECOMMEND_SELF_HEAL = "run_recommend_self_heal";
 const TOOL_BOSS_CHAT_HEALTH_CHECK = "boss_chat_health_check";
+const TOOL_BOSS_CHAT_LIST_JOBS = "list_boss_chat_jobs";
 const TOOL_BOSS_CHAT_PREPARE_RUN = "prepare_boss_chat_run";
 const TOOL_BOSS_CHAT_START_RUN = "start_boss_chat_run";
 const TOOL_BOSS_CHAT_GET_RUN = "get_boss_chat_run";
@@ -122,8 +123,50 @@ const TOOL_GET_RECRUIT_PIPELINE_RUN = "get_recruit_pipeline_run";
 const TOOL_CANCEL_RECRUIT_PIPELINE_RUN = "cancel_recruit_pipeline_run";
 const TOOL_PAUSE_RECRUIT_PIPELINE_RUN = "pause_recruit_pipeline_run";
 const TOOL_RESUME_RECRUIT_PIPELINE_RUN = "resume_recruit_pipeline_run";
-
-const SERVER_NAME = "boss-recommend-mcp";
+
+const SERVER_NAME = "boss-recommend-mcp";
+const MCP_TOOLSET_ENV = "BOSS_RECOMMEND_MCP_TOOLSET";
+const MCP_TOOLSET_ALL = "all";
+const MCP_TOOLSET_RECOMMEND = "recommend";
+const MCP_TOOLSET_CHAT = "chat";
+const MCP_TOOLSET_RECRUIT = "recruit";
+const VALID_MCP_TOOLSETS = new Set([
+  MCP_TOOLSET_ALL,
+  MCP_TOOLSET_RECOMMEND,
+  MCP_TOOLSET_CHAT,
+  MCP_TOOLSET_RECRUIT
+]);
+const RECOMMEND_TOOL_NAMES = new Set([
+  TOOL_LIST_RECOMMEND_JOBS,
+  TOOL_RUN_RECOMMEND,
+  TOOL_START_RUN,
+  TOOL_PREPARE_RUN,
+  TOOL_SCHEDULE_RUN,
+  TOOL_GET_SCHEDULED_RUN,
+  TOOL_GET_RUN,
+  TOOL_LIST_RUNS,
+  TOOL_CANCEL_RUN,
+  TOOL_PAUSE_RUN,
+  TOOL_RESUME_RUN
+]);
+const BOSS_CHAT_TOOL_NAMES = new Set([
+  TOOL_BOSS_CHAT_HEALTH_CHECK,
+  TOOL_BOSS_CHAT_LIST_JOBS,
+  TOOL_BOSS_CHAT_PREPARE_RUN,
+  TOOL_BOSS_CHAT_START_RUN,
+  TOOL_BOSS_CHAT_GET_RUN,
+  TOOL_BOSS_CHAT_PAUSE_RUN,
+  TOOL_BOSS_CHAT_RESUME_RUN,
+  TOOL_BOSS_CHAT_CANCEL_RUN
+]);
+const RECRUIT_TOOL_NAMES = new Set([
+  TOOL_RUN_RECRUIT_PIPELINE,
+  TOOL_START_RECRUIT_PIPELINE_RUN,
+  TOOL_GET_RECRUIT_PIPELINE_RUN,
+  TOOL_CANCEL_RECRUIT_PIPELINE_RUN,
+  TOOL_PAUSE_RECRUIT_PIPELINE_RUN,
+  TOOL_RESUME_RECRUIT_PIPELINE_RUN
+]);
 const FRAMING_UNKNOWN = "unknown";
 const FRAMING_HEADER = "header";
 const FRAMING_LINE = "line";
@@ -453,6 +496,26 @@ function readRawRunState(runId) {
   }
 }
 
+function compactProgressForList(progress = {}) {
+  const compact = {};
+  for (const key of [
+    "processed",
+    "screened",
+    "passed",
+    "skipped",
+    "target_count",
+    "card_count",
+    "detail_opened",
+    "greet_count",
+    "post_action_clicked"
+  ]) {
+    if (Number.isFinite(progress?.[key])) {
+      compact[key] = progress[key];
+    }
+  }
+  return compact;
+}
+
 function getRunSortTime(run = {}, fallbackMs = 0) {
   for (const key of ["updated_at", "heartbeat_at", "completed_at", "started_at", "updatedAt", "completedAt", "startedAt"]) {
     const ms = Date.parse(run?.[key] || "");
@@ -476,7 +539,7 @@ function compactRunForList(run = {}) {
     heartbeat_at: run.heartbeat_at || null,
     completed_at: run.completed_at || run.completedAt || null,
     pid: Number.isInteger(run.pid) && run.pid > 0 ? run.pid : null,
-    progress: run.progress || {},
+    progress: compactProgressForList(run.progress),
     last_message: normalizeText(run.last_message || error?.message || ""),
     control: {
       pause_requested: run.control?.pause_requested === true,
@@ -493,11 +556,10 @@ function compactRunForList(run = {}) {
       report_json: normalizeText(result.report_json || result.result?.report_json || ""),
       checkpoint_path: normalizeText(result.checkpoint_path || result.result?.checkpoint_path || "")
     } : null,
-    resume: {
-      checkpoint_path: normalizeText(run.resume?.checkpoint_path || ""),
-      output_csv: normalizeText(run.resume?.output_csv || ""),
-      worker_stdout_path: normalizeText(run.resume?.worker_stdout_path || ""),
-      worker_stderr_path: normalizeText(run.resume?.worker_stderr_path || "")
+    artifacts: {
+      output_csv: normalizeText(result?.output_csv || result?.result?.output_csv || ""),
+      report_json: normalizeText(result?.report_json || result?.result?.report_json || ""),
+      checkpoint_path: normalizeText(result?.checkpoint_path || result?.result?.checkpoint_path || "")
     }
   };
 }
@@ -1293,32 +1355,276 @@ function createScheduleRunInputSchema() {
   };
 }
 
-function createToolsSchema() {
-  return [
+function createCompactRunInputSchema() {
+  const targetCountSchema = {
+    anyOf: [
+      { type: "integer", minimum: 0 },
+      { type: "string" }
+    ],
+    description: "目标通过人数；扫到底/不限可传 all"
+  };
+  return {
+    type: "object",
+    properties: {
+      instruction: {
+        type: "string",
+        description: "用户原始筛选标准/任务说明；正式启动时逐字复用"
+      },
+      confirmation: {
+        type: "object",
+        properties: {
+          final_confirmed: {
+            type: "boolean",
+            description: "用户完成总确认后传 true"
+          }
+        },
+        additionalProperties: true
+      },
+      overrides: {
+        type: "object",
+        properties: {
+          page_scope: { type: "string", enum: ["recommend", "latest", "featured"] },
+          school_tag: {
+            anyOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          degree: {
+            anyOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          gender: { type: "string" },
+          recent_not_view: { type: "string" },
+          criteria: { type: "string" },
+          target_count: targetCountSchema,
+          post_action: { type: "string", enum: ["greet", "none"] },
+          max_greet_count: targetCountSchema,
+          job: { type: "string" }
+        },
+        additionalProperties: true
+      },
+      human_behavior: {
+        type: "object",
+        properties: {
+          restLevel: { type: "string", enum: ["low", "medium", "high"] },
+          rest_level: { type: "string", enum: ["low", "medium", "high"] }
+        },
+        additionalProperties: true
+      },
+      host: { type: "string" },
+      port: { type: "integer", minimum: 1 },
+      slow_live: { type: "boolean" },
+      delay_ms: { type: "integer", minimum: 0 },
+      detail_limit: { type: "integer", minimum: 0 },
+      execute_post_action: { type: "boolean" },
+      no_filter: { type: "boolean" },
+      dry_run: { type: "boolean" }
+    },
+    required: ["instruction"],
+    additionalProperties: true
+  };
+}
+
+function createCompactScheduleRunInputSchema() {
+  const base = createCompactRunInputSchema();
+  return {
+    ...base,
+    properties: {
+      ...base.properties,
+      schedule_id: {
+        type: "string",
+        description: "可选，自定义定时任务 id；默认自动生成"
+      },
+      schedule_run_at: {
+        type: "string",
+        description: "ISO 时间字符串"
+      },
+      schedule_delay_minutes: {
+        type: "number",
+        minimum: 0
+      },
+      schedule_delay_seconds: {
+        type: "number",
+        minimum: 0
+      }
+    }
+  };
+}
+
+function normalizeMcpToolset(value) {
+  const raw = String(value || "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (!raw) return MCP_TOOLSET_ALL;
+  if (raw === "boss-recommend" || raw === "recommend-page" || raw === "recommended") return MCP_TOOLSET_RECOMMEND;
+  if (raw === "boss-chat" || raw === "chat-only" || raw === "chat-page") return MCP_TOOLSET_CHAT;
+  if (raw === "boss-recruit" || raw === "search" || raw === "search-page" || raw === "recruit-page") return MCP_TOOLSET_RECRUIT;
+  return VALID_MCP_TOOLSETS.has(raw) ? raw : MCP_TOOLSET_ALL;
+}
+
+function getConfiguredMcpToolset(argv = process.argv, env = process.env) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || "");
+    if (arg === "--toolset" || arg === "--tools") {
+      return normalizeMcpToolset(args[index + 1]);
+    }
+    if (arg.startsWith("--toolset=")) {
+      return normalizeMcpToolset(arg.slice("--toolset=".length));
+    }
+    if (arg.startsWith("--tools=")) {
+      return normalizeMcpToolset(arg.slice("--tools=".length));
+    }
+  }
+  return normalizeMcpToolset(env?.[MCP_TOOLSET_ENV]);
+}
+
+function toolNamesForMcpToolset(toolset) {
+  const normalized = normalizeMcpToolset(toolset);
+  if (normalized === MCP_TOOLSET_RECOMMEND) return RECOMMEND_TOOL_NAMES;
+  if (normalized === MCP_TOOLSET_CHAT) return BOSS_CHAT_TOOL_NAMES;
+  if (normalized === MCP_TOOLSET_RECRUIT) return RECRUIT_TOOL_NAMES;
+  return null;
+}
+
+function filterToolsForMcpToolset(tools, toolset = getConfiguredMcpToolset()) {
+  const names = toolNamesForMcpToolset(toolset);
+  if (!names) return tools;
+  return tools.filter((tool) => names.has(tool.name));
+}
+
+function createToolsSchema(toolset = getConfiguredMcpToolset()) {
+  const normalizedToolset = normalizeMcpToolset(toolset);
+  const runInputSchema = normalizedToolset === MCP_TOOLSET_RECOMMEND
+    ? createCompactRunInputSchema()
+    : createRunInputSchema();
+  const scheduleRunInputSchema = normalizedToolset === MCP_TOOLSET_RECOMMEND
+    ? createCompactScheduleRunInputSchema()
+    : createScheduleRunInputSchema();
+  const tools = [
+    {
+      name: TOOL_BOSS_CHAT_HEALTH_CHECK,
+      description: "Boss 聊天页/chat-only 健康检查。chat-only、未读、全部聊天、求简历等任务必须先走 boss-chat 工具，不要调用 list_recommend_jobs 或 start_recommend_pipeline_run。",
+      inputSchema: {
+        type: "object",
+        properties: {
+          host: {
+            type: "string",
+            description: "可选，Chrome 调试 host；默认 127.0.0.1"
+          },
+          port: {
+            type: "integer",
+            minimum: 1,
+            description: "可选，Chrome 调试端口；默认读取 screening-config.json.debugPort 或 9222"
+          },
+          target_url_includes: {
+            type: "string",
+            description: "可选，Chrome target URL 匹配片段；默认 Boss chat 页"
+          },
+          allow_navigate: {
+            type: "boolean",
+            description: "可选，未在 chat 页时允许通过 Page.navigate 切换；默认 true"
+          },
+          slow_live: {
+            type: "boolean",
+            description: "可选，VPN/慢页面 live 测试模式，放宽等待时间"
+          }
+        },
+        additionalProperties: false
+      }
+    },
+    {
+      name: TOOL_BOSS_CHAT_LIST_JOBS,
+      description: "只读读取 Boss 聊天页岗位列表；这是 chat-only 获取 job_options 的首选别名，等价于 prepare_boss_chat_run 的预备步骤但不会启动任务。聊天页/未读/全部聊天/求简历任务必须用本工具或 prepare_boss_chat_run，严禁用 list_recommend_jobs。",
+      inputSchema: createBossChatStartInputSchema()
+    },
+    {
+      name: TOOL_BOSS_CHAT_PREPARE_RUN,
+      description: "预备一次 boss-chat/chat-only 任务：只导航聊天页并返回岗位列表与待补字段，不会启动任务。用它先获取 job_options；不要用 list_recommend_jobs。",
+      inputSchema: createBossChatStartInputSchema()
+    },
+    {
+      name: TOOL_BOSS_CHAT_START_RUN,
+      description: "异步启动一次 boss-chat/chat-only 任务。必须一次性提供 job、start_from、target_count、criteria；若用户选择扫到底/不限/全部候选人，必须字面传 target_count=\"all\"。严禁改用 start_recommend_pipeline_run。",
+      inputSchema: createBossChatStartInputSchema({ requireFullInput: true })
+    },
+    {
+      name: TOOL_BOSS_CHAT_GET_RUN,
+      description: "查询 boss-chat run_id 的当前状态。chat-only 状态查询用本工具，不要用 get_recommend_pipeline_run。",
+      inputSchema: {
+        type: "object",
+        properties: {
+          run_id: { type: "string" },
+          profile: { type: "string" }
+        },
+        required: ["run_id"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: TOOL_BOSS_CHAT_PAUSE_RUN,
+      description: "暂停运行中的 boss-chat 任务。",
+      inputSchema: {
+        type: "object",
+        properties: {
+          run_id: { type: "string" },
+          profile: { type: "string" }
+        },
+        required: ["run_id"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: TOOL_BOSS_CHAT_RESUME_RUN,
+      description: "继续已暂停的 boss-chat 任务。",
+      inputSchema: {
+        type: "object",
+        properties: {
+          run_id: { type: "string" },
+          profile: { type: "string" }
+        },
+        required: ["run_id"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: TOOL_BOSS_CHAT_CANCEL_RUN,
+      description: "取消运行中的 boss-chat 任务。",
+      inputSchema: {
+        type: "object",
+        properties: {
+          run_id: { type: "string" },
+          profile: { type: "string" }
+        },
+        required: ["run_id"],
+        additionalProperties: false
+      }
+    },
     {
       name: TOOL_LIST_RECOMMEND_JOBS,
-      description: "CDP-only 读取 Boss 推荐页岗位下拉框，返回所有可用岗位完整名称，方便 cron/一次性任务提前填写 job 参数。不会启动筛选任务。",
+      description: "CDP-only 读取 Boss 推荐页岗位下拉框，返回所有可用岗位完整名称，方便 recommend/推荐页 cron/一次性任务提前填写 job 参数。不会启动筛选任务。chat-only、未读、全部聊天、求简历任务严禁调用本工具，必须用 list_boss_chat_jobs 或 prepare_boss_chat_run。",
       inputSchema: createListRecommendJobsInputSchema()
     },
     {
       name: TOOL_RUN_RECOMMEND,
       description: "立即通过原生 MCP 启动 Boss 推荐页筛选。它是 start_recommend_pipeline_run 的短别名；用户已经确认并要现在启动时，优先调用本工具，不需要先调用 prepare_recommend_pipeline_run。必须作为 MCP tool call 调用，禁止通过 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC 代替，也不要用 schedule_recommend_pipeline_run 冒充立即启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_START_RUN,
       description: "立即通过原生 MCP 异步启动 Boss 推荐页流水线（含同步门禁预检）。用户已经确认并要现在启动时，优先调用本工具或 run_recommend，不需要先调用 prepare_recommend_pipeline_run。必须作为 MCP tool call 调用，禁止通过 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC 代替，也不要用 schedule_recommend_pipeline_run 冒充立即启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_PREPARE_RUN,
       description: "只校验 Boss 推荐页流水线参数是否完整；不会启动筛选任务。主要用于显式预检或稍后/cron/定时启动前校验。若用户要现在运行，READY/cron_ready=true 后必须继续调用本 MCP server 的 run_recommend 或 start_recommend_pipeline_run；prepare 能返回结果就证明原生 MCP 可用，禁止改用 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC，也禁止再次调用 prepare 试图启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_SCHEDULE_RUN,
       description: "只用于用户明确要求稍后/cron/定时启动的 package-owned Boss 推荐页定时任务。若用户要现在运行，必须调用 run_recommend 或 start_recommend_pipeline_run，不要用短延迟 schedule 冒充立即启动。schedule 会先校验 READY/cron_ready，再保存完整 payload，并由 detached scheduler 到点直接启动，不依赖 AI harness 自己拼 shell cron。",
-      inputSchema: createScheduleRunInputSchema()
+      inputSchema: scheduleRunInputSchema
     },
     {
       name: TOOL_GET_SCHEDULED_RUN,
@@ -1428,99 +1734,6 @@ function createToolsSchema() {
       description: "手动运维自愈工具：扫描 Boss recommend 相关 selector / network 规则漂移，并在确认后应用高置信度修复。",
       inputSchema: createRunRecommendSelfHealInputSchema()
     },
-    {
-      name: TOOL_BOSS_CHAT_HEALTH_CHECK,
-      description: "CDP-only 检查 Boss chat 页面、自愈 probes、共享 screening-config.json 与 chat runtime 目录是否可用。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          host: {
-            type: "string",
-            description: "可选，Chrome 调试 host；默认 127.0.0.1"
-          },
-          port: {
-            type: "integer",
-            minimum: 1,
-            description: "可选，Chrome 调试端口；默认读取 screening-config.json.debugPort 或 9222"
-          },
-          target_url_includes: {
-            type: "string",
-            description: "可选，Chrome target URL 匹配片段；默认 Boss chat 页"
-          },
-          allow_navigate: {
-            type: "boolean",
-            description: "可选，未在 chat 页时允许通过 Page.navigate 切换；默认 true"
-          },
-          slow_live: {
-            type: "boolean",
-            description: "可选，VPN/慢页面 live 测试模式，放宽等待时间"
-          }
-        },
-        additionalProperties: false
-      }
-    },
-    {
-      name: TOOL_BOSS_CHAT_PREPARE_RUN,
-      description: "预备一次 boss-chat 任务：只导航聊天页并返回岗位列表与待补字段，不会启动任务。用它先获取 job_options。",
-      inputSchema: createBossChatStartInputSchema()
-    },
-    {
-      name: TOOL_BOSS_CHAT_START_RUN,
-      description: "异步启动一次 boss-chat 任务。必须一次性提供 job、start_from、target_count、criteria；若用户选择扫到底/不限/全部候选人，必须字面传 target_count=\"all\"。",
-      inputSchema: createBossChatStartInputSchema({ requireFullInput: true })
-    },
-    {
-      name: TOOL_BOSS_CHAT_GET_RUN,
-      description: "查询 boss-chat run_id 的当前状态。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          run_id: { type: "string" },
-          profile: { type: "string" }
-        },
-        required: ["run_id"],
-        additionalProperties: false
-      }
-    },
-    {
-      name: TOOL_BOSS_CHAT_PAUSE_RUN,
-      description: "暂停运行中的 boss-chat 任务。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          run_id: { type: "string" },
-          profile: { type: "string" }
-        },
-        required: ["run_id"],
-        additionalProperties: false
-      }
-    },
-    {
-      name: TOOL_BOSS_CHAT_RESUME_RUN,
-      description: "继续已暂停的 boss-chat 任务。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          run_id: { type: "string" },
-          profile: { type: "string" }
-        },
-        required: ["run_id"],
-        additionalProperties: false
-      }
-    },
-    {
-      name: TOOL_BOSS_CHAT_CANCEL_RUN,
-      description: "取消运行中的 boss-chat 任务。",
-      inputSchema: {
-        type: "object",
-        properties: {
-          run_id: { type: "string" },
-          profile: { type: "string" }
-        },
-        required: ["run_id"],
-        additionalProperties: false
-      }
-    },
     {
       name: TOOL_RUN_RECRUIT_PIPELINE,
       description: "兼容 Boss recruit 入口：默认 async；sync 模式会等待终态。所有浏览器动作走共享 CDP-only recruit service。",
@@ -1552,6 +1765,7 @@ function createToolsSchema() {
       inputSchema: createRecruitRunIdInputSchema()
     }
   ];
+  return filterToolsForMcpToolset(tools, toolset);
 }
 
 function createToolResultResponse(id, payload, isError = false) {
@@ -2853,10 +3067,19 @@ async function handleRequest(message, workspaceRoot) {
     };
   }
 
-  if (method === "tools/call") {
-    const toolName = params?.name;
-    const args = params?.arguments || {};
-
+  if (method === "tools/call") {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+    const toolset = getConfiguredMcpToolset();
+    const visibleToolNames = new Set(createToolsSchema(toolset).map((tool) => tool.name));
+    if (!visibleToolNames.has(toolName)) {
+      return createJsonRpcError(
+        id,
+        -32602,
+        `Tool ${toolName || ""} is not available in the ${toolset} boss-recommend-mcp toolset. Use the MCP server/toolset that exposes this domain instead of terminal or CLI fallback.`
+      );
+    }
+
     if ([TOOL_RUN_RECOMMEND, TOOL_START_RUN].includes(toolName)) {
       const inputError = validateRunArgs(args);
       if (inputError) {
@@ -2885,7 +3108,7 @@ async function handleRequest(message, workspaceRoot) {
       }
     }
 
-    if ([TOOL_BOSS_CHAT_PREPARE_RUN, TOOL_BOSS_CHAT_START_RUN].includes(toolName)) {
+    if ([TOOL_BOSS_CHAT_LIST_JOBS, TOOL_BOSS_CHAT_PREPARE_RUN, TOOL_BOSS_CHAT_START_RUN].includes(toolName)) {
       const inputError = validateBossChatStartArgs(args);
       if (inputError) {
         return createJsonRpcError(id, -32602, inputError);
@@ -2941,6 +3164,8 @@ async function handleRequest(message, workspaceRoot) {
         payload = await handleRunRecommendSelfHealTool({ workspaceRoot, args });
       } else if (toolName === TOOL_BOSS_CHAT_HEALTH_CHECK) {
         payload = await handleBossChatHealthCheckTool(workspaceRoot, args);
+      } else if (toolName === TOOL_BOSS_CHAT_LIST_JOBS) {
+        payload = await handleBossChatPrepareRunTool({ workspaceRoot, args });
       } else if (toolName === TOOL_BOSS_CHAT_PREPARE_RUN) {
         payload = await handleBossChatPrepareRunTool({ workspaceRoot, args });
       } else if (toolName === TOOL_BOSS_CHAT_START_RUN) {
@@ -3097,6 +3322,9 @@ export function startServer() {
 }
 
 export const __testables = {
+  createToolsSchema,
+  getConfiguredMcpToolset,
+  normalizeMcpToolset,
   handleRequest,
   runDetachedWorkerForTests(options = {}) {
     return runDetachedWorker(options);

package/src/recommend-mcp.js

@@ -75,13 +75,119 @@ let recommendRunService = createRecommendRunService({
 });
 const recommendRunMeta = new Map();
 
-function normalizeText(value) {
-  return String(value || "").replace(/\s+/g, " ").trim();
-}
-
-function parsePositiveInteger(raw, fallback) {
-  const parsed = Number.parseInt(String(raw || ""), 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function collectRecommendRouteText(args = {}) {
+  return normalizeText([
+    args.instruction,
+    args.criteria,
+    args.target_url_includes,
+    args.page_scope,
+    args.confirmation?.page_value,
+    args.confirmation?.job_value,
+    args.overrides?.criteria,
+    args.overrides?.page_scope,
+    args.overrides?.job,
+    args.overrides?.target_url_includes
+  ].filter((value) => value !== undefined && value !== null).join(" "));
+}
+
+function findRouteSignals(text, patterns = []) {
+  const signals = [];
+  for (const { label, pattern } of patterns) {
+    if (pattern.test(text)) signals.push(label);
+  }
+  return signals;
+}
+
+function detectNonRecommendRoute(args = {}) {
+  const text = collectRecommendRouteText(args);
+  if (!text) return null;
+  const chatSignals = findRouteSignals(text, [
+    { label: "chat-only", pattern: /\bchat[-\s]?only\b/i },
+    { label: "boss-chat", pattern: /\bboss[-\s]?chat\b/i },
+    { label: "chat page", pattern: /\bchat\s+page\b/i },
+    { label: "chat/index", pattern: /(?:\/web\/chat\/index|chat\/index)/i },
+    { label: "聊天页", pattern: /聊天页/ },
+    { label: "聊天列表", pattern: /聊天列表/ },
+    { label: "未读", pattern: /未读/ },
+    { label: "全部聊天", pattern: /全部聊天|所有聊天/ },
+    { label: "求简历", pattern: /求简历|索要简历|要简历|在线简历/ }
+  ]);
+  if (chatSignals.length) {
+    return {
+      domain: "chat",
+      signals: chatSignals,
+      text
+    };
+  }
+  const searchSignals = findRouteSignals(text, [
+    { label: "search-only", pattern: /\bsearch[-\s]?only\b/i },
+    { label: "search page", pattern: /\bsearch\s+page\b/i },
+    { label: "recruit pipeline", pattern: /\brecruit\s+pipeline\b/i },
+    { label: "chat/search", pattern: /(?:\/web\/chat\/search|chat\/search)/i },
+    { label: "搜索页", pattern: /搜索页/ },
+    { label: "招聘搜索", pattern: /招聘搜索/ }
+  ]);
+  if (searchSignals.length) {
+    return {
+      domain: "search",
+      signals: searchSignals,
+      text
+    };
+  }
+  return null;
+}
+
+function buildWrongRecommendRouteResponse(route) {
+  if (route?.domain === "chat") {
+    return {
+      status: "FAILED",
+      route_guard: true,
+      error: {
+        code: "WRONG_BOSS_TOOL_FOR_CHAT",
+        message: "This request is explicitly chat-only/chat-page work. Do not use recommend tools. Use boss_chat_health_check, then list_boss_chat_jobs or prepare_boss_chat_run, then start_boss_chat_run.",
+        retryable: false
+      },
+      detected_domain: "chat",
+      detected_signals: route.signals || [],
+      recommended_tool_sequence: [
+        "boss_chat_health_check",
+        "list_boss_chat_jobs",
+        "prepare_boss_chat_run",
+        "start_boss_chat_run"
+      ]
+    };
+  }
+  if (route?.domain === "search") {
+    return {
+      status: "FAILED",
+      route_guard: true,
+      error: {
+        code: "WRONG_BOSS_TOOL_FOR_SEARCH",
+        message: "This request is explicitly search/recruit-page work. Do not use recommend tools. Use run_recruit_pipeline or start_recruit_pipeline_run.",
+        retryable: false
+      },
+      detected_domain: "search",
+      detected_signals: route.signals || [],
+      recommended_tool_sequence: [
+        "run_recruit_pipeline",
+        "start_recruit_pipeline_run"
+      ]
+    };
+  }
+  return null;
+}
+
+function guardRecommendRoute(args = {}) {
+  return buildWrongRecommendRouteResponse(detectNonRecommendRoute(args));
+}
+
+function parsePositiveInteger(raw, fallback) {
+  const parsed = Number.parseInt(String(raw || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
 function parseNonNegativeInteger(raw, fallback) {
@@ -855,9 +961,17 @@ async function readRecommendJobOptionsFromSession(session) {
   };
 }
 
-export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } = {}) {
-  const configResolution = resolveBossScreeningConfig(workspaceRoot);
-  const host = normalizeText(args.host) || DEFAULT_RECOMMEND_HOST;
+export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } = {}) {
+  const routeGuard = guardRecommendRoute(args);
+  if (routeGuard) {
+    return {
+      ...routeGuard,
+      stage: "recommend_job_list",
+      message: "list_recommend_jobs is recommend-page only. For chat-only job lists, call list_boss_chat_jobs or prepare_boss_chat_run."
+    };
+  }
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const host = normalizeText(args.host) || DEFAULT_RECOMMEND_HOST;
   const port = parsePositiveInteger(
     args.port,
     configResolution.ok ? configResolution.config.debugPort : DEFAULT_RECOMMEND_PORT
@@ -1477,8 +1591,10 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
   };
 }
 
-function prepareRecommendPipelineStart(args = {}, { workspaceRoot = "" } = {}) {
-  const parsed = parseRecommendPipelineRequest(args);
+function prepareRecommendPipelineStart(args = {}, { workspaceRoot = "" } = {}) {
+  const routeGuard = guardRecommendRoute(args);
+  if (routeGuard) return { response: routeGuard };
+  const parsed = parseRecommendPipelineRequest(args);
   const gate = evaluateRecommendPipelineGate(parsed, args);
   if (gate) return { response: gate };
   const configResolution = resolveBossScreeningConfig(workspaceRoot);