@reconcrap/boss-recommend-mcp 1.3.17 → 1.3.19

package/package.json

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

package/vendor/boss-recommend-screen-cli/boss-recommend-screen-cli.cjs

@@ -16,7 +16,7 @@ const CSV_HEADER = [
   "最近工作职位",
   "评估通过详细原因",
   "处理结果",
-  "筛选原因",
+  "判断依据(CoT)",
   "动作执行结果",
   "简历来源",
   "原始判定通过",
@@ -592,6 +592,101 @@ function mergeCandidateProfiles(...profiles) {
   };
 }
 
+function buildCardProfileFallbackText(cardProfile = {}) {
+  const profile = cardProfile && typeof cardProfile === "object" ? cardProfile : {};
+  const educationList = Array.isArray(profile.educationList)
+    ? profile.educationList
+        .map((item) => ({
+          school: normalizeText(item?.school || ""),
+          major: normalizeText(item?.major || ""),
+          degree: normalizeText(item?.degree || ""),
+          start: normalizeText(item?.start || ""),
+          end: normalizeText(item?.end || "")
+        }))
+        .filter((item) => item.school || item.major || item.degree || item.start || item.end)
+        .slice(0, 2)
+    : [];
+  const hasCore = Boolean(
+    normalizeText(profile.name || "")
+    || normalizeText(profile.age || "")
+    || normalizeText(profile.gender || "")
+    || normalizeText(profile.highestDegree || "")
+    || normalizeText(profile.workYears || "")
+    || normalizeText(profile.company || "")
+    || normalizeText(profile.position || "")
+    || normalizeText(profile.latestWorkStart || "")
+    || normalizeText(profile.latestWorkEnd || "")
+    || educationList.length > 0
+  );
+  if (!hasCore) return "";
+
+  const lines = ["=== 人选卡片兜底信息（仅在简历缺失时使用） ==="];
+  const pushField = (label, value) => {
+    const text = normalizeText(value);
+    if (!text) return;
+    lines.push(`${label}: ${text}`);
+  };
+
+  pushField("姓名", profile.name);
+  pushField("年龄", profile.age);
+  pushField("性别", profile.gender);
+  pushField("最高学历", profile.highestDegree);
+  pushField("工作年限", profile.workYears);
+  pushField("最近一份工作公司", profile.company);
+  pushField("最近一份职位", profile.position);
+  const workPeriod = formatResumeTimeRange(profile.latestWorkStart, profile.latestWorkEnd, "至今");
+  if (workPeriod) {
+    lines.push(`最近一份工作在职日期: ${workPeriod}`);
+  }
+  if (educationList.length > 0) {
+    lines.push("最近两段学校经历:");
+    educationList.forEach((item, index) => {
+      const eduPeriod = formatResumeTimeRange(item.start, item.end);
+      const detailParts = [
+        item.school ? `学校=${item.school}` : "",
+        item.major ? `专业=${item.major}` : "",
+        item.degree ? `学历=${item.degree}` : "",
+        eduPeriod ? `时间=${eduPeriod}` : ""
+      ].filter(Boolean);
+      if (detailParts.length > 0) {
+        lines.push(`${index + 1}. ${detailParts.join("；")}`);
+      }
+    });
+  }
+  return lines.join("\n");
+}
+
+function enrichCandidateInfoWithCardProfile(candidateInfo = {}, cardProfile = null) {
+  const info = candidateInfo && typeof candidateInfo === "object" ? candidateInfo : {};
+  const profile = cardProfile && typeof cardProfile === "object" ? cardProfile : null;
+  if (!profile) return { ...info };
+
+  const educationList = Array.isArray(profile.educationList) ? profile.educationList : [];
+  const firstEducation = educationList[0] || {};
+  const merged = {
+    ...info,
+    name: preferReadableName(info?.name || "", profile?.name || ""),
+    school: normalizeText(info?.school || "") || normalizeText(profile?.school || "") || normalizeText(firstEducation?.school || ""),
+    major: normalizeText(info?.major || "") || normalizeText(profile?.major || "") || normalizeText(firstEducation?.major || ""),
+    company: normalizeText(info?.company || "") || normalizeText(profile?.company || ""),
+    position: normalizeText(info?.position || "") || normalizeText(profile?.position || ""),
+    alreadyInterested: info?.alreadyInterested === true
+  };
+
+  const baseResumeText = normalizeText(info?.resumeText || "");
+  const cardFallbackText = buildCardProfileFallbackText(profile);
+  if (cardFallbackText) {
+    merged.resumeText = baseResumeText.includes("=== 人选卡片兜底信息（仅在简历缺失时使用） ===")
+      ? baseResumeText
+      : baseResumeText
+        ? `${baseResumeText}\n\n${cardFallbackText}`
+        : cardFallbackText;
+  } else {
+    merged.resumeText = baseResumeText;
+  }
+  return merged;
+}
+
 function isDomProfileConsistentWithCard(cardProfile, domProfile) {
   if (!cardProfile || !domProfile) return true;
   let compared = 0;
@@ -652,6 +747,101 @@ function formatEducationSchoolTags(edu) {
   return tags.join("、");
 }
 
+function inferDegreeRank(degreeText) {
+  const normalized = normalizeText(degreeText).toLowerCase();
+  if (!normalized) return 0;
+  if (/博士|phd|doctor/.test(normalized)) return 7;
+  if (/硕士|master/.test(normalized)) return 6;
+  if (/本科|学士|bachelor/.test(normalized)) return 5;
+  if (/大专|专科|junior/.test(normalized)) return 4;
+  if (/高中/.test(normalized)) return 3;
+  if (/中专|中技/.test(normalized)) return 2;
+  if (/初中|小学|及以下/.test(normalized)) return 1;
+  return 0;
+}
+
+function normalizeResumeDateToken(value) {
+  const raw = normalizeText(value);
+  if (!raw) return "";
+  const digits = raw.replace(/[^\d]/g, "");
+  if (/^\d{8}$/.test(digits)) {
+    return `${digits.slice(0, 4)}.${digits.slice(4, 6)}`;
+  }
+  if (/^\d{6}$/.test(digits)) {
+    return `${digits.slice(0, 4)}.${digits.slice(4, 6)}`;
+  }
+  if (/^\d{4}$/.test(digits)) {
+    return digits;
+  }
+  return raw;
+}
+
+function formatResumeTimeRange(startRaw, endRaw, fallbackEnd = "") {
+  const start = normalizeResumeDateToken(startRaw);
+  const end = normalizeResumeDateToken(endRaw) || normalizeText(fallbackEnd);
+  if (start && end) return `${start} ~ ${end}`;
+  if (start) return `${start} ~`;
+  if (end) return `~ ${end}`;
+  return "";
+}
+
+function formatResumeTimeRangeFromFields(source, startFields = [], endFields = [], fallbackEnd = "") {
+  const startRaw = startFields
+    .map((field) => source?.[field])
+    .find((value) => normalizeText(value));
+  const endRaw = endFields
+    .map((field) => source?.[field])
+    .find((value) => normalizeText(value));
+  return formatResumeTimeRange(startRaw, endRaw, fallbackEnd);
+}
+
+function formatNamedListText(items = []) {
+  if (!Array.isArray(items) || items.length <= 0) return "";
+  return items
+    .map((item) => normalizeText(item?.name || item?.subjectName || item?.title || item))
+    .filter(Boolean)
+    .join("、");
+}
+
+function extractYearFromResumeDate(value) {
+  const token = normalizeResumeDateToken(value);
+  if (!token) return "";
+  const match = token.match(/(19|20)\d{2}/);
+  return match ? match[0] : "";
+}
+
+function deriveHighestEducation(eduExpList = []) {
+  const list = Array.isArray(eduExpList) ? eduExpList : [];
+  let selected = null;
+  for (const edu of list) {
+    const degree = formatEducationDegree(edu);
+    const rank = inferDegreeRank(degree);
+    const endYear = extractYearFromResumeDate(
+      edu?.endYearMonStr || edu?.endYearStr || edu?.endDateDesc || edu?.endDate || ""
+    );
+    const candidate = {
+      school: normalizeText(edu?.school || edu?.schoolName || ""),
+      degree,
+      rank,
+      endYear
+    };
+    if (!selected) {
+      selected = candidate;
+      continue;
+    }
+    const selectedYear = Number(selected.endYear || 0);
+    const candidateYear = Number(candidate.endYear || 0);
+    if (candidate.rank > selected.rank) {
+      selected = candidate;
+      continue;
+    }
+    if (candidate.rank === selected.rank && candidateYear > selectedYear) {
+      selected = candidate;
+    }
+  }
+  return selected || { school: "", degree: "", rank: 0, endYear: "" };
+}
+
 function splitTextByChunks(text, chunkSize, overlap, maxChunks) {
   const source = String(text || "");
   if (!source) return [];
@@ -714,6 +904,101 @@ function parseBoolean(value) {
   return null;
 }
 
+function parsePassedDecision(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+  }
+  const normalized = normalizeText(value).toLowerCase();
+  if (!normalized) return null;
+  if (/不符合|不通过|未通过|未命中|不匹配|不满足/.test(normalized)) return false;
+  if (/符合|通过|命中|匹配|满足/.test(normalized)) return true;
+  return null;
+}
+
+function parsePassedDecisionFromContent(content) {
+  const raw = String(content || "");
+  const explicit = raw.match(/"passed"\s*:\s*(true|false)/i);
+  if (explicit) {
+    return explicit[1].toLowerCase() === "true";
+  }
+  return parsePassedDecision(raw);
+}
+
+function flattenChatMessageContent(content) {
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === "string") return item;
+        if (item && typeof item === "object") {
+          return item.text || item.content || item.reasoning_content || "";
+        }
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  return String(content || "");
+}
+
+function collectNestedText(value, out = [], depth = 0) {
+  if (depth > 6 || value === null || value === undefined) return out;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    const normalized = normalizeText(String(value));
+    if (normalized) out.push(normalized);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectNestedText(item, out, depth + 1);
+    }
+    return out;
+  }
+  if (typeof value === "object") {
+    const priorityKeys = ["text", "reasoning_content", "summary_text", "summary", "content", "cot", "reason"];
+    const seen = new Set();
+    for (const key of priorityKeys) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        seen.add(key);
+        collectNestedText(value[key], out, depth + 1);
+      }
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (seen.has(key)) continue;
+      collectNestedText(nested, out, depth + 1);
+    }
+  }
+  return out;
+}
+
+function extractCotFromChoice(choice, parsed = {}) {
+  const fragments = [];
+  const candidates = [
+    choice?.message?.reasoning_content,
+    choice?.message?.reasoning,
+    choice?.reasoning_content,
+    choice?.reasoning,
+    parsed?.cot,
+    parsed?.reasoning_content,
+    parsed?.reasoning,
+    parsed?.summary_text,
+    parsed?.summary,
+    parsed?.reason
+  ];
+  for (const candidate of candidates) {
+    collectNestedText(candidate, fragments);
+  }
+  const deduped = [];
+  const seen = new Set();
+  for (const item of fragments) {
+    if (seen.has(item)) continue;
+    seen.add(item);
+    deduped.push(item);
+  }
+  return deduped.join("\n");
+}
+
 function normalizeCliOptionToken(rawToken) {
   const token = String(rawToken || "").trim();
   if (!token) {
@@ -1536,12 +1821,21 @@ function formatResumeApiData(data) {
   const parts = [];
   const geekDetail = data?.geekDetail || data?.geekDetailInfo || data || {};
   const baseInfo = geekDetail.geekBaseInfo || {};
-  const expectList = geekDetail.geekExpectList || [];
+  const expectList = Array.isArray(geekDetail.geekExpectList) && geekDetail.geekExpectList.length > 0
+    ? geekDetail.geekExpectList
+    : Array.isArray(geekDetail.geekExpPosList) && geekDetail.geekExpPosList.length > 0
+      ? geekDetail.geekExpPosList
+      : geekDetail.showExpectPosition
+        ? [geekDetail.showExpectPosition]
+        : [];
   const workExpList = geekDetail.geekWorkExpList || [];
   const projExpList = geekDetail.geekProjExpList || [];
   const eduExpList = geekDetail.geekEduExpList || geekDetail.geekEducationList || [];
   const advantage = geekDetail.geekAdvantage || baseInfo.userDesc || baseInfo.userDescription || "";
   const skillList = geekDetail.geekSkillList || geekDetail.skillList || [];
+  const certificationList = geekDetail.geekCertificationList || [];
+  const workExpCheckRes = Array.isArray(geekDetail.workExpCheckRes) ? geekDetail.workExpCheckRes : [];
+  const highestEdu = deriveHighestEducation(eduExpList);
 
   parts.push("=== 基本信息 ===");
   if (baseInfo.name) parts.push(`姓名: ${baseInfo.name}`);
@@ -1549,6 +1843,9 @@ function formatResumeApiData(data) {
   if (baseInfo.gender !== undefined) parts.push(`性别: ${baseInfo.gender === 1 ? "男" : "女"}`);
   if (baseInfo.degreeCategory) parts.push(`学历: ${baseInfo.degreeCategory}`);
   if (baseInfo.workYearDesc) parts.push(`工作经验: ${baseInfo.workYearDesc}`);
+  if (typeof baseInfo.freshGraduate === "number") parts.push(`应届状态: ${baseInfo.freshGraduate === 1 ? "应届生" : "非应届生"}`);
+  const workDate = normalizeResumeDateToken(baseInfo.workDate8);
+  if (workDate) parts.push(`参加工作时间: ${workDate}`);
   if (baseInfo.activeTimeDesc) parts.push(`活跃状态: ${baseInfo.activeTimeDesc}`);
   if (baseInfo.applyStatusContent) parts.push(`求职状态: ${baseInfo.applyStatusContent}`);
 
@@ -1573,13 +1870,27 @@ function formatResumeApiData(data) {
       const company = exp.company || "";
       const position = stripHtml(exp.positionName || "");
       parts.push(`${index + 1}. ${company} - ${position}`);
-      if (exp.startYearMonStr) {
-        parts.push(`   时间: ${exp.startYearMonStr} ~ ${exp.endYearMonStr || "至今"}`);
+      const workTime = formatResumeTimeRangeFromFields(
+        exp,
+        ["startYearMonStr", "startYearStr", "startDateDesc", "startDate"],
+        ["endYearMonStr", "endYearStr", "endDateDesc", "endDate"],
+        "至今"
+      );
+      if (workTime) {
+        parts.push(`   时间: ${workTime}`);
       }
       const workContent = exp.responsibility || exp.workContent || "";
       if (workContent) {
         parts.push(`   职责: ${stripHtml(workContent)}`);
       }
+      const workPerformance = exp.workPerformance || exp.performance || "";
+      if (workPerformance) {
+        parts.push(`   成果: ${stripHtml(workPerformance)}`);
+      }
+      const workEmphasis = exp.workEmphasis || "";
+      if (workEmphasis) {
+        parts.push(`   补充: ${stripHtml(workEmphasis)}`);
+      }
     });
   }
 
@@ -1588,8 +1899,14 @@ function formatResumeApiData(data) {
     projExpList.forEach((proj, index) => {
       parts.push(`${index + 1}. ${proj.name || proj.projectName || "未知项目"}`);
       if (proj.roleName) parts.push(`   角色: ${proj.roleName}`);
-      if (proj.startYearMonStr) {
-        parts.push(`   时间: ${proj.startYearMonStr} ~ ${proj.endYearMonStr || "至今"}`);
+      const projTime = formatResumeTimeRangeFromFields(
+        proj,
+        ["startYearMonStr", "startYearStr", "startDateDesc", "startDate"],
+        ["endYearMonStr", "endYearStr", "endDateDesc", "endDate"],
+        "至今"
+      );
+      if (projTime) {
+        parts.push(`   时间: ${projTime}`);
       }
       const projectDescription = proj.description || proj.projectDescription || "";
       if (projectDescription) parts.push(`   描述: ${stripHtml(projectDescription)}`);
@@ -1605,15 +1922,35 @@ function formatResumeApiData(data) {
       if (edu.major || edu.majorName) parts.push(`   专业: ${edu.major || edu.majorName}`);
       const eduDegree = formatEducationDegree(edu);
       if (eduDegree) parts.push(`   学历: ${eduDegree}`);
-      const eduStart = edu.startYearMonStr || edu.startYearStr;
-      if (eduStart) {
-        const eduEnd = edu.endYearMonStr || edu.endYearStr || "";
-        parts.push(`   时间: ${eduStart} ~ ${eduEnd}`);
+      const eduTime = formatResumeTimeRangeFromFields(
+        edu,
+        ["startYearMonStr", "startYearStr", "startDateDesc", "startDate"],
+        ["endYearMonStr", "endYearStr", "endDateDesc", "endDate"]
+      );
+      if (eduTime) {
+        parts.push(`   时间: ${eduTime}`);
       }
       const schoolTags = formatEducationSchoolTags(edu);
       if (schoolTags) {
         parts.push(`   学校标签: ${schoolTags}`);
       }
+      const eduDescription = stripHtml(edu.eduDescription || edu.description || "");
+      if (eduDescription) {
+        parts.push(`   描述: ${eduDescription}`);
+      }
+      const courseDesc = stripHtml(edu.courseDesc || "");
+      if (courseDesc) {
+        parts.push(`   课程/研究: ${courseDesc}`);
+      }
+      const keySubjects = formatNamedListText(edu.keySubjectList || []);
+      if (keySubjects) {
+        parts.push(`   核心课程: ${keySubjects}`);
+      }
+      const thesisTitle = normalizeText(edu.thesisTitle || "");
+      const thesisDesc = stripHtml(edu.thesisDesc || "");
+      if (thesisTitle || thesisDesc) {
+        parts.push(`   论文: ${thesisTitle}${thesisDesc ? ` - ${thesisDesc}` : ""}`);
+      }
     });
   }
 
@@ -1626,6 +1963,33 @@ function formatResumeApiData(data) {
     });
   }
 
+  if (certificationList.length > 0) {
+    parts.push("\n=== 资格证书 ===");
+    certificationList.forEach((cert) => {
+      const certName = normalizeText(cert?.certName || cert?.name || "");
+      if (certName) parts.push(`- ${certName}`);
+    });
+  }
+
+  parts.push("\n=== 结构化判定线索 ===");
+  if (highestEdu.degree) parts.push(`最高学历: ${highestEdu.degree}`);
+  if (highestEdu.school) parts.push(`最高学历学校: ${highestEdu.school}`);
+  if (highestEdu.endYear) parts.push(`最高学历毕业年份: ${highestEdu.endYear}`);
+  parts.push(`是否有工作经历: ${workExpList.length > 0 ? "是" : "否"}`);
+  parts.push(`是否有项目经历: ${projExpList.length > 0 ? "是" : "否"}`);
+  parts.push("相关经验硬判口径: 仅工作经历/项目经历可作为“相关经验”硬性证据；教育/课程/技能仅作补充。");
+  if (workExpCheckRes.length > 0) {
+    const riskText = workExpCheckRes
+      .map((item) => normalizeText(item?.desc || item?.firstTip || item?.chatDesc || ""))
+      .filter(Boolean)
+      .slice(0, 3)
+      .join("；");
+    if (riskText) {
+      parts.push(`软风险提示(需追问，不直接淘汰): ${riskText}`);
+    }
+  }
+  parts.push("判定忽略项: 活跃度/沟通热度/受欢迎度等运营指标不参与通过判定。");
+
   return parts.join("\n");
 }
 
@@ -1634,11 +1998,19 @@ function extractJsonObject(text) {
   const start = raw.indexOf("{");
   const end = raw.lastIndexOf("}");
   if (start === -1 || end === -1 || end <= start) {
-    throw new Error("Vision model response did not contain JSON");
+    throw new Error("Model response did not contain JSON");
   }
   return JSON.parse(raw.slice(start, end + 1));
 }
 
+function tryExtractJsonObject(text) {
+  try {
+    return extractJsonObject(text);
+  } catch {
+    return {};
+  }
+}
+
 async function promptPostAction() {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error("POST_ACTION_CONFIRMATION_REQUIRED");
@@ -4301,6 +4673,18 @@ class RecommendScreenCli {
           }
           return "";
         };
+        const rankDegree = (value) => {
+          const text = normalize(value).toLowerCase();
+          if (!text) return 0;
+          if (/博士|phd|doctor/.test(text)) return 7;
+          if (/硕士|master/.test(text)) return 6;
+          if (/本科|学士|bachelor/.test(text)) return 5;
+          if (/大专|专科/.test(text)) return 4;
+          if (/高中/.test(text)) return 3;
+          if (/中专|中技/.test(text)) return 2;
+          if (/初中|小学/.test(text)) return 1;
+          return 0;
+        };
         const recommendInner = Array.from(doc.querySelectorAll(".card-inner[data-geekid]"))
           .find((item) => (item.getAttribute("data-geekid") || "") === String(candidateKey)) || null;
         const latestInner = recommendInner
@@ -4326,13 +4710,84 @@ class RecommendScreenCli {
         const workSpans = latestWork
           ? Array.from(latestWork.querySelectorAll(".join-text-wrap.content span")).map((item) => textOf(item)).filter(Boolean)
           : [];
+        const workTimeSpans = latestWork
+          ? Array.from(latestWork.querySelectorAll(".join-text-wrap.time span")).map((item) => textOf(item)).filter(Boolean)
+          : [];
+        const eduItems = Array.from(card.querySelectorAll(".timeline-wrap.edu-exps .timeline-item"))
+          .map((item) => {
+            const timeSpans = Array.from(item.querySelectorAll(".join-text-wrap.time span")).map((node) => textOf(node)).filter(Boolean);
+            const contentSpans = Array.from(item.querySelectorAll(".join-text-wrap.content span")).map((node) => textOf(node)).filter(Boolean);
+            return {
+              school: contentSpans[0] || "",
+              major: contentSpans[1] || "",
+              degree: contentSpans[2] || "",
+              start: timeSpans[0] || "",
+              end: timeSpans[1] || ""
+            };
+          })
+          .filter((item) => item.school || item.major || item.degree || item.start || item.end)
+          .slice(0, 2);
+        if (eduItems.length === 0 && (eduSpans[0] || eduSpans[1] || eduSpans[2])) {
+          eduItems.push({
+            school: eduSpans[0] || "",
+            major: eduSpans[1] || "",
+            degree: eduSpans[2] || "",
+            start: "",
+            end: ""
+          });
+        }
+        const baseInfoTokens = Array.from(card.querySelectorAll(".join-text-wrap.base-info span, .base-info span"))
+          .map((item) => textOf(item))
+          .filter(Boolean);
+        let age = "";
+        let workYears = "";
+        let highestDegree = "";
+        for (const token of baseInfoTokens) {
+          if (!age && /\d+\s*岁/u.test(token)) {
+            age = token;
+            continue;
+          }
+          if (!workYears && /(\d+\s*年|应届|在校)/u.test(token) && !/\d+\s*岁/u.test(token)) {
+            workYears = token;
+            continue;
+          }
+          if (!highestDegree && /(博士|硕士|本科|大专|专科|高中|中专|中技|初中)/u.test(token)) {
+            highestDegree = token;
+          }
+        }
+        const genderUse = card.querySelector("svg.gender use, .gender use, svg[class*='gender'] use");
+        const genderHref = String(
+          (genderUse && (genderUse.getAttribute("xlink:href") || genderUse.getAttribute("href") || ""))
+          || ""
+        ).toLowerCase();
+        let gender = "";
+        if (/(man|male|boy|icon-man|男)/.test(genderHref)) {
+          gender = "男";
+        } else if (/(woman|female|girl|icon-woman|女)/.test(genderHref)) {
+          gender = "女";
+        }
+        if (!highestDegree) {
+          const degreeFromEdu = eduItems
+            .slice()
+            .sort((a, b) => rankDegree(b.degree) - rankDegree(a.degree))[0];
+          if (degreeFromEdu?.degree) {
+            highestDegree = degreeFromEdu.degree;
+          }
+        }
         return {
           ok: true,
           name: pick(card, [".geek-name-wrap .name", ".name-wrap .name", "span.name", ".name"]),
           school: eduSpans[0] || pick(card, [".edu-wrap .school-name", ".base-info .school-name", ".school-name"]),
           major: eduSpans[1] || pick(card, [".edu-wrap .major", ".major"]),
           company: workSpans[0] || pick(card, [".company-name-wrap .name", ".company-name"]),
-          position: workSpans[1] || pick(card, [".position span", ".position"])
+          position: workSpans[1] || pick(card, [".position span", ".position"]),
+          age,
+          gender,
+          highest_degree: highestDegree,
+          work_years: workYears,
+          latest_work_start: workTimeSpans[0] || "",
+          latest_work_end: workTimeSpans[1] || "",
+          education_list: eduItems
         };
       })(${JSON.stringify(candidateKey)})`);
     } catch {
@@ -4346,7 +4801,25 @@ class RecommendScreenCli {
       school: normalizeText(profile?.school || ""),
       major: normalizeText(profile?.major || ""),
       company: normalizeText(profile?.company || ""),
-      position: normalizeText(profile?.position || "")
+      position: normalizeText(profile?.position || ""),
+      age: normalizeText(profile?.age || ""),
+      gender: normalizeText(profile?.gender || ""),
+      highestDegree: normalizeText(profile?.highest_degree || ""),
+      workYears: normalizeText(profile?.work_years || ""),
+      latestWorkStart: normalizeText(profile?.latest_work_start || ""),
+      latestWorkEnd: normalizeText(profile?.latest_work_end || ""),
+      educationList: Array.isArray(profile?.education_list)
+        ? profile.education_list
+            .map((item) => ({
+              school: normalizeText(item?.school || ""),
+              major: normalizeText(item?.major || ""),
+              degree: normalizeText(item?.degree || ""),
+              start: normalizeText(item?.start || ""),
+              end: normalizeText(item?.end || "")
+            }))
+            .filter((item) => item.school || item.major || item.degree || item.start || item.end)
+            .slice(0, 2)
+        : []
     };
   }
 
@@ -4479,22 +4952,32 @@ class RecommendScreenCli {
   applyVisionEvidenceGate(result) {
     const parsed = result && typeof result === "object" ? result : {};
     const rawPassed = parsed?.rawPassed === true || parsed?.passed === true;
-    const parsedEvidence = toStringArray(parsed?.evidence);
-    const evidenceRawCount = Number.isFinite(Number(parsed?.evidenceRawCount))
-      ? Number(parsed.evidenceRawCount)
-      : parsedEvidence.length;
-    const evidenceMatchedCount = Number.isFinite(Number(parsed?.evidenceMatchedCount))
-      ? Number(parsed.evidenceMatchedCount)
-      : parsedEvidence.length;
-    const evidenceGateDemoted = parsed?.evidenceGateDemoted === true || (rawPassed && evidenceMatchedCount <= 0);
-    const reason = normalizeText(parsed?.reason || "");
-    const summary = normalizeText(parsed?.summary || reason);
+    const evidenceGateEligible = parsed?.evidenceGateEligible === true
+      || Array.isArray(parsed?.evidence)
+      || Number.isFinite(Number(parsed?.evidenceRawCount))
+      || Number.isFinite(Number(parsed?.evidenceMatchedCount));
+    const parsedEvidence = evidenceGateEligible ? toStringArray(parsed?.evidence) : [];
+    const evidenceRawCount = evidenceGateEligible
+      ? (Number.isFinite(Number(parsed?.evidenceRawCount))
+        ? Number(parsed.evidenceRawCount)
+        : parsedEvidence.length)
+      : null;
+    const evidenceMatchedCount = evidenceGateEligible
+      ? (Number.isFinite(Number(parsed?.evidenceMatchedCount))
+        ? Number(parsed.evidenceMatchedCount)
+        : parsedEvidence.length)
+      : null;
+    const evidenceGateDemoted = parsed?.evidenceGateDemoted === true
+      || (evidenceGateEligible && rawPassed && evidenceMatchedCount <= 0);
+    const cot = normalizeText(parsed?.cot || parsed?.reason || "");
+    const summary = normalizeText(parsed?.summary || cot);
     const finalReason = evidenceGateDemoted
-      ? `模型未给出可在简历截图中引用的证据，按安全策略判为不通过。${reason ? ` 原始原因: ${reason}` : ""}`
-      : (reason || (rawPassed ? "满足筛选标准。" : "未满足筛选标准。"));
+      ? `模型未给出可在简历截图中引用的证据，按安全策略判为不通过。${cot ? ` 原始判断依据(CoT): ${cot}` : ""}`
+      : (cot || (rawPassed ? "模型判定符合筛选标准。" : "模型判定不符合筛选标准。"));
     return {
       passed: evidenceGateDemoted ? false : rawPassed,
       rawPassed,
+      cot: finalReason,
       reason: finalReason,
       summary: summary || finalReason,
       evidence: parsedEvidence,
@@ -4698,13 +5181,17 @@ class RecommendScreenCli {
           `筛选标准:\n${this.args.criteria}\n\n` +
           "你将收到候选人完整简历的一个或多个顺序分段图片。必须完整阅读全部分段后再判断，" +
           "不能只根据前几段下结论；后续分段中的教育、项目、经历或否定信息必须纳入最终判断。" +
-          "严禁编造任何不存在的经历、项目、学校、公司或时间线；证据不足时必须判定为不通过。\n\n" +
+          "严禁编造任何不存在的经历、项目、学校、公司或时间线；证据不足时必须判定为不通过。\n" +
+          "当筛选条件涉及应届/毕业年份时，必须以最高学历毕业年份作为主依据；若简历中出现教育起止时间、毕业时间或可推断年份信息，必须先推断再判断，" +
+          "只有完全不存在可推断时间信息时才可以写“无法判断”。\n" +
+          "当筛选条件提及“相关经验”时，必须以工作经历或项目经历作为硬性证据；教育/课程/论文/技能/个人优势只能作为补充，不能单独判定满足。\n" +
+          "workExpCheckRes 等经历校验项仅作为“需追问”软风险，不得直接据此判定不通过。\n" +
+          "活跃度、沟通热度、受欢迎度等运营指标不参与筛选通过判定。\n\n" +
           "要求：\n" +
-          "1) reason 必须写出可审计的判定依据，至少包含 2 条与筛选标准直接相关的事实。\n" +
-          "2) 禁止只写“候选人同时满足全部筛选条件/不满足筛选条件”等泛化句。\n" +
-          "3) evidence 至少给出 2 条可在简历中定位的原文短句。\n\n" +
+          "1) 只做结论判断：候选人是否符合筛选标准。\n" +
+          "2) 只返回 passed 布尔值，不要在 JSON 中输出 reason/summary/evidence 等字段。\n\n" +
           "请返回严格 JSON: " +
-          "{\"passed\": true/false, \"reason\": \"...\", \"summary\": \"...\", \"evidence\": [\"证据原文1\", \"证据原文2\"]}"
+          "{\"passed\": true/false}"
       }
     ];
     for (let index = 0; index < imagePaths.length; index += 1) {
@@ -4764,28 +5251,47 @@ class RecommendScreenCli {
       throw this.buildError("VISION_MODEL_FAILED", `Vision model request failed: ${response.status} ${body.slice(0, 400)}`);
     }
     const json = await response.json();
-    const content = Array.isArray(json?.choices?.[0]?.message?.content)
-      ? json.choices[0].message.content.map((item) => item?.text || "").join("\n")
-      : json?.choices?.[0]?.message?.content || "";
-    const parsed = extractJsonObject(content);
-    const rawPassed = parsed.passed === true;
-    const reason = normalizeText(parsed.reason);
-    const summary = normalizeText(parsed.summary || reason);
-    const evidence = toStringArray(parsed.evidence);
-    const evidenceGateDemoted = rawPassed && evidence.length <= 0;
+    const choice = json?.choices?.[0] || {};
+    const content = flattenChatMessageContent(choice?.message?.content);
+    const parsed = tryExtractJsonObject(content);
+    const parsedPassed = parsePassedDecision(parsed?.passed);
+    const fallbackPassed = parsePassedDecisionFromContent(content);
+    const rawPassed = parsedPassed !== null ? parsedPassed : fallbackPassed;
+    if (rawPassed === null) {
+      throw this.buildError(
+        "VISION_MODEL_FAILED",
+        `Vision model response missing boolean passed decision. content=${truncateText(content, 180)}`
+      );
+    }
+    const cot = normalizeText(extractCotFromChoice(choice, parsed));
+    const reason = cot || (rawPassed ? "模型判定符合筛选标准。" : "模型判定不符合筛选标准。");
+    const summary = reason;
+    const evidenceGateEligible = Array.isArray(parsed?.evidence)
+      || Number.isFinite(Number(parsed?.evidenceRawCount))
+      || Number.isFinite(Number(parsed?.evidenceMatchedCount));
+    const parsedEvidence = evidenceGateEligible ? toStringArray(parsed?.evidence) : [];
+    const evidenceRawCount = evidenceGateEligible
+      ? (Number.isFinite(Number(parsed?.evidenceRawCount)) ? Number(parsed.evidenceRawCount) : parsedEvidence.length)
+      : null;
+    const evidenceMatchedCount = evidenceGateEligible
+      ? (Number.isFinite(Number(parsed?.evidenceMatchedCount)) ? Number(parsed.evidenceMatchedCount) : parsedEvidence.length)
+      : null;
+    const evidenceGateDemoted = evidenceGateEligible && rawPassed && (evidenceMatchedCount ?? 0) <= 0;
     const finalReason = evidenceGateDemoted
-      ? `模型未给出可在简历截图中引用的证据，按安全策略判为不通过。${reason ? ` 原始原因: ${reason}` : ""}`
-      : (reason || (rawPassed ? "满足筛选标准。" : "未满足筛选标准。"));
+      ? `模型未给出可在简历截图中引用的证据，按安全策略判为不通过。${reason ? ` 原始判断依据(CoT): ${reason}` : ""}`
+      : reason;
     const passed = evidenceGateDemoted ? false : rawPassed;
-    const enrichedReason = enrichReasonWithEvidence(finalReason, summary || finalReason, evidence, passed);
+    const enrichedReason = enrichReasonWithEvidence(finalReason, summary || finalReason, parsedEvidence, passed);
     return {
       passed,
       rawPassed,
+      cot: reason,
       reason: enrichedReason,
       summary: summary || enrichedReason,
-      evidence,
-      evidenceRawCount: evidence.length,
-      evidenceMatchedCount: evidence.length,
+      evidence: parsedEvidence,
+      evidenceRawCount,
+      evidenceMatchedCount,
+      evidenceGateEligible,
       evidenceGateDemoted
     };
   }
@@ -4885,12 +5391,17 @@ class RecommendScreenCli {
             "要求：\n" +
             "1) 必须完整阅读上面的全部简历文本。\n" +
             "2) 只能依据简历中真实出现的信息判断，严禁编造不存在的经历/项目/学历/公司。\n" +
-            "3) 若证据不足，必须返回 passed=false。\n\n" +
-            "4) reason 必须写出可审计依据，至少包含 2 条与筛选标准直接相关的事实。\n" +
-            "5) 禁止只写“候选人同时满足全部筛选条件/不满足筛选条件”等泛化句。\n" +
-            "6) evidence 至少给出 2 条可在简历原文定位的证据短句。\n\n" +
+            "3) 若文本中包含“人选卡片兜底信息（仅在简历缺失时使用）”段落，只能在主简历缺失对应字段时引用该段，不可覆盖主简历已明确字段。\n" +
+            "4) 若证据不足，必须返回 passed=false。\n\n" +
+            "5) 当筛选条件涉及应届/毕业年份时，必须以最高学历毕业年份作为主依据；若简历中存在教育时间、毕业时间或可推断年份信息，必须先推断再判断；" +
+            "只有完全不存在时间线信息时才可写“无法判断”。\n" +
+            "6) 当筛选条件提及“相关经验”时，必须以工作经历或项目经历作为硬性证据；教育/课程/论文/技能/个人优势只能作为补充，不能单独判定满足。\n" +
+            "7) workExpCheckRes 等经历校验项仅作为“需追问”软风险，不得直接据此判定不通过。\n" +
+            "8) 活跃度、沟通热度、受欢迎度等运营指标不参与筛选通过判定。\n" +
+            "9) 只做结论判断：候选人是否符合筛选标准。\n" +
+            "10) 只返回 passed 布尔值，不要在 JSON 中输出 reason/summary/evidence 等字段。\n\n" +
             "请返回严格 JSON: " +
-            "{\"passed\": true/false, \"reason\": \"...\", \"summary\": \"...\", \"evidence\": [\"证据原文1\", \"证据原文2\"]}"
+            "{\"passed\": true/false}"
         }
       ]
     };
@@ -4916,32 +5427,43 @@ class RecommendScreenCli {
       throw this.buildError("TEXT_MODEL_FAILED", `Text model request failed: ${response.status} ${body.slice(0, 400)}`);
     }
     const json = await response.json();
-    const content = Array.isArray(json?.choices?.[0]?.message?.content)
-      ? json.choices[0].message.content.map((item) => item?.text || "").join("\n")
-      : json?.choices?.[0]?.message?.content || "";
-    const parsed = extractJsonObject(content);
-    const reason = normalizeText(parsed.reason);
-    const summary = normalizeText(parsed.summary || reason);
+    const choice = json?.choices?.[0] || {};
+    const content = flattenChatMessageContent(choice?.message?.content);
+    const parsed = tryExtractJsonObject(content);
+    const cot = normalizeText(extractCotFromChoice(choice, parsed));
     const normalizedResume = normalizeText(safeResumeText);
     const normalizedResumeLower = toLowerSafe(normalizedResume);
-    const parsedEvidence = toStringArray(parsed.evidence);
+    const evidenceGateEligible = Array.isArray(parsed?.evidence)
+      || Number.isFinite(Number(parsed?.evidenceRawCount))
+      || Number.isFinite(Number(parsed?.evidenceMatchedCount));
+    const parsedEvidence = evidenceGateEligible ? toStringArray(parsed.evidence) : [];
     const evidence = [];
     const unmatchedEvidence = [];
-    for (const item of parsedEvidence) {
-      const matched = matchEvidenceAgainstResume(item, safeResumeText, normalizedResume, normalizedResumeLower);
-      if (matched.matched) {
-        evidence.push(item);
-      } else {
-        unmatchedEvidence.push(item);
+    if (evidenceGateEligible) {
+      for (const item of parsedEvidence) {
+        const matched = matchEvidenceAgainstResume(item, safeResumeText, normalizedResume, normalizedResumeLower);
+        if (matched.matched) {
+          evidence.push(item);
+        } else {
+          unmatchedEvidence.push(item);
+        }
       }
     }
-    const rawPassed = parsed.passed === true;
+    const parsedPassed = parsePassedDecision(parsed?.passed);
+    const fallbackPassed = parsePassedDecisionFromContent(content);
+    const rawPassed = parsedPassed !== null ? parsedPassed : fallbackPassed;
+    if (rawPassed === null) {
+      throw this.buildError(
+        "TEXT_MODEL_FAILED",
+        `Text model response missing boolean passed decision. content=${truncateText(content, 180)}`
+      );
+    }
     let passed = rawPassed;
-    let finalReason = reason || (passed ? "满足筛选标准。" : "不满足筛选标准。");
-    const evidenceGateDemoted = rawPassed && evidence.length <= 0;
+    let finalReason = cot || (passed ? "模型判定符合筛选标准。" : "模型判定不符合筛选标准。");
+    const evidenceGateDemoted = evidenceGateEligible && rawPassed && evidence.length <= 0;
     if (evidenceGateDemoted) {
       passed = false;
-      finalReason = `模型未给出可在简历原文中校验的证据，按安全策略判为不通过。${reason ? ` 原始原因: ${reason}` : ""}`;
+      finalReason = `模型未给出可在简历原文中校验的证据，按安全策略判为不通过。${finalReason ? ` 原始判断依据(CoT): ${finalReason}` : ""}`;
       if (unmatchedEvidence.length > 0) {
         log(
           `[EVIDENCE_GATE] passed=true 但证据未命中简历原文，已降级为不通过；` +
@@ -4949,15 +5471,17 @@ class RecommendScreenCli {
         );
       }
     }
+    const summary = finalReason;
     const enrichedReason = enrichReasonWithEvidence(finalReason, summary || finalReason, evidence, passed);
     return {
       passed,
       rawPassed,
+      cot: finalReason,
       reason: enrichedReason,
       summary: summary || enrichedReason,
       evidence,
-      evidenceRawCount: parsedEvidence.length,
-      evidenceMatchedCount: evidence.length,
+      evidenceRawCount: evidenceGateEligible ? parsedEvidence.length : null,
+      evidenceMatchedCount: evidenceGateEligible ? evidence.length : null,
       evidenceGateDemoted,
       chunkIndex,
       chunkTotal
@@ -5538,6 +6062,7 @@ class RecommendScreenCli {
           let domCandidateInfo = null;
 
           if (networkCandidateInfo?.resumeText) {
+            networkCandidateInfo = enrichCandidateInfoWithCardProfile(networkCandidateInfo, cardProfile || null);
             screening = await timeCandidateStage(
               "text_model_ms",
               () => this.callTextModel(networkCandidateInfo.resumeText)
@@ -5577,7 +6102,10 @@ class RecommendScreenCli {
                 })
               );
               if (lateNetworkCandidateInfo?.resumeText) {
-                networkCandidateInfo = lateNetworkCandidateInfo;
+                networkCandidateInfo = enrichCandidateInfoWithCardProfile(
+                  lateNetworkCandidateInfo,
+                  cardProfile || null
+                );
                 screening = await timeCandidateStage(
                   "text_model_ms",
                   () => this.callTextModel(networkCandidateInfo.resumeText)
@@ -5602,7 +6130,10 @@ class RecommendScreenCli {
                   () => this.resolveDomResumeFallback(nextCandidate, cardProfile || null)
                 );
                 if (domFallback?.networkCandidateInfo?.resumeText) {
-                  networkCandidateInfo = domFallback.networkCandidateInfo;
+                  networkCandidateInfo = enrichCandidateInfoWithCardProfile(
+                    domFallback.networkCandidateInfo,
+                    cardProfile || null
+                  );
                   screening = await timeCandidateStage(
                     "text_model_ms",
                     () => this.callTextModel(networkCandidateInfo.resumeText)
@@ -5622,7 +6153,10 @@ class RecommendScreenCli {
                     }
                   );
                 } else if (domFallback?.domCandidateInfo?.resumeText) {
-                  domCandidateInfo = domFallback.domCandidateInfo;
+                  domCandidateInfo = enrichCandidateInfoWithCardProfile(
+                    domFallback.domCandidateInfo,
+                    cardProfile || null
+                  );
                   screening = await timeCandidateStage(
                     "text_model_ms",
                     () => this.callTextModel(domCandidateInfo.resumeText)
@@ -5985,6 +6519,8 @@ if (require.main === module) {
       isRecoverablePostActionError,
       classifyFinishedWrapState,
       formatResumeApiData,
+      buildCardProfileFallbackText,
+      enrichCandidateInfoWithCardProfile,
       extractEvidenceTokens,
       matchEvidenceAgainstResume
     }

package/vendor/boss-recommend-screen-cli/test-recoverable-resume-failures.cjs

@@ -959,6 +959,100 @@ function testFormatResumeApiDataShouldPreserveEducationTagsAndProjectDescription
   assert.equal(formatted.includes("描述: 采用stable diffusion进行编辑实验"), true);
 }
 
+function testFormatResumeApiDataShouldIncludeStructuredJudgementHints() {
+  const source = {
+    geekDetailInfo: {
+      geekBaseInfo: {
+        name: "测试候选人",
+        degreeCategory: "硕士"
+      },
+      geekWorkExpList: [
+        {
+          company: "中科院",
+          positionName: "科研助理",
+          startDate: "20241001",
+          endDate: "",
+          responsibility: "科研以及项目"
+        }
+      ],
+      geekProjExpList: [],
+      geekEduExpList: [
+        {
+          school: "科克大学",
+          major: "理学",
+          degreeName: "硕士",
+          startDateDesc: "2020",
+          endDateDesc: "2023"
+        },
+        {
+          school: "东北大学",
+          major: "数学与应用数学",
+          degreeName: "本科",
+          startDate: "20140101",
+          endDate: "20180101"
+        }
+      ],
+      workExpCheckRes: [
+        {
+          desc: "毕业同年未填写工作经历"
+        }
+      ],
+      jobCompetitive: {
+        tips: [{ content: "受欢迎程度高" }]
+      }
+    }
+  };
+  const formatted = __testables.formatResumeApiData(source);
+  assert.equal(formatted.includes("=== 结构化判定线索 ==="), true);
+  assert.equal(formatted.includes("最高学历: 硕士"), true);
+  assert.equal(formatted.includes("最高学历毕业年份: 2023"), true);
+  assert.equal(formatted.includes("是否有工作经历: 是"), true);
+  assert.equal(formatted.includes("是否有项目经历: 否"), true);
+  assert.equal(formatted.includes("相关经验硬判口径"), true);
+  assert.equal(formatted.includes("软风险提示(需追问，不直接淘汰): 毕业同年未填写工作经历"), true);
+  assert.equal(formatted.includes("判定忽略项: 活跃度/沟通热度/受欢迎度等运营指标不参与通过判定。"), true);
+}
+
+function testEnrichCandidateInfoWithCardProfileShouldAppendCardFallbackWhenDomInfoMissing() {
+  const candidateInfo = {
+    name: "",
+    school: "",
+    major: "",
+    company: "",
+    position: "",
+    resumeText: "=== 基本信息 ===\n姓名: 赵梓轩\n"
+  };
+  const cardProfile = {
+    name: "赵梓轩",
+    age: "29岁",
+    gender: "男",
+    highestDegree: "硕士",
+    workYears: "2年",
+    company: "中科院",
+    position: "科研助理",
+    latestWorkStart: "2024.10",
+    latestWorkEnd: "至今",
+    educationList: [
+      { school: "科克大学", major: "理学", degree: "硕士", start: "2020", end: "2023" },
+      { school: "东北大学", major: "数学与应用数学", degree: "本科", start: "2014", end: "2018" }
+    ]
+  };
+
+  const enriched = __testables.enrichCandidateInfoWithCardProfile(candidateInfo, cardProfile);
+  assert.equal(enriched.name, "赵梓轩");
+  assert.equal(enriched.company, "中科院");
+  assert.equal(enriched.position, "科研助理");
+  assert.equal(enriched.resumeText.includes("=== 人选卡片兜底信息（仅在简历缺失时使用） ==="), true);
+  assert.equal(enriched.resumeText.includes("年龄: 29岁"), true);
+  assert.equal(enriched.resumeText.includes("性别: 男"), true);
+  assert.equal(enriched.resumeText.includes("最近一份工作在职日期: 2024.10 ~ 至今"), true);
+  assert.equal(enriched.resumeText.includes("1. 学校=科克大学；专业=理学；学历=硕士；时间=2020 ~ 2023"), true);
+  assert.equal(enriched.resumeText.includes("2. 学校=东北大学；专业=数学与应用数学；学历=本科；时间=2014 ~ 2018"), true);
+
+  const enrichedAgain = __testables.enrichCandidateInfoWithCardProfile(enriched, cardProfile);
+  assert.equal((enrichedAgain.resumeText.match(/人选卡片兜底信息（仅在简历缺失时使用）/g) || []).length, 1);
+}
+
 function testEvidenceTokenMatcherShouldSupportParaphrasedEvidence() {
   const resume = [
     "南京大学 专业: 数学",
@@ -1702,6 +1796,8 @@ async function main() {
   testFavoriteActionParserShouldOnlyTrustKnownRequestShapes();
   testFinishedWrapClassifierShouldNotTreatLoadMoreAsBottom();
   testFormatResumeApiDataShouldPreserveEducationTagsAndProjectDescription();
+  testFormatResumeApiDataShouldIncludeStructuredJudgementHints();
+  testEnrichCandidateInfoWithCardProfileShouldAppendCardFallbackWhenDomInfoMissing();
   testEvidenceTokenMatcherShouldSupportParaphrasedEvidence();
   testCheckpointPayloadShouldIncludeCandidateAudits();
   testCheckpointShouldPersistAndRestoreInputSummary();