@reconcrap/boss-recruit-mcp 1.0.1 → 1.0.2

package/README.md

@@ -91,7 +91,9 @@ boss-recruit-mcp doctor --port 9222
   "instruction": "自然语言招聘指令",
   "confirmation": {
     "keyword_confirmed": true,
-    "keyword_value": "ai infra"
+    "keyword_value": "ai infra",
+    "search_params_confirmed": true,
+    "use_default_for_missing": false
   },
   "overrides": {
     "target_count": 500
@@ -102,7 +104,9 @@ boss-recruit-mcp doctor --port 9222
 ## 行为说明
 
 - 若缺 `city/degree/schools/keyword/target_count`，返回 `NEED_INPUT`
-- 若 keyword 由语义自动抽取（非显式给出），返回 `NEED_CONFIRMATION`
+- 若 keyword 由语义自动抽取、或搜索参数仍未被用户明确确认，返回 `NEED_CONFIRMATION`
+- 正式执行前应先单独做一轮参数确认，把已识别参数、待确认项、缺失项、默认值风险分开给用户确认
+- 用户未补齐缺失参数时，只有在明确同意默认值及其质量风险后，才允许继续
 - 确认后自动执行：搜索 CLI -> 筛选 CLI
 - 返回摘要：目标数、已处理、通过数、耗时、输出 CSV
 - 执行前会先做本地依赖预检查，若目录 / 入口 / 配置文件缺失则返回 `PIPELINE_PREFLIGHT_FAILED`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recruit-mcp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Unified MCP pipeline for boss-search-cli and boss-screen-cli",
   "keywords": [
     "boss",

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

@@ -20,3 +20,10 @@ npx @reconcrap/boss-recruit-mcp install
 - Boss 页面已登录
 - 已在用户配置中填写有效的 `baseUrl`、`apiKey`、`model`
 - 已生成 `$CODEX_HOME/boss-recruit-mcp/favorite-calibration.json`
+
+## 运行注意事项
+
+- 正式开始前，必须先做一轮参数确认，分开展示已识别参数、待确认参数、缺失参数。
+- 参数确认尽量复用统一模板：`已识别参数` / `待确认或待修正` / `缺失参数` / `默认值提醒` / `请用户回复`。
+- 如果识别结果里出现明显脏值或可疑字段，例如“杭州筛选做过”，必须要求用户改成标准值后再继续。
+- 若缺失参数仍未补齐，只能在用户明确确认接受默认值和质量风险后继续，不能静默按默认执行。

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

@@ -53,7 +53,39 @@
 - Input:
   - `instruction` (string, required)
   - `confirmation` (object, optional)
+    - `keyword_confirmed` (boolean): 是否确认关键词
+    - `keyword_value` (string): 用户确认或改写后的关键词
+    - `search_params_confirmed` (boolean): 用户是否已明确确认当前参数集
+    - `use_default_for_missing` (boolean): 用户是否明确同意对缺失参数使用默认值
   - `overrides` (object, optional)
+    - `city` (string)
+    - `degree` (string)
+    - `schools` (string[] | comma-separated string)
+    - `keyword` (string)
+    - `target_count` (number)
+- Tool response 重点字段：
+  - `status`
+  - `required_confirmations`
+  - `review.extracted_search_params`
+  - `review.current_search_params`
+  - `review.missing_fields`
+  - `review.suspicious_fields`
+  - `review.default_preview`
+  - `review.applied_defaults`
+
+## Confirmation First
+
+- 在任何一次正式搜索 / 筛选开始前，必须先单开一轮“参数确认对话”，不能在首轮解析后直接开跑。
+- 这轮确认对话必须把当前已提取参数、疑似错误参数、缺失参数分开列给用户。
+- 对于明显异常或语义可疑的提取值，不能默认接受，必须让用户二次确认后才能继续。
+- 例如：
+  - 提取出的城市像“杭州筛选做过”这类明显脏值时，必须明确告诉用户“当前识别结果可能不正确”，并请用户改成标准城市名如“杭州”。
+  - 学历、学校标签、关键词、目标人数等若提取结果带噪声、过长、混入条件短语，也都要按“待确认项”处理。
+- 如果用户在这轮确认后仍未补全缺失项，agent 也不能直接静默开始，必须再明确说明：
+  - 哪些参数仍缺失；
+  - 将会使用什么默认值；
+  - 这些默认值会降低搜索结果质量或扩大偏差。
+- 只有在用户明确回复“确认按这些默认值继续”后，才允许正式执行。
 
 ## Execution Policy
 
@@ -68,22 +100,38 @@
    - 然后使用用户的 MCP 配置启动 `boss-recruit-mcp`
 3. 若缺少校准文件：
    - 明确提示用户先完成校准，不要直接调用流水线。
-4. 只有当以上条件满足时，才首次调用 `run_recruit_pipeline`（只传 `instruction`）。
-2. 若返回 `NEED_INPUT`：
-   - 一次性向用户列出 `missing_fields` 所有缺失项；
-   - 缺失项常见含义：
-     - `city`: 城市，如“杭州”
-     - `degree`: 学历，如“本科”“硕士及以上”
-     - `schools`: 学校标签，如“985、211、qs100”
-     - `target_count`: 目标筛选人数，如“10”
-   - 用户补充后再次调用工具。
-3. 若返回 `NEED_CONFIRMATION`：
+4. 只有当以上条件满足时，才首次调用 `run_recruit_pipeline`（只传 `instruction`），用于“解析”，不是立刻执行最终搜索结论。
+5. 拿到首次解析结果后，先进入单独的“参数确认对话”：
+   - 列出当前已提取到的参数；
+   - 单独标出需要用户确认的参数；
+   - 单独列出 `missing_fields` 中所有缺失项；
+   - 如果某个字段看起来明显异常、像脏字符串、或不符合标准筛选值，直接归入“待确认 / 待修正”而不是默认使用。
+6. 缺失项常见含义：
+   - `city`: 城市，如“杭州”
+   - `degree`: 学历，如“本科”“硕士及以上”
+   - `schools`: 学校标签，如“985、211、qs100”
+   - `target_count`: 目标筛选人数，如“10”
+   - `keyword`: 搜索关键词，如“AI infra”“推荐系统”
+7. 若返回 `NEED_INPUT`：
+   - 不要只问一次就结束；
+   - 要把缺失参数集中列出，请用户一次性补充；
+   - 若用户补充后仍有缺失，再次单独列出剩余缺失项；
+   - 若用户始终不补充，必须显式征求“是否接受默认值继续”的确认，不能直接默认执行。
+8. 若返回 `NEED_CONFIRMATION`：
    - 询问用户是否确认 `proposed_keyword`；
+   - 同时也要让用户确认其他已提取参数里是否有误；
    - 若确认，带 `confirmation.keyword_confirmed=true` 和 `keyword_value` 再次调用；
    - 若用户修改关键词，传用户给的新词作为 `keyword_value` 再次调用。
-4. 若返回 `COMPLETED`：
+9. 当仍有缺失参数但用户想直接开始时：
+   - 先明确告知默认值及风险；
+   - 必须得到用户明确确认“可以按默认值继续”后，才能继续执行。
+10. 只有在以下条件都满足后，才允许正式开始：
+   - 用户已经确认已提取参数无误；
+   - 缺失参数已补齐，或用户已明确接受默认值；
+   - `NEED_CONFIRMATION` 分支中的关键词也已确认。
+11. 若返回 `COMPLETED`：
    - 向用户返回摘要：目标数、已处理、通过数、耗时、输出文件路径。
-5. 若返回 `FAILED`：
+12. 若返回 `FAILED`：
    - 先提炼 `error.code`、`error.message`、`diagnostics`；
    - 如果是 `PIPELINE_PREFLIGHT_FAILED`，明确指出缺失的本地目录 / 文件；
    - 如果是 `CALIBRATION_REQUIRED`，明确提醒用户执行校准，并给出校准步骤；
@@ -96,8 +144,62 @@
 - 优先鼓励用户一次性给全这些字段：城市、学历、学校标签、目标人数、核心方向关键词。
 - 当用户提到“做过 AI infra / 推荐系统 / 搜索 / 广告 / 多模态”等经历，但没有显式写“关键词”，默认允许流水线先自动抽取，再走确认分支。
 - 当用户附带筛选要求（如“必须发表过 CCF-A 区论文”“有开源项目”“带过团队”），这些要求应该保留在 `criteria` 中，不应被误当作搜索过滤条件。
+- 若参数提取结果出现明显噪声、截断、短语串接、非标准枚举值，优先视为“识别不可靠”，要求用户确认，不要为了推进流程直接采用。
+- 不要把“用户没有继续回复”解释为“默认同意”；默认值只能在用户明确口头确认后使用。
+- 参数确认对话里，优先采用这种结构：
+  - 已识别参数
+  - 待确认 / 待修正参数
+  - 缺失参数
+- 若继续默认执行会采用的默认值与风险
 - 回答时不要暴露 `screening-config.json` 中的 `apiKey`、`baseUrl` 等敏感值。
 
+## Standard Confirmation Template
+
+- 发起参数确认时，优先复用统一结构，不要每次自由发挥。
+- 首轮确认模板建议按下面顺序输出：
+  - `已识别参数`
+  - `待确认 / 待修正`
+  - `缺失参数`
+  - `默认值提醒（如果适用）`
+  - `请用户回复`
+- `已识别参数` 只放当前看起来可信的值，例如：
+  - 城市：杭州
+  - 学历：本科
+  - 学校标签：985 / 211 / QS100
+  - 关键词：AI infra
+  - 目标人数：10
+- `待确认 / 待修正` 要明确写出“识别值 -> 疑点 -> 需要用户给出的标准值”，例如：
+  - 城市：当前识别为“杭州筛选做过”，这看起来混入了其他短语，请确认是否应为“杭州”
+  - 关键词：当前识别为“AI infra 论文”，看起来混入了附加条件，请确认是否只保留“AI infra”
+- `缺失参数` 要逐项列出，不要笼统说“还差一些信息”，例如：
+  - 缺少城市
+  - 缺少目标人数
+- `默认值提醒` 只在仍有缺失项时出现，且必须同时包含三部分：
+  - 还缺哪些参数
+  - 若继续会使用哪些默认值
+  - 会导致搜索范围变宽、相关性下降或结果偏差增大
+- `请用户回复` 要求用户一次性回复完整，优先使用这种收口方式：
+  - 请直接按“城市 / 学历 / 学校标签 / 关键词 / 目标人数”补充或修正
+  - 如果你接受默认值继续，请明确回复“确认按默认值继续”
+- 若用户补充后仍有缺失，再发第二轮确认时继续复用同一结构，只保留：
+  - 已更新的参数
+  - 仍待确认项
+  - 仍缺失项
+  - 默认值风险
+- 若用户明确表示“不想再补充，直接开始”，也不能跳过模板；要先发一版精简确认：
+  - 当前仍缺失的参数
+  - 将采用的默认值
+  - 风险提示
+  - 明确询问“请确认是否按默认值继续”
+- 不要把下面这类表达当成有效确认：
+  - “先这样吧”
+  - “你看着办”
+  - “差不多”
+  - “随便”
+- 只有当用户明确确认参数无误，且对默认值给出清晰同意后，才设置：
+  - `confirmation.search_params_confirmed=true`
+  - `confirmation.use_default_for_missing=true`（如适用）
+
 ## Failure Handling
 
 - 不要把底层 stderr 原样大段贴给用户，只提炼关键错误和下一步。
@@ -128,4 +230,7 @@
 - 优先结构化、简洁中文输出。
 - 不展示密钥和底层敏感配置。
 - 不跳过 `NEED_CONFIRMATION` 分支。
+- 正式开始前，优先给用户一轮“参数确认卡片式摘要”。
+- 参数确认阶段尽量复用统一模板，减少自由表述带来的漏项。
+- 若要使用默认值，必须写明“请确认是否按默认值继续”，不能模糊带过。
 - 若运行失败，优先给用户“现在卡在哪一步 + 怎么继续”。

package/src/index.js

@@ -36,13 +36,24 @@ function createToolSchema() {
           type: "object",
           properties: {
             keyword_confirmed: { type: "boolean" },
-            keyword_value: { type: "string" }
+            keyword_value: { type: "string" },
+            search_params_confirmed: { type: "boolean" },
+            use_default_for_missing: { type: "boolean" }
           },
           additionalProperties: false
         },
         overrides: {
           type: "object",
           properties: {
+            city: { type: "string" },
+            degree: { type: "string" },
+            schools: {
+              anyOf: [
+                { type: "array", items: { type: "string" } },
+                { type: "string" }
+              ]
+            },
+            keyword: { type: "string" },
             target_count: { type: "integer", minimum: 1 }
           },
           additionalProperties: false

package/src/parser.js

@@ -3,6 +3,23 @@ const SEARCH_SCHOOL_MAP = {
   "211": "211院校",
   "qs100": "QS 100"
 };
+const KNOWN_SCHOOL_LABELS = new Set(Object.values(SEARCH_SCHOOL_MAP));
+const DEFAULT_PARAM_VALUES = {
+  city: null,
+  degree: "不限",
+  schools: [],
+  keyword: "算法工程师",
+  target_count: 10
+};
+const DEFAULT_PARAM_LABELS = {
+  city: "不限城市",
+  degree: "不限",
+  schools: "不限院校标签",
+  keyword: "算法工程师",
+  target_count: 10
+};
+const DEGREE_VALUES = new Set(["不限", "本科", "本科及以上", "硕士及以上", "博士"]);
+const CITY_STOP_PATTERN = /(?:筛选|搜索|查找|找|做过|从事过|有过|相关|的人选|的人|并且|且|学历|学校|目标|必须|优先|，|。|；|;|,)/;
 
 function normalizeText(input) {
   return String(input || "").replace(/\s+/g, " ").trim();
@@ -12,16 +29,47 @@ function uniqueList(items) {
   return Array.from(new Set(items.filter(Boolean)));
 }
 
+function normalizeSchoolLabel(value) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (!raw) return null;
+
+  if (KNOWN_SCHOOL_LABELS.has(raw)) {
+    return raw;
+  }
+
+  const compact = raw.toLowerCase().replace(/\s+/g, "");
+  return SEARCH_SCHOOL_MAP[compact] || SEARCH_SCHOOL_MAP[raw] || raw;
+}
+
+function sanitizeCityCandidate(value) {
+  if (typeof value !== "string") return null;
+  let candidate = value.trim();
+  if (!candidate) return null;
+
+  candidate = candidate.replace(/^(在|是|为)\s*/, "").trim();
+  const stopIndex = candidate.search(CITY_STOP_PATTERN);
+  if (stopIndex >= 0) {
+    candidate = candidate.slice(0, stopIndex).trim();
+  }
+
+  candidate = candidate.replace(/[的\s]+$/g, "").trim();
+  return candidate || null;
+}
+
 function extractCity(text) {
   const explicitPatterns = [
-    /地点(?:在|是|为|:|：)?\s*([^\s，。；;、]+)/i,
-    /城市(?:在|是|为|:|：)?\s*([^\s，。；;、]+)/i
+    /地点(?:在|是|为|:|：)?\s*([^\n，。；;、]+)/i,
+    /城市(?:在|是|为|:|：)?\s*([^\n，。；;、]+)/i,
+    /工作地(?:在|是|为|:|：)?\s*([^\n，。；;、]+)/i,
+    /base(?:在|是|为|:|：)?\s*([^\n，。；;、]+)/i
   ];
 
   for (const pattern of explicitPatterns) {
     const m = text.match(pattern);
     if (m && m[1]) {
-      return m[1].trim();
+      const city = sanitizeCityCandidate(m[1]);
+      if (city) return city;
     }
   }
 
@@ -44,6 +92,24 @@ function extractSchools(text) {
   return uniqueList(schools);
 }
 
+function normalizeStringOverride(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+function normalizeSchoolsOverride(value) {
+  if (Array.isArray(value)) {
+    return uniqueList(value.map(normalizeSchoolLabel));
+  }
+
+  if (typeof value === "string") {
+    return uniqueList(value.split(/[，,]/).map(normalizeSchoolLabel));
+  }
+
+  return null;
+}
+
 function extractKeywordExplicit(text) {
   const patterns = [
     /搜索关键词(?:为|是|:|：)?\s*([^\n，。；;]+)/i,
@@ -145,6 +211,10 @@ function buildScreenCriteria(text, searchParams) {
 }
 
 function resolveKeyword(parsed, confirmation) {
+  if (parsed.keyword_override) {
+    return { keyword: parsed.keyword_override, needsConfirmation: false, proposedKeyword: null };
+  }
+
   const explicit = parsed.keyword_explicit;
   const auto = parsed.keyword_auto;
   const confirmed = confirmation && confirmation.keyword_confirmed === true;
@@ -175,6 +245,97 @@ function resolveKeyword(parsed, confirmation) {
   return { keyword: null, needsConfirmation: false, proposedKeyword: null };
 }
 
+function collectSuspiciousFields(searchParams, screenParams) {
+  const suspicious = [];
+
+  if (searchParams.city && (/\s/.test(searchParams.city) || CITY_STOP_PATTERN.test(searchParams.city) || searchParams.city.length > 8)) {
+    suspicious.push({
+      field: "city",
+      value: searchParams.city,
+      reason: "城市提取结果看起来包含多余短语，请确认是否为标准城市名。"
+    });
+  }
+
+  if (searchParams.degree && !DEGREE_VALUES.has(searchParams.degree)) {
+    suspicious.push({
+      field: "degree",
+      value: searchParams.degree,
+      reason: "学历提取结果不在预期枚举内，请确认。"
+    });
+  }
+
+  if (searchParams.keyword && /城市|学历|学校|目标人数|目标数量|筛选\d+位/i.test(searchParams.keyword)) {
+    suspicious.push({
+      field: "keyword",
+      value: searchParams.keyword,
+      reason: "关键词看起来混入了筛选条件，请确认是否只保留核心方向词。"
+    });
+  }
+
+  if (screenParams.target_count && (!Number.isInteger(screenParams.target_count) || screenParams.target_count <= 0)) {
+    suspicious.push({
+      field: "target_count",
+      value: screenParams.target_count,
+      reason: "目标人数不是有效正整数，请确认。"
+    });
+  }
+
+  return suspicious;
+}
+
+function buildDefaultPreview(missingFields, options = {}) {
+  const { skipKeywordDefault = false } = options;
+  return missingFields.reduce((acc, field) => {
+    if (field === "keyword" && skipKeywordDefault) {
+      return acc;
+    }
+    acc[field] = DEFAULT_PARAM_LABELS[field];
+    return acc;
+  }, {});
+}
+
+function applyDefaults(searchParams, screenParams, missingFields, useDefaultForMissing, options = {}) {
+  const { skipKeywordDefault = false } = options;
+  if (!useDefaultForMissing) {
+    return {
+      searchParams,
+      screenParams,
+      appliedDefaults: {}
+    };
+  }
+
+  const appliedDefaults = {};
+  const nextSearchParams = { ...searchParams };
+  const nextScreenParams = { ...screenParams };
+
+  if (missingFields.includes("city")) {
+    nextSearchParams.city = DEFAULT_PARAM_VALUES.city;
+    appliedDefaults.city = DEFAULT_PARAM_LABELS.city;
+  }
+  if (missingFields.includes("degree")) {
+    nextSearchParams.degree = DEFAULT_PARAM_VALUES.degree;
+    appliedDefaults.degree = DEFAULT_PARAM_LABELS.degree;
+  }
+  if (missingFields.includes("schools")) {
+    nextSearchParams.schools = DEFAULT_PARAM_VALUES.schools.slice();
+    appliedDefaults.schools = DEFAULT_PARAM_LABELS.schools;
+  }
+  if (missingFields.includes("keyword") && !skipKeywordDefault) {
+    nextSearchParams.keyword = DEFAULT_PARAM_VALUES.keyword;
+    appliedDefaults.keyword = DEFAULT_PARAM_LABELS.keyword;
+  }
+  if (missingFields.includes("target_count")) {
+    nextScreenParams.target_count = DEFAULT_PARAM_VALUES.target_count;
+    appliedDefaults.target_count = DEFAULT_PARAM_LABELS.target_count;
+  }
+
+  return {
+    searchParams: nextSearchParams,
+    screenParams: nextScreenParams,
+    appliedDefaults
+  };
+}
+
 export function parseRecruitInstruction({ instruction, confirmation, overrides }) {
   const text = normalizeText(instruction);
   const parsed = {
@@ -186,36 +347,76 @@ export function parseRecruitInstruction({ instruction, confirmation, overrides }
     target_count: extractTargetCount(text)
   };
 
-  if (overrides && Number.isFinite(overrides.target_count) && overrides.target_count > 0) {
-    parsed.target_count = Number.parseInt(String(overrides.target_count), 10);
+  if (overrides) {
+    const overrideCity = sanitizeCityCandidate(normalizeStringOverride(overrides.city));
+    const overrideDegree = normalizeStringOverride(overrides.degree);
+    const overrideSchools = normalizeSchoolsOverride(overrides.schools);
+    const overrideKeyword = normalizeStringOverride(overrides.keyword);
+
+    if (overrideCity) parsed.city = overrideCity;
+    if (overrideDegree) parsed.degree = overrideDegree;
+    if (overrideSchools && overrideSchools.length > 0) parsed.schools = overrideSchools;
+    if (overrideKeyword) parsed.keyword_override = overrideKeyword;
+
+    if (Number.isFinite(overrides.target_count) && overrides.target_count > 0) {
+      parsed.target_count = Number.parseInt(String(overrides.target_count), 10);
+    }
   }
 
   const keywordResolution = resolveKeyword(parsed, confirmation);
-  const searchParams = {
+  const baseSearchParams = {
     city: parsed.city,
     degree: parsed.degree,
     schools: parsed.schools,
     keyword: keywordResolution.keyword
   };
 
-  const screenParams = {
-    criteria: buildScreenCriteria(text, searchParams),
+  const baseScreenParams = {
+    criteria: buildScreenCriteria(text, baseSearchParams),
     target_count: parsed.target_count
   };
 
-  const missing = [];
-  if (!searchParams.city) missing.push("city");
-  if (!searchParams.degree) missing.push("degree");
-  if (!searchParams.schools || searchParams.schools.length === 0) missing.push("schools");
-  if (!searchParams.keyword) missing.push("keyword");
-  if (!screenParams.target_count) missing.push("target_count");
+  const missingBeforeDefaults = [];
+  if (!baseSearchParams.city) missingBeforeDefaults.push("city");
+  if (!baseSearchParams.degree) missingBeforeDefaults.push("degree");
+  if (!baseSearchParams.schools || baseSearchParams.schools.length === 0) missingBeforeDefaults.push("schools");
+  if (!baseSearchParams.keyword) missingBeforeDefaults.push("keyword");
+  if (!baseScreenParams.target_count) missingBeforeDefaults.push("target_count");
+
+  const useDefaultForMissing = confirmation?.use_default_for_missing === true;
+  const skipKeywordDefault = keywordResolution.needsConfirmation;
+  const defaultPreview = buildDefaultPreview(missingBeforeDefaults, { skipKeywordDefault });
+  const { searchParams, screenParams, appliedDefaults } = applyDefaults(
+    baseSearchParams,
+    baseScreenParams,
+    missingBeforeDefaults,
+    useDefaultForMissing,
+    { skipKeywordDefault }
+  );
+  const suspicious_fields = collectSuspiciousFields(searchParams, screenParams);
 
   return {
     parsed,
     searchParams,
     screenParams,
-    missing_fields: missing,
+    missing_fields: missingBeforeDefaults,
+    has_unresolved_missing_fields: missingBeforeDefaults.length > 0 && !useDefaultForMissing,
+    suspicious_fields,
     needs_keyword_confirmation: keywordResolution.needsConfirmation,
-    proposed_keyword: keywordResolution.proposedKeyword
+    needs_search_params_confirmation: confirmation?.search_params_confirmed !== true,
+    proposed_keyword: keywordResolution.proposedKeyword,
+    default_preview: defaultPreview,
+    applied_defaults: appliedDefaults,
+    review: {
+      extracted_search_params: baseSearchParams,
+      extracted_screen_params: baseScreenParams,
+      current_search_params: searchParams,
+      current_screen_params: screenParams,
+      missing_fields: missingBeforeDefaults,
+      has_unresolved_missing_fields: missingBeforeDefaults.length > 0 && !useDefaultForMissing,
+      suspicious_fields,
+      default_preview: defaultPreview,
+      applied_defaults: appliedDefaults
+    }
   };
 }

package/src/pipeline.js

@@ -1,15 +1,34 @@
 import { parseRecruitInstruction } from "./parser.js";
 import { runPipelinePreflight, runSearchCli, runScreenCli } from "./adapters.js";
 
+function buildRequiredConfirmations(parsedResult) {
+  const confirmations = [];
+
+  if (parsedResult.needs_search_params_confirmation) {
+    confirmations.push("search_params");
+  }
+  if (parsedResult.needs_keyword_confirmation) {
+    confirmations.push("keyword");
+  }
+  if (parsedResult.has_unresolved_missing_fields) {
+    confirmations.push("missing_fields_or_defaults");
+  }
+
+  return confirmations;
+}
+
 function buildNeedInputResponse(parsedResult) {
   return {
     status: "NEED_INPUT",
     missing_fields: parsedResult.missing_fields,
+    proposed_keyword: parsedResult.proposed_keyword,
+    required_confirmations: buildRequiredConfirmations(parsedResult),
     search_params: parsedResult.searchParams,
     screen_params: parsedResult.screenParams,
+    review: parsedResult.review,
     error: {
       code: "MISSING_REQUIRED_FIELDS",
-      message: "缺少必要字段，请一次性补充缺失项后再执行。",
+      message: "缺少必要字段。请先补齐缺失项；若要按默认值继续，必须先明确确认默认值及其风险。",
       retryable: true
     }
   };
@@ -19,11 +38,13 @@ function buildNeedConfirmationResponse(parsedResult) {
   return {
     status: "NEED_CONFIRMATION",
     proposed_keyword: parsedResult.proposed_keyword,
+    required_confirmations: buildRequiredConfirmations(parsedResult),
     search_params: {
       ...parsedResult.searchParams,
-      keyword: parsedResult.proposed_keyword
+      keyword: parsedResult.proposed_keyword || parsedResult.searchParams.keyword
     },
-    screen_params: parsedResult.screenParams
+    screen_params: parsedResult.screenParams,
+    review: parsedResult.review
   };
 }
 
@@ -121,12 +142,12 @@ export async function runRecruitPipeline({
     overrides
   });
 
-  if (parsed.needs_keyword_confirmation) {
-    return buildNeedConfirmationResponse(parsed);
+  if (parsed.has_unresolved_missing_fields) {
+    return buildNeedInputResponse(parsed);
   }
 
-  if (parsed.missing_fields.length > 0) {
-    return buildNeedInputResponse(parsed);
+  if (parsed.needs_keyword_confirmation || parsed.needs_search_params_confirmation) {
+    return buildNeedConfirmationResponse(parsed);
   }
 
   const preflight = runPipelinePreflight(workspaceRoot);

package/src/test-parser.js

@@ -9,7 +9,17 @@ function testNeedInput() {
   });
 
   assert.equal(r.needs_keyword_confirmation, true);
+  assert.equal(r.needs_search_params_confirmation, true);
   assert.equal(r.proposed_keyword?.toLowerCase(), "ai infra");
+  assert.deepEqual(
+    r.default_preview,
+    {
+      city: "不限城市",
+      degree: "不限",
+      schools: "不限院校标签",
+      target_count: 10
+    }
+  );
 }
 
 function testExampleExtraction() {
@@ -31,11 +41,16 @@ function testExampleExtraction() {
 
   const confirmed = parseRecruitInstruction({
     instruction,
-    confirmation: { keyword_confirmed: true, keyword_value: "ai infra" },
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "ai infra",
+      search_params_confirmed: true
+    },
     overrides: null
   });
 
   assert.equal(confirmed.needs_keyword_confirmation, false);
+  assert.equal(confirmed.needs_search_params_confirmation, false);
   assert.equal(confirmed.searchParams.keyword, "ai infra");
   assert.equal(confirmed.missing_fields.length, 0);
 }
@@ -54,7 +69,11 @@ function testStructuredInputAndCriteriaCleanup() {
   const r = parseRecruitInstruction({
     instruction:
       "使用boss-recruit-pipeline skills帮我在boss上找做过AI infra的人选，必须发表过CCF-A区论文。城市：杭州，学历：本科，学校：985、211、qs100，目标人数：10人",
-    confirmation: { keyword_confirmed: true, keyword_value: "AI infra" },
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "AI infra",
+      search_params_confirmed: true
+    },
     overrides: null
   });
 
@@ -67,11 +86,50 @@ function testStructuredInputAndCriteriaCleanup() {
   );
 }
 
+function testCitySanitizationAndConfirmationGate() {
+  const r = parseRecruitInstruction({
+    instruction:
+      "在 Boss 直聘按城市杭州筛选做过 AI infra 的人选，学历为本科及以上，来自 985/211/QS100 学校，必须有 CCF-A 区会议论文，目标 10 人，关键词 AI infra。",
+    confirmation: null,
+    overrides: null
+  });
+
+  assert.equal(r.searchParams.city, "杭州");
+  assert.equal(r.needs_search_params_confirmation, true);
+  assert.equal(r.suspicious_fields.length, 0);
+}
+
+function testDefaultsCanOnlyApplyWhenExplicitlyRequested() {
+  const r = parseRecruitInstruction({
+    instruction: "帮我找做过推荐系统的人",
+    confirmation: {
+      keyword_confirmed: true,
+      keyword_value: "推荐系统",
+      use_default_for_missing: true,
+      search_params_confirmed: true
+    },
+    overrides: null
+  });
+
+  assert.equal(r.searchParams.city, null);
+  assert.equal(r.searchParams.degree, "不限");
+  assert.deepEqual(r.searchParams.schools, []);
+  assert.equal(r.screenParams.target_count, 10);
+  assert.deepEqual(r.applied_defaults, {
+    city: "不限城市",
+    degree: "不限",
+    schools: "不限院校标签",
+    target_count: 10
+  });
+}
+
 function main() {
   testNeedInput();
   testExampleExtraction();
   testMissingFieldsBatch();
   testStructuredInputAndCriteriaCleanup();
+  testCitySanitizationAndConfirmationGate();
+  testDefaultsCanOnlyApplyWhenExplicitlyRequested();
   // eslint-disable-next-line no-console
   console.log("parser tests passed");
 }