@reconcrap/boss-recommend-mcp 1.3.36 → 1.3.38

package/src/test-boss-chat.js

@@ -287,16 +287,17 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.equal(stateAfterPrepare.last_prepare_args["llm-timeout-ms"], "65000");
     assert.equal(stateAfterPrepare.last_prepare_args["llm-max-retries"], "4");
 
-    const started = await startBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        job: "算法工程师",
-        start_from: "unread",
-        criteria: "有 AI Agent 经验",
-        target_count: 2
-      }
-    });
+    const started = await startBossChatRun({
+      workspaceRoot,
+      input: {
+        profile: "default",
+        job: "算法工程师",
+        start_from: "unread",
+        criteria: "有 AI Agent 经验",
+        greeting_text: "你好，方便发下简历吗？",
+        target_count: 2
+      }
+    });
     assert.equal(started.status, "ACCEPTED");
     assert.equal(Boolean(started.run_id), true);
 
@@ -304,9 +305,10 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     assert.equal(stateAfterStart.last_start_args.profile, "default");
     assert.equal(stateAfterStart.last_start_args["data-dir"], getTestChatDataDir(workspaceRoot));
     assert.equal(stateAfterStart.last_start_args.job, "算法工程师");
-    assert.equal(stateAfterStart.last_start_args["start-from"], "unread");
-    assert.equal(stateAfterStart.last_start_args.criteria, "有 AI Agent 经验");
-    assert.equal(stateAfterStart.last_start_args.targetCount, "2");
+    assert.equal(stateAfterStart.last_start_args["start-from"], "unread");
+    assert.equal(stateAfterStart.last_start_args.criteria, "有 AI Agent 经验");
+    assert.equal(stateAfterStart.last_start_args.greeting, "你好，方便发下简历吗？");
+    assert.equal(stateAfterStart.last_start_args.targetCount, "2");
     assert.equal(stateAfterStart.last_start_args.baseurl, "https://api.example.com/v1");
     assert.equal(stateAfterStart.last_start_args.apikey, "sk-test-key");
     assert.equal(stateAfterStart.last_start_args.model, "gpt-4.1-mini");
@@ -908,15 +910,20 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
       method: "tools/list",
       params: {}
     }, workspaceRoot);
-    const tools = toolsResponse.result.tools;
-    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", "criteria"]);
-    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("target_count")), true);
-    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("targetCount")), true);
-    assert.equal(startToolSchema.properties.target_count.examples.includes("all"), true);
-    assert.equal(startToolSchema.examples.some((item) => item.target_count === "all"), true);
+    const tools = toolsResponse.result.tools;
+    const runToolSchema = tools.find((item) => item.name === "start_recommend_pipeline_run").inputSchema;
+    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", "criteria"]);
+    assert.equal(typeof startToolSchema.properties.greeting_text, "object");
+    assert.equal(typeof startToolSchema.properties.greetingText, "object");
+    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("target_count")), true);
+    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("targetCount")), true);
+    assert.equal(startToolSchema.properties.target_count.examples.includes("all"), true);
+    assert.equal(startToolSchema.examples.some((item) => item.target_count === "all"), true);
+    assert.equal(typeof runToolSchema.properties.follow_up.properties.chat.properties.greeting_text, "object");
+    assert.equal(typeof runToolSchema.properties.follow_up.properties.chat.properties.greetingText, "object");
 
     const prepared = await callTool(workspaceRoot, TOOL_BOSS_CHAT_PREPARE_RUN, {}, 101);
     assert.equal(prepared.status, "NEED_INPUT");
@@ -960,13 +967,20 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     assert.equal(invalidTargetOnly.next_call_example.target_count, "all");
     assert.equal(invalidTargetOnly.recommended_argument_patch.target_count, "all");
 
-    const invalidStartResponse = await handleRequest(
-      makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {
-        start_from: "invalid-value"
+    const invalidStartResponse = await handleRequest(
+      makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {
+        start_from: "invalid-value"
       }),
       workspaceRoot
-    );
-    assert.equal(invalidStartResponse.error.code, -32602);
+    );
+    assert.equal(invalidStartResponse.error.code, -32602);
+    const invalidGreetingResponse = await handleRequest(
+      makeToolCall(1112, TOOL_BOSS_CHAT_START_RUN, {
+        greeting_text: 123
+      }),
+      workspaceRoot
+    );
+    assert.equal(invalidGreetingResponse.error.code, -32602);
 
     const invalidGetResponse = await handleRequest(
       makeToolCall(12, TOOL_BOSS_CHAT_GET_RUN, {}),
@@ -977,13 +991,15 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const health = await callTool(workspaceRoot, TOOL_BOSS_CHAT_HEALTH_CHECK, {}, 13);
     assert.equal(health.status, "OK");
 
-    const started = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
-      job: "算法工程师",
-      start_from: "unread",
-      criteria: "有 AI Agent 经验",
-      target_count: 2
-    }, 14);
-    assert.equal(started.status, "ACCEPTED");
+    const started = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
+      job: "算法工程师",
+      start_from: "unread",
+      criteria: "有 AI Agent 经验",
+      greeting_text: "您好，方便投递一份简历吗？",
+      target_count: 2
+    }, 14);
+    assert.equal(started.status, "ACCEPTED");
+    assert.equal(readStubState(workspaceRoot).last_start_args.greeting, "您好，方便投递一份简历吗？");
 
     const startedAll = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
       job: "算法工程师",
@@ -1033,15 +1049,17 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
 async function testBossChatCliShouldSupportRunAndFollowUpParsing() {
   const followUpJson = cliTestables.getRunFollowUp({
     "follow-up-json": JSON.stringify({
-      chat: {
-        criteria: "有 AI Agent 经验",
-        start_from: "unread",
-        target_count: 2
-      }
-    })
-  });
-  assert.equal(followUpJson.chat.criteria, "有 AI Agent 经验");
-  assert.equal(followUpJson.chat.target_count, 2);
+      chat: {
+        criteria: "有 AI Agent 经验",
+        start_from: "unread",
+        greeting_text: "您好，方便发下简历吗？",
+        target_count: 2
+      }
+    })
+  });
+  assert.equal(followUpJson.chat.criteria, "有 AI Agent 经验");
+  assert.equal(followUpJson.chat.greeting_text, "您好，方便发下简历吗？");
+  assert.equal(followUpJson.chat.target_count, 2);
 
   const tempFile = path.join(os.tmpdir(), `boss-recommend-follow-up-${Date.now()}.json`);
   fs.writeFileSync(tempFile, JSON.stringify({
@@ -1074,18 +1092,20 @@ async function testBossChatCliShouldSupportRunAndFollowUpParsing() {
     const logs = await captureConsoleLogs(async () => {
       await cliTestables.runBossChatCliCommand("run", {
         "workspace-root": workspaceRoot,
-        job: "算法工程师",
-        "start-from": "unread",
-        criteria: "有 AI Agent 经验",
-        targetCount: "2"
-      });
+        job: "算法工程师",
+        "start-from": "unread",
+        criteria: "有 AI Agent 经验",
+        "greeting-text": "您好，方便发下简历吗？",
+        targetCount: "2"
+      });
     });
     assert.equal(logs.length > 0, true);
-    const payload = JSON.parse(logs[0]);
-    assert.equal(payload.status, "ACCEPTED");
-    assert.equal(typeof payload.run_id, "string");
-    const state = readStubState(workspaceRoot);
-    assert.equal(state.get_calls[payload.run_id] || 0, 0);
+    const payload = JSON.parse(logs[0]);
+    assert.equal(payload.status, "ACCEPTED");
+    assert.equal(typeof payload.run_id, "string");
+    const state = readStubState(workspaceRoot);
+    assert.equal(state.last_start_args.greeting, "您好，方便发下简历吗？");
+    assert.equal(state.get_calls[payload.run_id] || 0, 0);
 
     await captureConsoleLogs(async () => {
       await cliTestables.runBossChatCliCommand("run", {
@@ -1179,14 +1199,106 @@ async function testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile() {
     overrides: {
       jobSelection: "AI应用开发工程师（2026） _ 杭州",
       startFrom: "unread",
-      screeningCriteria: "小样本联通性验证",
-      targetCount: 1,
-    },
-  });
-  assert.equal(profile.jobSelection.label, "AI应用开发工程师（2026） _ 杭州");
-  assert.equal(profile.startFrom, "unread");
-  assert.equal(profile.targetCount, 1);
-}
+      screeningCriteria: "小样本联通性验证",
+      greetingText: "你好，方便发下简历吗？",
+      targetCount: 1,
+    },
+  });
+  assert.equal(profile.jobSelection.label, "AI应用开发工程师（2026） _ 杭州");
+  assert.equal(profile.startFrom, "unread");
+  assert.equal(profile.greetingText, "你好，方便发下简历吗？");
+  assert.equal(profile.targetCount, 1);
+}
+
+async function testVendorBossChatCliShouldUseGreetingFallbacksInPromptRunProfile() {
+  const page = {
+    async ensureOnChatPage() {
+      return {
+        href: "https://www.zhipin.com/web/chat/index",
+        hasListContainer: true,
+        listItemCount: 8,
+      };
+    },
+    async listJobs() {
+      return [
+        {
+          value: "job-1",
+          label: "算法工程师 _ 杭州",
+          active: true,
+        },
+      ];
+    },
+  };
+
+  const fromLastProfile = await vendorCliTestables.promptRunProfile({
+    page,
+    persistentProfile: {
+      greetingText: "上次招呼语",
+      llm: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-test-key",
+        model: "gpt-4.1-mini",
+      },
+      chrome: {
+        port: 9222,
+      },
+      runtime: {},
+    },
+    overrides: {
+      jobSelection: "算法工程师 _ 杭州",
+      startFrom: "unread",
+      screeningCriteria: "有 AI Agent 经验",
+      targetCount: 1,
+    },
+  });
+  assert.equal(fromLastProfile.greetingText, "上次招呼语");
+
+  const fromExplicitOverride = await vendorCliTestables.promptRunProfile({
+    page,
+    persistentProfile: {
+      greetingText: "上次招呼语",
+      llm: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-test-key",
+        model: "gpt-4.1-mini",
+      },
+      chrome: {
+        port: 9222,
+      },
+      runtime: {},
+    },
+    overrides: {
+      jobSelection: "算法工程师 _ 杭州",
+      startFrom: "unread",
+      screeningCriteria: "有 AI Agent 经验",
+      greetingText: "本次新招呼语",
+      targetCount: 1,
+    },
+  });
+  assert.equal(fromExplicitOverride.greetingText, "本次新招呼语");
+
+  const fromBuiltInDefault = await vendorCliTestables.promptRunProfile({
+    page,
+    persistentProfile: {
+      llm: {
+        baseUrl: "https://api.example.com/v1",
+        apiKey: "sk-test-key",
+        model: "gpt-4.1-mini",
+      },
+      chrome: {
+        port: 9222,
+      },
+      runtime: {},
+    },
+    overrides: {
+      jobSelection: "算法工程师 _ 杭州",
+      startFrom: "unread",
+      screeningCriteria: "有 AI Agent 经验",
+      targetCount: 1,
+    },
+  });
+  assert.equal(fromBuiltInDefault.greetingText, "Hi同学，能麻烦发下简历吗？");
+}
 
 function testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig() {
   const installedSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
@@ -1213,18 +1325,21 @@ function testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig() {
   assert.equal(launchConfig.args[0], "-y");
 }
 
-function testVendorBossChatCliShouldParseSharedLlmTransportArgs() {
-  const parsed = vendorCliTestables.parseArgs([
-    "start-run",
-    "--llm-timeout-ms",
-    "70000",
-    "--llm-max-retries",
-    "5",
-  ]);
-  assert.equal(parsed.command, "start-run");
-  assert.equal(parsed.overrides.llm.timeoutMs, 70000);
-  assert.equal(parsed.overrides.llm.maxRetries, 5);
-}
+function testVendorBossChatCliShouldParseSharedLlmTransportArgs() {
+  const parsed = vendorCliTestables.parseArgs([
+    "start-run",
+    "--llm-timeout-ms",
+    "70000",
+    "--llm-max-retries",
+    "5",
+    "--greeting",
+    "您好，方便发下简历吗？",
+  ]);
+  assert.equal(parsed.command, "start-run");
+  assert.equal(parsed.overrides.llm.timeoutMs, 70000);
+  assert.equal(parsed.overrides.llm.maxRetries, 5);
+  assert.equal(parsed.overrides.greetingText, "您好，方便发下简历吗？");
+}
 
 function testBossChatLlmParserShouldAcceptMinimalDecisionJson() {
   const parsed = parseLlmJson(
@@ -3049,8 +3164,9 @@ async function main() {
   testVendorBossChatCliShouldResolveExplicitDataDir();
   testVendorBossChatCliShouldUseRecommendHomeForDefaultDataDir();
   await testVendorBossChatCliShouldWaitForHydratedChatShell();
-  await testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile();
-  testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig();
+  await testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile();
+  await testVendorBossChatCliShouldUseGreetingFallbacksInPromptRunProfile();
+  testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig();
   testVendorBossChatCliShouldParseSharedLlmTransportArgs();
   testBossChatLlmParserShouldAcceptMinimalDecisionJson();
   testBossChatLlmParserShouldAcceptPlainPassFailText();

package/src/test-pipeline.js

@@ -2183,8 +2183,9 @@ async function testFollowUpChatMissingFieldsShouldExposeRecommendDefaults() {
   const targetCountQuestion = result.pending_questions.find((item) => item.field === "follow_up.chat.target_count");
   assert.equal(criteriaQuestion?.value, "默认沿用 recommend 的筛选条件");
   assert.equal(startFromQuestion?.value, "unread");
-  assert.equal(targetCountQuestion?.value, 18);
-  assert.equal(targetCountQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
+  assert.equal(targetCountQuestion?.value, "通过筛选数");
+  assert.equal(targetCountQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "通过筛选数");
+  assert.equal(targetCountQuestion?.options?.some((item) => item.label.includes("通过筛选数（推荐）")), true);
   assert.equal(targetCountQuestion?.options?.some((item) => item.label.includes('follow_up.chat.target_count="all"')), true);
 }
 
@@ -2225,7 +2226,9 @@ async function testFollowUpChatMissingTargetCountShouldNeedInput() {
   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(Boolean(targetQuestion), true);
-  assert.equal(targetQuestion.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
+  assert.equal(targetQuestion.recommended_argument_patch?.follow_up?.chat?.target_count, "通过筛选数");
+  assert.equal(targetQuestion.options?.some((item) => item.value === "通过筛选数"), true);
+  assert.equal(targetQuestion.options?.some((item) => item.value === "all"), true);
 }
 
 async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics() {
@@ -2248,7 +2251,8 @@ async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics(
   assert.equal(targetQuestion?.received_target_count, "not a target");
   assert.equal(Boolean(targetQuestion?.target_count_parse_error), true);
   assert.equal(targetQuestion?.accepted_examples.includes("all"), true);
-  assert.equal(targetQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "all");
+  assert.equal(targetQuestion?.accepted_examples.includes("通过筛选数"), true);
+  assert.equal(targetQuestion?.recommended_argument_patch?.follow_up?.chat?.target_count, "通过筛选数");
 }
 
 async function testFollowUpChatAllTargetCountShouldLaunchUnlimited() {
@@ -2317,6 +2321,63 @@ async function testFollowUpChatAllTargetCountShouldLaunchUnlimited() {
   assert.equal(result.follow_up?.chat?.target_count, "all");
 }
 
+async function testFollowUpChatPassedTargetCountShouldLaunchWithPassedCount() {
+  let capturedChatInput = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      followUp: createFollowUpChat({ target_count: "通过筛选数" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9555 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 6,
+          applied_filters: {},
+          page_state: {}
+        }
+      }),
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 6,
+          passed_count: 2,
+          skipped_count: 0
+        }
+      }),
+      startBossChatRun: async ({ input }) => {
+        capturedChatInput = input;
+        return {
+          status: "ACCEPTED",
+          run_id: "chat-run-pass-count",
+          message: "chat started"
+        };
+      },
+      getBossChatRun: async () => ({
+        status: "COMPLETED",
+        run: {
+          runId: "chat-run-pass-count",
+          state: "completed",
+          lastMessage: "chat completed",
+          progress: { processed: 2, matched: 2 }
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(capturedChatInput?.target_count, 2);
+  assert.equal(result.follow_up?.chat?.input?.target_count, 2);
+  assert.equal(result.follow_up?.chat?.input?.target_count_requested, "passed_count");
+}
+
 async function testFinalReviewShouldIncludeFollowUpChatSummary() {
   const result = await runRecommendPipeline(
     {
@@ -2343,6 +2404,62 @@ async function testFinalReviewShouldIncludeFollowUpChatSummary() {
   assert.equal(finalReview?.value?.follow_up?.chat?.target_count, 5);
 }
 
+async function testFollowUpChatGreetingTextShouldPassThroughWhenProvided() {
+  let capturedChatInput = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      followUp: createFollowUpChat({ greeting_text: "您好，方便发下简历吗？" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9555 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 6,
+          applied_filters: {},
+          page_state: {}
+        }
+      }),
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 6,
+          passed_count: 2,
+          skipped_count: 0
+        }
+      }),
+      startBossChatRun: async ({ input }) => {
+        capturedChatInput = input;
+        return {
+          status: "ACCEPTED",
+          run_id: "chat-run-greeting",
+          message: "chat started"
+        };
+      },
+      getBossChatRun: async () => ({
+        status: "COMPLETED",
+        run: {
+          runId: "chat-run-greeting",
+          state: "completed",
+          lastMessage: "chat completed",
+          progress: { processed: 2, matched: 2 }
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(capturedChatInput?.greeting_text, "您好，方便发下简历吗？");
+  assert.equal(result.follow_up?.chat?.input?.greeting_text, "您好，方便发下简历吗？");
+}
+
 async function testCompletedPipelineShouldRunChatFollowUp() {
   let getChatRunCalls = 0;
   const result = await runRecommendPipeline(
@@ -2574,8 +2691,10 @@ async function main() {
   await testFollowUpChatMissingTargetCountShouldNeedInput();
   await testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics();
   await testFinalReviewShouldIncludeFollowUpChatSummary();
+  await testFollowUpChatGreetingTextShouldPassThroughWhenProvided();
   await testCompletedPipelineShouldRunChatFollowUp();
   await testFollowUpChatAllTargetCountShouldLaunchUnlimited();
+  await testFollowUpChatPassedTargetCountShouldLaunchWithPassedCount();
   await testCompletedPipelineShouldFailWhenChatLaunchFails();
   await testCompletedPipelineShouldFailWhenChatRunFails();
   console.log("pipeline tests passed");

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

@@ -1,8 +1,9 @@
-import { mkdir } from 'node:fs/promises';
-import path from 'node:path';
-
-import { isDomProfileConsistentWithCard, NETWORK_RESUME_RETRY_WAIT_MS } from './services/resume-network.js';
-import { createCustomerAliases, createCustomerKey } from './utils/customer-key.js';
+import { mkdir } from 'node:fs/promises';
+import path from 'node:path';
+
+import { isDomProfileConsistentWithCard, NETWORK_RESUME_RETRY_WAIT_MS } from './services/resume-network.js';
+import { DEFAULT_GREETING_TEXT } from './services/profile-store.js';
+import { createCustomerAliases, createCustomerKey } from './utils/customer-key.js';
 
 function runToken(date = new Date()) {
   return date.toISOString().replace(/[:.]/g, '-');
@@ -37,12 +38,16 @@ 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('简历请求已发送'));
-}
+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('简历请求已发送'));
+}
+
+function resolveGreetingText(profile = {}) {
+  return normalizeText(profile?.greetingText || '') || DEFAULT_GREETING_TEXT;
+}
 
 const CANDIDATE_LIST_WAIT_AFTER_CONTEXT_MS = 5000;
 const CANDIDATE_LIST_WAIT_POLL_MS = 500;
@@ -1323,13 +1328,13 @@ export class BossChatApp {
           return baseResult;
         }
 
-        const greetingText = 'Hi同学，能麻烦发下简历吗？';
+        const greetingText = resolveGreetingText(profile);
         this.logger.log(`候选人通过，先发送消息：${greetingText}`);
         await this.checkpoint();
-        const editorState = await this.page.setEditorMessage(greetingText);
-        if (!String(editorState?.value || '').includes('Hi同学')) {
-          throw new Error('CHAT_EDITOR_MESSAGE_MISMATCH');
-        }
+        const editorState = await this.page.setEditorMessage(greetingText);
+        if (!normalizeText(editorState?.value || '').includes(normalizeText(greetingText))) {
+          throw new Error('CHAT_EDITOR_MESSAGE_MISMATCH');
+        }
         this.logger.log(
           `招呼语写入输入框：activeSubmit=${Boolean(editorState?.activeSubmit)} | valueLen=${String(editorState?.value || '').length}`,
         );