@reconcrap/boss-recommend-mcp 2.0.56 → 2.1.0

package/README.md

@@ -259,13 +259,16 @@ config/screening-config.example.json
 - `debugPort`：未显式传 `port` 时，recommend / search / chat CDP-only MCP run 和健康检查默认连接这个 Chrome 调试端口。
 - `outputDir`：recommend / search / chat 完成后的最终 CSV 与 report JSON 会写入这里；run state / checkpoint 仍保留在各自状态目录，方便 pause/resume/cancel。
 - `llmThinkingLevel`：默认 `low`。可设为 `off/minimal/low/medium/high/auto/current`，用于控制 OpenAI-compatible LLM 的 thinking/reasoning 强度。
-- `humanBehavior`：默认 `{ "enabled": true, "profile": "paced_with_rests" }`。用于 recommend / search / chat 的可靠性实验，支持：
+- `humanBehavior`：默认 `{ "enabled": true, "profile": "paced_with_rests", "restLevel": "low" }`。用于 recommend / search / chat 的可靠性实验，支持：
   - `profile: "baseline"`：关闭人类节奏，保持确定性行为。
   - `profile: "paced"`：启用 CDP-only Bezier 鼠标移动、较大按钮的安全 inset 点击点、分块 `Input.insertText`、列表 wheel/settle jitter，以及小的动作前后读秒。
   - `profile: "paced_with_rests"`：在 `paced` 基础上启用候选人短休和批次休息。
+  - `restLevel: "low"`：保持旧版休息策略不变，候选人短休 8% 概率暂停 3-7 秒，批次休息约每 25-32 人暂停 15-30 秒。
+  - `restLevel: "medium"`：随机分散短/长休息，平均目标约每 5 小时或 700 位候选人累计休息 30 分钟。
+  - `restLevel: "high"`：随机分散短/长休息，平均目标约每 5 小时或 700 位候选人累计休息 1 小时。
 - `humanRestEnabled`：兼容旧配置。设为 `true` 时等价于 `humanBehavior.profile="paced_with_rests"`；设为 `false` 时不会关闭当前默认节奏。如需关闭，请显式设置 `humanBehavior.enabled=false` 或 `humanBehavior.profile="baseline"`。
   - recommend / search / chat 图片简历 fallback 与主列表滚动都会在启用 `listScrollJitter` 时使用 coverage-safe scroll jitter：每次 wheel delta 在安全范围内变化，并保留截图重叠、重复检测、bottom-marker / stop-boundary 逻辑，实际 delta 和 settle 时间会写入 artifact metadata。
-  - chat/recommend/search run 也兼容显式参数 `safe_pacing` 与 `batch_rest_enabled`：run 参数优先于配置文件。
+  - chat/recommend/search run 也兼容显式参数 `safe_pacing`、`batch_rest_enabled` 与 `human_behavior.restLevel`：run 参数优先于配置文件。AI harness/skill 启动每次 run 前必须让用户明确选择 `low/medium/high`，再把选择写入 `human_behavior.restLevel`。
 
 ## 常用命令
 

package/config/screening-config.example.json

@@ -16,6 +16,7 @@
   "humanBehavior": {
     "enabled": true,
     "profile": "paced_with_rests",
+    "restLevel": "low",
     "clickMovement": true,
     "textEntry": true,
     "listScrollJitter": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.56",
+  "version": "2.1.0",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",
@@ -88,6 +88,7 @@
     "src/chat-mcp.js",
     "src/chat-runtime-config.js",
     "src/cli.js",
+    "src/detached-worker.js",
     "src/index.js",
     "src/parser.js",
     "src/recommend-mcp.js",

package/skills/boss-chat/README.md

@@ -17,7 +17,7 @@ Please run a Boss chat-only task (do not switch to recommend flow).
 Execution order:
 1) Call boss_chat_health_check.
 2) Call prepare_boss_chat_run once (empty params allowed) to fetch job_options and missing fields.
-3) Ask for these required fields in one shot: job, start_from (unread/all), target_count, criteria.
+3) Ask for these required fields in one shot: job, start_from (unread/all), target_count, criteria, rest_level (low/medium/high).
 4) After user reply, call start_boss_chat_run exactly once to start the run.
 5) If ACCEPTED, reply only with run_id and "task started"; no auto polling.
 
@@ -27,6 +27,7 @@ Anti-loop rules:
 - Do not use start_boss_chat_run for preflight. It is only for the final start call and must include job/start_from/target_count/criteria.
 - Do not call start_boss_chat_run repeatedly in one turn.
 - Do not call get_boss_chat_run unless user explicitly asks for progress.
+- Do not choose rest_level for the user. Pass the user's choice as `human_behavior.restLevel`.
 
 target_count mapping:
 - Positive integer means explicit cap (for example 20).

package/skills/boss-chat/SKILL.md

@@ -27,6 +27,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - `start_from`: `unread|all`
 - `target_count`
 - `criteria`
+- `rest_level`: `low|medium|high`
 
 可选：
 
@@ -38,6 +39,12 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - `safe_pacing`
 - `batch_rest_enabled`
 
+启动工具时，把用户确认的休息强度写入 `human_behavior.restLevel`，例如：
+
+```json
+{ "human_behavior": { "restLevel": "medium" } }
+```
+
 `greeting_text` 默认规则：
 
 - 本次显式传入 `greeting_text`：使用本次值
@@ -62,6 +69,7 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 - 若本机找不到 Chrome，可提示用户设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`；非本机 debug host 不自动启动。
 - `job` / `start_from` / `criteria` 缺一不可；缺参时只补缺口。
 - `target_count` 在 chat-only 启动前也是必填项，不能默认省略。
+- 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
 - 当用户说“全部候选人/所有候选人”时，必须按“扫到底（unlimited）”处理，不要再追问正整数。
 - 参数名必须写 `target_count`（不要写“目标数量”等中文键名）。
 - 当用户选择“扫到底/全部候选人/所有候选人”时，调用参数优先写：`"target_count": "all"`；`-1` 只作为兼容输入和内部 CLI 表示。
@@ -89,5 +97,5 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
 
 - 用结构化中文。
 - 首轮建议先调用一次 `prepare_boss_chat_run`（可空参）获取 `job_options` 与 `pending_questions`。
-- 缺参时必须逐项确认：`job`（来自岗位列表）、`start_from`（`unread|all`）、`target_count`、`criteria`。
+- 缺参时必须逐项确认：`job`（来自岗位列表）、`start_from`（`unread|all`）、`target_count`、`criteria`、`rest_level`。
 - 若健康检查失败，明确提示共享配置文件 `screening-config.json` 不可用。

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

@@ -7,6 +7,7 @@
 - 先确认推荐页 filters
 - 再确认筛选 criteria
 - 再确认本次运行统一动作 `favorite` 或 `greet`
+- 每次运行都要让用户明确选择休息强度 `low` / `medium` / `high`，并传入 `human_behavior.restLevel`
 - 只确认一次 `post_action`，不要逐个候选人反复确认
 - 运行中临时中断请使用 `pause_recommend_pipeline_run`（按 run_id），不要靠自然语言“暂停/继续”指令
 - 继续执行请使用 `resume_recommend_pipeline_run`；状态查询默认按用户指令触发，不自动轮询

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

@@ -20,7 +20,8 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 - **确认不可代填（强制）**
   - 禁止 agent 自行“设置合理参数”并代替用户确认。
   - 禁止在用户未明确回复前，把任意 `*_confirmed` 字段设为 `true`。
-  - 禁止在用户未明确回复前，自行填充 `page_scope/school_tag/degree/gender/recent_not_view/criteria/target_count/post_action/max_greet_count/job`。
+  - 禁止在用户未明确回复前，自行填充 `page_scope/school_tag/degree/gender/recent_not_view/criteria/target_count/post_action/max_greet_count/job/rest_level`。
+  - 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
   - 若工具返回 `pending_questions`，必须逐项向用户提问并等待用户回复；不得跳过提问直接执行。
 
 - **岗位确认时机**
@@ -54,6 +55,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 - `target_count`（可空）
 - `post_action`：`favorite|greet|none`
 - `max_greet_count`（仅当 `post_action=greet`）
+- `rest_level`：`low|medium|high`
 
 ### Stage B (页面就绪后)
 
@@ -82,6 +84,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
   - `gender`: `不限/男/女`
   - `recent_not_view`: `不限/近14天没有`
   - `post_action`: `favorite/greet/none`
+  - `rest_level`: `low/medium/high`
 
 ## Tool Usage
 
@@ -94,6 +97,7 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 - 关键输入：
   - `confirmation`：`page_confirmed/page_value/filters_confirmed/school_tag_confirmed.../job_confirmed/job_value/final_confirmed`
   - `overrides`：`page_scope/school_tag/degree/gender/recent_not_view/criteria/job/target_count/post_action/max_greet_count`
+  - `human_behavior`：必须包含本次用户确认的 `restLevel`（例如 `{ "restLevel": "medium" }`）
   - 不要传 `follow_up.chat`；该路径属于 legacy-only 行为
 
 最小策略：

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

@@ -15,3 +15,5 @@ This skill intentionally replaces legacy `boss-recruit-mcp` skill installs. It r
 - `cancel_recruit_pipeline_run`
 
 Do not call the old `@reconcrap/boss-recruit-mcp` package from this skill.
+
+Each run must ask the user to choose `rest_level` (`low` / `medium` / `high`) and pass the answer as `human_behavior.restLevel`; do not pick a default for the user.

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

@@ -32,6 +32,7 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - 若用户提供城市、学历、学校、关键词、过滤已看、人选目标数、筛选条件、post action、max greet 等参数，必须逐项传入或确认。
 - `post_action=greet` 时必须确认 `max_greet_count`；不要默认等于 `target_count`。
 - 搜索页和推荐页一样支持多选筛选条件；不要把多选降级成单选。
+- 每次 run 必须明确询问用户本次休息强度 `rest_level`：`low`（旧策略）/ `medium`（约 5 小时或 700 人累计休息 30 分钟）/ `high`（约 5 小时或 700 人累计休息 1 小时）；不得默认使用配置文件里的值替用户决定。
 
 ## Required Inputs
 
@@ -39,6 +40,7 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - `keyword` 或用户明确的搜索意图
 - `criteria`
 - `target_count`
+- `rest_level`: `low|medium|high`
 
 常用可选项：
 
@@ -50,6 +52,12 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - `max_greet_count`
 - `port`
 
+启动工具时，把用户确认的休息强度写入 `human_behavior.restLevel`，例如：
+
+```json
+{ "human_behavior": { "restLevel": "medium" } }
+```
+
 ## Response Style
 
 - 用结构化中文确认参数。

package/src/chat-mcp.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import {
   assertNoForbiddenCdpCalls,
   bringPageToFront,
@@ -18,7 +20,8 @@ import {
   RUN_STATUS_CANCELED,
   RUN_STATUS_COMPLETED,
   RUN_STATUS_FAILED,
-  RUN_STATUS_PAUSED
+  RUN_STATUS_PAUSED,
+  RUN_STATUS_RUNNING
 } from "./core/run/index.js";
 import {
   buildLegacyScreenInputRows,
@@ -60,6 +63,8 @@ const DEFAULT_CHAT_GREETING_TEXT = "Hi同学，能麻烦发下简历吗？";
 const CHAT_ALL_MAX_CANDIDATES = 100000;
 const TARGET_COUNT_SEMANTICS = "target_count means candidates that pass screening; numeric targets scan until that many candidates pass or the list ends; all/全部/扫到底 scans to the end";
 const RUN_MODE_ASYNC = "async";
+const DETACHED_WORKER_SCRIPT = fileURLToPath(new URL("./detached-worker.js", import.meta.url));
+const DETACHED_WORKER_POLL_MS = 1000;
 
 const CHAT_REQUIRED_FIELDS = Object.freeze([
   "job",
@@ -170,6 +175,9 @@ function getChatRunArtifacts(runId) {
     runs_dir: runsDir,
     output_dir: outputDir,
     run_state_path: path.join(runsDir, `${normalized}.json`),
+    detached_args_path: path.join(runsDir, `${normalized}.detached-args.json`),
+    worker_stdout_path: path.join(runsDir, `${normalized}.worker.stdout.log`),
+    worker_stderr_path: path.join(runsDir, `${normalized}.worker.stderr.log`),
     checkpoint_path: path.join(runsDir, `${normalized}.checkpoint.json`),
     output_csv: path.join(outputDir, `${normalized}.results.csv`),
     report_json: path.join(outputDir, `${normalized}.report.json`)
@@ -256,6 +264,156 @@ function readChatRunState(runId) {
   return readJsonFile(artifacts.run_state_path);
 }
 
+function writeChatRunState(runId, payload) {
+  const artifacts = getChatRunArtifacts(runId);
+  if (!artifacts) return null;
+  writeJsonAtomic(artifacts.run_state_path, payload);
+  return payload;
+}
+
+function createDetachedChatRunId() {
+  return `mcp_chat_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function buildInitialChatDetachedState(runId, {
+  workspaceRoot = "",
+  args = {},
+  normalized = {},
+  pid = process.pid
+} = {}) {
+  const artifacts = getChatRunArtifacts(runId);
+  const now = new Date().toISOString();
+  const isAllTarget = normalized.publicTargetCount === "all";
+  const processedLimit = isAllTarget ? CHAT_ALL_MAX_CANDIDATES : Math.max(1, Number(normalized.targetCount) || 1);
+  return {
+    run_id: runId,
+    mode: RUN_MODE_ASYNC,
+    state: "queued",
+    status: "queued",
+    stage: "queued",
+    started_at: now,
+    updated_at: now,
+    heartbeat_at: now,
+    completed_at: null,
+    pid: Number.isInteger(pid) && pid > 0 ? pid : process.pid,
+    progress: {
+      target_count: normalized.publicTargetCount ?? normalized.targetCount ?? null,
+      target_pass_count: isAllTarget ? null : normalized.targetCount ?? null,
+      processed_limit: processedLimit,
+      processed: 0,
+      screened: 0,
+      detail_opened: 0,
+      llm_screened: 0,
+      passed: 0,
+      skipped: 0,
+      requested: 0,
+      request_satisfied: 0,
+      request_skipped: 0,
+      greet_count: 0
+    },
+    last_message: "Boss chat detached worker is queued.",
+    context: {
+      domain: "chat",
+      target_url: CHAT_TARGET_URL,
+      workspace_root: normalizeText(workspaceRoot) || process.cwd(),
+      profile: normalized.profile || args.profile || "default",
+      job: normalized.job || args.job || "",
+      start_from: normalized.startFrom || args.start_from || "",
+      criteria: normalized.criteria || args.criteria || "",
+      greeting_text: normalized.greetingText || args.greeting_text || args.greetingText || DEFAULT_CHAT_GREETING_TEXT,
+      target_count: normalized.publicTargetCount ?? normalized.targetCount ?? null,
+      target_count_semantics: TARGET_COUNT_SEMANTICS,
+      request_resume_for_passed: shouldRequestChatResume(args),
+      detached_worker: true
+    },
+    control: {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    },
+    resume: {
+      checkpoint_path: artifacts?.checkpoint_path || null,
+      pause_control_path: artifacts?.run_state_path || null,
+      output_csv: null,
+      worker_stdout_path: artifacts?.worker_stdout_path || null,
+      worker_stderr_path: artifacts?.worker_stderr_path || null,
+      resume_count: 0,
+      last_resumed_at: null,
+      last_paused_at: null
+    },
+    error: null,
+    result: null,
+    summary: null,
+    artifacts
+  };
+}
+
+function patchPersistedChatControl(runId, controlPatch = {}, {
+  status = "RUN_STATUS",
+  message = "",
+  lastMessage = ""
+} = {}) {
+  const current = readChatRunState(runId);
+  if (!current) return null;
+  const state = normalizeText(current.state || current.status);
+  if (TERMINAL_STATUSES.has(state)) return null;
+  const now = new Date().toISOString();
+  const patched = {
+    ...current,
+    updated_at: now,
+    heartbeat_at: now,
+    last_message: lastMessage || message || current.last_message || "",
+    control: {
+      ...(current.control || {}),
+      ...controlPatch
+    }
+  };
+  writeChatRunState(runId, patched);
+  return {
+    status,
+    run: patched,
+    message,
+    persistence: {
+      source: "disk",
+      active_control_available: false,
+      detached_control_requested: true
+    },
+    runtime_evaluate_used: false,
+    method_summary: {},
+    method_log: [],
+    chrome: null
+  };
+}
+
+function launchDetachedChatWorker(runId) {
+  const artifacts = getChatRunArtifacts(runId);
+  if (!artifacts) throw new Error("Invalid chat run_id");
+  fs.mkdirSync(path.dirname(artifacts.worker_stdout_path), { recursive: true });
+  const stdoutFd = fs.openSync(artifacts.worker_stdout_path, "a");
+  const stderrFd = fs.openSync(artifacts.worker_stderr_path, "a");
+  let child;
+  try {
+    child = spawn(process.execPath, [
+      DETACHED_WORKER_SCRIPT,
+      "--domain",
+      "chat",
+      "--run-id",
+      runId
+    ], {
+      detached: true,
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true,
+      env: process.env
+    });
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+  if (typeof child?.unref === "function") child.unref();
+  return child;
+}
+
 function toIsoOrNull(value) {
   const normalized = normalizeText(value);
   return normalized || null;
@@ -491,6 +649,27 @@ function finalizePersistedChatRun(persisted = {}, {
   return attachLegacyArtifactsToPersistedChatRun(next);
 }
 
+export function markBossChatDetachedWorkerFailed(runId, error, options = {}) {
+  const normalizedRunId = normalizeRunId(runId);
+  if (!normalizedRunId) return null;
+  const persisted = readChatRunState(normalizedRunId) || buildInitialChatDetachedState(normalizedRunId, {});
+  const state = normalizeText(persisted.state || persisted.status);
+  if (TERMINAL_STATUSES.has(state)) return persisted;
+  const errorPayload = {
+    name: error?.name || "Error",
+    code: options.code || error?.code || "CHAT_WORKER_UNHANDLED_EXCEPTION",
+    message: normalizeText(error?.message || error || options.message) || "Boss chat detached worker exited unexpectedly."
+  };
+  if (normalizeText(error?.stack || "")) {
+    errorPayload.stack = String(error.stack).slice(0, 8000);
+  }
+  return finalizePersistedChatRun(persisted, {
+    status: RUN_STATUS_FAILED,
+    error: errorPayload,
+    message: errorPayload.message
+  });
+}
+
 function persistedChatRunArtifactMissing(persisted = {}) {
   const runId = normalizeRunId(persisted.run_id || persisted.runId);
   const artifacts = getChatRunArtifacts(runId);
@@ -568,6 +747,8 @@ function buildLegacyChatResult(snapshot) {
     output_csv: artifacts?.output_csv || meta.outputCsvPath || null,
     report_json: artifacts?.report_json || meta.reportJsonPath || null,
     checkpoint_path: artifacts?.checkpoint_path || meta.checkpointPath || null,
+    worker_stdout_path: artifacts?.worker_stdout_path || null,
+    worker_stderr_path: artifacts?.worker_stderr_path || null,
     started_at: snapshot.startedAt,
     completed_at: snapshot.completedAt || null,
     duration_sec: secondsBetween(snapshot.startedAt, snapshot.completedAt),
@@ -624,6 +805,8 @@ function normalizeRunSnapshot(snapshot) {
       checkpoint_path: legacyResult?.checkpoint_path || meta.checkpointPath || artifacts?.checkpoint_path || null,
       pause_control_path: artifacts?.run_state_path || null,
       output_csv: legacyResult?.output_csv || null,
+      worker_stdout_path: artifacts?.worker_stdout_path || null,
+      worker_stderr_path: artifacts?.worker_stderr_path || null,
       resume_count: meta.resumeCount || 0,
       last_resumed_at: meta.lastResumedAt || null,
       last_paused_at: snapshot.status === RUN_STATUS_PAUSED ? snapshot.updatedAt : null
@@ -1177,7 +1360,7 @@ function trackChatRun(runId) {
     });
 }
 
-async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {}) {
+async function startBossChatRunInternal(args = {}, { workspaceRoot = "", runId = "" } = {}) {
   const defaultConfigResolution = resolveBossScreeningConfig(workspaceRoot);
   const normalized = normalizeChatStartInput(args, defaultConfigResolution);
   const missingFields = getMissingChatStartFields(args, normalized);
@@ -1245,7 +1428,10 @@ async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {})
 
   let started;
   try {
-    started = chatRunService.startChatRun(getRunOptions(args, normalized, session, { workspaceRoot, configResolution }));
+    started = chatRunService.startChatRun({
+      ...getRunOptions(args, normalized, session, { workspaceRoot, configResolution }),
+      runId
+    });
   } catch (error) {
     await session.close?.();
     return {
@@ -1525,6 +1711,178 @@ export async function startBossChatRunTool({ workspaceRoot = "", args = {} } = {
   return attachMethodEvidence(started, started.run_id);
 }
 
+export async function startBossChatDetachedRunTool({ workspaceRoot = "", args = {} } = {}) {
+  const defaultConfigResolution = resolveBossScreeningConfig(workspaceRoot);
+  const normalized = normalizeChatStartInput(args, defaultConfigResolution);
+  const missingFields = getMissingChatStartFields(args, normalized);
+  if (missingFields.length) {
+    return buildNeedInputResponse({
+      args,
+      missingFields,
+      normalized
+    });
+  }
+
+  const useLlm = shouldUseChatLlm(args);
+  const debugTestOptions = collectChatDebugTestOptions(args);
+  if (debugTestOptions.length && !isDebugTestMode(args)) {
+    return {
+      status: "FAILED",
+      error: {
+        code: "DEBUG_TEST_MODE_REQUIRED",
+        message: `这些参数属于调试/测试路径，正式 live run 不会默认启用：${debugTestOptions.join(", ")}。如确需测试，请显式传 debug_test_mode=true。`,
+        retryable: false
+      },
+      debug_test_options: debugTestOptions
+    };
+  }
+  const configResolution = useLlm ? resolveBossScreeningConfig(workspaceRoot) : null;
+  if (useLlm && !configResolution?.ok) {
+    return {
+      status: "FAILED",
+      error: {
+        code: "SCREEN_CONFIG_ERROR",
+        message: configResolution?.error?.message || "screening-config.json is required for chat LLM screening",
+        retryable: true
+      }
+    };
+  }
+
+  const runId = createDetachedChatRunId();
+  const artifacts = getChatRunArtifacts(runId);
+  const initial = buildInitialChatDetachedState(runId, {
+    workspaceRoot,
+    args,
+    normalized,
+    pid: process.pid
+  });
+  try {
+    writeJsonAtomic(artifacts.detached_args_path, {
+      domain: "chat",
+      run_id: runId,
+      workspace_root: normalizeText(workspaceRoot) || process.cwd(),
+      args: clonePlain(args, {})
+    });
+    writeChatRunState(runId, initial);
+  } catch (error) {
+    return {
+      status: "FAILED",
+      error: {
+        code: "CHAT_RUN_STATE_IO_ERROR",
+        message: `Unable to write Boss chat detached run state: ${error?.message || error}`,
+        retryable: false
+      }
+    };
+  }
+
+  let child;
+  try {
+    child = launchDetachedChatWorker(runId);
+    const now = new Date().toISOString();
+    const latest = readChatRunState(runId) || initial;
+    const latestState = normalizeText(latest.state || latest.status);
+    if (TERMINAL_STATUSES.has(latestState)) {
+      return {
+        status: "FAILED",
+        error: latest.error || {
+          code: "CHAT_WORKER_LAUNCH_FAILED",
+          message: "Boss chat detached worker exited during launch.",
+          retryable: true
+        },
+        run: latest,
+        runtime_evaluate_used: false,
+        method_summary: {},
+        method_log: [],
+        chrome: null
+      };
+    }
+    const queued = {
+      ...latest,
+      pid: child.pid || process.pid,
+      updated_at: now,
+      heartbeat_at: now,
+      last_message: "Boss chat detached worker launched."
+    };
+    writeChatRunState(runId, queued);
+    return {
+      status: "ACCEPTED",
+      run_id: runId,
+      state: "queued",
+      run: queued,
+      poll_after_sec: DEFAULT_CHAT_POLL_AFTER_SEC,
+      message: "Boss chat run started in a detached worker. It can continue after the MCP host returns or is recycled.",
+      target_count_semantics: TARGET_COUNT_SEMANTICS,
+      detached_worker: true,
+      runtime_evaluate_used: false,
+      method_summary: {},
+      method_log: [],
+      chrome: null
+    };
+  } catch (error) {
+    const failed = markBossChatDetachedWorkerFailed(runId, error, {
+      code: "CHAT_WORKER_LAUNCH_FAILED",
+      message: "Unable to launch Boss chat detached worker."
+    });
+    return {
+      status: "FAILED",
+      error: failed?.error || {
+        code: "CHAT_WORKER_LAUNCH_FAILED",
+        message: error?.message || "Unable to launch Boss chat detached worker.",
+        retryable: true
+      },
+      run: failed || readChatRunState(runId),
+      runtime_evaluate_used: false,
+      method_summary: {},
+      method_log: [],
+      chrome: null
+    };
+  }
+}
+
+export async function runBossChatDetachedWorker({ runId } = {}) {
+  const normalizedRunId = normalizeRunId(runId);
+  if (!normalizedRunId) return { ok: false, error: "run_id is required" };
+  const artifacts = getChatRunArtifacts(normalizedRunId);
+  const spec = readJsonFile(artifacts?.detached_args_path || "");
+  if (!spec) {
+    const error = new Error(`Boss chat detached args were not found for run_id=${normalizedRunId}`);
+    markBossChatDetachedWorkerFailed(normalizedRunId, error, { code: "CHAT_WORKER_ARGS_MISSING" });
+    return { ok: false, error: error.message };
+  }
+
+  const started = await startBossChatRunInternal(spec.args || {}, {
+    workspaceRoot: spec.workspace_root || "",
+    runId: normalizedRunId
+  });
+  if (started?.status !== "ACCEPTED") {
+    const failedError = started?.error || {
+      code: "CHAT_WORKER_START_FAILED",
+      message: started?.status || "Boss chat detached worker failed to start.",
+      retryable: true
+    };
+    markBossChatDetachedWorkerFailed(normalizedRunId, failedError, {
+      code: failedError.code || "CHAT_WORKER_START_FAILED"
+    });
+    return { ok: false, error: failedError.message || "Boss chat detached worker failed to start." };
+  }
+
+  while (true) {
+    const payload = getBossChatRunTool({ args: { run_id: normalizedRunId } });
+    const state = normalizeText(payload?.run?.state || payload?.run?.status || "");
+    if (TERMINAL_STATUSES.has(state)) break;
+    const persisted = readChatRunState(normalizedRunId);
+    if (persisted?.control?.cancel_requested === true) {
+      cancelBossChatRunTool({ args: { run_id: normalizedRunId } });
+    } else if (persisted?.control?.pause_requested === true && state === RUN_STATUS_RUNNING) {
+      pauseBossChatRunTool({ args: { run_id: normalizedRunId } });
+    } else if (persisted?.control?.pause_requested === false && state === RUN_STATUS_PAUSED) {
+      resumeBossChatRunTool({ args: { run_id: normalizedRunId } });
+    }
+    await sleep(DETACHED_WORKER_POLL_MS);
+  }
+  return { ok: true };
+}
+
 export function getBossChatRunTool({ args = {} } = {}) {
   const runId = normalizeRunId(args.run_id || args.runId);
   if (!runId) {
@@ -1615,6 +1973,20 @@ export function pauseBossChatRunTool({ args = {} } = {}) {
         chrome: null
       };
     }
+    if (persisted) {
+      const reconciled = reconcilePersistedChatRun(persisted);
+      if (reconciled.stale_finalized) return getBossChatRunTool({ args });
+      return patchPersistedChatControl(runId, {
+        pause_requested: true,
+        pause_requested_at: new Date().toISOString(),
+        pause_requested_by: "pause_boss_chat_run",
+        cancel_requested: false
+      }, {
+        status: "PAUSE_REQUESTED",
+        message: "暂停请求已写入 detached chat run 控制文件。",
+        lastMessage: "暂停请求已写入 detached chat run 控制文件。"
+      }) || getBossChatRunTool({ args });
+    }
     return getBossChatRunTool({ args });
   }
 }
@@ -1665,6 +2037,18 @@ export function resumeBossChatRunTool({ args = {} } = {}) {
     if (persisted) {
       const reconciled = reconcilePersistedChatRun(persisted);
       const reconciledStatus = reconciled.run?.status || reconciled.run?.state;
+      if (!TERMINAL_STATUSES.has(reconciledStatus)) {
+        return patchPersistedChatControl(runId, {
+          pause_requested: false,
+          pause_requested_at: null,
+          pause_requested_by: null,
+          cancel_requested: false
+        }, {
+          status: "RESUME_REQUESTED",
+          message: "恢复请求已写入 detached chat run 控制文件。",
+          lastMessage: "恢复请求已写入 detached chat run 控制文件。"
+        }) || getBossChatRunTool({ args });
+      }
       return {
         status: "FAILED",
         error: {
@@ -1743,6 +2127,16 @@ export function cancelBossChatRunTool({ args = {} } = {}) {
           chrome: null
         };
       }
+      return patchPersistedChatControl(runId, {
+        pause_requested: true,
+        pause_requested_at: new Date().toISOString(),
+        pause_requested_by: "cancel_boss_chat_run",
+        cancel_requested: true
+      }, {
+        status: "CANCEL_REQUESTED",
+        message: "取消请求已写入 detached chat run 控制文件。",
+        lastMessage: "取消请求已写入 detached chat run 控制文件。"
+      }) || getBossChatRunTool({ args });
     }
     return getBossChatRunTool({ args });
   }