@reconcrap/boss-recommend-mcp 1.3.39 → 2.0.0

package/src/test-boss-chat.js

@@ -1,3196 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { mkdir } from "node:fs/promises";
-
-import {
-  cancelBossChatRun,
-  ensureBossChatRuntimeReady,
-  getBossChatHealthCheck,
-  getBossChatRun,
-  pauseBossChatRun,
-  prepareBossChatRun,
-  resolveBossChatRuntimeLayout,
-  resumeBossChatRun,
-  startBossChatRun
-} from "./boss-chat.js";
-import { __testables as cliTestables, runCli } from "./cli.js";
-import { __testables as indexTestables } from "./index.js";
-import { BossChatApp } from "../vendor/boss-chat-cli/src/app.js";
-import { __testables as vendorCliTestables } from "../vendor/boss-chat-cli/src/cli.js";
-import { BossChatPage } from "../vendor/boss-chat-cli/src/browser/chat-page.js";
-import { ChromeClient } from "../vendor/boss-chat-cli/src/services/chrome-client.js";
-import { LlmClient, parseLlmJson, __testables as llmTestables } from "../vendor/boss-chat-cli/src/services/llm.js";
-import { ReportStore } from "../vendor/boss-chat-cli/src/services/report-store.js";
-import {
-  NETWORK_RESUME_IMAGE_MODE_GRACE_MS,
-  NETWORK_RESUME_RETRY_WAIT_MS,
-  NETWORK_RESUME_WAIT_MS,
-  ResumeNetworkTracker,
-} from "../vendor/boss-chat-cli/src/services/resume-network.js";
-
-const { handleRequest } = indexTestables;
-
-const TOOL_BOSS_CHAT_HEALTH_CHECK = "boss_chat_health_check";
-const TOOL_BOSS_CHAT_PREPARE_RUN = "prepare_boss_chat_run";
-const TOOL_BOSS_CHAT_START_RUN = "start_boss_chat_run";
-const TOOL_BOSS_CHAT_GET_RUN = "get_boss_chat_run";
-const TOOL_BOSS_CHAT_PAUSE_RUN = "pause_boss_chat_run";
-const TOOL_BOSS_CHAT_RESUME_RUN = "resume_boss_chat_run";
-const TOOL_BOSS_CHAT_CANCEL_RUN = "cancel_boss_chat_run";
-const { extractCompletionReasoningText, extractResponsesReasoningText } = llmTestables;
-
-function makeToolCall(id, name, args = {}) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    method: "tools/call",
-    params: {
-      name,
-      arguments: args
-    }
-  };
-}
-
-async function callTool(workspaceRoot, name, args = {}, id = 1) {
-  const response = await handleRequest(makeToolCall(id, name, args), workspaceRoot);
-  return response?.result?.structuredContent;
-}
-
-function createBossChatTestWorkspace() {
-  const workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-boss-chat-"));
-  const configDir = path.join(workspaceRoot, "config");
-  const cliDir = path.join(workspaceRoot, "boss-chat-cli", "src");
-  fs.mkdirSync(configDir, { recursive: true });
-  fs.mkdirSync(cliDir, { recursive: true });
-
-  fs.writeFileSync(path.join(configDir, "screening-config.json"), JSON.stringify({
-    baseUrl: "https://api.example.com/v1",
-    apiKey: "sk-test-key",
-    model: "gpt-4.1-mini",
-    llmTimeoutMs: 65000,
-    llmMaxRetries: 4,
-    debugPort: 9666
-  }, null, 2));
-
-  fs.writeFileSync(path.join(cliDir, "cli.js"), [
-    "#!/usr/bin/env node",
-    "const fs = require('node:fs');",
-    "const path = require('node:path');",
-    "const argv = process.argv.slice(2);",
-    "const command = String(argv[0] || '').trim();",
-    "const options = {};",
-    "for (let index = 1; index < argv.length; index += 1) {",
-    "  const token = String(argv[index] || '');",
-    "  if (!token.startsWith('--')) continue;",
-    "  const key = token.slice(2);",
-    "  const next = argv[index + 1];",
-    "  if (next && !String(next).startsWith('--')) {",
-    "    options[key] = String(next);",
-    "    index += 1;",
-    "  } else {",
-    "    options[key] = true;",
-    "  }",
-    "}",
-    "const cwd = process.cwd();",
-    "const dataDir = String(options['data-dir'] || process.env.BOSS_CHAT_HOME || path.join(cwd, '.boss-chat'));",
-    "const statePath = path.join(dataDir, 'stub-state.json');",
-    "fs.mkdirSync(path.dirname(statePath), { recursive: true });",
-    "const raw = fs.existsSync(statePath) ? fs.readFileSync(statePath, 'utf8') : '{}';",
-    "const state = JSON.parse(raw || '{}');",
-    "state.counter = Number.isInteger(state.counter) ? state.counter : 0;",
-    "state.prepare_calls = Number.isInteger(state.prepare_calls) ? state.prepare_calls : 0;",
-    "if (!Number.isInteger(state.prepare_fail_budget)) {",
-    "  const configured = Number.parseInt(process.env.BOSS_CHAT_STUB_PREPARE_FAILS || '0', 10);",
-    "  state.prepare_fail_budget = Number.isFinite(configured) && configured > 0 ? configured : 0;",
-    "}",
-    "state.runs = state.runs && typeof state.runs === 'object' ? state.runs : {};",
-    "state.get_calls = state.get_calls && typeof state.get_calls === 'object' ? state.get_calls : {};",
-    "function saveAndPrint(payload) {",
-    "  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));",
-    "  process.stdout.write(`${JSON.stringify(payload)}\\n`);",
-    "}",
-    "if (command === 'prepare-run') {",
-    "  state.prepare_calls += 1;",
-    "  if (state.prepare_fail_budget > 0) {",
-    "    state.prepare_fail_budget -= 1;",
-    "    saveAndPrint({ status: 'FAILED', error: { code: 'CHAT_PAGE_NOT_READY', message: 'chat page is still loading' } });",
-    "    process.exit(1);",
-    "  }",
-    "  state.last_prepare_args = options;",
-    "  saveAndPrint({",
-    "    status: 'NEED_INPUT',",
-    "    stage: 'chat_run_setup',",
-    "    page_url: 'https://www.zhipin.com/web/chat/index',",
-    "    required_fields: ['job', 'start_from', 'target_count', 'criteria'],",
-    "    job_options: [",
-    "      { index: 1, label: '算法工程师', value: '算法工程师', active: true },",
-    "      { index: 2, label: '大模型算法', value: '大模型算法', active: false }",
-    "    ],",
-    "    pending_questions: [",
-    "      { field: 'job', question: '请选择岗位（必须从岗位列表中选择）', required: true },",
-    "      { field: 'start_from', question: '请选择起始范围', required: true },",
-    "      { field: 'target_count', question: '请输入目标数量（正整数）', required: true },",
-    "      { field: 'criteria', question: '请输入筛选标准（自然语言）', required: true }",
-    "    ],",
-    "    message: 'prepared'",
-    "  });",
-    "  process.exit(0);",
-    "}",
-    "if (command === 'start-run') {",
-    "  state.counter += 1;",
-    "  const runId = `chat-${state.counter}`;",
-    "  state.last_start_args = options;",
-    "  state.runs[runId] = { state: 'queued' };",
-    "  state.get_calls[runId] = 0;",
-    "  saveAndPrint({ status: 'ACCEPTED', run_id: runId, message: 'chat started' });",
-    "  process.exit(0);",
-    "}",
-    "const runId = String(options['run-id'] || '');",
-    "const current = state.runs[runId] || { state: 'queued' };",
-    "if (command === 'get-run') {",
-    "  state.get_calls[runId] = (state.get_calls[runId] || 0) + 1;",
-    "  if (!['paused', 'canceled'].includes(current.state)) {",
-    "    current.state = state.get_calls[runId] >= 2 ? 'completed' : 'running';",
-    "  }",
-    "  state.runs[runId] = current;",
-    "  saveAndPrint({",
-    "    status: 'RUN_STATUS',",
-    "    run: {",
-    "      runId,",
-    "      state: current.state,",
-    "      lastMessage: `state=${current.state}`,",
-    "      progress: { inspected: state.get_calls[runId], passed: current.state === 'completed' ? 1 : 0, requested: current.state === 'completed' ? 1 : 0, skipped: 0, errors: 0 },",
-    "      result: current.state === 'completed' ? { requested_count: 1 } : null",
-    "    }",
-    "  });",
-    "  process.exit(0);",
-    "}",
-    "if (command === 'pause-run') {",
-    "  current.state = 'paused';",
-    "  state.runs[runId] = current;",
-    "  saveAndPrint({ status: 'PAUSE_REQUESTED', run: { runId, state: 'paused' } });",
-    "  process.exit(0);",
-    "}",
-    "if (command === 'resume-run') {",
-    "  current.state = 'running';",
-    "  state.runs[runId] = current;",
-    "  saveAndPrint({ status: 'RESUME_REQUESTED', run: { runId, state: 'running' } });",
-    "  process.exit(0);",
-    "}",
-    "if (command === 'cancel-run') {",
-    "  current.state = 'canceled';",
-    "  state.runs[runId] = current;",
-    "  saveAndPrint({ status: 'CANCEL_REQUESTED', run: { runId, state: 'canceled' } });",
-    "  process.exit(0);",
-    "}",
-    "saveAndPrint({ status: 'FAILED', error: { code: 'UNKNOWN_COMMAND', message: command || 'missing command' } });",
-    "process.exit(1);"
-  ].join("\n"), "utf8");
-
-  return workspaceRoot;
-}
-
-function getTestChatDataDir(workspaceRoot) {
-  return resolveBossChatRuntimeLayout(workspaceRoot).data_dir;
-}
-
-function readStubState(workspaceRoot) {
-  const statePath = path.join(getTestChatDataDir(workspaceRoot), "stub-state.json");
-  return JSON.parse(fs.readFileSync(statePath, "utf8"));
-}
-
-async function withBossChatWorkspace(testFn) {
-  const workspaceRoot = createBossChatTestWorkspace();
-  const previousScreenConfig = process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
-  const previousBossChatHome = process.env.BOSS_CHAT_HOME;
-  process.env.BOSS_RECOMMEND_SCREEN_CONFIG = path.join(workspaceRoot, "config", "screening-config.json");
-  process.env.BOSS_CHAT_HOME = path.join(workspaceRoot, "user-boss-chat");
-  try {
-    await testFn(workspaceRoot);
-  } finally {
-    if (previousScreenConfig === undefined) {
-      delete process.env.BOSS_RECOMMEND_SCREEN_CONFIG;
-    } else {
-      process.env.BOSS_RECOMMEND_SCREEN_CONFIG = previousScreenConfig;
-    }
-    if (previousBossChatHome === undefined) {
-      delete process.env.BOSS_CHAT_HOME;
-    } else {
-      process.env.BOSS_CHAT_HOME = previousBossChatHome;
-    }
-    fs.rmSync(workspaceRoot, { recursive: true, force: true });
-  }
-}
-
-async function captureConsoleLogs(fn) {
-  const messages = [];
-  const originalLog = console.log;
-  console.log = (...args) => {
-    messages.push(args.join(" "));
-  };
-  try {
-    await fn();
-  } finally {
-    console.log = originalLog;
-  }
-  return messages;
-}
-
-async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const health = getBossChatHealthCheck(workspaceRoot);
-    assert.equal(health.status, "OK");
-    assert.equal(health.shared_llm_config, true);
-    assert.equal(health.debug_port, 9666);
-    assert.equal(health.data_dir_source, "env:BOSS_CHAT_HOME");
-    assert.equal(health.data_dir, getTestChatDataDir(workspaceRoot));
-    assert.equal(health.legacy_workspace_dir, path.join(workspaceRoot, ".boss-chat"));
-    assert.equal(health.migration_pending, false);
-
-    const prepared = await prepareBossChatRun({
-      workspaceRoot,
-      input: {}
-    });
-    assert.equal(prepared.status, "NEED_INPUT");
-    assert.deepEqual(prepared.missing_fields, ["job", "start_from", "target_count", "criteria"]);
-    const preparedTargetQuestion = prepared.pending_questions.find((item) => item.field === "target_count");
-    assert.equal(preparedTargetQuestion.argument_name, "target_count");
-    assert.equal(preparedTargetQuestion.recommended_value, "all");
-    assert.equal(preparedTargetQuestion.recommended_argument_patch.target_count, "all");
-    assert.equal(preparedTargetQuestion.options.some((item) => item.label.includes('target_count="all"')), true);
-    assert.equal(prepared.next_call_example.target_count, "all");
-
-    const preflight = await startBossChatRun({
-      workspaceRoot,
-      input: {}
-    });
-    assert.equal(preflight.status, "NEED_INPUT");
-    assert.deepEqual(preflight.required_fields, ["job", "start_from", "target_count", "criteria"]);
-    assert.equal(Array.isArray(preflight.job_options), true);
-    assert.equal(preflight.job_options.length, 2);
-    assert.equal(Array.isArray(preflight.pending_questions), true);
-    const preflightTargetQuestion = preflight.pending_questions.find((item) => item.field === "target_count");
-    assert.equal(Boolean(preflightTargetQuestion), true);
-    assert.equal(preflightTargetQuestion.argument_name, "target_count");
-    assert.equal(preflightTargetQuestion.recommended_argument_patch.target_count, "all");
-    assert.equal(Array.isArray(preflightTargetQuestion.options), true);
-
-    const stateAfterPrepare = readStubState(workspaceRoot);
-    assert.equal(stateAfterPrepare.last_prepare_args.profile, "default");
-    assert.equal(stateAfterPrepare.last_prepare_args["data-dir"], getTestChatDataDir(workspaceRoot));
-    assert.equal(stateAfterPrepare.last_prepare_args.port, "9666");
-    assert.equal(stateAfterPrepare.last_prepare_args.baseurl, "https://api.example.com/v1");
-    assert.equal(stateAfterPrepare.last_prepare_args.apikey, "sk-test-key");
-    assert.equal(stateAfterPrepare.last_prepare_args.model, "gpt-4.1-mini");
-    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 经验",
-        greeting_text: "你好，方便发下简历吗？",
-        target_count: 2
-      }
-    });
-    assert.equal(started.status, "ACCEPTED");
-    assert.equal(Boolean(started.run_id), true);
-
-    const stateAfterStart = readStubState(workspaceRoot);
-    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.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");
-    assert.equal(stateAfterStart.last_start_args.port, "9666");
-    assert.equal(stateAfterStart.last_start_args["llm-timeout-ms"], "65000");
-    assert.equal(stateAfterStart.last_start_args["llm-max-retries"], "4");
-
-    const startedAll = await startBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        job: "算法工程师",
-        start_from: "all",
-        criteria: "全部候选人都过一遍",
-        target_count: "全部候选人"
-      }
-    });
-    assert.equal(startedAll.status, "ACCEPTED");
-    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);
-    assert.equal(invalidTarget.recommended_argument_patch.target_count, "all");
-
-    const running = await getBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        run_id: started.run_id
-      }
-    });
-    assert.equal(running.run.state, "running");
-
-    const paused = await pauseBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        run_id: started.run_id
-      }
-    });
-    assert.equal(paused.run.state, "paused");
-
-    const resumed = await resumeBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        run_id: started.run_id
-      }
-    });
-    assert.equal(resumed.run.state, "running");
-
-    const canceled = await cancelBossChatRun({
-      workspaceRoot,
-      input: {
-        profile: "default",
-        run_id: started.run_id
-      }
-    });
-    assert.equal(canceled.run.state, "canceled");
-  });
-}
-
-async function testBossChatRuntimeShouldMigrateLegacyWorkspaceDataOnce() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const legacyDir = path.join(workspaceRoot, ".boss-chat");
-    const legacyStatePath = path.join(legacyDir, "state", "default.json");
-    const legacyRunPath = path.join(legacyDir, "runs", "legacy-run.json");
-    fs.mkdirSync(path.dirname(legacyStatePath), { recursive: true });
-    fs.mkdirSync(path.dirname(legacyRunPath), { recursive: true });
-    fs.writeFileSync(legacyStatePath, JSON.stringify({ cursor: 7 }, null, 2));
-    fs.writeFileSync(legacyRunPath, JSON.stringify({ run_id: "legacy-run" }, null, 2));
-
-    const before = resolveBossChatRuntimeLayout(workspaceRoot);
-    assert.equal(before.data_dir, getTestChatDataDir(workspaceRoot));
-    assert.equal(before.legacy_workspace_dir, legacyDir);
-    assert.equal(before.migration_source_dir, legacyDir);
-    assert.equal(before.migration_pending, true);
-
-    const ready = ensureBossChatRuntimeReady(workspaceRoot);
-    assert.equal(ready.migration.attempted, true);
-    assert.equal(ready.migration.performed, true);
-    assert.equal(fs.existsSync(path.join(ready.data_dir, "state", "default.json")), true);
-    assert.equal(fs.existsSync(path.join(ready.data_dir, "runs", "legacy-run.json")), true);
-    assert.deepEqual(
-      JSON.parse(fs.readFileSync(path.join(ready.data_dir, "state", "default.json"), "utf8")),
-      { cursor: 7 }
-    );
-    assert.equal(fs.existsSync(legacyStatePath), true);
-
-    const after = resolveBossChatRuntimeLayout(workspaceRoot);
-    assert.equal(after.migration_pending, false);
-    assert.equal(after.migration_source_dir, null);
-
-    const secondReady = ensureBossChatRuntimeReady(workspaceRoot);
-    assert.equal(secondReady.migration.attempted, false);
-    assert.equal(secondReady.migration.performed, false);
-  });
-}
-
-function testBossChatRuntimeShouldResolveUserDirForRootWorkspace() {
-  const previousBossChatHome = process.env.BOSS_CHAT_HOME;
-  const previousRecommendHome = process.env.BOSS_RECOMMEND_HOME;
-  const runtimeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-root-runtime-"));
-  try {
-    delete process.env.BOSS_CHAT_HOME;
-    process.env.BOSS_RECOMMEND_HOME = runtimeRoot;
-    const rootWorkspace = path.parse(process.cwd()).root;
-    const runtime = resolveBossChatRuntimeLayout(rootWorkspace);
-    assert.equal(runtime.data_dir, path.join(runtimeRoot, "boss-chat"));
-    assert.equal(runtime.legacy_workspace_dir, null);
-    assert.equal(runtime.migration_pending, false);
-
-    const ready = ensureBossChatRuntimeReady(rootWorkspace);
-    assert.equal(fs.existsSync(ready.data_dir), true);
-    assert.equal(fs.existsSync(path.join(ready.data_dir, "runs")), true);
-  } finally {
-    if (previousBossChatHome === undefined) {
-      delete process.env.BOSS_CHAT_HOME;
-    } else {
-      process.env.BOSS_CHAT_HOME = previousBossChatHome;
-    }
-    if (previousRecommendHome === undefined) {
-      delete process.env.BOSS_RECOMMEND_HOME;
-    } else {
-      process.env.BOSS_RECOMMEND_HOME = previousRecommendHome;
-    }
-    fs.rmSync(runtimeRoot, { recursive: true, force: true });
-  }
-}
-
-async function testBossChatWhereShouldPrintUserRuntimePath() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const previousWorkspaceRoot = process.env.BOSS_WORKSPACE_ROOT;
-    process.env.BOSS_WORKSPACE_ROOT = workspaceRoot;
-    try {
-      const logs = await captureConsoleLogs(async () => {
-        await runCli(["node", "src/cli.js", "where"]);
-      });
-      assert.equal(logs.some((line) => line.includes(`boss_chat_runtime=${getTestChatDataDir(workspaceRoot)}`)), true);
-      assert.equal(logs.some((line) => line.includes(`boss_chat_legacy_workspace_runtime=${path.join(workspaceRoot, ".boss-chat")}`)), true);
-    } finally {
-      if (previousWorkspaceRoot === undefined) {
-        delete process.env.BOSS_WORKSPACE_ROOT;
-      } else {
-        process.env.BOSS_WORKSPACE_ROOT = previousWorkspaceRoot;
-      }
-    }
-  });
-}
-
-async function testBossChatPrepareShouldRetryWhenChatPageIsNotReady() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const previousPrepareFails = process.env.BOSS_CHAT_STUB_PREPARE_FAILS;
-    process.env.BOSS_CHAT_STUB_PREPARE_FAILS = "2";
-    try {
-      const prepared = await prepareBossChatRun({
-        workspaceRoot,
-        input: {}
-      });
-      assert.equal(prepared.status, "NEED_INPUT");
-      const state = readStubState(workspaceRoot);
-      assert.equal(state.prepare_calls, 3);
-      assert.equal(state.prepare_fail_budget, 0);
-    } finally {
-      if (previousPrepareFails === undefined) {
-        delete process.env.BOSS_CHAT_STUB_PREPARE_FAILS;
-      } else {
-        process.env.BOSS_CHAT_STUB_PREPARE_FAILS = previousPrepareFails;
-      }
-    }
-  });
-}
-
-function testVendorBossChatCliShouldResolveExplicitDataDir() {
-  const cwd = path.join(path.parse(process.cwd()).root, "workspace");
-  const args = vendorCliTestables.parseArgs(["start-run", "--data-dir", "/tmp/boss-chat-data"]);
-  assert.equal(args.dataDir, "/tmp/boss-chat-data");
-  const explicitResolved = vendorCliTestables.resolveDataDirDetails(args, { BOSS_CHAT_HOME: "/tmp/ignored" }, cwd);
-  assert.equal(explicitResolved.source, "arg:data-dir");
-  assert.equal(explicitResolved.path, path.resolve("/tmp/boss-chat-data"));
-  assert.equal(
-    vendorCliTestables.resolveDataDir(args, { BOSS_CHAT_HOME: "/tmp/ignored" }, cwd),
-    path.resolve("/tmp/boss-chat-data")
-  );
-  const envResolved = vendorCliTestables.resolveDataDirDetails({}, { BOSS_CHAT_HOME: "/tmp/from-env" }, cwd);
-  assert.equal(envResolved.source, "env:BOSS_CHAT_HOME");
-  assert.equal(envResolved.path, path.resolve("/tmp/from-env"));
-  assert.equal(
-    vendorCliTestables.resolveDataDir({}, { BOSS_CHAT_HOME: "/tmp/from-env" }, cwd),
-    path.resolve("/tmp/from-env")
-  );
-  const defaultResolved = vendorCliTestables.resolveDataDirDetails({}, {}, cwd);
-  assert.equal(defaultResolved.source, "default:user_home");
-  assert.equal(defaultResolved.path, path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat"));
-  assert.equal(
-    vendorCliTestables.resolveDataDir({}, {}, cwd),
-    path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat")
-  );
-
-  const unsafeRoot = vendorCliTestables.validateDataDir(path.parse(process.cwd()).root);
-  assert.equal(unsafeRoot.ok, false);
-  assert.equal(unsafeRoot.code, "UNSAFE_DATA_DIR");
-  assert.equal(unsafeRoot.message.includes("Refusing unsafe boss-chat data dir"), true);
-
-  const safePath = vendorCliTestables.validateDataDir(path.join(os.homedir(), ".boss-recommend-mcp", "boss-chat"));
-  assert.equal(safePath.ok, true);
-}
-
-function testVendorBossChatCliShouldUseRecommendHomeForDefaultDataDir() {
-  const resolved = vendorCliTestables.resolveDataDirDetails(
-    {},
-    { BOSS_RECOMMEND_HOME: "/tmp/recommend-home" },
-    path.join(path.parse(process.cwd()).root, "workspace")
-  );
-  assert.equal(resolved.source, "default:env:BOSS_RECOMMEND_HOME");
-  assert.equal(resolved.path, path.resolve("/tmp/recommend-home/boss-chat"));
-}
-
-async function testBossChatPageShouldTreatBlankChatShellAsOnChatPage() {
-  const fakeChromeClient = {
-    async callFunction() {
-      return {
-        href: "https://www.zhipin.com/web/chat/index",
-        readyState: "complete",
-        hasListContainer: false,
-        listItemCount: 0
-      };
-    }
-  };
-
-  const page = new BossChatPage(fakeChromeClient);
-  const pageState = await page.ensureOnChatPage();
-  assert.equal(pageState.href, "https://www.zhipin.com/web/chat/index");
-
-  await assert.rejects(
-    () => page.ensureReady(),
-    /CHAT_LIST_CONTAINER_NOT_FOUND/
-  );
-}
-
-async function testBossChatRecoverToChatIndexShouldForceNavigateAndWaitForCompleteLoad() {
-  const calls = [];
-  let stateIndex = 0;
-  const states = [
-    {
-      href: "https://www.zhipin.com/web/chat/index",
-      readyState: "loading",
-      hasListContainer: false,
-      listItemCount: 0
-    },
-    {
-      href: "https://www.zhipin.com/web/chat/index",
-      readyState: "interactive",
-      hasListContainer: false,
-      listItemCount: 0
-    },
-    {
-      href: "https://www.zhipin.com/web/chat/index",
-      readyState: "complete",
-      hasListContainer: false,
-      listItemCount: 0
-    }
-  ];
-
-  const fakeChromeClient = {
-    async callFunction(fn, arg) {
-      calls.push({ name: fn.name, arg });
-      if (fn.name === "browserGetCurrentHref") {
-        return { href: "https://www.zhipin.com/web/chat/index" };
-      }
-      if (fn.name === "browserNavigateToChatIndex") {
-        return { ok: true, changed: true, href: "https://www.zhipin.com/web/chat/index" };
-      }
-      if (fn.name === "browserGetPageState") {
-        const value = states[Math.min(stateIndex, states.length - 1)];
-        stateIndex += 1;
-        return value;
-      }
-      throw new Error(`unexpected function: ${fn.name}`);
-    }
-  };
-
-  const page = new BossChatPage(fakeChromeClient);
-  const result = await page.recoverToChatIndex({
-    forceNavigate: true,
-    waitForReadyState: "complete",
-    maxAttempts: 5,
-    delayMs: 0
-  });
-
-  assert.equal(result.changed, true);
-  assert.equal(result.href, "https://www.zhipin.com/web/chat/index");
-  assert.equal(
-    calls.some((entry) => entry.name === "browserNavigateToChatIndex" && entry.arg?.force === true),
-    true
-  );
-  assert.equal(
-    calls.filter((entry) => entry.name === "browserGetPageState").length >= 3,
-    true
-  );
-}
-
-async function testBossChatPageShouldFallbackToEscapeWhenClosingCandidateDetail() {
-  const calls = [];
-  const mouseEvents = [];
-  let stateIndex = 0;
-  const openState = {
-    open: true,
-    panelCount: 1,
-    closeCount: 1,
-    topPanelClass: "new-resume-online-main-ui",
-    topPanelScore: 520,
-    panelRect: {
-      left: 980,
-      top: 0,
-      width: 330,
-      height: 760,
-      right: 1310,
-      bottom: 760
-    },
-    closeRect: {
-      left: 1274,
-      top: 12,
-      width: 30,
-      height: 30,
-      right: 1304,
-      bottom: 42
-    },
-    overlayClass: "dialog-wrap active",
-    overlayRect: {
-      left: 0,
-      top: 0,
-      width: 1440,
-      height: 773,
-      right: 1440,
-      bottom: 773
-    },
-    contentClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-    contentRect: {
-      left: 980,
-      top: 0,
-      width: 330,
-      height: 760,
-      right: 1310,
-      bottom: 760
-    }
-  };
-  const states = [
-    openState,
-    openState,
-    openState,
-    {
-      open: false,
-      panelCount: 0,
-      closeCount: 0,
-      topPanelClass: "",
-      topPanelScore: 0,
-      panelRect: null,
-      closeRect: null,
-      overlayClass: "",
-      overlayRect: null,
-      contentClass: "",
-      contentRect: null
-    }
-  ];
-
-  const fakeChromeClient = {
-    Input: {
-      async dispatchMouseEvent(payload) {
-        mouseEvents.push(payload);
-      }
-    },
-    async pressEscape() {
-      calls.push("pressEscape");
-    },
-    async callFunction(fn) {
-      calls.push(fn.name);
-      if (fn.name === "browserIsCandidateDetailOpen") {
-        const value = states[Math.min(stateIndex, states.length - 1)];
-        stateIndex += 1;
-        return value;
-      }
-      if (fn.name === "browserCloseCandidateDetailDomOnce") {
-        return {
-          ok: true,
-          selector: ".close-btn",
-          method: "dom-click-once"
-        };
-      }
-      if (fn.name === "browserFindCandidateDetailOutsideClickPoint") {
-        return {
-          ok: true,
-          strategy: "left-gap",
-          point: { x: 72, y: 260 },
-          state: openState
-        };
-      }
-      throw new Error(`unexpected function: ${fn.name}`);
-    }
-  };
-
-  const page = new BossChatPage(fakeChromeClient);
-  const result = await page.closeCandidateDetail({
-    maxAttempts: 1,
-    ensureDismiss: true
-  });
-
-  assert.equal(result.closed, true);
-  assert.equal(calls.includes("pressEscape"), true);
-  assert.equal(mouseEvents.length > 0, true);
-  assert.equal(result.method.includes("outside-click:left-gap"), true);
-}
-
-async function testChromeClientShouldInjectBrowserHelpersIntoCallFunction() {
-  function helper(value) {
-    return Number(value || 0) + 1;
-  }
-  function target(value) {
-    return helper(value) * 2;
-  }
-  target.helpers = [helper];
-
-  const client = new ChromeClient(9222);
-  let capturedExpression = "";
-  client.evaluate = async (expression) => {
-    capturedExpression = String(expression || "");
-    return "ok";
-  };
-
-  const result = await client.callFunction(target, 2);
-
-  assert.equal(result, "ok");
-  assert.equal(capturedExpression.includes("function helper"), true);
-  assert.equal(capturedExpression.includes("function target"), true);
-  assert.equal(capturedExpression.includes("return (helper(value) * 2)") || capturedExpression.includes("return helper(value) * 2"), true);
-}
-
-async function testBossChatPageShouldWaitForPanelsClosedInStrictConversationReady() {
-  const calls = [];
-  let stateIndex = 0;
-  const states = [
-    {
-      hasOnlineResume: true,
-      hasAskResume: true,
-      hasAttachmentResume: false,
-      attachmentResumeEnabled: false,
-      resumeModalOpen: false,
-      candidateDetailOpen: true,
-      panelsClosed: false,
-      editorVisible: true,
-      activeSubmit: true,
-      hasAnySubmit: true,
-      messageInputReady: true,
-    },
-    {
-      hasOnlineResume: true,
-      hasAskResume: true,
-      hasAttachmentResume: false,
-      attachmentResumeEnabled: false,
-      resumeModalOpen: false,
-      candidateDetailOpen: false,
-      panelsClosed: true,
-      editorVisible: true,
-      activeSubmit: true,
-      hasAnySubmit: true,
-      messageInputReady: true,
-    }
-  ];
-  const fakeChromeClient = {
-    async callFunction(fn) {
-      calls.push(fn.name);
-      if (fn.name === "browserConversationReadyState") {
-        const value = states[Math.min(stateIndex, states.length - 1)];
-        stateIndex += 1;
-        return value;
-      }
-      throw new Error(`unexpected function: ${fn.name}`);
-    }
-  };
-
-  const page = new BossChatPage(fakeChromeClient);
-  const result = await page.waitForConversationReady({
-    requirePanelsClosed: true,
-    maxAttempts: 3,
-    delayMs: 0
-  });
-
-  assert.equal(result.panelsClosed, true);
-  assert.equal(calls.filter((name) => name === "browserConversationReadyState").length, 2);
-}
-
-async function testBossChatPageShouldSurfaceCandidateDetailOverlayAndContentState() {
-  const fakeChromeClient = {
-    async callFunction(fn) {
-      if (fn.name === "browserIsCandidateDetailOpen") {
-        return {
-          open: true,
-          panelCount: 1,
-          closeCount: 1,
-          topPanelClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-          topPanelScore: 620,
-          panelRect: {
-            left: 980,
-            top: 0,
-            width: 330,
-            height: 760,
-            right: 1310,
-            bottom: 760
-          },
-          closeRect: {
-            left: 1274,
-            top: 12,
-            width: 30,
-            height: 30,
-            right: 1304,
-            bottom: 42
-          },
-          overlayClass: "dialog-wrap active",
-          overlayRect: {
-            left: 0,
-            top: 0,
-            width: 1440,
-            height: 773,
-            right: 1440,
-            bottom: 773
-          },
-          contentClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-          contentRect: {
-            left: 980,
-            top: 0,
-            width: 330,
-            height: 760,
-            right: 1310,
-            bottom: 760
-          }
-        };
-      }
-      throw new Error(`unexpected function: ${fn.name}`);
-    }
-  };
-
-  const page = new BossChatPage(fakeChromeClient);
-  const result = await page.getCandidateDetailState();
-
-  assert.equal(result.overlayClass, "dialog-wrap active");
-  assert.equal(result.contentClass.includes("new-resume-online-main-ui"), true);
-  assert.equal(result.panelRect.left, result.contentRect.left);
-  assert.equal(result.overlayRect.width > result.contentRect.width, true);
-}
-
-async function testBossChatMcpToolsShouldValidateAndRoute() {
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const toolsResponse = await handleRequest({
-      jsonrpc: "2.0",
-      id: 10,
-      method: "tools/list",
-      params: {}
-    }, workspaceRoot);
-    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");
-    assert.deepEqual(prepared.missing_fields, ["job", "start_from", "target_count", "criteria"]);
-    const preparedTargetCountQuestion = prepared.pending_questions.find((item) => item.field === "target_count");
-    assert.equal(preparedTargetCountQuestion.argument_name, "target_count");
-    assert.equal(preparedTargetCountQuestion.recommended_argument_patch.target_count, "all");
-
-    const needInput = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {}, 11);
-    assert.equal(needInput.status, "NEED_INPUT");
-    assert.deepEqual(needInput.required_fields, ["job", "start_from", "target_count", "criteria"]);
-    assert.equal(Array.isArray(needInput.job_options), true);
-    assert.equal(needInput.job_options.length, 2);
-    const targetQuestion = needInput.pending_questions.find((item) => item.field === "target_count");
-    assert.equal(Boolean(targetQuestion), true);
-    assert.equal(targetQuestion.argument_name, "target_count");
-    assert.equal(targetQuestion.recommended_argument_patch.target_count, "all");
-    assert.equal(targetQuestion.options.some((item) => item.value === "all"), true);
-    assert.equal(targetQuestion.options.some((item) => item.label.includes('target_count="all"')), true);
-
-    const missingTargetOnly = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
-      job: "算法工程师",
-      start_from: "all",
-      criteria: "全部候选人都过一遍"
-    }, 111);
-    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");
-    assert.equal(invalidTargetOnly.recommended_argument_patch.target_count, "all");
-
-    const invalidStartResponse = await handleRequest(
-      makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {
-        start_from: "invalid-value"
-      }),
-      workspaceRoot
-    );
-    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, {}),
-      workspaceRoot
-    );
-    assert.equal(invalidGetResponse.error.code, -32602);
-
-    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 经验",
-      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: "算法工程师",
-      start_from: "all",
-      criteria: "全部候选人都过一遍",
-      target_count: "全部候选人"
-    }, 140);
-    assert.equal(startedAll.status, "ACCEPTED");
-    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"
-    }, 15);
-    assert.equal(running.run.state, "running");
-
-    const paused = await callTool(workspaceRoot, TOOL_BOSS_CHAT_PAUSE_RUN, {
-      run_id: started.run_id,
-      profile: "default"
-    }, 16);
-    assert.equal(paused.run.state, "paused");
-
-    const resumed = await callTool(workspaceRoot, TOOL_BOSS_CHAT_RESUME_RUN, {
-      run_id: started.run_id,
-      profile: "default"
-    }, 17);
-    assert.equal(resumed.run.state, "running");
-
-    const canceled = await callTool(workspaceRoot, TOOL_BOSS_CHAT_CANCEL_RUN, {
-      run_id: started.run_id,
-      profile: "default"
-    }, 18);
-    assert.equal(canceled.run.state, "canceled");
-  });
-}
-
-async function testBossChatCliShouldSupportRunAndFollowUpParsing() {
-  const followUpJson = cliTestables.getRunFollowUp({
-    "follow-up-json": JSON.stringify({
-      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({
-    chat: {
-      criteria: "熟悉 MCP",
-      start_from: "all",
-      target_count: 3
-    }
-  }, null, 2));
-  try {
-    const followUpFile = cliTestables.getRunFollowUp({
-      "follow-up-file": tempFile
-    });
-    assert.equal(followUpFile.chat.criteria, "熟悉 MCP");
-    assert.equal(followUpFile.chat.start_from, "all");
-  } finally {
-    fs.rmSync(tempFile, { force: true });
-  }
-
-  await withBossChatWorkspace(async (workspaceRoot) => {
-    const prepareLogs = await captureConsoleLogs(async () => {
-      await cliTestables.runBossChatCliCommand("prepare-run", {
-        "workspace-root": workspaceRoot
-      });
-    });
-    const prepared = JSON.parse(prepareLogs[0]);
-    assert.equal(prepared.status, "NEED_INPUT");
-    assert.equal(prepared.pending_questions.find((item) => item.field === "target_count").argument_name, "target_count");
-
-    const logs = await captureConsoleLogs(async () => {
-      await cliTestables.runBossChatCliCommand("run", {
-        "workspace-root": workspaceRoot,
-        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.last_start_args.greeting, "您好，方便发下简历吗？");
-    assert.equal(state.get_calls[payload.run_id] || 0, 0);
-
-    await captureConsoleLogs(async () => {
-      await cliTestables.runBossChatCliCommand("run", {
-        "workspace-root": workspaceRoot,
-        job: "算法工程师",
-        "start-from": "all",
-        criteria: "全部候选人都过一遍",
-        targetCount: "全部候选人"
-      });
-    });
-    const allState = readStubState(workspaceRoot);
-    assert.equal(allState.last_start_args.targetCount, "-1");
-  });
-}
-
-async function testVendorBossChatCliShouldWaitForHydratedChatShell() {
-  const pageStates = [
-    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: false, listItemCount: 0 },
-    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: false, listItemCount: 0 },
-    { href: "https://www.zhipin.com/web/chat/index", hasListContainer: true, listItemCount: 40 },
-  ];
-  const jobsPerAttempt = [
-    [],
-    [],
-    [{ value: "job-1", label: "AI应用开发工程师（2026） _ 杭州", active: false }],
-  ];
-  let ensureCallCount = 0;
-  let listJobsCallCount = 0;
-  const page = {
-    async ensureOnChatPage() {
-      const next = pageStates[Math.min(ensureCallCount, pageStates.length - 1)];
-      ensureCallCount += 1;
-      return next;
-    },
-    async listJobs() {
-      const next = jobsPerAttempt[Math.min(listJobsCallCount, jobsPerAttempt.length - 1)];
-      listJobsCallCount += 1;
-      return next;
-    },
-  };
-
-  const hydrated = await vendorCliTestables.waitForChatShellHydration({
-    page,
-    maxAttempts: 4,
-    delayMs: 0,
-  });
-  assert.equal(Array.isArray(hydrated.jobs), true);
-  assert.equal(hydrated.jobs.length, 1);
-  assert.equal(hydrated.pageState.listItemCount, 40);
-  assert.equal(ensureCallCount >= 3, true);
-}
-
-async function testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile() {
-  const page = {
-    _attempt: 0,
-    async ensureOnChatPage() {
-      return {
-        href: "https://www.zhipin.com/web/chat/index",
-        hasListContainer: this._attempt >= 1,
-        listItemCount: this._attempt >= 1 ? 10 : 0,
-      };
-    },
-    async listJobs() {
-      this._attempt += 1;
-      if (this._attempt < 2) {
-        return [];
-      }
-      return [
-        {
-          value: "job-1",
-          label: "AI应用开发工程师（2026） _ 杭州",
-          active: false,
-        },
-      ];
-    },
-  };
-
-  const profile = 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: "AI应用开发工程师（2026） _ 杭州",
-      startFrom: "unread",
-      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({
-    packageVersion: "1.3.25",
-    packageRootPath: "C:\\Users\\yaolin\\AppData\\Roaming\\npm\\node_modules\\@reconcrap\\boss-recommend-mcp",
-  });
-  assert.equal(installedSpecifier, "@reconcrap/boss-recommend-mcp@1.3.25");
-
-  const cachedSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
-    packageVersion: "1.3.25",
-    packageRootPath: "C:\\Users\\yaolin\\AppData\\Local\\npm-cache\\_npx\\abcd1234\\node_modules\\@reconcrap\\boss-recommend-mcp",
-  });
-  assert.equal(cachedSpecifier, "@reconcrap/boss-recommend-mcp@1.3.25");
-
-  const sourceSpecifier = cliTestables.getDefaultMcpPackageSpecifier({
-    packageVersion: "1.3.25-dev",
-    packageRootPath: "C:\\Users\\yaolin\\Documents\\codex_projects\\boss recommend pipeline\\boss-recommend-mcp",
-  });
-  assert.equal(sourceSpecifier, "@reconcrap/boss-recommend-mcp@latest");
-
-  const launchConfig = cliTestables.buildMcpLaunchConfig({});
-  assert.equal(launchConfig.command, "npx");
-  assert.equal(Array.isArray(launchConfig.args), true);
-  assert.equal(launchConfig.args[0], "-y");
-}
-
-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(
-    JSON.stringify({
-      passed: true,
-    }),
-  );
-  assert.equal(parsed.passed, true);
-  assert.equal(parsed.rawOutputText.includes('"passed":true'), true);
-}
-
-function testBossChatLlmParserShouldAcceptPlainPassFailText() {
-  const passed = parseLlmJson("PASS");
-  assert.equal(passed.passed, true);
-  const failed = parseLlmJson("false");
-  assert.equal(failed.passed, false);
-}
-
-function testBossChatLlmParserShouldAcceptDecisionField() {
-  const parsed = parseLlmJson(
-    JSON.stringify({
-      decision: "fail",
-    }),
-  );
-  assert.equal(parsed.passed, false);
-}
-
-function testBossChatLlmParserShouldPreserveReasoningFields() {
-  const parsed = parseLlmJson(
-    JSON.stringify({
-      passed: true,
-      reason: "候选人具备 2 段 AI Agent 项目经验",
-      summary: "符合筛选要求",
-      evidence: ["AI Agent", "MCP"],
-    }),
-    {
-      reasoningText: "先检查项目经历，再核对技能栈，结论为通过。",
-    },
-  );
-  assert.equal(parsed.passed, true);
-  assert.equal(parsed.reason, "候选人具备 2 段 AI Agent 项目经验");
-  assert.equal(parsed.summary, "符合筛选要求");
-  assert.equal(parsed.cot, "先检查项目经历，再核对技能栈，结论为通过。");
-  assert.deepEqual(parsed.evidence, ["AI Agent", "MCP"]);
-  assert.equal(parsed.rawReasoningText, "先检查项目经历，再核对技能栈，结论为通过。");
-}
-
-function testBossChatLlmExtractorsShouldReadProviderReasoningFields() {
-  const completionReasoning = extractCompletionReasoningText({
-    choices: [
-      {
-        message: {
-          content: [{ type: "text", text: "{\"passed\":true}" }],
-          reasoning_content: [{ text: "先核对教育背景，再核对项目经历。" }],
-        },
-      },
-    ],
-  });
-  assert.equal(completionReasoning.includes("教育背景"), true);
-
-  const responsesReasoning = extractResponsesReasoningText({
-    output: [
-      {
-        type: "reasoning",
-        summary: [{ text: "根据项目经历与技能关键词判断为通过。" }],
-      },
-    ],
-  });
-  assert.equal(responsesReasoning.includes("技能关键词"), true);
-}
-
-async function testBossChatLlmTextChunkFallbackShouldWork() {
-  const originalChunkSize = process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS;
-  const originalChunkOverlap = process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS;
-  const originalMaxChunks = process.env.BOSS_CHAT_TEXT_MAX_CHUNKS;
-  process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS = "1000";
-  process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS = "120";
-  process.env.BOSS_CHAT_TEXT_MAX_CHUNKS = "6";
-  try {
-    class FakeChunkFallbackClient extends LlmClient {
-      constructor() {
-        super({
-          baseUrl: "https://api.example.com/v1",
-          apiKey: "sk-test",
-          model: "gpt-test",
-        });
-        this.calls = [];
-      }
-
-      async requestByPreference(payload) {
-        this.calls.push(payload);
-        const prompt = String(payload?.prompt || "");
-        if (prompt.includes("简历文本:") && !prompt.includes("当前分段：")) {
-          const error = new Error("maximum context length exceeded");
-          throw error;
-        }
-        if (prompt.includes("当前分段：")) {
-          return {
-            rawOutputText: JSON.stringify({
-              chunk_passed: Number(payload.chunkIndex) === 2,
-              chunk_summary: Number(payload.chunkIndex) === 2 ? "命中核心 AI 项目经历" : "当前分段证据不足",
-              hard_evidence: Number(payload.chunkIndex) === 2 ? ["PASS_MARKER_DEF"] : ["PASS_MARKER_ABC"],
-              soft_evidence: [],
-              hard_blockers: [],
-              missing_or_uncertain: Number(payload.chunkIndex) === 2 ? [] : ["需结合后续分段"],
-              quoted_spans: Number(payload.chunkIndex) === 2 ? ["PASS_MARKER_DEF"] : ["PASS_MARKER_ABC"],
-              chunk_index: payload.chunkIndex,
-              chunk_total: payload.chunkTotal,
-            }),
-            chunk_passed: Number(payload.chunkIndex) === 2,
-            chunkIndex: payload.chunkIndex,
-            chunkTotal: payload.chunkTotal,
-          };
-        }
-        return {
-          passed: true,
-          rawOutputText: JSON.stringify({
-            passed: true,
-            reason: "综合全部分段后，候选人具备目标 AI 项目证据。",
-            summary: "长简历聚合后通过",
-            evidence: ["PASS_MARKER_DEF"],
-          }),
-          chunkIndex: null,
-          chunkTotal: payload?.aggregateInput?.chunk_count || null,
-        };
-      }
-    }
-
-    const client = new FakeChunkFallbackClient();
-    const longResume = `${"A".repeat(1200)} PASS_MARKER_ABC ${"B".repeat(1200)} PASS_MARKER_DEF`;
-    const result = await client.evaluateResume({
-      screeningCriteria: "有 AI 项目经验",
-      candidate: {
-        name: "候选人A",
-        sourceJob: "算法工程师",
-        resumeText: longResume,
-        evidenceCorpus: longResume,
-      },
-      imagePath: null,
-    });
-    assert.equal(result.passed, true);
-    assert.equal(result.evaluationMode, "text-chunk-aggregate");
-    assert.equal(result.chunkIndex, null);
-    assert.equal(Number(result.chunkTotal) > 1, true);
-  } finally {
-    if (originalChunkSize === undefined) delete process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS;
-    else process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS = originalChunkSize;
-    if (originalChunkOverlap === undefined) delete process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS;
-    else process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS = originalChunkOverlap;
-    if (originalMaxChunks === undefined) delete process.env.BOSS_CHAT_TEXT_MAX_CHUNKS;
-    else process.env.BOSS_CHAT_TEXT_MAX_CHUNKS = originalMaxChunks;
-  }
-}
-
-async function testBossChatLlmShouldApplyThinkingDefaultsAndOverrides() {
-  const completionResponse = {
-    ok: true,
-    status: 200,
-    async json() {
-      return {
-        choices: [
-          {
-            message: {
-              content: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"resume\"]}"
-            }
-          }
-        ]
-      };
-    }
-  };
-  const responsesResponse = {
-    ok: true,
-    status: 200,
-    async json() {
-      return {
-        output_text: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"resume\"]}"
-      };
-    }
-  };
-
-  let volcCompletionPayload = null;
-  const volcClient = new LlmClient({
-    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
-    apiKey: "sk-test",
-    model: "doubao-seed-2-0-mini-260215",
-  }, {
-    fetchImpl: async (_url, options = {}) => {
-      volcCompletionPayload = JSON.parse(String(options.body || "{}"));
-      return completionResponse;
-    },
-  });
-  await volcClient.requestCompletions({ prompt: "prompt", evidenceCorpus: "resume" });
-  assert.deepEqual(volcCompletionPayload.thinking, { type: "enabled" });
-  assert.equal(volcCompletionPayload.reasoning_effort, "low");
-
-  let lowCompletionPayload = null;
-  const lowClient = new LlmClient({
-    baseUrl: "https://ark.cn-beijing.volces.com/api/v3",
-    apiKey: "sk-test",
-    model: "doubao-seed-2-0-mini-260215",
-    thinkingLevel: "low",
-  }, {
-    fetchImpl: async (_url, options = {}) => {
-      lowCompletionPayload = JSON.parse(String(options.body || "{}"));
-      return completionResponse;
-    },
-  });
-  await lowClient.requestCompletions({ prompt: "prompt", evidenceCorpus: "resume" });
-  assert.deepEqual(lowCompletionPayload.thinking, { type: "enabled" });
-  assert.equal(lowCompletionPayload.reasoning_effort, "low");
-
-  let openaiCompletionPayload = null;
-  const openaiClient = new LlmClient({
-    baseUrl: "https://api.openai.com/v1",
-    apiKey: "sk-test",
-    model: "gpt-test",
-  }, {
-    fetchImpl: async (_url, options = {}) => {
-      openaiCompletionPayload = JSON.parse(String(options.body || "{}"));
-      return completionResponse;
-    },
-  });
-  await openaiClient.requestCompletions({ prompt: "prompt", evidenceCorpus: "resume" });
-  assert.equal(openaiCompletionPayload.thinking, undefined);
-  assert.equal(openaiCompletionPayload.reasoning_effort, "low");
-
-  let responsesPayload = null;
-  const responsesClient = new LlmClient({
-    baseUrl: "https://api.openai.com/v1",
-    apiKey: "sk-test",
-    model: "gpt-test",
-    thinkingLevel: "low",
-  }, {
-    fetchImpl: async (_url, options = {}) => {
-      responsesPayload = JSON.parse(String(options.body || "{}"));
-      return responsesResponse;
-    },
-  });
-  await responsesClient.requestResponses({ prompt: "prompt", evidenceCorpus: "resume" });
-  assert.deepEqual(responsesPayload.reasoning, { effort: "low" });
-}
-
-async function testBossChatLlmShouldSendAllImageChunksInSingleRequest() {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-image-chunks-"));
-  const firstImage = path.join(tempDir, "chunk-1.png");
-  const secondImage = path.join(tempDir, "chunk-2.png");
-  fs.writeFileSync(
-    firstImage,
-    Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN4QAAAAASUVORK5CYII=", "base64"),
-  );
-  fs.writeFileSync(
-    secondImage,
-    Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN4QAAAAASUVORK5CYII=", "base64"),
-  );
-
-  let completionPayload = null;
-  const client = new LlmClient({
-    baseUrl: "https://api.openai.com/v1",
-    apiKey: "sk-test",
-    model: "gpt-test",
-  }, {
-    fetchImpl: async (_url, options = {}) => {
-      completionPayload = JSON.parse(String(options.body || "{}"));
-      return {
-        ok: true,
-        status: 200,
-        async json() {
-          return {
-            choices: [
-              {
-                message: {
-                  content: "{\"passed\":true}",
-                },
-              },
-            ],
-          };
-        },
-      };
-    },
-  });
-
-  try {
-    const result = await client.evaluateResume({
-      screeningCriteria: "有 AI 项目经验",
-      candidate: {
-        name: "候选人A",
-        sourceJob: "算法工程师",
-        resumeText: "",
-        evidenceCorpus: "",
-      },
-      imagePaths: [firstImage, secondImage],
-    });
-
-    assert.equal(result.passed, true);
-    assert.equal(result.evaluationMode, "image-multi-chunk");
-    assert.equal(result.imageCount, 2);
-    assert.equal(Array.isArray(completionPayload.messages?.[0]?.content), true);
-    assert.equal(
-      completionPayload.messages[0].content.filter((item) => item.type === "image_url").length,
-      2,
-    );
-  } finally {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  }
-}
-
-async function testBossChatAppShouldResetPrimaryChatLabelBeforeInitialPrime() {
-  const calls = [];
-  const page = {
-    async ensureReady() {
-      calls.push("ensureReady");
-      return { hasListContainer: true, listItemCount: 1 };
-    },
-    async activatePrimaryChatLabel(label) {
-      calls.push(`activatePrimaryChatLabel:${label}`);
-      return { changed: false, verified: true, activeLabel: label };
-    },
-    async selectJob(jobSelection) {
-      calls.push(`selectJob:${jobSelection.label}`);
-      return jobSelection;
-    },
-    async activateUnreadFilter() {
-      calls.push("activateUnreadFilter");
-      return { changed: false, verified: true, activeLabel: "未读" };
-    },
-    async primeConversationByFirstCandidate() {
-      calls.push("primeConversationByFirstCandidate:1");
-      return {
-        candidate: {
-          customerId: "1001",
-          name: "候选人A",
-          sourceJob: "算法工程师",
-          domIndex: 0,
-        },
-        totalVisibleCandidates: 1,
-        readyState: {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false,
-        },
-      };
-    },
-    async getLoadedCustomers() {
-      calls.push("getLoadedCustomers:1");
-      return [];
-    },
-    async closeResumeModalDomOnce() {
-      return {
-        closed: true,
-        method: "already-closed",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-  };
-  const stateStore = {
-    async load() {},
-    hasAny() {
-      return false;
-    },
-    async record() {},
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient: {},
-    interaction: {
-      async sleepRange() {},
-      async maybeRest() {},
-    },
-    resumeCaptureService: {},
-    stateStore,
-    reportStore: {
-      async write() {
-        return "report.json";
-      },
-    },
-    logger: { log() {} },
-    dryRun: true,
-    artifactRootDir: os.tmpdir(),
-    resumeOpenCooldownMs: 0,
-  });
-  app.waitForCandidateList = async ({ reason } = {}) => {
-    calls.push(`waitForCandidateList:${reason || "unknown"}`);
-    return {
-      ready: true,
-      waitedMs: 0,
-      attempts: 1,
-      listItemCount: 1,
-      lastError: "",
-    };
-  };
-  app.processCustomer = async (_customer, _profile, _runId, options = {}) => {
-    calls.push(`processCustomer:${options.skipCardClick === true ? "skip" : "click"}`);
-    return {
-      name: "候选人A",
-      passed: false,
-      requested: false,
-      reason: "skip",
-      error: "",
-      artifacts: {},
-    };
-  };
-
-  const summary = await app.run({
-    screeningCriteria: "有 AI 项目经验",
-    targetCount: 1,
-    startFrom: "unread",
-    jobSelection: { label: "算法工程师", value: "job-1" },
-    chrome: { port: 9222 },
-    llm: { model: "gpt-test" },
-  });
-
-  assert.deepEqual(calls.slice(0, 4), [
-    "ensureReady",
-    "activatePrimaryChatLabel:全部",
-    "selectJob:算法工程师",
-    "activateUnreadFilter",
-  ]);
-  assert.equal(calls.includes("primeConversationByFirstCandidate:1"), true);
-  assert.equal(calls.includes("processCustomer:skip"), true);
-  assert.equal(summary.inspected, 1);
-  assert.equal(summary.skipped, 1);
-}
-
-async function testBossChatAppShouldCloseCandidateDetailDuringRunCleanup() {
-  const calls = [];
-  const page = {
-    async ensureReady() {
-      calls.push("ensureReady");
-      return { hasListContainer: true, listItemCount: 1 };
-    },
-    async activatePrimaryChatLabel(label) {
-      calls.push(`activatePrimaryChatLabel:${label}`);
-      return { changed: false, verified: true, activeLabel: label };
-    },
-    async selectJob(jobSelection) {
-      calls.push(`selectJob:${jobSelection.label}`);
-      return jobSelection;
-    },
-    async activateUnreadFilter() {
-      calls.push("activateUnreadFilter");
-      return { changed: false, verified: true, activeLabel: "未读" };
-    },
-    async primeConversationByFirstCandidate() {
-      calls.push("primeConversationByFirstCandidate:1");
-      return {
-        candidate: {
-          customerId: "1008",
-          name: "候选人清理",
-          sourceJob: "算法工程师",
-          domIndex: 0
-        },
-        totalVisibleCandidates: 1,
-        readyState: {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false
-        }
-      };
-    },
-    async getLoadedCustomers() {
-      calls.push("getLoadedCustomers:1");
-      return [];
-    },
-    async closeResumeModalDomOnce() {
-      calls.push("closeResumeModalDomOnce");
-      return {
-        closed: true,
-        method: "already-closed",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" }
-      };
-    },
-    async closeCandidateDetailDomOnce() {
-      calls.push("closeCandidateDetailDomOnce");
-      return {
-        closed: true,
-        method: "dom-close-once:.close-btn",
-        finalState: { panelCount: 0, closeCount: 0, topPanelClass: "" }
-      };
-    }
-  };
-  const stateStore = {
-    async load() {},
-    hasAny() {
-      return false;
-    },
-    async record() {}
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient: {},
-    interaction: {
-      async sleepRange() {},
-      async maybeRest() {}
-    },
-    resumeCaptureService: {},
-    stateStore,
-    reportStore: {
-      async write() {
-        return "report.json";
-      }
-    },
-    logger: { log() {} },
-    dryRun: true,
-    artifactRootDir: os.tmpdir(),
-    resumeOpenCooldownMs: 0
-  });
-  app.waitForCandidateList = async ({ reason } = {}) => {
-    calls.push(`waitForCandidateList:${reason || "unknown"}`);
-    return {
-      ready: true,
-      waitedMs: 0,
-      attempts: 1,
-      listItemCount: 1,
-      lastError: ""
-    };
-  };
-  app.processCustomer = async () => ({
-    name: "候选人清理",
-    passed: false,
-    requested: false,
-    reason: "skip",
-    error: "",
-    artifacts: {}
-  });
-
-  const summary = await app.run({
-    screeningCriteria: "有 AI 项目经验",
-    targetCount: 1,
-    startFrom: "unread",
-    jobSelection: { label: "算法工程师", value: "job-1" },
-    chrome: { port: 9222 },
-    llm: { model: "gpt-test" }
-  });
-
-  assert.equal(summary.inspected, 1);
-  assert.equal(calls.includes("closeCandidateDetailDomOnce"), true);
-  assert.equal(calls.lastIndexOf("closeCandidateDetailDomOnce") > calls.indexOf("getLoadedCustomers:1"), true);
-}
-
-async function testBossChatAppShouldRestoreListContextAfterRecovery() {
-  const calls = [];
-  let primeCount = 0;
-  let loadedCount = 0;
-  const page = {
-    async ensureReady() {
-      return { hasListContainer: true, listItemCount: 1 };
-    },
-    async activatePrimaryChatLabel(label) {
-      calls.push(`activatePrimaryChatLabel:${label}`);
-      return { changed: false, verified: true, activeLabel: label };
-    },
-    async selectJob(jobSelection) {
-      calls.push(`selectJob:${jobSelection.label}`);
-      return jobSelection;
-    },
-    async activateUnreadFilter() {
-      calls.push("activateUnreadFilter");
-      return { changed: false, verified: true, activeLabel: "未读" };
-    },
-    async primeConversationByFirstCandidate() {
-      primeCount += 1;
-      calls.push(`primeConversationByFirstCandidate:${primeCount}`);
-      if (primeCount === 1) {
-        throw new Error("NO_FIRST_CANDIDATE");
-      }
-      return {
-        candidate: {
-          customerId: "1002",
-          name: "候选人B",
-          sourceJob: "算法工程师",
-          domIndex: 0,
-        },
-        totalVisibleCandidates: 1,
-        readyState: {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false,
-        },
-      };
-    },
-    async getLoadedCustomers() {
-      loadedCount += 1;
-      calls.push(`getLoadedCustomers:${loadedCount}`);
-      if (loadedCount === 1) {
-        throw new Error("CHAT_CARD_LIST_NOT_FOUND");
-      }
-      return [];
-    },
-    async recoverToChatIndex() {
-      calls.push("recoverToChatIndex");
-      return { changed: true, href: "https://www.zhipin.com/web/chat/index" };
-    },
-    async closeResumeModalDomOnce() {
-      return {
-        closed: true,
-        method: "already-closed",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-  };
-  const stateStore = {
-    async load() {},
-    hasAny() {
-      return false;
-    },
-    async record() {},
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient: {},
-    interaction: {
-      async sleepRange() {},
-      async maybeRest() {},
-    },
-    resumeCaptureService: {},
-    stateStore,
-    reportStore: {
-      async write() {
-        return "report.json";
-      },
-    },
-    logger: { log() {} },
-    dryRun: true,
-    artifactRootDir: os.tmpdir(),
-    resumeOpenCooldownMs: 0,
-  });
-  app.waitForCandidateList = async ({ reason } = {}) => {
-    calls.push(`waitForCandidateList:${reason || "unknown"}`);
-    return {
-      ready:
-        reason === "initial-context-restore" ||
-        reason === "post-recovery-context-restore",
-      waitedMs: 0,
-      attempts: 1,
-      listItemCount:
-        reason === "initial-context-restore" ||
-        reason === "post-recovery-context-restore"
-          ? 1
-          : 0,
-      lastError: "",
-    };
-  };
-  app.processCustomer = async (_customer, _profile, _runId, options = {}) => {
-    calls.push(`processCustomer:${options.skipCardClick === true ? "skip" : "click"}`);
-    return {
-      name: "候选人B",
-      passed: false,
-      requested: false,
-      reason: "skip",
-      error: "",
-      artifacts: {},
-    };
-  };
-
-  const summary = await app.run({
-    screeningCriteria: "有 AI 项目经验",
-    targetCount: 1,
-    startFrom: "unread",
-    jobSelection: { label: "算法工程师", value: "job-1" },
-    chrome: { port: 9222 },
-    llm: { model: "gpt-test" },
-  });
-
-  assert.equal(calls.filter((item) => item === "activatePrimaryChatLabel:全部").length, 2);
-  const recoverIndex = calls.indexOf("recoverToChatIndex");
-  assert.equal(recoverIndex >= 0, true);
-  assert.equal(calls[recoverIndex + 1], "activatePrimaryChatLabel:全部");
-  assert.equal(calls[recoverIndex + 2], "selectJob:算法工程师");
-  assert.equal(calls[recoverIndex + 3], "activateUnreadFilter");
-  assert.equal(calls[recoverIndex + 4], "waitForCandidateList:post-recovery-context-restore");
-  assert.equal(calls[recoverIndex + 5], "primeConversationByFirstCandidate:2");
-  assert.equal(calls.includes("processCustomer:skip"), true);
-  assert.equal(summary.inspected, 1);
-  assert.equal(summary.skipped, 1);
-}
-
-async function testBossChatAppShouldWaitForCandidateListBeforePriming() {
-  const calls = [];
-  let pageStateCall = 0;
-  const page = {
-    async ensureReady() {
-      calls.push("ensureReady");
-      return { hasListContainer: false, listItemCount: 0 };
-    },
-    async activatePrimaryChatLabel(label) {
-      calls.push(`activatePrimaryChatLabel:${label}`);
-      return { changed: false, verified: true, activeLabel: label };
-    },
-    async selectJob(jobSelection) {
-      calls.push(`selectJob:${jobSelection.label}`);
-      return jobSelection;
-    },
-    async activateUnreadFilter() {
-      calls.push("activateUnreadFilter");
-      return { changed: true, verified: true, activeLabel: "未读" };
-    },
-    async getPageState() {
-      pageStateCall += 1;
-      calls.push(`getPageState:${pageStateCall}`);
-      return {
-        href: "https://www.zhipin.com/web/chat/index",
-        readyState: "complete",
-        hasListContainer: pageStateCall >= 3,
-        listItemCount: pageStateCall >= 3 ? 2 : 0,
-      };
-    },
-    async primeConversationByFirstCandidate() {
-      calls.push("primeConversationByFirstCandidate:1");
-      return {
-        candidate: {
-          customerId: "1003",
-          name: "候选人C",
-          sourceJob: "算法工程师",
-          domIndex: 0,
-        },
-        totalVisibleCandidates: 2,
-        readyState: {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false,
-        },
-      };
-    },
-    async getLoadedCustomers() {
-      calls.push("getLoadedCustomers:1");
-      return [];
-    },
-    async closeResumeModalDomOnce() {
-      return {
-        closed: true,
-        method: "already-closed",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-  };
-  const stateStore = {
-    async load() {},
-    hasAny() {
-      return false;
-    },
-    async record() {},
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient: {},
-    interaction: {
-      async sleepRange() {},
-      async maybeRest() {},
-    },
-    resumeCaptureService: {},
-    stateStore,
-    reportStore: {
-      async write() {
-        return "report.json";
-      },
-    },
-    logger: { log() {} },
-    dryRun: true,
-    artifactRootDir: os.tmpdir(),
-    resumeOpenCooldownMs: 0,
-  });
-  app.processCustomer = async (_customer, _profile, _runId, options = {}) => {
-    calls.push(`processCustomer:${options.skipCardClick === true ? "skip" : "click"}`);
-    return {
-      name: "候选人C",
-      passed: false,
-      requested: false,
-      reason: "skip",
-      error: "",
-      artifacts: {},
-    };
-  };
-
-  const summary = await app.run({
-    screeningCriteria: "有 AI 项目经验",
-    targetCount: 1,
-    startFrom: "unread",
-    jobSelection: { label: "算法工程师", value: "job-1" },
-    chrome: { port: 9222 },
-    llm: { model: "gpt-test" },
-  });
-
-  const primeIndex = calls.indexOf("primeConversationByFirstCandidate:1");
-  const thirdStateIndex = calls.indexOf("getPageState:3");
-  assert.equal(thirdStateIndex >= 0, true);
-  assert.equal(primeIndex > thirdStateIndex, true);
-  assert.equal(summary.inspected, 1);
-  assert.equal(summary.skipped, 1);
-}
-
-function createProcessCustomerHarness({
-  llmEvaluate,
-  captureResume,
-  tracker,
-  pageOverrides = {},
-  dryRun = true,
-} = {}) {
-  const recorded = [];
-  const page = {
-    async closeResumeModalDomOnce() {
-      recorded.push("closeResumeModalDomOnce");
-      return {
-        closed: true,
-        method: "dom",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-    async closeResumeModal() {
-      recorded.push("closeResumeModal");
-      return {
-        closed: true,
-        method: "closeResumeModal",
-        finalState: { open: false, scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-    async closeCandidateDetailDomOnce() {
-      recorded.push("closeCandidateDetailDomOnce");
-      return {
-        closed: true,
-        method: "already-closed",
-        finalState: {
-          open: false,
-          panelCount: 0,
-          closeCount: 0,
-          topPanelClass: "",
-          overlayClass: "",
-          contentClass: "",
-        },
-      };
-    },
-    async closeCandidateDetail() {
-      recorded.push("closeCandidateDetail");
-      return {
-        closed: true,
-        method: "closeCandidateDetail",
-        finalState: {
-          open: false,
-          panelCount: 0,
-          closeCount: 0,
-          topPanelClass: "",
-          overlayClass: "",
-          contentClass: "",
-        },
-      };
-    },
-    async waitForConversationReady(options = {}) {
-      recorded.push(options.requirePanelsClosed ? "waitForConversationReady:strict" : "waitForConversationReady");
-      return {
-        hasOnlineResume: true,
-        hasAskResume: true,
-        hasAttachmentResume: false,
-        attachmentResumeEnabled: false,
-        resumeModalOpen: false,
-        candidateDetailOpen: false,
-        panelsClosed: true,
-        editorVisible: true,
-        activeSubmit: true,
-        hasAnySubmit: true,
-        messageInputReady: true,
-      };
-    },
-    async openOnlineResume() {
-      recorded.push("openOnlineResume");
-      return { clicked: true, detectedOpen: true, by: "dom" };
-    },
-    async getResumeRateLimitWarning() {
-      return { hit: false, text: "" };
-    },
-    async getResumeModalState() {
-      return { open: true, iframeCount: 1, scopeCount: 1, closeCount: 1 };
-    },
-    async getCandidateDetailState() {
-      return {
-        open: false,
-        panelCount: 0,
-        closeCount: 0,
-        topPanelClass: "",
-        overlayClass: "",
-        contentClass: "",
-        panelRect: null,
-        overlayRect: null,
-        contentRect: null,
-        closeRect: null,
-      };
-    },
-    async waitForCandidateActivated() {
-      recorded.push("waitForCandidateActivated");
-      return { matched: true };
-    },
-    async activateCandidate() {
-      recorded.push("activateCandidate");
-      return { ok: true };
-    },
-    async setEditorMessage(message) {
-      recorded.push("setEditorMessage");
-      return { value: message, activeSubmit: true };
-    },
-    async sendMessage() {
-      recorded.push("sendMessage");
-      return { sent: true, method: "dom-submit", cleared: true, editorAfter: "" };
-    },
-    async clickAskResume() {
-      recorded.push("clickAskResume");
-      return { ok: true, alreadyRequested: false };
-    },
-    async clickConfirmRequestResume() {
-      recorded.push("clickConfirmRequestResume");
-      return {
-        ok: true,
-        confirmed: true,
-        requestedVerified: true,
-        assumedRequested: false,
-        uiState: { hasDisabledOperateAsk: true },
-      };
-    },
-    async getResumeRequestMessageState() {
-      recorded.push("getResumeRequestMessageState");
-      return { ok: true, count: 0, lastText: "", recent: [] };
-    },
-    async waitForResumeRequestMessage() {
-      recorded.push("waitForResumeRequestMessage");
-      return {
-        observed: true,
-        state: {
-          ok: true,
-          count: 1,
-          lastText: "简历请求已发送",
-          recent: ["简历请求已发送"],
-        },
-      };
-    },
-    ...pageOverrides,
-  };
-  const llmCalls = [];
-  const llmClient = {
-    async evaluateResume(payload) {
-      llmCalls.push(payload);
-      return llmEvaluate(payload);
-    },
-  };
-  const resumeCaptureService = {
-    async captureResume(payload) {
-      recorded.push("captureResume");
-      return captureResume(payload);
-    },
-  };
-  const stateStore = {
-    async record(_key, result) {
-      recorded.push(`record:${result.decision}`);
-    },
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient,
-    interaction: {
-      async sleepRange() {},
-      async clickRect() {},
-    },
-    resumeCaptureService,
-    resumeNetworkTracker: tracker || null,
-    stateStore,
-    reportStore: { async write() { return ""; } },
-    dryRun,
-    artifactRootDir: os.tmpdir(),
-    resumeOpenCooldownMs: 0,
-    logger: { log() {} },
-  });
-  app.waitResumeOpenCooldown = async () => {};
-  return { app, llmCalls, recorded };
-}
-
-async function testBossChatResumeTrackerShouldRetryInitialNetworkWait() {
-  const tracker = new ResumeNetworkTracker({
-    chromeClient: { Network: null },
-    logger: { log() {} },
-  });
-  const waits = [];
-  let callCount = 0;
-  tracker.waitForNetworkResumeCandidateInfo = async (_candidate, timeoutMs) => {
-    waits.push(timeoutMs);
-    callCount += 1;
-    if (callCount === 2) {
-      return {
-        candidateInfo: { resumeText: "network resume" },
-        source: "geek_id_map",
-        waitedMs: 80,
-      };
-    }
-    return null;
-  };
-  const result = await tracker.waitForResumeNetworkByMode({ customerId: "1001" });
-  assert.deepEqual(waits, [NETWORK_RESUME_WAIT_MS, NETWORK_RESUME_RETRY_WAIT_MS]);
-  assert.equal(result.acquisitionReason, "network_retry_hit");
-}
-
-async function testBossChatResumeTrackerShouldUseImageModeGraceWindow() {
-  const tracker = new ResumeNetworkTracker({
-    chromeClient: { Network: null },
-    logger: { log() {} },
-  });
-  tracker.setResumeAcquisitionMode("image", "previous_image_fallback");
-  const waits = [];
-  tracker.waitForNetworkResumeCandidateInfo = async (_candidate, timeoutMs) => {
-    waits.push(timeoutMs);
-    return null;
-  };
-  const result = await tracker.waitForResumeNetworkByMode({ customerId: "1002" });
-  assert.deepEqual(waits, [NETWORK_RESUME_IMAGE_MODE_GRACE_MS]);
-  assert.equal(result.initialWaitMs >= 0, true);
-  assert.equal(result.retryWaitMs, 0);
-}
-
-async function testBossChatAppShouldUseNetworkBeforeImageFallback() {
-  const tracker = {
-    resumeNetworkDiagnostics: [],
-    getResumeAcquisitionState() {
-      return { mode: "network", reason: "initial_network_hit" };
-    },
-    async waitForResumeNetworkByMode() {
-      return {
-        candidateInfo: {
-          name: "候选人A",
-          school: "清华大学",
-          major: "计算机",
-          company: "OpenAI",
-          position: "工程师",
-          resumeText: "清华大学 计算机 OpenAI",
-          evidenceCorpus: "清华大学 计算机 OpenAI",
-        },
-        acquisitionReason: "initial_network_hit",
-        initialWaitMs: 12,
-        retryWaitMs: 0,
-      };
-    },
-    async waitForLateNetworkResumeCandidateInfo() {
-      throw new Error("late network retry should not run");
-    },
-  };
-  const { app, llmCalls, recorded } = createProcessCustomerHarness({
-    tracker,
-    llmEvaluate: async () => ({
-      passed: true,
-      rawOutputText: '{"passed":true}',
-      evaluationMode: "text",
-      chunkIndex: 1,
-      chunkTotal: 1,
-    }),
-    captureResume: async () => {
-      throw new Error("image capture should not run");
-    },
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-network",
-      name: "候选人A",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "1001",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-network",
-    { skipCardClick: true },
-  );
-
-  assert.equal(result.artifacts.resumeAcquisitionMode, "network");
-  assert.equal(result.artifacts.resumeAcquisitionReason, "initial_network_hit");
-  assert.equal(llmCalls.length, 1);
-  assert.equal(llmCalls[0].candidate.resumeText.includes("清华大学"), true);
-  assert.equal(Array.isArray(llmCalls[0].imagePaths), false);
-  assert.equal(recorded.includes("captureResume"), false);
-}
-
-async function testBossChatAppShouldFallbackToImageAfterNetworkMiss() {
-  const tracker = {
-    resumeNetworkDiagnostics: [],
-    setResumeAcquisitionMode(mode, reason) {
-      this.state = { mode, reason };
-    },
-    getResumeAcquisitionState() {
-      return this.state || { mode: "image", reason: "image_capture_success" };
-    },
-    async waitForResumeNetworkByMode() {
-      return {
-        candidateInfo: null,
-        acquisitionReason: "",
-        initialWaitMs: 10,
-        retryWaitMs: 20,
-      };
-    },
-    async waitForLateNetworkResumeCandidateInfo() {
-      return {
-        candidateInfo: null,
-        acquisitionReason: "",
-        lateRetryMs: 0,
-      };
-    },
-  };
-  const { app, llmCalls } = createProcessCustomerHarness({
-    tracker,
-    llmEvaluate: async () => ({
-      passed: false,
-      rawOutputText: '{"passed":false}',
-      evaluationMode: "image-multi-chunk",
-      imageCount: 2,
-      chunkIndex: 1,
-      chunkTotal: 1,
-    }),
-    captureResume: async ({ artifactDir }) => ({
-      metadataFile: path.join(artifactDir, "chunks.json"),
-      chunkDir: path.join(artifactDir, "chunks"),
-      chunkCount: 2,
-      modelImagePaths: [
-        path.join(artifactDir, "chunks", "chunk_000.png"),
-        path.join(artifactDir, "chunks", "chunk_001.png"),
-      ],
-      stitchedImage: "",
-      quality: { likelyBlank: false },
-    }),
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-image",
-      name: "候选人B",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "1002",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-image",
-    { skipCardClick: true },
-  );
-
-  assert.equal(result.artifacts.resumeAcquisitionMode, "image_fallback");
-  assert.equal(result.artifacts.resumeAcquisitionReason, "image_capture_success");
-  assert.equal(Array.isArray(llmCalls[0].imagePaths), true);
-  assert.equal(llmCalls[0].imagePaths.length, 2);
-}
-
-async function testBossChatAppShouldRetryLateNetworkBeforeDomFallback() {
-  const tracker = {
-    resumeNetworkDiagnostics: [],
-    getResumeAcquisitionState() {
-      return { mode: "network", reason: "late_network_hit" };
-    },
-    setResumeAcquisitionMode() {},
-    async waitForResumeNetworkByMode() {
-      return {
-        candidateInfo: null,
-        acquisitionReason: "",
-        initialWaitMs: 10,
-        retryWaitMs: 20,
-      };
-    },
-    async waitForLateNetworkResumeCandidateInfo() {
-      return {
-        candidateInfo: {
-          name: "候选人C",
-          school: "上海交大",
-          major: "软件工程",
-          resumeText: "上海交大 软件工程",
-          evidenceCorpus: "上海交大 软件工程",
-        },
-        acquisitionReason: "late_network_hit",
-        lateRetryMs: 30,
-      };
-    },
-  };
-  let imageAttempt = 0;
-  const { app, llmCalls } = createProcessCustomerHarness({
-    tracker,
-    llmEvaluate: async (payload) => {
-      imageAttempt += 1;
-      if (Array.isArray(payload.imagePaths) && payload.imagePaths.length > 0) {
-        throw new Error("VISION_MODEL_FAILED");
-      }
-      return {
-        passed: true,
-        rawOutputText: '{"passed":true}',
-        evaluationMode: "text",
-        chunkIndex: 1,
-        chunkTotal: 1,
-      };
-    },
-    captureResume: async ({ artifactDir }) => ({
-      metadataFile: path.join(artifactDir, "chunks.json"),
-      chunkDir: path.join(artifactDir, "chunks"),
-      chunkCount: 1,
-      modelImagePaths: [path.join(artifactDir, "chunks", "chunk_000.png")],
-      stitchedImage: "",
-      quality: { likelyBlank: false },
-    }),
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-late-network",
-      name: "候选人C",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "1003",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-late-network",
-    { skipCardClick: true },
-  );
-
-  assert.equal(imageAttempt >= 2, true);
-  assert.equal(result.artifacts.resumeAcquisitionMode, "network");
-  assert.equal(result.artifacts.resumeAcquisitionReason, "late_network_hit");
-  assert.equal(llmCalls[llmCalls.length - 1].candidate.resumeText.includes("上海交大"), true);
-}
-
-async function testBossChatAppShouldUseDomOnlyAfterHigherPriorityPathsFail() {
-  let domReadCount = 0;
-  const tracker = {
-    resumeNetworkDiagnostics: [],
-    getResumeAcquisitionState() {
-      return { mode: "image", reason: "image_capture_success" };
-    },
-    setResumeAcquisitionMode() {},
-    async waitForResumeNetworkByMode() {
-      return {
-        candidateInfo: null,
-        acquisitionReason: "",
-        initialWaitMs: 10,
-        retryWaitMs: 20,
-      };
-    },
-    async waitForLateNetworkResumeCandidateInfo() {
-      return {
-        candidateInfo: null,
-        acquisitionReason: "",
-        lateRetryMs: 15,
-      };
-    },
-    async waitForNetworkResumeCandidateInfo() {
-      return null;
-    },
-  };
-  const { app, recorded } = createProcessCustomerHarness({
-    tracker,
-    llmEvaluate: async (payload) => ({
-      passed: false,
-      rawOutputText: '{"passed":false}',
-      evaluationMode: "text",
-      chunkIndex: 1,
-      chunkTotal: 1,
-      imageCount: 0,
-    }),
-    captureResume: async () => {
-      throw new Error("IMAGE_CAPTURE_FAILED");
-    },
-    pageOverrides: {
-      async getResumeProfileFromDom() {
-        domReadCount += 1;
-        if (domReadCount === 1) {
-          return {
-            ok: true,
-            name: "李同学",
-            primarySchool: "北京大学",
-            schools: ["北京大学"],
-            major: "数学",
-            majors: ["数学"],
-            company: "",
-            position: "",
-            resumeText: "北京大学 数学",
-            evidenceCorpus: "北京大学 数学",
-          };
-        }
-        return {
-          ok: true,
-          name: "候选人D",
-          primarySchool: "浙江大学",
-          schools: ["浙江大学"],
-          major: "计算机",
-          majors: ["计算机"],
-          company: "",
-          position: "",
-          resumeText: "浙江大学 计算机",
-          evidenceCorpus: "浙江大学 计算机",
-        };
-      },
-    },
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-dom",
-      name: "候选人D",
-      school: "浙江大学",
-      major: "计算机",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "1004",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-dom",
-    { skipCardClick: true },
-  );
-
-  assert.equal(result.artifacts.resumeAcquisitionMode, "dom_fallback");
-  assert.equal(result.artifacts.resumeAcquisitionReason, "dom_retry_hit");
-  assert.equal(domReadCount, 2);
-  assert.equal(recorded.includes("activateCandidate"), true);
-  assert.equal(recorded.includes("openOnlineResume"), true);
-}
-
-async function testBossChatAppShouldGateOutreachUntilPanelsClosed() {
-  let resumeModalOpen = true;
-  let detailOpen = true;
-  const { app, recorded } = createProcessCustomerHarness({
-    dryRun: false,
-    llmEvaluate: async () => ({
-      passed: true,
-      rawOutputText: '{"passed":true}',
-      evaluationMode: "image-multi-chunk",
-      imageCount: 1,
-      chunkIndex: 1,
-      chunkTotal: 1,
-    }),
-    captureResume: async ({ artifactDir }) => ({
-      metadataFile: path.join(artifactDir, "chunks.json"),
-      chunkDir: path.join(artifactDir, "chunks"),
-      chunkCount: 1,
-      modelImagePaths: [path.join(artifactDir, "chunks", "chunk_000.png")],
-      stitchedImage: "",
-      quality: { likelyBlank: false },
-    }),
-    pageOverrides: {
-      async closeResumeModalDomOnce() {
-        recorded.push("closeResumeModalDomOnce");
-        resumeModalOpen = false;
-        return {
-          closed: true,
-          method: "dom-close-once:.boss-popup__close",
-          finalState: { open: false, scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-        };
-      },
-      async getResumeModalState() {
-        return {
-          open: resumeModalOpen,
-          iframeCount: resumeModalOpen ? 1 : 0,
-          scopeCount: resumeModalOpen ? 1 : 0,
-          closeCount: resumeModalOpen ? 1 : 0,
-          topScopeClass: resumeModalOpen ? "resume-modal" : "",
-        };
-      },
-      async closeCandidateDetailDomOnce() {
-        recorded.push("closeCandidateDetailDomOnce");
-        detailOpen = false;
-        return {
-          closed: true,
-          method: "dom-close-once:.close-btn",
-          finalState: {
-            open: false,
-            panelCount: 0,
-            closeCount: 0,
-            topPanelClass: "",
-            overlayClass: "",
-            contentClass: "",
-          },
-        };
-      },
-      async getCandidateDetailState() {
-        return {
-          open: detailOpen,
-          panelCount: detailOpen ? 1 : 0,
-          closeCount: detailOpen ? 1 : 0,
-          topPanelClass: detailOpen ? "new-resume-online-main-ui" : "",
-          overlayClass: detailOpen ? "dialog-wrap active" : "",
-          contentClass: detailOpen ? "new-resume-online-main-ui resume-recommend resume-common-wrap" : "",
-          panelRect: detailOpen ? { left: 980, top: 0, width: 330, height: 760, right: 1310, bottom: 760 } : null,
-          overlayRect: detailOpen ? { left: 0, top: 0, width: 1440, height: 773, right: 1440, bottom: 773 } : null,
-          contentRect: detailOpen ? { left: 980, top: 0, width: 330, height: 760, right: 1310, bottom: 760 } : null,
-          closeRect: detailOpen ? { left: 1274, top: 12, width: 30, height: 30, right: 1304, bottom: 42 } : null,
-        };
-      },
-      async waitForConversationReady(options = {}) {
-        recorded.push(options.requirePanelsClosed ? "waitForConversationReady:strict" : "waitForConversationReady");
-        if (options.requirePanelsClosed && (resumeModalOpen || detailOpen)) {
-          throw new Error("CONVERSATION_PANEL_NOT_READY_OR_BLOCKED");
-        }
-        return {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false,
-          attachmentResumeEnabled: false,
-          resumeModalOpen,
-          candidateDetailOpen: detailOpen,
-          panelsClosed: !resumeModalOpen && !detailOpen,
-          editorVisible: true,
-          activeSubmit: true,
-          hasAnySubmit: true,
-          messageInputReady: true,
-        };
-      },
-    },
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-gated",
-      name: "候选人G",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "2001",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-gated",
-    { skipCardClick: true },
-  );
-
-  const captureIndex = recorded.indexOf("captureResume");
-  const closeResumeIndex = recorded.findIndex((item, index) => index > captureIndex && item === "closeResumeModalDomOnce");
-  const closeDetailIndex = recorded.findIndex((item, index) => index > closeResumeIndex && item === "closeCandidateDetailDomOnce");
-  const strictReadyIndex = recorded.findIndex((item, index) => index > closeDetailIndex && item === "waitForConversationReady:strict");
-  const setEditorIndex = recorded.findIndex((item, index) => index > strictReadyIndex && item === "setEditorMessage");
-  const sendMessageIndex = recorded.findIndex((item, index) => index > setEditorIndex && item === "sendMessage");
-  const askResumeIndex = recorded.findIndex((item, index) => index > sendMessageIndex && item === "clickAskResume");
-
-  assert.equal(result.decision, "passed");
-  assert.equal(result.requested, true);
-  assert.equal(result.artifacts.preActionResumeClosed, true);
-  assert.equal(result.artifacts.preActionDetailClosed, true);
-  assert.equal(closeResumeIndex > captureIndex, true);
-  assert.equal(closeDetailIndex > closeResumeIndex, true);
-  assert.equal(strictReadyIndex > closeDetailIndex, true);
-  assert.equal(setEditorIndex > strictReadyIndex, true);
-  assert.equal(sendMessageIndex > setEditorIndex, true);
-  assert.equal(askResumeIndex > sendMessageIndex, true);
-}
-
-async function testBossChatAppShouldSkipOutreachWhenDetailStillOpenAfterRetry() {
-  let resumeModalOpen = true;
-  const { app, recorded } = createProcessCustomerHarness({
-    dryRun: false,
-    llmEvaluate: async () => ({
-      passed: true,
-      rawOutputText: '{"passed":true}',
-      evaluationMode: "image-multi-chunk",
-      imageCount: 1,
-      chunkIndex: 1,
-      chunkTotal: 1,
-    }),
-    captureResume: async ({ artifactDir }) => ({
-      metadataFile: path.join(artifactDir, "chunks.json"),
-      chunkDir: path.join(artifactDir, "chunks"),
-      chunkCount: 1,
-      modelImagePaths: [path.join(artifactDir, "chunks", "chunk_000.png")],
-      stitchedImage: "",
-      quality: { likelyBlank: false },
-    }),
-    pageOverrides: {
-      async closeResumeModalDomOnce() {
-        recorded.push("closeResumeModalDomOnce");
-        resumeModalOpen = false;
-        return {
-          closed: true,
-          method: "dom-close-once:.boss-popup__close",
-          finalState: { open: false, scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-        };
-      },
-      async getResumeModalState() {
-        return {
-          open: resumeModalOpen,
-          iframeCount: resumeModalOpen ? 1 : 0,
-          scopeCount: resumeModalOpen ? 1 : 0,
-          closeCount: resumeModalOpen ? 1 : 0,
-          topScopeClass: resumeModalOpen ? "resume-modal" : "",
-        };
-      },
-      async closeCandidateDetailDomOnce() {
-        recorded.push("closeCandidateDetailDomOnce");
-        return {
-          closed: false,
-          method: "dom-close-miss:.close-btn",
-          finalState: {
-            open: true,
-            panelCount: 1,
-            closeCount: 1,
-            topPanelClass: "new-resume-online-main-ui",
-            overlayClass: "dialog-wrap active",
-            contentClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-          },
-        };
-      },
-      async closeCandidateDetail() {
-        recorded.push("closeCandidateDetail");
-        return {
-          closed: false,
-          method: "selector:.close-btn+escape+outside-click:left-gap",
-          finalState: {
-            open: true,
-            panelCount: 1,
-            closeCount: 1,
-            topPanelClass: "new-resume-online-main-ui",
-            overlayClass: "dialog-wrap active",
-            contentClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-          },
-        };
-      },
-      async getCandidateDetailState() {
-        return {
-          open: true,
-          panelCount: 1,
-          closeCount: 1,
-          topPanelClass: "new-resume-online-main-ui",
-          overlayClass: "dialog-wrap active",
-          contentClass: "new-resume-online-main-ui resume-recommend resume-common-wrap",
-          panelRect: { left: 980, top: 0, width: 330, height: 760, right: 1310, bottom: 760 },
-          overlayRect: { left: 0, top: 0, width: 1440, height: 773, right: 1440, bottom: 773 },
-          contentRect: { left: 980, top: 0, width: 330, height: 760, right: 1310, bottom: 760 },
-          closeRect: { left: 1274, top: 12, width: 30, height: 30, right: 1304, bottom: 42 },
-        };
-      },
-      async waitForConversationReady(options = {}) {
-        recorded.push(options.requirePanelsClosed ? "waitForConversationReady:strict" : "waitForConversationReady");
-        return {
-          hasOnlineResume: true,
-          hasAskResume: true,
-          hasAttachmentResume: false,
-          attachmentResumeEnabled: false,
-          resumeModalOpen: false,
-          candidateDetailOpen: true,
-          panelsClosed: false,
-          editorVisible: true,
-          activeSubmit: true,
-          hasAnySubmit: true,
-          messageInputReady: true,
-        };
-      },
-    },
-  });
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-skip-outreach",
-      name: "候选人H",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "2002",
-      textSnippet: "",
-    },
-    { screeningCriteria: "有 AI 项目经验" },
-    "run-skip-outreach",
-    { skipCardClick: true },
-  );
-
-  assert.equal(result.decision, "skipped");
-  assert.equal(result.passed, false);
-  assert.equal(result.artifacts.finalPassed, true);
-  assert.equal(result.artifacts.preActionResumeClosed, true);
-  assert.equal(result.artifacts.preActionDetailClosed, false);
-  assert.equal(result.artifacts.preActionCleanupRetried, true);
-  assert.equal(result.artifacts.preActionCleanupFailureReason.includes("candidate-detail-still-open"), true);
-  assert.equal(result.artifacts.finalDetailClosed, false);
-  assert.equal(recorded.includes("setEditorMessage"), false);
-  assert.equal(recorded.includes("sendMessage"), false);
-  assert.equal(recorded.includes("clickAskResume"), false);
-}
-
-async function testBossChatAppShouldPersistEvidenceArtifacts() {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-artifacts-"));
-  await mkdir(tempDir, { recursive: true });
-  const records = [];
-  const page = {
-    async closeResumeModalDomOnce() {
-      return {
-        closed: true,
-        method: "dom",
-        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
-      };
-    },
-    async waitForConversationReady() {
-      return {
-        hasOnlineResume: true,
-        hasAskResume: true,
-        hasAttachmentResume: false,
-        attachmentResumeEnabled: false,
-      };
-    },
-    async openOnlineResume() {
-      return { clicked: true, detectedOpen: true, by: "dom" };
-    },
-    async getResumeRateLimitWarning() {
-      return { hit: false, text: "" };
-    },
-    async getResumeProfileFromDom() {
-      return {
-        ok: true,
-        primarySchool: "南京大学",
-        schools: ["南京大学"],
-        major: "计算机",
-        majors: ["计算机"],
-        company: "OpenAI",
-        position: "工程师",
-        resumeText: "南京大学 计算机 PASS_MARKER_ABC",
-        evidenceCorpus: "南京大学 计算机 PASS_MARKER_ABC",
-      };
-    },
-    async getResumeModalState() {
-      return { open: true, iframeCount: 1, scopeCount: 1, closeCount: 1 };
-    },
-  };
-  const llmClient = {
-    async evaluateResume() {
-      return {
-        passed: false,
-        rawOutputText: '{"passed":false}',
-        rawReasoningText: "先看项目经验，再看技能，结论不通过。",
-        cot: "先看项目经验，再看技能，结论不通过。",
-        reason: "项目经验与岗位要求不符",
-        summary: "不符合要求",
-        evidence: ["Python"],
-        evaluationMode: "image-multi-chunk",
-        imageCount: 3,
-        chunkIndex: 1,
-        chunkTotal: 1,
-      };
-    },
-  };
-  const interaction = {
-    async sleepRange() {},
-    async clickRect() {},
-  };
-  const resumeCaptureService = {
-    async captureResume({ artifactDir }) {
-      return {
-        metadataFile: path.join(artifactDir, "chunks.json"),
-        chunkDir: path.join(artifactDir, "chunks"),
-        chunkCount: 1,
-        modelImagePaths: [
-          path.join(artifactDir, "chunks", "chunk_000.png"),
-          path.join(artifactDir, "chunks", "chunk_001.png"),
-          path.join(artifactDir, "chunks", "chunk_002.png"),
-        ],
-        stitchedImage: "",
-        quality: { likelyBlank: false },
-      };
-    },
-  };
-  const stateStore = {
-    async record(_key, result) {
-      records.push(result);
-    },
-  };
-  const app = new BossChatApp({
-    page,
-    llmClient,
-    interaction,
-    resumeCaptureService,
-    stateStore,
-    reportStore: { async write() { return ""; } },
-    dryRun: true,
-    artifactRootDir: tempDir,
-    resumeOpenCooldownMs: 0,
-    logger: { log() {} },
-  });
-  app.waitResumeOpenCooldown = async () => {};
-
-  const result = await app.processCustomer(
-    {
-      customerKey: "candidate-key",
-      name: "候选人A",
-      sourceJob: "算法工程师",
-      domIndex: 0,
-      customerId: "1001",
-      textSnippet: "",
-    },
-    {
-      screeningCriteria: "有 AI 项目经验",
-    },
-    "run-test",
-    { skipCardClick: true },
-  );
-
-  assert.equal(result.passed, false);
-  assert.equal(result.artifacts.finalPassed, false);
-  assert.equal(result.reason, "项目经验与岗位要求不符");
-  assert.equal(result.artifacts.evaluationMode, "image-multi-chunk");
-  assert.equal(result.artifacts.evaluationImageCount, 3);
-  assert.equal(result.artifacts.llmReason, "项目经验与岗位要求不符");
-  assert.equal(result.artifacts.llmSummary, "不符合要求");
-  assert.equal(result.artifacts.llmCot, "先看项目经验，再看技能，结论不通过。");
-  assert.deepEqual(result.artifacts.llmEvidence, ["Python"]);
-  assert.equal(result.artifacts.llmRawReasoning, "先看项目经验，再看技能，结论不通过。");
-  assert.equal(result.artifacts.llmRawOutput, '{"passed":false}');
-  assert.equal(Array.isArray(result.artifacts.modelImagePaths), true);
-  assert.equal(result.artifacts.modelImagePaths.length, 3);
-  assert.equal(Array.isArray(records), true);
-  assert.equal(records.length, 1);
-}
-
-async function testBossChatReportStoreShouldWriteReadableMarkdownAndCsv() {
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-report-store-"));
-  const reportStore = new ReportStore(tempDir);
-  const summary = {
-    startedAt: "2026-04-17T10:00:00.000Z",
-    finishedAt: "2026-04-17T10:01:05.000Z",
-    dryRun: true,
-    profile: {
-      targetCount: 5,
-      screeningCriteria: "有 AI 项目经验",
-    },
-    inspected: 2,
-    passed: 1,
-    requested: 0,
-    skipped: 1,
-    errors: 0,
-    exhausted: false,
-    stopped: false,
-    stopReason: "",
-    results: [
-      {
-        name: "候选人A",
-        sourceJob: "算法工程师",
-        decision: "passed",
-        passed: true,
-        requested: false,
-        reason: "符合要求",
-        error: "",
-        artifacts: {
-          resumeAcquisitionMode: "network",
-          resumeAcquisitionReason: "initial_hit",
-          textModelMs: 18234,
-          initialNetworkWaitMs: 4200,
-          evaluationMode: "text",
-          llmSummary: "教育与项目经历匹配",
-          llmCot: "先看教育背景，再看项目经历，结论通过。",
-          llmEvidence: ["AI Agent", "MCP"],
-          llmRawReasoning: "先看教育背景，再看项目经历，结论通过。",
-          llmRawOutput: '{"passed":true}',
-        },
-      },
-      {
-        name: "候选人B",
-        sourceJob: "大模型算法",
-        decision: "skipped",
-        passed: false,
-        requested: false,
-        reason: "LLM判定不通过",
-        error: "",
-        artifacts: {
-          resumeAcquisitionMode: "image_fallback",
-          resumeAcquisitionReason: "late_network_miss",
-          imageCaptureMs: 2300,
-          imageModelMs: 19500,
-          lateNetworkRetryMs: 3000,
-          evaluationMode: "image-multi-chunk",
-          evaluationImageCount: 3,
-          llmSummary: "项目经历不足",
-          llmCot: "先看项目经历，再看实习时长，结论不通过。",
-          llmEvidence: ["数据分析"],
-          llmRawReasoning: "先看项目经历，再看实习时长，结论不通过。",
-          llmRawOutput: '{"passed":false}',
-        },
-      },
-    ],
-    reportPath: null,
-  };
-
-  const jsonPath = await reportStore.write(summary);
-  const markdownPath = summary.reportMarkdownPath;
-  const csvPath = summary.reportCsvPath;
-  const jsonContent = fs.readFileSync(jsonPath, "utf8");
-  const markdownContent = fs.readFileSync(markdownPath, "utf8");
-  const csvContent = fs.readFileSync(csvPath, "utf8");
-
-  assert.equal(path.extname(jsonPath), ".json");
-  assert.equal(path.extname(markdownPath), ".md");
-  assert.equal(path.extname(csvPath), ".csv");
-  assert.equal(summary.reportPath, jsonPath);
-  assert.equal(typeof summary.reportArtifacts, "object");
-  assert.equal(summary.reportArtifacts.markdownPath, markdownPath);
-  assert.equal(summary.reportArtifacts.csvPath, csvPath);
-
-  const parsedJson = JSON.parse(jsonContent);
-  assert.equal(parsedJson.reportPath, jsonPath);
-  assert.equal(parsedJson.reportMarkdownPath, markdownPath);
-  assert.equal(parsedJson.reportCsvPath, csvPath);
-
-  assert.match(markdownContent, /# Boss Chat 运行报告/);
-  assert.match(markdownContent, /Resume Acquisition 汇总/);
-  assert.match(markdownContent, /Timing 汇总/);
-  assert.match(markdownContent, /候选人A/);
-  assert.match(markdownContent, /image_fallback/);
-  assert.match(markdownContent, /图片模型 19500ms/);
-
-  assert.match(csvContent, /resume_acquisition_mode/);
-  assert.match(csvContent, /initial_network_wait_ms/);
-  assert.match(csvContent, /late_network_retry_ms/);
-  assert.match(csvContent, /llm_summary/);
-  assert.match(csvContent, /llm_cot/);
-  assert.match(csvContent, /llm_raw_reasoning/);
-  assert.match(csvContent, /llm_raw_output/);
-  assert.match(csvContent, /候选人B/);
-  assert.match(csvContent, /image-multi-chunk/);
-  assert.match(csvContent, /先看项目经历，再看实习时长/);
-}
-
-async function main() {
-  await testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli();
-  await testBossChatRuntimeShouldMigrateLegacyWorkspaceDataOnce();
-  testBossChatRuntimeShouldResolveUserDirForRootWorkspace();
-  await testBossChatWhereShouldPrintUserRuntimePath();
-  await testBossChatPrepareShouldRetryWhenChatPageIsNotReady();
-  await testBossChatPageShouldTreatBlankChatShellAsOnChatPage();
-  await testBossChatRecoverToChatIndexShouldForceNavigateAndWaitForCompleteLoad();
-  await testBossChatPageShouldFallbackToEscapeWhenClosingCandidateDetail();
-  await testChromeClientShouldInjectBrowserHelpersIntoCallFunction();
-  await testBossChatPageShouldWaitForPanelsClosedInStrictConversationReady();
-  await testBossChatPageShouldSurfaceCandidateDetailOverlayAndContentState();
-  await testBossChatMcpToolsShouldValidateAndRoute();
-  await testBossChatCliShouldSupportRunAndFollowUpParsing();
-  testVendorBossChatCliShouldResolveExplicitDataDir();
-  testVendorBossChatCliShouldUseRecommendHomeForDefaultDataDir();
-  await testVendorBossChatCliShouldWaitForHydratedChatShell();
-  await testVendorBossChatCliShouldRetryJobListDuringPromptRunProfile();
-  await testVendorBossChatCliShouldUseGreetingFallbacksInPromptRunProfile();
-  testCliShouldPinInstalledPackageVersionInGeneratedMcpConfig();
-  testVendorBossChatCliShouldParseSharedLlmTransportArgs();
-  testBossChatLlmParserShouldAcceptMinimalDecisionJson();
-  testBossChatLlmParserShouldAcceptPlainPassFailText();
-  testBossChatLlmParserShouldAcceptDecisionField();
-  testBossChatLlmParserShouldPreserveReasoningFields();
-  testBossChatLlmExtractorsShouldReadProviderReasoningFields();
-  await testBossChatLlmTextChunkFallbackShouldWork();
-  await testBossChatLlmShouldApplyThinkingDefaultsAndOverrides();
-  await testBossChatLlmShouldSendAllImageChunksInSingleRequest();
-  await testBossChatAppShouldResetPrimaryChatLabelBeforeInitialPrime();
-  await testBossChatAppShouldCloseCandidateDetailDuringRunCleanup();
-  await testBossChatAppShouldRestoreListContextAfterRecovery();
-  await testBossChatAppShouldWaitForCandidateListBeforePriming();
-  await testBossChatResumeTrackerShouldRetryInitialNetworkWait();
-  await testBossChatResumeTrackerShouldUseImageModeGraceWindow();
-  await testBossChatAppShouldUseNetworkBeforeImageFallback();
-  await testBossChatAppShouldFallbackToImageAfterNetworkMiss();
-  await testBossChatAppShouldRetryLateNetworkBeforeDomFallback();
-  await testBossChatAppShouldUseDomOnlyAfterHigherPriorityPathsFail();
-  await testBossChatAppShouldGateOutreachUntilPanelsClosed();
-  await testBossChatAppShouldSkipOutreachWhenDetailStillOpenAfterRetry();
-  await testBossChatAppShouldPersistEvidenceArtifacts();
-  await testBossChatReportStoreShouldWriteReadableMarkdownAndCsv();
-  console.log("boss-chat tests passed");
-}
-
-await main();