@reconcrap/boss-recommend-mcp 1.3.20 → 1.3.22

package/README.md

@@ -245,6 +245,7 @@ Trae-CN / 长对话防循环建议：
 
 - 固定流程：`boss_chat_health_check` -> `prepare_boss_chat_run(空参可)` -> 一次性补齐 `job/start_from/target_count/criteria` -> `start_boss_chat_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` 后直接结束当前回合，不要自动轮询。
 - 缺参或校验失败时，一次性列出全部缺失/错误项，避免重复同一句提示触发宿主“陷入循环”保护。
 - 仅当用户明确要求“查进度”时再调用 `get_boss_chat_run`。

package/package.json

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

package/skills/boss-chat/README.md

@@ -34,5 +34,6 @@ target_count mapping:
 - `全部候选人` / `所有候选人` must also be treated as unlimited.
 - Always write the argument key as `target_count`.
 - For unlimited mode, prefer `"target_count": "all"` in the tool call; `-1` is accepted for compatibility and used internally by the CLI.
+- If the tool/UI shows `扫到底（必须传 target_count="all"）`, copy that literal into the next tool call instead of paraphrasing it.
 - If start_boss_chat_run returns NEED_INPUT for `target_count`, the previous tool call omitted the argument. Retry once using `next_call_example` and include `"target_count": "all"` or a positive integer.
 ```

package/skills/boss-chat/SKILL.md

@@ -55,6 +55,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - 当用户说“全部候选人/所有候选人”时，必须按“扫到底（unlimited）”处理，不要再追问正整数。
 - 参数名必须写 `target_count`（不要写“目标数量”等中文键名）。
 - 当用户选择“扫到底/全部候选人/所有候选人”时，调用参数优先写：`"target_count": "all"`；`-1` 只作为兼容输入和内部 CLI 表示。
+- 若工具或提问选项里出现“扫到底（必须传 `target_count=\"all\"`）”之类字样，下一次工具调用时必须直接照抄这个字面量，不要只保留“扫到底”语义。
 - 禁止 agent 自行补全 `job/start_from/criteria` 并直接执行，必须由用户明确给出或确认。
 - chat-only 启动流程必须先进入聊天页并拉取岗位列表，再让用户从列表中选择 `job`。
 - 必须先用空参调用 `prepare_boss_chat_run` 获取 `job_options`；不要用 `start_boss_chat_run` 做预备调用。

package/src/boss-chat.js

@@ -14,7 +14,8 @@ const PREPARE_BOSS_CHAT_MAX_ATTEMPTS = 3;
 const PREPARE_BOSS_CHAT_RETRY_DELAY_MS = 1200;
 const BOSS_CHAT_TERMINAL_STATES = new Set(["completed", "failed", "canceled"]);
 const CHAT_REQUIRED_FIELDS = ["job", "start_from", "target_count", "criteria"];
-export const TARGET_COUNT_ACCEPTED_EXAMPLES = ["all", -1, 20, "全部候选人"];
+export const TARGET_COUNT_CANONICAL_ALL = "all";
+export const TARGET_COUNT_ACCEPTED_EXAMPLES = [TARGET_COUNT_CANONICAL_ALL, -1, 20, "全部候选人"];
 const TARGET_COUNT_WRAPPER_KEYS = ["target_count", "targetCount", "value", "count", "limit"];
 const LLM_THINKING_LEVEL_FIELDS = [
   "llmThinkingLevel",
@@ -128,6 +129,55 @@ function cloneForDiagnostics(value) {
   }
 }
 
+export function buildTargetCountCompatibilityHints({
+  argumentName = "target_count",
+  recommendedArgumentPatch = { target_count: TARGET_COUNT_CANONICAL_ALL },
+  includeOptions = true
+} = {}) {
+  const normalizedArgumentName = normalizeText(argumentName) || "target_count";
+  const clonedRecommendedPatch = cloneForDiagnostics(recommendedArgumentPatch)
+    || { target_count: TARGET_COUNT_CANONICAL_ALL };
+  const literal = `${normalizedArgumentName}="${TARGET_COUNT_CANONICAL_ALL}"`;
+  const base = {
+    argument_name: normalizedArgumentName,
+    answer_format: `${normalizedArgumentName} = 正整数 | "${TARGET_COUNT_CANONICAL_ALL}"`,
+    canonical_unlimited_value: TARGET_COUNT_CANONICAL_ALL,
+    recommended_value: TARGET_COUNT_CANONICAL_ALL,
+    recommended_argument_patch: clonedRecommendedPatch,
+    accepted_examples: TARGET_COUNT_ACCEPTED_EXAMPLES.slice()
+  };
+  if (!includeOptions) return base;
+  return {
+    ...base,
+    options: [
+      {
+        label: `扫到底（必须传 ${literal}，推荐）`,
+        value: TARGET_COUNT_CANONICAL_ALL,
+        canonical_value: TARGET_COUNT_CANONICAL_ALL,
+        argument_patch: cloneForDiagnostics(clonedRecommendedPatch)
+      },
+      {
+        label: `不限（等价于 ${literal}）`,
+        value: "unlimited",
+        canonical_value: TARGET_COUNT_CANONICAL_ALL,
+        argument_patch: cloneForDiagnostics(clonedRecommendedPatch)
+      },
+      {
+        label: `全部候选人（等价于 ${literal}）`,
+        value: "全部候选人",
+        canonical_value: TARGET_COUNT_CANONICAL_ALL,
+        argument_patch: cloneForDiagnostics(clonedRecommendedPatch)
+      },
+      {
+        label: `所有候选人（等价于 ${literal}）`,
+        value: "所有候选人",
+        canonical_value: TARGET_COUNT_CANONICAL_ALL,
+        argument_patch: cloneForDiagnostics(clonedRecommendedPatch)
+      }
+    ]
+  };
+}
+
 export function normalizeTargetCountInput(value) {
   if (value === undefined || value === null) {
     return {
@@ -369,16 +419,16 @@ function getMissingBossChatStartFields(input = {}) {
 
 function buildTargetCountQuestionHint(item = {}) {
   const next = { ...item };
-  next.question = "请输入 target_count：正整数，或 all（扫到底）。";
-  next.options = [
-    { label: "扫到底（推荐）", value: "all" },
-    { label: "不限", value: "unlimited" },
-    { label: "全部候选人", value: "全部候选人" },
-    { label: "所有候选人", value: "所有候选人" }
-  ];
-  next.examples = TARGET_COUNT_ACCEPTED_EXAMPLES.slice();
-  next.argument_name = "target_count";
-  return next;
+  const hints = buildTargetCountCompatibilityHints({
+    argumentName: "target_count",
+    recommendedArgumentPatch: { target_count: TARGET_COUNT_CANONICAL_ALL }
+  });
+  return {
+    ...next,
+    ...hints,
+    question: `请输入 target_count：正整数，或直接填写 "${TARGET_COUNT_CANONICAL_ALL}"（扫到底）。`,
+    examples: TARGET_COUNT_ACCEPTED_EXAMPLES.slice()
+  };
 }
 
 function normalizePendingQuestions(pendingQuestions = []) {
@@ -406,8 +456,13 @@ function buildNextCallExample(input = {}, missingFields = []) {
 function buildTargetCountNeedInputDiagnostics(input = {}, missingFields = []) {
   if (!Array.isArray(missingFields) || !missingFields.includes("target_count")) return {};
   const normalized = normalizeBossChatStartInput(input);
+  const hints = buildTargetCountCompatibilityHints({
+    argumentName: "target_count",
+    recommendedArgumentPatch: { target_count: TARGET_COUNT_CANONICAL_ALL },
+    includeOptions: false
+  });
   return {
-    accepted_examples: TARGET_COUNT_ACCEPTED_EXAMPLES.slice(),
+    ...hints,
     ...(normalized.targetCountRawValue !== undefined ? { received_target_count: normalized.targetCountRawValue } : {}),
     ...(normalized.targetCountParseError ? { target_count_parse_error: normalized.targetCountParseError } : {})
   };

package/src/cli.js

@@ -45,6 +45,10 @@ const recommendMcpBinaryName = "boss-recommend-mcp";
 const autoSyncSkipCommands = new Set(["install", "install-skill", "where", "help", "--help", "-h"]);
 const externalMcpTargetsEnv = "BOSS_RECOMMEND_MCP_CONFIG_TARGETS";
 const externalSkillDirsEnv = "BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS";
+const installConfigDefaults = Object.freeze({
+  llmThinkingLevel: "low",
+  humanRestEnabled: false
+});
 
 function getSkillSourceDir(name = skillName) {
   return path.join(packageRoot, "skills", name);
@@ -655,6 +659,21 @@ function resolveCliConfigTarget(options = {}) {
   };
 }
 
+function applyMissingInstallConfigDefaults(config = {}) {
+  const nextConfig = { ...config };
+  const patchedKeys = [];
+  for (const [key, defaultValue] of Object.entries(installConfigDefaults)) {
+    if (!Object.prototype.hasOwnProperty.call(nextConfig, key)) {
+      nextConfig[key] = defaultValue;
+      patchedKeys.push(key);
+    }
+  }
+  return {
+    nextConfig,
+    patchedKeys
+  };
+}
+
 function ensureUserConfig(options = {}) {
   const { configPath, workspacePreferred } = resolveCliConfigTarget(options);
   const writeTargets = dedupePaths([configPath, workspacePreferred]).filter(Boolean);
@@ -671,7 +690,27 @@ function ensureUserConfig(options = {}) {
       }
       const stat = fs.statSync(targetPath);
       if (stat.isFile()) {
-        return { path: targetPath, created: false };
+        try {
+          const existingConfig = readJsonObjectFile(targetPath);
+          const patched = applyMissingInstallConfigDefaults(existingConfig);
+          if (patched.patchedKeys.length > 0) {
+            fs.writeFileSync(targetPath, JSON.stringify(patched.nextConfig, null, 2), "utf8");
+          }
+          return {
+            path: targetPath,
+            created: false,
+            patched: patched.patchedKeys.length > 0,
+            patched_keys: patched.patchedKeys
+          };
+        } catch (error) {
+          return {
+            path: targetPath,
+            created: false,
+            patched: false,
+            patched_keys: [],
+            patch_error: error?.message || "screening-config.json 解析失败，跳过自动补字段。"
+          };
+        }
       }
       lastError = new Error(`Config target is a directory and cannot be used as file: ${targetPath}`);
     } catch (error) {
@@ -1286,6 +1325,11 @@ function installAll(options = {}) {
       ? `screening-config.json created: ${configResult.path}`
       : `screening-config.json already exists: ${configResult.path}`
   );
+  if (Array.isArray(configResult.patched_keys) && configResult.patched_keys.length > 0) {
+    console.log(`screening-config.json patched missing defaults: ${configResult.patched_keys.join(", ")}`);
+  } else if (configResult.patch_error) {
+    console.warn(`screening-config.json skip default patch: ${configResult.patch_error}`);
+  }
   console.log(`请在该目录修改 baseUrl/apiKey/model 并替换占位词后再运行：${path.dirname(configResult.path)}`);
   console.log(`MCP config templates exported to: ${mcpTemplateResult.outputDir}`);
   for (const item of mcpTemplateResult.files) {
@@ -1482,6 +1526,11 @@ export async function runCli(argv = process.argv) {
     case "init-config": {
       const result = ensureUserConfig(options);
       console.log(result.created ? `Config template created at: ${result.path}` : `Config already exists at: ${result.path}`);
+      if (Array.isArray(result.patched_keys) && result.patched_keys.length > 0) {
+        console.log(`Config patched missing defaults: ${result.patched_keys.join(", ")}`);
+      } else if (result.patch_error) {
+        console.warn(`Config skip default patch: ${result.patch_error}`);
+      }
       break;
     }
     case "set-port": {

package/src/index.js

@@ -164,7 +164,8 @@ function createTargetCountInputSchema(description) {
         additionalProperties: true
       }
     ],
-    description
+    description: `${description} 若用户选择扫到底/不限/全部候选人，优先字面传 "all"。`,
+    examples: ["all", 20, { value: "all" }]
   };
 }
 
@@ -486,7 +487,21 @@ function createBossChatStartInputSchema({ requireFullInput = false } = {}) {
       safe_pacing: { type: "boolean" },
       batch_rest_enabled: { type: "boolean" }
     },
-    additionalProperties: false
+    additionalProperties: false,
+    examples: [
+      {
+        job: "530272634",
+        start_from: "unread",
+        target_count: "all",
+        criteria: "请扫到底筛选符合条件的人选"
+      },
+      {
+        job: "530272634",
+        start_from: "unread",
+        target_count: 20,
+        criteria: "请筛选 20 位符合条件的人选"
+      }
+    ]
   };
   if (requireFullInput) {
     schema.required = ["job", "start_from", "criteria"];
@@ -653,7 +668,7 @@ function createToolsSchema() {
     },
     {
       name: TOOL_BOSS_CHAT_START_RUN,
-      description: "异步启动一次 boss-chat 任务。必须一次性提供 job、start_from、target_count、criteria；扫到底请传 target_count=\"all\"。",
+      description: "异步启动一次 boss-chat 任务。必须一次性提供 job、start_from、target_count、criteria；若用户选择扫到底/不限/全部候选人，必须字面传 target_count=\"all\"。",
       inputSchema: createBossChatStartInputSchema({ requireFullInput: true })
     },
     {

package/src/pipeline.js

@@ -14,6 +14,7 @@ import {
   switchRecommendTab
 } from "./adapters.js";
 import {
+  buildTargetCountCompatibilityHints,
   cancelBossChatRun,
   getBossChatRun,
   normalizeTargetCountInput,
@@ -445,12 +446,22 @@ function normalizeFollowUpChatInput(followUp = null, defaults = null) {
     });
   }
   if (!hasExplicitTargetCount) {
+    const targetCountHints = buildTargetCountCompatibilityHints({
+      argumentName: "follow_up.chat.target_count",
+      recommendedArgumentPatch: {
+        follow_up: {
+          chat: {
+            target_count: "all"
+          }
+        }
+      }
+    });
     missing_fields.push("follow_up.chat.target_count");
     pending_questions.push({
+      ...targetCountHints,
       field: "follow_up.chat.target_count",
-      question: "请填写 boss-chat follow-up 本次处理人数上限（正整数，或 all/-1 表示扫到底，必填）。",
+      question: "请填写 boss-chat follow-up 本次处理人数上限。若扫到底，请在 follow_up.chat.target_count 里字面填写 \"all\"。",
       value: summary.target_count,
-      accepted_examples: ["all", -1, 20, "全部候选人"],
       ...(explicitTarget.rawValue !== undefined ? { received_target_count: explicitTarget.rawValue } : {}),
       ...(explicitTarget.parseError ? { target_count_parse_error: explicitTarget.parseError } : {})
     });

package/src/test-boss-chat.js

@@ -226,6 +226,9 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.deepEqual(prepared.missing_fields, ["job", "start_from", "target_count", "criteria"]);
     const preparedTargetQuestion = prepared.pending_questions.find((item) => item.field === "target_count");
     assert.equal(preparedTargetQuestion.argument_name, "target_count");
+    assert.equal(preparedTargetQuestion.recommended_value, "all");
+    assert.equal(preparedTargetQuestion.recommended_argument_patch.target_count, "all");
+    assert.equal(preparedTargetQuestion.options.some((item) => item.label.includes('target_count="all"')), true);
     assert.equal(prepared.next_call_example.target_count, "all");
 
     const preflight = await startBossChatRun({
@@ -240,6 +243,7 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     const preflightTargetQuestion = preflight.pending_questions.find((item) => item.field === "target_count");
     assert.equal(Boolean(preflightTargetQuestion), true);
     assert.equal(preflightTargetQuestion.argument_name, "target_count");
+    assert.equal(preflightTargetQuestion.recommended_argument_patch.target_count, "all");
     assert.equal(Array.isArray(preflightTargetQuestion.options), true);
 
     const stateAfterPrepare = readStubState(workspaceRoot);
@@ -331,6 +335,7 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.equal(Boolean(invalidTarget.target_count_parse_error), true);
     assert.equal(invalidTarget.next_call_example.target_count, "all");
     assert.equal(invalidTarget.accepted_examples.includes("all"), true);
+    assert.equal(invalidTarget.recommended_argument_patch.target_count, "all");
 
     const running = await getBossChatRun({
       workspaceRoot,
@@ -408,11 +413,15 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     assert.deepEqual(startToolSchema.required, ["job", "start_from", "criteria"]);
     assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("target_count")), true);
     assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("targetCount")), true);
+    assert.equal(startToolSchema.properties.target_count.examples.includes("all"), true);
+    assert.equal(startToolSchema.examples.some((item) => item.target_count === "all"), true);
 
     const prepared = await callTool(workspaceRoot, TOOL_BOSS_CHAT_PREPARE_RUN, {}, 101);
     assert.equal(prepared.status, "NEED_INPUT");
     assert.deepEqual(prepared.missing_fields, ["job", "start_from", "target_count", "criteria"]);
-    assert.equal(prepared.pending_questions.find((item) => item.field === "target_count").argument_name, "target_count");
+    const preparedTargetCountQuestion = prepared.pending_questions.find((item) => item.field === "target_count");
+    assert.equal(preparedTargetCountQuestion.argument_name, "target_count");
+    assert.equal(preparedTargetCountQuestion.recommended_argument_patch.target_count, "all");
 
     const needInput = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {}, 11);
     assert.equal(needInput.status, "NEED_INPUT");
@@ -422,7 +431,9 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const targetQuestion = needInput.pending_questions.find((item) => item.field === "target_count");
     assert.equal(Boolean(targetQuestion), true);
     assert.equal(targetQuestion.argument_name, "target_count");
+    assert.equal(targetQuestion.recommended_argument_patch.target_count, "all");
     assert.equal(targetQuestion.options.some((item) => item.value === "all"), true);
+    assert.equal(targetQuestion.options.some((item) => item.label.includes('target_count="all"')), true);
 
     const missingTargetOnly = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
       job: "算法工程师",
@@ -445,6 +456,7 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     assert.equal(invalidTargetOnly.received_target_count, "not a target");
     assert.equal(Boolean(invalidTargetOnly.target_count_parse_error), true);
     assert.equal(invalidTargetOnly.next_call_example.target_count, "all");
+    assert.equal(invalidTargetOnly.recommended_argument_patch.target_count, "all");
 
     const invalidStartResponse = await handleRequest(
       makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {

package/src/test-pipeline.js

@@ -2184,6 +2184,8 @@ async function testFollowUpChatMissingFieldsShouldExposeRecommendDefaults() {
   assert.equal(criteriaQuestion?.value, "默认沿用 recommend 的筛选条件");
   assert.equal(startFromQuestion?.value, "unread");
   assert.equal(targetCountQuestion?.value, 18);
+  assert.equal(targetCountQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
+  assert.equal(targetCountQuestion?.options?.some((item) => item.label.includes('follow_up.chat.target_count="all"')), true);
 }
 
 async function testFollowUpChatMissingStartFromShouldNeedInput() {
@@ -2221,7 +2223,9 @@ async function testFollowUpChatMissingTargetCountShouldNeedInput() {
 
   assert.equal(result.status, "NEED_INPUT");
   assert.equal(result.missing_fields.includes("follow_up.chat.target_count"), true);
-  assert.equal(result.pending_questions.some((item) => item.field === "follow_up.chat.target_count"), true);
+  const targetQuestion = result.pending_questions.find((item) => item.field === "follow_up.chat.target_count");
+  assert.equal(Boolean(targetQuestion), true);
+  assert.equal(targetQuestion.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
 }
 
 async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics() {
@@ -2244,6 +2248,7 @@ async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics(
   assert.equal(targetQuestion?.received_target_count, "not a target");
   assert.equal(Boolean(targetQuestion?.target_count_parse_error), true);
   assert.equal(targetQuestion?.accepted_examples.includes("all"), true);
+  assert.equal(targetQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
 }
 
 async function testFollowUpChatAllTargetCountShouldLaunchUnlimited() {