@reconcrap/boss-recommend-mcp 1.3.8 → 1.3.10

package/README.md

@@ -2,6 +2,11 @@
 
 Boss 推荐页自动化流水线 MCP（stdio）服务。
 
+发布入口：
+
+- npm: `@reconcrap/boss-recommend-mcp`（https://www.npmjs.com/package/@reconcrap/boss-recommend-mcp）
+- GitHub: `reconcrap-cpu/boss-recommend-mcp`（https://github.com/reconcrap-cpu/boss-recommend-mcp）
+
 它把 recommend 页面上的两段能力串起来：
 
 - `boss-recommend-search-cli`: 只负责推荐页筛选项
@@ -79,13 +84,25 @@ MCP 工具：
 
 ## 安装
 
+推荐（npm 全局安装）：
+
 ```bash
-npm install
+npm install -g @reconcrap/boss-recommend-mcp@latest
+boss-recommend-mcp start
+```
+
+无需安装（npx 直接运行）：
+
+```bash
+npx -y @reconcrap/boss-recommend-mcp@latest start
 ```
 
-安装后可以直接运行：
+从 GitHub 源码运行（开发/调试）：
 
 ```bash
+git clone https://github.com/reconcrap-cpu/boss-recommend-mcp.git
+cd boss-recommend-mcp
+npm install
 node src/cli.js start
 ```
 
@@ -101,8 +118,9 @@ BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS  # JSON 数组或系统 path 分隔路径列
 或使用 CLI fallback：
 
 ```bash
-node src/cli.js run --instruction "推荐页筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏"
 npx -y @reconcrap/boss-recommend-mcp@latest run --instruction "推荐页筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏"
+# 源码模式（GitHub clone 后）
+node src/cli.js run --instruction "推荐页筛选985男生，近14天没有，有大模型平台经验，符合标准的收藏"
 ```
 
 ## 配置
@@ -152,6 +170,8 @@ config/screening-config.example.json
 
 ## 常用命令
 
+npm 包安装后可直接使用可执行命令 `boss-recommend-mcp`。以下示例展示源码模式（`node src/cli.js`）：
+
 ```bash
 node src/cli.js install --agent trae-cn
 node src/cli.js init-config
@@ -217,7 +237,7 @@ chat-only 交互建议：
 
 - 先调用一次 `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` 启动任务。
-- `target_count` 支持正整数；若用户给出 `全部候选人` / `所有候选人`，会自动按不限（扫到底）处理。
+- `target_count` 支持正整数、`all`、`-1`；若用户给出 `全部候选人` / `所有候选人`，会自动按不限（扫到底）处理。
 
 Trae-CN / 长对话防循环建议：
 

package/package.json

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

package/skills/boss-chat/README.md

@@ -2,6 +2,9 @@
 
 Bundled chat-page automation skill shipped with `boss-recommend-mcp`.
 
+Package: `@reconcrap/boss-recommend-mcp` (npm)
+Source: `https://github.com/reconcrap-cpu/boss-recommend-mcp`
+
 Use this skill when the user wants a chat-only Boss workflow without installing `boss-chat` separately.
 
 ## Stable Prompt Template (Trae-CN)
@@ -27,9 +30,9 @@ Anti-loop rules:
 
 target_count mapping:
 - Positive integer means explicit cap (for example 20).
-- `all` / `unlimited` / `全部` / `不限` / `扫到底` / `全量` means unlimited.
+- `all` / `-1` / `unlimited` / `全部` / `不限` / `扫到底` / `全量` means unlimited.
 - `全部候选人` / `所有候选人` must also be treated as unlimited.
 - Always write the argument key as `target_count`.
-- For unlimited mode, send `"target_count": "all"` in the tool call.
+- For unlimited mode, prefer `"target_count": "all"` in the tool call; `-1` is accepted for compatibility and used internally by the CLI.
 - 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

@@ -40,7 +40,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 `target_count` 填写规则（关键）：
 
 - 正整数：如 `20`
-- 扫到底：`all` / `unlimited` / `全部` / `不限` / `扫到底` / `全量`
+- 扫到底：`all` / `-1` / `unlimited` / `全部` / `不限` / `扫到底` / `全量`
 - 同义短语也可直接用：`全部候选人` / `所有候选人`（等价于扫到底）
 
 ## Hard Rules
@@ -54,7 +54,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - `target_count` 在 chat-only 启动前也是必填项，不能默认省略。
 - 当用户说“全部候选人/所有候选人”时，必须按“扫到底（unlimited）”处理，不要再追问正整数。
 - 参数名必须写 `target_count`（不要写“目标数量”等中文键名）。
-- 当用户选择“扫到底/全部候选人/所有候选人”时，调用参数统一写：`"target_count": "all"`。
+- 当用户选择“扫到底/全部候选人/所有候选人”时，调用参数优先写：`"target_count": "all"`；`-1` 只作为兼容输入和内部 CLI 表示。
 - 禁止 agent 自行补全 `job/start_from/criteria` 并直接执行，必须由用户明确给出或确认。
 - chat-only 启动流程必须先进入聊天页并拉取岗位列表，再让用户从列表中选择 `job`。
 - 必须先用空参调用 `prepare_boss_chat_run` 获取 `job_options`；不要用 `start_boss_chat_run` 做预备调用。

package/src/boss-chat.js

@@ -12,6 +12,8 @@ const VENDORED_BOSS_CHAT_DIR = path.join(packageRoot, "vendor", "boss-chat-cli")
 const DEFAULT_BOSS_CHAT_POLL_MS = 1500;
 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, "全部候选人"];
+const TARGET_COUNT_WRAPPER_KEYS = ["target_count", "targetCount", "value", "count", "limit"];
 
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
@@ -34,6 +36,7 @@ function isUnlimitedTargetCountToken(value) {
   const token = normalizeText(value).toLowerCase();
   if (!token) return false;
   const compact = token.replace(/\s+/g, "");
+  const withoutAnnotation = compact.replace(/[（(【[].*?[）)】\]]/gu, "");
   const knownTokens = new Set([
     "all",
     "unlimited",
@@ -52,33 +55,81 @@ function isUnlimitedTargetCountToken(value) {
     "所有人选",
     "直到完成所有人选"
   ]);
-  if (knownTokens.has(token) || knownTokens.has(compact)) return true;
+  if (knownTokens.has(token) || knownTokens.has(compact) || knownTokens.has(withoutAnnotation)) return true;
   if (/^(?:all|unlimited|infinity|inf|max|full)(?:candidate|candidates)?$/i.test(compact)) return true;
+  if (/^(?:all|unlimited|infinity|inf|max|full)(?:候选人|人选|牛人|人才|人员)?$/iu.test(withoutAnnotation)) return true;
   if (/^(?:全部|所有|全量|不限)(?:候选人|人选|牛人|人才|人员)?$/u.test(compact)) return true;
+  if (!/\d/.test(compact) && /(?:扫到底|全部候选人|所有候选人|全部人选|所有人选)/u.test(compact)) return true;
   return false;
 }
 
-function parseBossChatTargetCount(value) {
+function getWrappedTargetCountValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  for (const key of TARGET_COUNT_WRAPPER_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(value, key)) {
+      return value[key];
+    }
+  }
+  return value;
+}
+
+export function getBossChatTargetCountValue(input = {}) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return undefined;
+  if (Object.prototype.hasOwnProperty.call(input, "target_count") && input.target_count !== undefined && input.target_count !== null) {
+    return input.target_count;
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "targetCount") && input.targetCount !== undefined && input.targetCount !== null) {
+    return input.targetCount;
+  }
+  if (Object.prototype.hasOwnProperty.call(input, "target_count")) return input.target_count;
+  if (Object.prototype.hasOwnProperty.call(input, "targetCount")) return input.targetCount;
+  return undefined;
+}
+
+function cloneForDiagnostics(value) {
+  if (value === undefined) return undefined;
+  if (value === null || ["string", "number", "boolean"].includes(typeof value)) return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+
+export function normalizeTargetCountInput(value) {
   if (value === undefined || value === null) {
     return {
       provided: false,
       targetCount: null,
-      cliArg: null
+      cliArg: null,
+      publicValue: null,
+      rawValue: value,
+      parseError: null
     };
   }
-  const raw = normalizeText(value);
+  const unwrapped = getWrappedTargetCountValue(value);
+  if (unwrapped !== value) {
+    return normalizeTargetCountInput(unwrapped);
+  }
+  const raw = normalizeText(unwrapped);
   if (!raw) {
     return {
       provided: false,
       targetCount: null,
-      cliArg: null
+      cliArg: null,
+      publicValue: null,
+      rawValue: value,
+      parseError: null
     };
   }
   if (isUnlimitedTargetCountToken(raw)) {
     return {
       provided: true,
       targetCount: null,
-      cliArg: "-1"
+      cliArg: "-1",
+      publicValue: "all",
+      rawValue: cloneForDiagnostics(value),
+      parseError: null
     };
   }
   const parsed = Number.parseInt(String(raw), 10);
@@ -86,20 +137,29 @@ function parseBossChatTargetCount(value) {
     return {
       provided: true,
       targetCount: null,
-      cliArg: "-1"
+      cliArg: "-1",
+      publicValue: "all",
+      rawValue: cloneForDiagnostics(value),
+      parseError: null
     };
   }
   if (Number.isFinite(parsed) && parsed > 0) {
     return {
       provided: true,
       targetCount: parsed,
-      cliArg: String(parsed)
+      cliArg: String(parsed),
+      publicValue: parsed,
+      rawValue: cloneForDiagnostics(value),
+      parseError: null
     };
   }
   return {
     provided: false,
     targetCount: null,
-    cliArg: null
+    cliArg: null,
+    publicValue: null,
+    rawValue: cloneForDiagnostics(value),
+    parseError: "target_count must be a positive integer, -1, or one of: all, unlimited, 全部, 不限, 扫到底, 全量, 全部候选人, 所有候选人"
   };
 }
 
@@ -225,7 +285,7 @@ function normalizeBossChatStartInput(input = {}) {
   const startFromRaw = normalizeText(input.startFrom || input.start_from).toLowerCase();
   const startFrom = startFromRaw === "all" ? "all" : startFromRaw === "unread" ? "unread" : "";
   const criteria = normalizeText(input.criteria);
-  const parsedTarget = parseBossChatTargetCount(input.targetCount ?? input.target_count);
+  const parsedTarget = normalizeTargetCountInput(getBossChatTargetCountValue(input));
   const port = parsePositiveInteger(input.port);
   return {
     profile,
@@ -235,6 +295,9 @@ function normalizeBossChatStartInput(input = {}) {
     targetCount: parsedTarget.targetCount,
     targetCountArg: parsedTarget.cliArg,
     targetCountProvided: parsedTarget.provided,
+    targetCountPublicValue: parsedTarget.publicValue,
+    targetCountRawValue: parsedTarget.rawValue,
+    targetCountParseError: parsedTarget.parseError,
     port,
     dryRun: input.dryRun === true || input.dry_run === true,
     noState: input.noState === true || input.no_state === true,
@@ -270,7 +333,7 @@ function buildTargetCountQuestionHint(item = {}) {
     { label: "全部候选人", value: "全部候选人" },
     { label: "所有候选人", value: "所有候选人" }
   ];
-  next.examples = ["all", 20];
+  next.examples = TARGET_COUNT_ACCEPTED_EXAMPLES.slice();
   next.argument_name = "target_count";
   return next;
 }
@@ -290,13 +353,23 @@ function buildNextCallExample(input = {}, missingFields = []) {
   if (normalized.startFrom) sample.start_from = normalized.startFrom;
   if (normalized.criteria) sample.criteria = normalized.criteria;
   if (normalized.targetCountProvided) {
-    sample.target_count = normalized.targetCountArg === "-1" ? "all" : normalized.targetCount;
+    sample.target_count = normalized.targetCountPublicValue || (normalized.targetCountArg === "-1" ? "all" : normalized.targetCount);
   } else if (missingFields.includes("target_count")) {
     sample.target_count = "all";
   }
   return Object.keys(sample).length > 0 ? sample : null;
 }
 
+function buildTargetCountNeedInputDiagnostics(input = {}, missingFields = []) {
+  if (!Array.isArray(missingFields) || !missingFields.includes("target_count")) return {};
+  const normalized = normalizeBossChatStartInput(input);
+  return {
+    accepted_examples: TARGET_COUNT_ACCEPTED_EXAMPLES.slice(),
+    ...(normalized.targetCountRawValue !== undefined ? { received_target_count: normalized.targetCountRawValue } : {}),
+    ...(normalized.targetCountParseError ? { target_count_parse_error: normalized.targetCountParseError } : {})
+  };
+}
+
 function buildBossChatCliArgs(command, input, resolvedConfig) {
   const args = [command, "--json"];
   if (command === "prepare-run") {
@@ -493,12 +566,14 @@ export async function startBossChatRun({ workspaceRoot, input = {} }) {
       : [];
     const normalizedPendingQuestions = normalizePendingQuestions(pendingQuestions);
     const nextCallExample = buildNextCallExample(input, missingFields);
+    const targetCountDiagnostics = buildTargetCountNeedInputDiagnostics(input, missingFields);
     return {
       ...prepared,
       status: "NEED_INPUT",
       required_fields: CHAT_REQUIRED_FIELDS.slice(),
       missing_fields: missingFields,
       pending_questions: normalizedPendingQuestions,
+      ...targetCountDiagnostics,
       ...(nextCallExample ? { next_call_example: nextCallExample } : {}),
       message: prepared?.message
         || "已获取 Boss 聊天页岗位列表，请先补齐 job / start_from / target_count / criteria。"
@@ -518,11 +593,13 @@ export async function prepareBossChatRun({ workspaceRoot, input = {} }) {
     ))
     : [];
   const nextCallExample = buildNextCallExample(input, missingFields);
+  const targetCountDiagnostics = buildTargetCountNeedInputDiagnostics(input, missingFields);
   return {
     ...payload,
     required_fields: CHAT_REQUIRED_FIELDS.slice(),
     missing_fields: missingFields,
     pending_questions: normalizePendingQuestions(pendingQuestions),
+    ...targetCountDiagnostics,
     ...(nextCallExample ? { next_call_example: nextCallExample } : {})
   };
 }

package/src/index.js

@@ -12,6 +12,8 @@ import {
   cancelBossChatRun,
   getBossChatHealthCheck,
   getBossChatRun,
+  getBossChatTargetCountValue,
+  normalizeTargetCountInput,
   pauseBossChatRun,
   prepareBossChatRun,
   resumeBossChatRun,
@@ -119,6 +121,53 @@ function getLongRunPollAfterSec() {
   return Math.max(60, fromEnv);
 }
 
+function createTargetCountInputSchema(description) {
+  return {
+    oneOf: [
+      {
+        type: "integer",
+        minimum: 1
+      },
+      {
+        type: "integer",
+        enum: [-1]
+      },
+      {
+        type: "string",
+        enum: ["all", "unlimited", "-1", "全部", "不限", "扫到底", "全量", "全部候选人", "所有候选人"]
+      },
+      {
+        type: "object",
+        properties: {
+          value: {
+            oneOf: [
+              { type: "integer", minimum: 1 },
+              { type: "integer", enum: [-1] },
+              { type: "string" }
+            ]
+          },
+          target_count: {
+            oneOf: [
+              { type: "integer", minimum: 1 },
+              { type: "integer", enum: [-1] },
+              { type: "string" }
+            ]
+          },
+          targetCount: {
+            oneOf: [
+              { type: "integer", minimum: 1 },
+              { type: "integer", enum: [-1] },
+              { type: "string" }
+            ]
+          }
+        },
+        additionalProperties: true
+      }
+    ],
+    description
+  };
+}
+
 function getRecommendedPollAfterSec(args = {}) {
   return hasFollowUpChatRequest(args)
     ? getLongRunPollAfterSec()
@@ -387,18 +436,7 @@ function createRunInputSchema() {
                 type: "string",
                 enum: ["unread", "all"]
               },
-              target_count: {
-                oneOf: [
-                  {
-                    type: "integer",
-                    minimum: 1
-                  },
-                  {
-                    type: "string",
-                    enum: ["all", "unlimited", "全部", "不限", "扫到底", "全量", "全部候选人", "所有候选人"]
-                  }
-                ]
-              },
+              target_count: createTargetCountInputSchema("boss-chat follow-up 本次处理人数上限；支持正整数、all 或 -1（扫到底）"),
               dry_run: { type: "boolean" },
               no_state: { type: "boolean" },
               safe_pacing: { type: "boolean" },
@@ -436,19 +474,8 @@ function createBossChatStartInputSchema({ requireFullInput = false } = {}) {
         type: "string",
         description: "boss-chat 的筛选 criteria"
       },
-      target_count: {
-        oneOf: [
-          {
-            type: "integer",
-            minimum: 1
-          },
-          {
-            type: "string",
-            enum: ["all", "unlimited", "全部", "不限", "扫到底", "全量", "全部候选人", "所有候选人"]
-          }
-        ],
-        description: "本次处理人数上限；支持正整数或 all/不限/全部候选人（扫到底）"
-      },
+      target_count: createTargetCountInputSchema("本次处理人数上限；支持正整数、all 或 -1（扫到底），也兼容 { value: \"all\" } 等包装对象"),
+      targetCount: createTargetCountInputSchema("兼容字段；优先使用 target_count。本次处理人数上限，支持正整数、all 或 -1（扫到底）"),
       port: {
         type: "integer",
         minimum: 1,
@@ -462,7 +489,11 @@ function createBossChatStartInputSchema({ requireFullInput = false } = {}) {
     additionalProperties: false
   };
   if (requireFullInput) {
-    schema.required = ["job", "start_from", "target_count", "criteria"];
+    schema.required = ["job", "start_from", "criteria"];
+    schema.anyOf = [
+      { required: ["target_count"] },
+      { required: ["targetCount"] }
+    ];
   }
   return schema;
 }
@@ -727,15 +758,11 @@ function validateBossChatStartArgs(args) {
       return "criteria must be a non-empty string when provided";
     }
   }
-  if (Object.prototype.hasOwnProperty.call(args, "target_count")) {
-    const rawTargetCount = args.target_count;
-    const targetCount = Number.parseInt(String(rawTargetCount), 10);
-    const tokenAllowed =
-      typeof rawTargetCount === "string" && isUnlimitedTargetCountToken(rawTargetCount);
-    const numericUnlimited = Number.isFinite(targetCount) && targetCount === -1;
-    if ((!Number.isFinite(targetCount) || targetCount <= 0) && !tokenAllowed && !numericUnlimited) {
-      return "target_count must be a positive integer or one of: all, unlimited, 全部, 不限, 扫到底, 全量, 全部候选人, 所有候选人";
-    }
+  if (
+    Object.prototype.hasOwnProperty.call(args, "target_count")
+    || Object.prototype.hasOwnProperty.call(args, "targetCount")
+  ) {
+    normalizeTargetCountInput(getBossChatTargetCountValue(args));
   }
   if (Object.prototype.hasOwnProperty.call(args, "port")) {
     const port = Number.parseInt(String(args.port), 10);

package/src/pipeline.js

@@ -16,6 +16,7 @@ import {
 import {
   cancelBossChatRun,
   getBossChatRun,
+  normalizeTargetCountInput,
   pauseBossChatRun,
   resumeBossChatRun,
   startBossChatRun
@@ -66,6 +67,10 @@ function parsePositiveIntegerValue(value) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 
+function normalizePipelineTargetCountValue(value) {
+  return normalizeTargetCountInput(value).publicValue;
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -388,16 +393,17 @@ function normalizeFollowUpChatInput(followUp = null, defaults = null) {
   const defaultCriteria = normalizeText(defaults?.criteria || "");
   const defaultStartFromRaw = normalizeText(defaults?.start_from || "").toLowerCase();
   const defaultStartFrom = defaultStartFromRaw === "all" ? "all" : "unread";
-  const defaultTargetCount = parsePositiveIntegerValue(defaults?.target_count);
+  const defaultTargetCount = normalizePipelineTargetCountValue(defaults?.target_count);
 
   const explicitCriteria = normalizeText(raw.criteria);
   const explicitStartFromRaw = normalizeText(raw.start_from).toLowerCase();
   const explicitStartFrom = explicitStartFromRaw === "all" ? "all" : explicitStartFromRaw === "unread" ? "unread" : "";
-  const explicitTargetCount = parsePositiveIntegerValue(raw.target_count);
+  const explicitTarget = normalizeTargetCountInput(raw.target_count);
+  const explicitTargetCount = explicitTarget.publicValue;
 
   const hasExplicitCriteria = Boolean(explicitCriteria);
   const hasExplicitStartFrom = Boolean(explicitStartFrom);
-  const hasExplicitTargetCount = Number.isInteger(explicitTargetCount) && explicitTargetCount > 0;
+  const hasExplicitTargetCount = explicitTarget.provided;
 
   const criteria = explicitCriteria || defaultCriteria;
   const startFrom = explicitStartFrom || defaultStartFrom;
@@ -442,8 +448,11 @@ function normalizeFollowUpChatInput(followUp = null, defaults = null) {
     missing_fields.push("follow_up.chat.target_count");
     pending_questions.push({
       field: "follow_up.chat.target_count",
-      question: "请填写 boss-chat follow-up 本次处理人数上限（正整数，必填）。",
-      value: summary.target_count
+      question: "请填写 boss-chat follow-up 本次处理人数上限（正整数，或 all/-1 表示扫到底，必填）。",
+      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 } : {})
     });
   }
 
@@ -523,7 +532,7 @@ function buildBossChatFollowUpStatus({ payload, runId, fallbackInput = null, sta
     job: normalizeText(fallbackInput?.job) || null,
     start_from: normalizeText(fallbackInput?.start_from) || null,
     criteria: normalizeText(fallbackInput?.criteria) || null,
-    target_count: parsePositiveIntegerValue(fallbackInput?.target_count),
+    target_count: normalizePipelineTargetCountValue(fallbackInput?.target_count),
     port: parsePositiveIntegerValue(fallbackInput?.port),
     progress: {
       inspected: Number.isInteger(progress.inspected) ? progress.inspected : 0,

package/src/test-boss-chat.js

@@ -273,6 +273,51 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     const stateAfterStartAll = readStubState(workspaceRoot);
     assert.equal(stateAfterStartAll.last_start_args.targetCount, "-1");
 
+    for (const target_count of ["all", -1, "-1", { value: "all" }, "all（扫到底）"]) {
+      const startedVariant = await startBossChatRun({
+        workspaceRoot,
+        input: {
+          profile: "default",
+          job: "算法工程师",
+          start_from: "all",
+          criteria: "全部候选人都过一遍",
+          target_count
+        }
+      });
+      assert.equal(startedVariant.status, "ACCEPTED");
+      assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+    }
+
+    const startedCamelCase = await startBossChatRun({
+      workspaceRoot,
+      input: {
+        profile: "default",
+        job: "算法工程师",
+        start_from: "all",
+        criteria: "全部候选人都过一遍",
+        targetCount: { targetCount: "all" }
+      }
+    });
+    assert.equal(startedCamelCase.status, "ACCEPTED");
+    assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+
+    const invalidTarget = await startBossChatRun({
+      workspaceRoot,
+      input: {
+        profile: "default",
+        job: "算法工程师",
+        start_from: "all",
+        criteria: "全部候选人都过一遍",
+        target_count: "not a target"
+      }
+    });
+    assert.equal(invalidTarget.status, "NEED_INPUT");
+    assert.deepEqual(invalidTarget.missing_fields, ["target_count"]);
+    assert.equal(invalidTarget.received_target_count, "not a target");
+    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);
+
     const running = await getBossChatRun({
       workspaceRoot,
       input: {
@@ -323,7 +368,9 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const prepareToolSchema = tools.find((item) => item.name === TOOL_BOSS_CHAT_PREPARE_RUN).inputSchema;
     const startToolSchema = tools.find((item) => item.name === TOOL_BOSS_CHAT_START_RUN).inputSchema;
     assert.equal(prepareToolSchema.required, undefined);
-    assert.deepEqual(startToolSchema.required, ["job", "start_from", "target_count", "criteria"]);
+    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);
 
     const prepared = await callTool(workspaceRoot, TOOL_BOSS_CHAT_PREPARE_RUN, {}, 101);
     assert.equal(prepared.status, "NEED_INPUT");
@@ -348,6 +395,19 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     assert.equal(missingTargetOnly.status, "NEED_INPUT");
     assert.deepEqual(missingTargetOnly.missing_fields, ["target_count"]);
     assert.equal(missingTargetOnly.next_call_example.target_count, "all");
+    assert.equal(missingTargetOnly.accepted_examples.includes(-1), true);
+
+    const invalidTargetOnly = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
+      job: "算法工程师",
+      start_from: "all",
+      criteria: "全部候选人都过一遍",
+      target_count: "not a target"
+    }, 112);
+    assert.equal(invalidTargetOnly.status, "NEED_INPUT");
+    assert.deepEqual(invalidTargetOnly.missing_fields, ["target_count"]);
+    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");
 
     const invalidStartResponse = await handleRequest(
       makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {
@@ -384,6 +444,15 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const stateAfterStartAll = readStubState(workspaceRoot);
     assert.equal(stateAfterStartAll.last_start_args.targetCount, "-1");
 
+    const startedCamelCase = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
+      job: "算法工程师",
+      start_from: "all",
+      criteria: "全部候选人都过一遍",
+      targetCount: "all"
+    }, 141);
+    assert.equal(startedCamelCase.status, "ACCEPTED");
+    assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+
     const running = await callTool(workspaceRoot, TOOL_BOSS_CHAT_GET_RUN, {
       run_id: started.run_id,
       profile: "default"

package/src/test-pipeline.js

@@ -2224,6 +2224,94 @@ async function testFollowUpChatMissingTargetCountShouldNeedInput() {
   assert.equal(result.pending_questions.some((item) => item.field === "follow_up.chat.target_count"), true);
 }
 
+async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics() {
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: {},
+      overrides: {},
+      followUp: createFollowUpChat({ target_count: "not a target" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed()
+    }
+  );
+
+  assert.equal(result.status, "NEED_INPUT");
+  assert.equal(result.missing_fields.includes("follow_up.chat.target_count"), true);
+  const targetQuestion = result.pending_questions.find((item) => item.field === "follow_up.chat.target_count");
+  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);
+}
+
+async function testFollowUpChatAllTargetCountShouldLaunchUnlimited() {
+  let capturedChatInput = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      followUp: createFollowUpChat({ target_count: "all" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9555 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      readRecommendTabState: async () => ({ ok: true, active_tab_status: "0" }),
+      switchRecommendTab: async () => ({ ok: true, state: "TAB_READY" }),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 8,
+          applied_filters: { degree: ["本科"] },
+          selected_job: DEFAULT_JOB_OPTIONS[0]
+        }
+      }),
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 6,
+          passed_count: 2,
+          skipped_count: 4,
+          output_csv: "C:/temp/recommend.csv",
+          completion_reason: "screen_completed"
+        }
+      }),
+      startBossChatRun: async ({ input }) => {
+        capturedChatInput = input;
+        return {
+          status: "ACCEPTED",
+          run_id: "chat-run-unlimited",
+          message: "chat started"
+        };
+      },
+      getBossChatRun: async () => ({
+        status: "RUN_STATUS",
+        run: {
+          runId: "chat-run-unlimited",
+          state: "completed",
+          lastMessage: "chat completed",
+          progress: {
+            inspected: 3,
+            passed: 1,
+            requested: 1,
+            skipped: 2,
+            errors: 0
+          }
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(capturedChatInput.target_count, "all");
+  assert.equal(result.follow_up?.chat?.target_count, "all");
+}
+
 async function testFinalReviewShouldIncludeFollowUpChatSummary() {
   const result = await runRecommendPipeline(
     {
@@ -2479,8 +2567,10 @@ async function main() {
   await testFollowUpChatMissingFieldsShouldExposeRecommendDefaults();
   await testFollowUpChatMissingStartFromShouldNeedInput();
   await testFollowUpChatMissingTargetCountShouldNeedInput();
+  await testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics();
   await testFinalReviewShouldIncludeFollowUpChatSummary();
   await testCompletedPipelineShouldRunChatFollowUp();
+  await testFollowUpChatAllTargetCountShouldLaunchUnlimited();
   await testCompletedPipelineShouldFailWhenChatLaunchFails();
   await testCompletedPipelineShouldFailWhenChatRunFails();
   console.log("pipeline tests passed");

package/vendor/boss-chat-cli/src/app.js

@@ -57,6 +57,13 @@ function shouldContinue(summary, targetCount) {
   return summary.inspected < targetCount;
 }
 
+function hasResumeRequestSentMessage(state = {}) {
+  const lastText = normalizeText(state?.lastText || '');
+  const recent = Array.isArray(state?.recent) ? state.recent : [];
+  if (lastText.includes('简历请求已发送')) return true;
+  return recent.some((item) => normalizeText(item).includes('简历请求已发送'));
+}
+
 export class BossChatApp {
   constructor({
     page,
@@ -691,19 +698,30 @@ export class BossChatApp {
         await this.interaction.sleepRange(360, 120);
 
         this.logger.log('候选人通过，执行求简历动作。');
-        await this.checkpoint();
-        const messageBefore =
-          typeof this.page.getResumeRequestMessageState === 'function'
-            ? await this.page.getResumeRequestMessageState()
-            : { ok: false, count: 0, lastText: '', recent: [] };
-        const askResult = await this.page.clickAskResume();
-        await this.interaction.sleepRange(460, 150);
-        if (askResult?.alreadyRequested) {
-          baseResult.requested = true;
-          this.logger.log('求简历动作完成：alreadyRequested=true');
-        } else {
+        const maxRequestAttempts = 3;
+        let requestSucceeded = false;
+        let lastAttempt = null;
+
+        for (let requestAttempt = 0; requestAttempt < maxRequestAttempts; requestAttempt += 1) {
           await this.checkpoint();
-          const confirmResult = await this.page.clickConfirmRequestResume();
+          const messageBefore =
+            typeof this.page.getResumeRequestMessageState === 'function'
+              ? await this.page.getResumeRequestMessageState()
+              : { ok: false, count: 0, lastText: '', recent: [] };
+          const askResult = await this.page.clickAskResume();
+          await this.interaction.sleepRange(460, 150);
+
+          let confirmResult = {
+            confirmed: false,
+            requestedVerified: false,
+            assumedRequested: false,
+            uiState: null,
+          };
+          if (!askResult?.alreadyRequested) {
+            await this.checkpoint();
+            confirmResult = await this.page.clickConfirmRequestResume();
+          }
+
           let messageObserved = false;
           let messageAfter = null;
           if (typeof this.page.waitForResumeRequestMessage === 'function') {
@@ -712,29 +730,50 @@ export class BossChatApp {
               timeoutMs: 7000,
               pollMs: 260,
             });
-            messageObserved = Boolean(messageCheck?.observed);
             messageAfter = messageCheck?.state || null;
+            messageObserved = Boolean(messageCheck?.observed) || hasResumeRequestSentMessage(messageAfter || {});
           }
 
-          const requestedVerified =
-            Boolean(confirmResult?.requestedVerified) ||
-            Boolean(messageObserved);
-          baseResult.requested = requestedVerified;
+          const requestedVerified = Boolean(messageObserved);
+          lastAttempt = {
+            attempt: requestAttempt + 1,
+            askResult,
+            confirmResult,
+            messageBefore,
+            messageAfter,
+            messageObserved,
+            requestedVerified,
+          };
+
           if (messageAfter) {
             baseResult.artifacts.resumeRequestMessageBefore = Number(messageBefore?.count || 0);
             baseResult.artifacts.resumeRequestMessageAfter = Number(messageAfter?.count || 0);
             baseResult.artifacts.resumeRequestMessageObserved = messageObserved;
             baseResult.artifacts.resumeRequestMessageLastText = String(messageAfter?.lastText || '');
           }
+
           this.logger.log(
-            `求简历动作完成：confirmed=${Boolean(confirmResult?.confirmed)} | disabledOperateAsk=${Boolean(confirmResult?.uiState?.hasDisabledOperateAsk)} | verified=${requestedVerified} | messageObserved=${messageObserved} | assumed=${Boolean(confirmResult?.assumedRequested)}`,
+            `求简历动作检查：attempt=${requestAttempt + 1}/${maxRequestAttempts} | alreadyRequested=${Boolean(askResult?.alreadyRequested)} | confirmed=${Boolean(confirmResult?.confirmed)} | disabledOperateAsk=${Boolean(confirmResult?.uiState?.hasDisabledOperateAsk)} | messageObserved=${messageObserved} | verified=${requestedVerified} | assumed=${Boolean(confirmResult?.assumedRequested)}`,
           );
-          if (!requestedVerified) {
-            throw new Error(
-              `REQUEST_RESUME_NOT_CONFIRMED(state=${JSON.stringify(confirmResult?.uiState || {})},messageBefore=${Number(messageBefore?.count || 0)},messageAfter=${Number(messageAfter?.count || 0)})`,
-            );
+
+          if (requestedVerified) {
+            requestSucceeded = true;
+            break;
+          }
+
+          if (requestAttempt < maxRequestAttempts - 1) {
+            this.logger.log('未检测到“简历请求已发送”提示，重新发起求简历。');
+            await this.interaction.sleepRange(640, 180);
           }
         }
+
+        baseResult.requested = requestSucceeded;
+        if (!requestSucceeded) {
+          const confirmStateText = JSON.stringify(lastAttempt?.confirmResult?.uiState || {});
+          throw new Error(
+            `REQUEST_RESUME_MESSAGE_NOT_OBSERVED(state=${confirmStateText},messageBefore=${Number(lastAttempt?.messageBefore?.count || 0)},messageAfter=${Number(lastAttempt?.messageAfter?.count || 0)},attempts=${maxRequestAttempts})`,
+          );
+        }
       }
 
       await this.stateStore.record(baseResult.customerKey, baseResult, baseAliases);

package/vendor/boss-chat-cli/src/browser/chat-page.js

@@ -2756,10 +2756,16 @@ export class BossChatPage {
   async waitForResumeRequestMessage({ baselineCount = 0, timeoutMs = 6500, pollMs = 260 } = {}) {
     const start = Date.now();
     let latest = null;
+    const hasSentMessage = (state = {}) => {
+      const lastText = String(state?.lastText || '');
+      const recent = Array.isArray(state?.recent) ? state.recent : [];
+      if (lastText.includes('简历请求已发送')) return true;
+      return recent.some((item) => String(item || '').includes('简历请求已发送'));
+    };
     while (Date.now() - start < timeoutMs) {
       const state = await this.getResumeRequestMessageState();
       latest = state;
-      if (state.count > baselineCount) {
+      if (state.count > baselineCount || hasSentMessage(state)) {
         return {
           observed: true,
           state,