@reconcrap/boss-recommend-mcp 2.0.25 → 2.0.27

package/README.md

@@ -132,9 +132,9 @@ node src/cli.js start
 
 ### 迁移 legacy MCP / skills
 
-全局 npm 安装会自动运行 `boss-recommend-mcp install`。该安装器会在 Windows 和 macOS 上自动检测 Trae / Trae CN / OpenClaw 的常见配置目录：
+全局 npm 安装会自动运行 `boss-recommend-mcp install`。该安装器会在 Windows 和 macOS 上自动检测 Trae / Trae CN / OpenClaw / QClaw 的常见配置目录：
 
-- Windows: `%APPDATA%\Trae*\User\mcp.json`、`%USERPROFILE%\.trae*\mcp.json`、`%USERPROFILE%\.openclaw\mcp.json`、`%APPDATA%\OpenClaw\User\mcp.json`
+- Windows: `%APPDATA%\Trae*\User\mcp.json`、`%USERPROFILE%\.trae*\mcp.json`、`%USERPROFILE%\.openclaw\mcp.json`、`%APPDATA%\OpenClaw\User\mcp.json`、`%USERPROFILE%\.qclaw\openclaw.json`
 - macOS: `~/Library/Application Support/Trae*/User/mcp.json`、`~/.trae*/mcp.json`、`~/.openclaw/mcp.json`、`~/Library/Application Support/OpenClaw/User/mcp.json`
 
 如果检测到 legacy Boss server entries，installer 会：
@@ -150,8 +150,10 @@ node src/cli.js start
 ```bash
 boss-recommend-mcp install --agent trae-cn
 boss-recommend-mcp install --agent openclaw
+boss-recommend-mcp install --agent qclaw
 boss-recommend-mcp doctor --agent trae-cn
 boss-recommend-mcp doctor --agent openclaw
+boss-recommend-mcp doctor --agent qclaw
 ```
 
 自定义路径：
@@ -171,7 +173,13 @@ BOSS_RECOMMEND_MCP_CONFIG_TARGETS   # JSON 数组或系统 path 分隔路径列
 BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS  # JSON 数组或系统 path 分隔路径列表，指定额外 skills 根目录
 ```
 
-推荐运行入口是 MCP 工具。旧版 one-shot recommend CLI `run` 在 CDP-only 重写期间已 fenced；请使用 `start_recommend_pipeline_run` 或 live harness。岗位发现可以使用新的只读 CLI：
+推荐运行入口是 MCP 工具 `start_recommend_pipeline_run`。如果宿主是 QClaw 这类 shell-only agent，没有把 MCP tools 暴露给模型，可以使用 CDP-only CLI fallback：
+
+```bash
+npx -y @reconcrap/boss-recommend-mcp@latest run --detached --instruction-file boss-recommend-instruction.txt --overrides-file boss-recommend-overrides.json --confirmation-file boss-recommend-confirmation.json --slow-live --port 9222
+```
+
+`--detached` 会让父进程输出 `ACCEPTED + run_id` 后退出，子进程继续持有 Chrome DevTools 会话并执行长任务。岗位发现可以使用只读 CLI：
 
 ```bash
 npx -y @reconcrap/boss-recommend-mcp@latest list-jobs --slow-live --port 9222

package/package.json

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

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

@@ -139,11 +139,29 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 - `featured` 且缺少校准文件：先 `boss-recommend-mcp calibrate`。
 - `latest`：流程同 `recommend`，但使用最新 tab 结构（`data-status=1`）。
 
-## Fallback CLI
+## QClaw / Shell-Only Fallback
 
-MCP 不可用时：
+当 QClaw/OpenClaw 变体只暴露 shell、没有原生 MCP tool list 时，禁止停在“请使用 `start_recommend_pipeline_run` 工具”。必须用 shell 继续启动。
 
-`npx -y @reconcrap/boss-recommend-mcp@latest run --instruction "..." [--confirmation-json '{...}'] [--overrides-json '{...}']`
+推荐做法：
+
+1. 将锁定的用户原文写入 instruction 文件，将已确认参数写入 `overrides` 与 `confirmation` JSON 文件。
+2. 用 detached CLI 启动，让父命令返回启动证据，子进程继续持有 CDP 会话：
+
+```powershell
+npx -y @reconcrap/boss-recommend-mcp@latest run --detached --instruction-file .\boss-recommend-instruction.txt --overrides-file .\boss-recommend-overrides.json --confirmation-file .\boss-recommend-confirmation.json --slow-live --port 9222
+```
+
+3. 若返回 `ACCEPTED + run_id`，即任务已启动；记录 `run_id/stdout_path/stderr_path`。若返回 `NEED_INPUT` 或 `NEED_CONFIRMATION`，只补 `pending_questions`，不要重写已锁定的用户原文。
+
+兼容路径：
+
+- 若 `--detached` 不可用，或返回 `RECOMMEND_CLI_RUN_UNSUPPORTED_CDP_ONLY`，说明 npm/QClaw 仍在使用旧包；先运行 `npx -y @reconcrap/boss-recommend-mcp@latest install --agent qclaw` 并重启 QClaw。
+- 在包更新未生效时，可以使用已验证过的直接 MCP stdio JSON-RPC 方式调用 `start_recommend_pipeline_run`；该方式等价于原生 MCP tool 调用，不能改用 recruit/search 路径。
+
+普通 MCP 可用时：
+
+`start_recommend_pipeline_run` 仍是首选。
 
 禁止错误回退：
 

package/src/cli.js

@@ -23,7 +23,10 @@ import {
   prepareBossChatRunTool,
   resumeBossChatRunTool
 } from "./chat-mcp.js";
-import { listRecommendJobsTool } from "./recommend-mcp.js";
+import {
+  listRecommendJobsTool,
+  startRecommendPipelineRunTool
+} from "./recommend-mcp.js";
 import {
   getBossScreenConfigResolution,
   resolveBossChatRuntimeLayout as resolveCdpBossChatRuntimeLayout,
@@ -45,7 +48,7 @@ const bossLoginUrl = "https://www.zhipin.com/web/user/?ka=bticket";
 const chromeOnboardingUrlPattern = /^chrome:\/\/(welcome|intro|newtab|signin|history-sync|settings\/syncSetup)/i;
 const bossLoginUrlPattern = /(?:zhipin\.com\/web\/user(?:\/|\?|$)|passport\.zhipin\.com)/i;
 const bossLoginTitlePattern = /登录|signin|扫码登录|BOSS直聘登录/i;
-const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "openclaw"];
+const supportedMcpClients = ["generic", "cursor", "trae", "claudecode", "openclaw", "qclaw"];
 const defaultMcpServerName = "boss-recommend";
 const defaultMcpCommand = "npx";
 const recommendMcpPackageName = "@reconcrap/boss-recommend-mcp";
@@ -64,7 +67,7 @@ const installConfigDefaults = Object.freeze({
 const bossChatRuntimeChildDirs = ["logs", "runs", "profiles", "reports", "artifacts", "state"];
 const bossChatCliUnsupportedStartCode = "CHAT_CLI_ASYNC_UNSUPPORTED_CDP_ONLY";
 const calibrateUnsupportedCode = "CALIBRATE_UNSUPPORTED_CDP_ONLY";
-const recommendCliRunUnsupportedCode = "RECOMMEND_CLI_RUN_UNSUPPORTED_CDP_ONLY";
+const detachedRecommendRunChildEnv = "BOSS_RECOMMEND_DETACHED_RUN_CHILD";
 
 function getSkillSourceDir(name = skillName) {
   return path.join(packageRoot, "skills", name);
@@ -673,22 +676,25 @@ function getRunInstruction(options) {
 }
 
 function getRunConfirmation(options) {
-  if (typeof options["confirmation-file"] === "string" && options["confirmation-file"].trim()) {
-    return parseJsonOption(readTextFile(options["confirmation-file"], "confirmation"), "confirmation");
+  const filePath = options["confirmation-file"] || options["confirmation-json-path"];
+  if (typeof filePath === "string" && filePath.trim()) {
+    return parseJsonOption(readTextFile(filePath, "confirmation"), "confirmation");
   }
   return parseJsonOption(options["confirmation-json"], "confirmation");
 }
 
 function getRunOverrides(options) {
-  if (typeof options["overrides-file"] === "string" && options["overrides-file"].trim()) {
-    return parseJsonOption(readTextFile(options["overrides-file"], "overrides"), "overrides");
+  const filePath = options["overrides-file"] || options["overrides-json-path"];
+  if (typeof filePath === "string" && filePath.trim()) {
+    return parseJsonOption(readTextFile(filePath, "overrides"), "overrides");
   }
   return parseJsonOption(options["overrides-json"], "overrides");
 }
 
 function getRunFollowUp(options) {
-  if (typeof options["follow-up-file"] === "string" && options["follow-up-file"].trim()) {
-    return parseJsonOption(readTextFile(options["follow-up-file"], "follow_up"), "follow_up");
+  const filePath = options["follow-up-file"] || options["follow-up-json-path"];
+  if (typeof filePath === "string" && filePath.trim()) {
+    return parseJsonOption(readTextFile(filePath, "follow_up"), "follow_up");
   }
   return parseJsonOption(options["follow-up-json"], "follow_up");
 }
@@ -698,6 +704,7 @@ function normalizeMcpClientName(value) {
   if (!raw) return "";
   if (raw === "claude-code") return "claudecode";
   if (raw === "trae-cn") return "trae";
+  if (raw === "q-claw" || raw === "qclaw-win" || raw === "qclaw_win") return "qclaw";
   return raw;
 }
 
@@ -743,9 +750,19 @@ function buildMcpConfigFileContent(options = {}) {
   const serverName = typeof options["server-name"] === "string" && options["server-name"].trim()
     ? options["server-name"].trim()
     : defaultMcpServerName;
+  const launchConfig = buildMcpLaunchConfig(options);
+  if (normalizeMcpClientName(options.client) === "qclaw") {
+    return {
+      mcp: {
+        servers: {
+          [serverName]: launchConfig
+        }
+      }
+    };
+  }
   return {
     mcpServers: {
-      [serverName]: buildMcpLaunchConfig(options)
+      [serverName]: launchConfig
     }
   };
 }
@@ -757,7 +774,7 @@ function writeMcpConfigFiles(options = {}) {
   const files = [];
   for (const client of clients) {
     const filePath = path.join(outputDir, `mcp.${client}.json`);
-    fs.writeFileSync(filePath, JSON.stringify(buildMcpConfigFileContent(options), null, 2), "utf8");
+    fs.writeFileSync(filePath, JSON.stringify(buildMcpConfigFileContent({ ...options, client }), null, 2), "utf8");
     files.push({ client, file: filePath });
   }
   return { outputDir, files };
@@ -778,12 +795,13 @@ function parsePathListFromEnv(raw) {
   return dedupePaths(text.split(path.delimiter).map((item) => item.trim()).filter(Boolean));
 }
 
-const supportedExternalAgents = ["cursor", "trae", "trae-cn", "claude", "openclaw"];
+const supportedExternalAgents = ["cursor", "trae", "trae-cn", "claude", "openclaw", "qclaw"];
 
 function normalizeAgentName(value) {
   const raw = String(value || "").trim().toLowerCase();
   if (!raw) return "";
   if (raw === "claude-code") return "claude";
+  if (raw === "q-claw" || raw === "qclaw-win" || raw === "qclaw_win") return "qclaw";
   return raw;
 }
 
@@ -849,7 +867,8 @@ function getKnownExternalMcpConfigPathsByAgent() {
     trae: [...traeConfigPaths, path.join(home, ".trae", "mcp.json"), path.join(home, ".trae-cn", "mcp.json")],
     "trae-cn": [...traeConfigPaths, path.join(home, ".trae-cn", "mcp.json"), path.join(home, ".trae", "mcp.json")],
     claude: [path.join(home, ".claude", "mcp.json")],
-    openclaw: [path.join(home, ".openclaw", "mcp.json"), ...openClawConfigPaths]
+    openclaw: [path.join(home, ".openclaw", "mcp.json"), ...openClawConfigPaths],
+    qclaw: [path.join(home, ".qclaw", "openclaw.json")]
   };
 }
 
@@ -866,15 +885,38 @@ function resolveExternalMcpConfigTargets(options = {}) {
   return dedupePaths([...fromEnv, ...known]);
 }
 
+function isQClawMcpConfigTarget(filePath, options = {}, current = null) {
+  if (normalizeAgentName(options.agent) === "qclaw" || normalizeMcpClientName(options.client) === "qclaw") {
+    return true;
+  }
+  const normalized = path.resolve(String(filePath || "")).replace(/\\/g, "/").toLowerCase();
+  if (normalized.endsWith("/.qclaw/openclaw.json")) {
+    return true;
+  }
+  return Boolean(
+    current?.mcp?.servers
+    && typeof current.mcp.servers === "object"
+    && !Array.isArray(current.mcp.servers)
+    && !current?.mcpServers
+  );
+}
+
+function getMcpServersFromConfig(config = {}, useQClawShape = false) {
+  const servers = useQClawShape ? config?.mcp?.servers : config?.mcpServers;
+  if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+    return servers;
+  }
+  return {};
+}
+
 function mergeMcpServerConfigFile(filePath, options = {}) {
-  const nextConfig = buildMcpConfigFileContent(options);
-  const serverName = Object.keys(nextConfig.mcpServers || {})[0] || defaultMcpServerName;
-  const launchConfig = nextConfig.mcpServers?.[serverName] || buildMcpLaunchConfig(options);
   const current = readJsonObjectFileSafe(filePath);
-  const existingServers =
-    current?.mcpServers && typeof current.mcpServers === "object" && !Array.isArray(current.mcpServers)
-      ? current.mcpServers
-      : {};
+  const useQClawShape = isQClawMcpConfigTarget(filePath, options, current);
+  const nextConfig = buildMcpConfigFileContent({ ...options, client: useQClawShape ? "qclaw" : options.client });
+  const nextServers = useQClawShape ? nextConfig.mcp?.servers : nextConfig.mcpServers;
+  const serverName = Object.keys(nextServers || {})[0] || defaultMcpServerName;
+  const launchConfig = nextServers?.[serverName] || buildMcpLaunchConfig(options);
+  const existingServers = getMcpServersFromConfig(current, useQClawShape);
   const existingEntry = existingServers[serverName];
   const retainedServers = {};
   const migratedLegacyServers = [];
@@ -886,13 +928,24 @@ function mergeMcpServerConfigFile(filePath, options = {}) {
     }
     retainedServers[name] = config;
   }
-  const merged = {
-    ...current,
-    mcpServers: {
-      ...retainedServers,
-      [serverName]: launchConfig
-    }
-  };
+  const merged = useQClawShape
+    ? {
+        ...current,
+        mcp: {
+          ...(current?.mcp && typeof current.mcp === "object" && !Array.isArray(current.mcp) ? current.mcp : {}),
+          servers: {
+            ...retainedServers,
+            [serverName]: launchConfig
+          }
+        }
+      }
+    : {
+        ...current,
+        mcpServers: {
+          ...retainedServers,
+          [serverName]: launchConfig
+        }
+      };
 
   ensureDir(path.dirname(filePath));
   const before = pathExists(filePath) ? fs.readFileSync(filePath, "utf8") : "";
@@ -907,6 +960,7 @@ function mergeMcpServerConfigFile(filePath, options = {}) {
   return {
     file: filePath,
     server: serverName,
+    config_shape: useQClawShape ? "qclaw" : "mcpServers",
     updated,
     migrated_legacy_servers: migratedLegacyServers,
     backup_file: backupFile
@@ -957,7 +1011,8 @@ function getKnownExternalSkillBaseDirsByAgent() {
     trae: [path.join(home, ".trae", "skills"), path.join(home, ".trae-cn", "skills"), ...traeSkillDirs],
     "trae-cn": [path.join(home, ".trae-cn", "skills"), path.join(home, ".trae", "skills"), ...traeSkillDirs],
     claude: [path.join(home, ".claude", "skills")],
-    openclaw: [path.join(home, ".openclaw", "skills"), ...openClawSkillDirs]
+    openclaw: [path.join(home, ".openclaw", "skills"), ...openClawSkillDirs],
+    qclaw: [path.join(home, ".qclaw", "skills")]
   };
 }
 
@@ -1008,9 +1063,9 @@ function inspectMcpServerEntries(filePath) {
     };
   }
   const parsed = readJsonObjectFileSafe(filePath);
-  const servers = parsed?.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers)
-    ? parsed.mcpServers
-    : {};
+  const rootServers = getMcpServersFromConfig(parsed, false);
+  const qclawServers = getMcpServersFromConfig(parsed, true);
+  const servers = { ...rootServers, ...qclawServers };
   const recommendNames = [];
   const recruitNames = [];
   const chatNames = [];
@@ -1402,6 +1457,177 @@ function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
 
+function stripDetachedRunArgs(args = []) {
+  const booleanKeys = new Set(["--detached", "--background"]);
+  const valueKeys = new Set(["--detached-start-timeout-ms"]);
+  const nextArgs = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (booleanKeys.has(token)) continue;
+    if (valueKeys.has(token)) {
+      index += 1;
+      continue;
+    }
+    nextArgs.push(token);
+  }
+  return nextArgs;
+}
+
+function extractFirstJsonObject(text = "") {
+  const start = text.indexOf("{");
+  if (start < 0) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "\"") {
+      inString = true;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, index + 1);
+    }
+  }
+  return null;
+}
+
+function readFirstJsonObjectFromFile(filePath) {
+  try {
+    const text = fs.readFileSync(filePath, "utf8");
+    const jsonText = extractFirstJsonObject(text);
+    return jsonText ? JSON.parse(jsonText) : null;
+  } catch {
+    return null;
+  }
+}
+
+function createDetachedRecommendRunPaths() {
+  const dir = path.join(getStateHome(), "detached-runs");
+  ensureDir(dir);
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const nonce = Math.random().toString(36).slice(2, 8);
+  const base = `recommend-run-${stamp}-${nonce}`;
+  return {
+    dir,
+    stdoutPath: path.join(dir, `${base}.stdout.json`),
+    stderrPath: path.join(dir, `${base}.stderr.log`)
+  };
+}
+
+function appendDetachedCliMeta(payload, meta) {
+  return {
+    ...payload,
+    cli: {
+      ...(payload?.cli || {}),
+      command: "run",
+      cdp_only: true,
+      detached: true,
+      detached_parent: true,
+      child_pid: meta.childPid || null,
+      stdout_path: meta.stdoutPath,
+      stderr_path: meta.stderrPath
+    }
+  };
+}
+
+async function waitForDetachedRecommendRunStart({
+  child,
+  stdoutPath,
+  stderrPath,
+  timeoutMs
+}) {
+  const deadline = Date.now() + timeoutMs;
+  let childExit = null;
+  child.once("exit", (code, signal) => {
+    childExit = { code, signal };
+  });
+
+  while (Date.now() <= deadline) {
+    const parsed = readFirstJsonObjectFromFile(stdoutPath);
+    if (parsed) return appendDetachedCliMeta(parsed, {
+      childPid: child.pid,
+      stdoutPath,
+      stderrPath
+    });
+    if (childExit) break;
+    await sleepMs(500);
+  }
+
+  const stderrPreview = (() => {
+    try {
+      return fs.readFileSync(stderrPath, "utf8").slice(-2000);
+    } catch {
+      return "";
+    }
+  })();
+
+  return appendDetachedCliMeta({
+    status: "FAILED",
+    error: {
+      code: childExit ? "DETACHED_RECOMMEND_RUN_CHILD_EXITED" : "DETACHED_RECOMMEND_RUN_START_TIMEOUT",
+      message: childExit
+        ? `Detached recommend run child exited before producing a JSON result (code=${childExit.code ?? "null"}, signal=${childExit.signal ?? "null"}).`
+        : `Timed out waiting ${timeoutMs}ms for detached recommend run start output.`,
+      retryable: true,
+      child_exit: childExit,
+      stderr_preview: stderrPreview || null
+    }
+  }, {
+    childPid: child.pid,
+    stdoutPath,
+    stderrPath
+  });
+}
+
+async function runPipelineDetached(rawArgs = [], options = {}) {
+  const timeoutMs = parseNonNegativeInteger(options["detached-start-timeout-ms"], 180000);
+  const childArgs = stripDetachedRunArgs(rawArgs);
+  const { stdoutPath, stderrPath } = createDetachedRecommendRunPaths();
+  const stdoutFd = fs.openSync(stdoutPath, "a");
+  const stderrFd = fs.openSync(stderrPath, "a");
+  let child;
+  try {
+    child = spawn(process.execPath, [currentFilePath, "run", ...childArgs], {
+      cwd: process.cwd(),
+      detached: true,
+      env: {
+        ...process.env,
+        [detachedRecommendRunChildEnv]: "1"
+      },
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true
+    });
+  } finally {
+    fs.closeSync(stdoutFd);
+    fs.closeSync(stderrFd);
+  }
+  child.unref();
+
+  const result = await waitForDetachedRecommendRunStart({
+    child,
+    stdoutPath,
+    stderrPath,
+    timeoutMs
+  });
+  printJson(result);
+  if (result.status !== "ACCEPTED") {
+    process.exitCode = 1;
+  }
+}
+
 async function listChromeTabs(port) {
   const response = await fetch(`http://127.0.0.1:${port}/json/list`);
   if (!response.ok) {
@@ -2293,26 +2519,28 @@ function printHelp() {
   console.log("Usage:");
   console.log("  boss-recommend-mcp              Start the MCP server");
   console.log("  boss-recommend-mcp start        Start the MCP server");
-  console.log("  boss-recommend-mcp run          Disabled until the one-shot CLI has a CDP-only async replacement");
+  console.log("  boss-recommend-mcp run          Start a CDP-only recommend run through the shared run service");
   console.log("  boss-recommend-mcp list-jobs    CDP-only list of exact recommend job names for cron/one-shot inputs");
   console.log("  boss-recommend-mcp chat <subcommand>  Run CDP-only boss-chat health/prepare/status commands");
-  console.log("  boss-recommend-mcp install      Install/migrate skills and MCP configs; replaces legacy Boss MCP routes (supports --agent trae-cn/openclaw/...)");
+  console.log("  boss-recommend-mcp install      Install/migrate skills and MCP configs; replaces legacy Boss MCP routes (supports --agent trae-cn/openclaw/qclaw/...)");
   console.log("  boss-recommend-mcp install-skill Install bundled Codex skills (recommend/recruit/chat)");
   console.log("  boss-recommend-mcp init-config  Create screening-config.json if missing (prefer workspace config/, fallback ~/.boss-recommend-mcp)");
   console.log("  boss-recommend-mcp config set   Write baseUrl/apiKey/model (prefer workspace config/, fallback ~/.boss-recommend-mcp)");
   console.log("  boss-recommend-mcp set-port     Persist preferred Chrome debug port to screening-config.json");
-  console.log("  boss-recommend-mcp mcp-config   Generate MCP config JSON for Cursor/Trae(含 trae-cn)/Claude Code/OpenClaw");
-  console.log("  boss-recommend-mcp doctor       Check config/runtime/calibration prerequisites (supports --agent trae-cn/cursor/...)");
+  console.log("  boss-recommend-mcp mcp-config   Generate MCP config JSON for Cursor/Trae(含 trae-cn)/Claude Code/OpenClaw/QClaw");
+  console.log("  boss-recommend-mcp doctor       Check config/runtime/calibration prerequisites (supports --agent trae-cn/qclaw/cursor/...)");
   console.log("  boss-recommend-mcp calibrate    Disabled until CDP-only featured calibration is live-verified");
   console.log("  boss-recommend-mcp launch-chrome Launch or reuse Chrome debug instance and open Boss recommend page");
   console.log("  boss-recommend-mcp where        Print installed package, skill, and config paths");
   console.log("");
   console.log("Run command:");
-  console.log("  boss-recommend-mcp run --instruction \"推荐页上筛选211男生，近14天没有，有大模型平台经验\"    # returns RECOMMEND_CLI_RUN_UNSUPPORTED_CDP_ONLY during rewrite; use MCP start_recommend_pipeline_run");
+  console.log("  boss-recommend-mcp run --instruction \"推荐页上筛选211男生，近14天没有，有大模型平台经验\" --overrides-file overrides.json --confirmation-file confirmation.json");
+  console.log("  boss-recommend-mcp run --detached --instruction \"...\" --overrides-file overrides.json --confirmation-file confirmation.json");
   console.log("  boss-recommend-mcp list-jobs --slow-live --port 9222");
   console.log("  boss-recommend-mcp chat prepare-run --slow-live --port 9222    # CDP-only preflight; start runs through MCP start_boss_chat_run");
   console.log("  boss-recommend-mcp config set --base-url <url> --api-key <key> --model <model> [--thinking-level off|low|medium|high|current] [--openai-organization <id>] [--openai-project <id>]");
   console.log("  boss-recommend-mcp install --agent trae-cn");
+  console.log("  boss-recommend-mcp install --agent qclaw    # updates ~/.qclaw/openclaw.json mcp.servers and mirrors skills");
   console.log("  boss-recommend-mcp doctor --agent trae-cn --page-scope featured");
   console.log("  boss-recommend-mcp calibrate --port 9222    # returns CALIBRATE_UNSUPPORTED_CDP_ONLY during rewrite");
 }
@@ -2401,42 +2629,6 @@ async function installAll(options = {}) {
   }
 }
 
-function buildUnsupportedRecommendCliRunResponse({
-  instruction,
-  confirmation,
-  overrides,
-  followUp,
-  workspaceRoot,
-  port
-} = {}) {
-  return {
-    status: "FAILED",
-    error: {
-      code: recommendCliRunUnsupportedCode,
-      message: "boss-recommend-mcp run is fenced during the CDP-only rewrite because the old one-shot CLI route can reach page-JS/Runtime-based orchestration. Use the MCP tool start_recommend_pipeline_run for CDP-only recommend runs until a live-verified one-shot CLI replacement exists.",
-      retryable: false
-    },
-    cdp_only: true,
-    runtime_evaluate_used: false,
-    method_summary: {},
-    method_log: [],
-    run_mode: "mcp_async_required",
-    port,
-    target_url: bossUrl,
-    input: {
-      workspace_root: workspaceRoot,
-      instruction,
-      confirmation: confirmation ?? null,
-      overrides: overrides ?? null,
-      follow_up: followUp ?? null
-    },
-    guidance: {
-      recommended_tool: "start_recommend_pipeline_run",
-      next_development_task: "Implement a CDP-only CLI wrapper that starts a durable shared run-service session, persists run state, and exits only after its live gate proves no Runtime.* methods are reachable."
-    }
-  };
-}
-
 async function runPipelineOnce(options = {}) {
   const instruction = getRunInstruction(options);
   const confirmation = getRunConfirmation(options);
@@ -2445,15 +2637,70 @@ async function runPipelineOnce(options = {}) {
   const workspaceRoot = getWorkspaceRoot(options);
   const port = parsePositivePort(options.port) || parsePositivePort(process.env.BOSS_RECOMMEND_CHROME_PORT) || 9222;
 
-  printJson(buildUnsupportedRecommendCliRunResponse({
-    workspaceRoot,
+  const args = {
     instruction,
-    confirmation,
-    overrides,
-    followUp,
-    port
-  }));
-  process.exitCode = 1;
+    confirmation: confirmation ?? undefined,
+    overrides: overrides ?? undefined,
+    follow_up: followUp ?? undefined,
+    host: typeof options.host === "string" && options.host.trim() ? options.host.trim() : undefined,
+    port,
+    target_url_includes: typeof options["target-url-includes"] === "string" && options["target-url-includes"].trim()
+      ? options["target-url-includes"].trim()
+      : undefined,
+    allow_navigate: !(options["no-navigate"] === true || options.noNavigate === true || options.allow_navigate === false),
+    slow_live: options["slow-live"] === true || options.slowLive === true || options.slow_live === true
+  };
+
+  const optionalPassthrough = [
+    "detail_limit",
+    "allow_card_only_screening",
+    "debug_test_mode",
+    "screening_mode",
+    "use_llm",
+    "delay_ms",
+    "max_image_pages",
+    "image_wheel_delta_y",
+    "cv_acquisition_mode",
+    "list_max_scrolls",
+    "list_stable_signature_limit",
+    "list_wheel_delta_y",
+    "list_settle_ms",
+    "refresh_on_end",
+    "max_refresh_rounds",
+    "refresh_button_settle_ms",
+    "refresh_reload_settle_ms",
+    "dry_run_post_action",
+    "execute_post_action",
+    "action_timeout_ms",
+    "action_interval_ms",
+    "action_after_click_delay_ms",
+    "llm_timeout_ms",
+    "llm_image_limit",
+    "llm_image_detail"
+  ];
+  for (const key of optionalPassthrough) {
+    const kebab = key.replace(/_/g, "-");
+    if (options[key] !== undefined) args[key] = options[key];
+    else if (options[kebab] !== undefined) args[key] = options[kebab];
+  }
+
+  const result = await startRecommendPipelineRunTool({
+    workspaceRoot,
+    args
+  });
+  printJson({
+    ...result,
+    cli: {
+      command: "run",
+      cdp_only: true,
+      shared_run_service: true,
+      workspace_root: workspaceRoot,
+      port
+    }
+  });
+  if (result.status !== "ACCEPTED") {
+    process.exitCode = 1;
+  }
 }
 
 function buildRecommendJobListCliInput(options = {}) {
@@ -2590,11 +2837,19 @@ export async function runCli(argv = process.argv) {
 
   switch (command) {
     case "start":
+    case "mcp":
       startServer();
       break;
     case "run":
       try {
-        await runPipelineOnce(options);
+        if (
+          (options.detached === true || options.background === true)
+          && process.env[detachedRecommendRunChildEnv] !== "1"
+        ) {
+          await runPipelineDetached(argv.slice(3), options);
+        } else {
+          await runPipelineOnce(options);
+        }
       } catch (error) {
         printJson({
           status: "FAILED",
@@ -2754,7 +3009,6 @@ export const __testables = {
   buildBossChatCliInput,
   buildDefaultMcpArgs,
   buildMcpLaunchConfig,
-  buildUnsupportedRecommendCliRunResponse,
   collectRuntimeDirectories,
   ensureBossChatRuntimeReady: ensureBossChatRuntimeReadyLocal,
   ensureRuntimeDirectories,

package/src/core/infinite-list/index.js

@@ -30,6 +30,7 @@ export const DEFAULT_LOAD_MORE_HINT_KEYWORDS = Object.freeze([
 
 export const DEFAULT_BOTTOM_MARKER_SELECTORS = Object.freeze([
   ".finished-wrap",
+  ".loadmore",
   ".load-tips",
   "div[role=\"tfoot\"] .load-tips",
   ".no-data-refresh",
@@ -38,6 +39,7 @@ export const DEFAULT_BOTTOM_MARKER_SELECTORS = Object.freeze([
   ".no-data",
   ".tip-nodata",
   "[class*=\"finished\"]",
+  "[class*=\"loadmore\"]",
   "[class*=\"load-tips\"]",
   "[class*=\"no-more\"]",
   "[class*=\"no_more\"]"
@@ -96,6 +98,345 @@ function isUsableBox(box) {
   return Number(box?.rect?.width || 0) > 2 && Number(box?.rect?.height || 0) > 2;
 }
 
+function isUsableRect(rect) {
+  return Number(rect?.width || 0) > 2 && Number(rect?.height || 0) > 2;
+}
+
+function pointFromRect(rect, {
+  xRatio = 0.5,
+  yRatio = 0.75,
+  inset = 8
+} = {}) {
+  if (!isUsableRect(rect)) return null;
+  const safeInsetX = Math.min(Math.max(0, Number(inset) || 0), Math.max(0, rect.width / 2 - 1));
+  const safeInsetY = Math.min(Math.max(0, Number(inset) || 0), Math.max(0, rect.height / 2 - 1));
+  const minX = rect.x + safeInsetX;
+  const maxX = rect.x + rect.width - safeInsetX;
+  const minY = rect.y + safeInsetY;
+  const maxY = rect.y + rect.height - safeInsetY;
+  return {
+    x: Math.min(maxX, Math.max(minX, rect.x + rect.width * (Number(xRatio) || 0.5))),
+    y: Math.min(maxY, Math.max(minY, rect.y + rect.height * (Number(yRatio) || 0.75)))
+  };
+}
+
+function unionRects(rects = []) {
+  const usable = rects.filter(isUsableRect);
+  if (!usable.length) return null;
+  const left = Math.min(...usable.map((rect) => rect.x));
+  const top = Math.min(...usable.map((rect) => rect.y));
+  const right = Math.max(...usable.map((rect) => rect.x + rect.width));
+  const bottom = Math.max(...usable.map((rect) => rect.y + rect.height));
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+
+function pointInsideRect(point, rect, {
+  padding = 0
+} = {}) {
+  if (!point || !isUsableRect(rect)) return false;
+  const pad = Math.max(0, Number(padding) || 0);
+  return Number(point.x) >= rect.x + pad
+    && Number(point.x) <= rect.x + rect.width - pad
+    && Number(point.y) >= rect.y + pad
+    && Number(point.y) <= rect.y + rect.height - pad;
+}
+
+function rectsIntersect(a, b, {
+  padding = 0
+} = {}) {
+  if (!isUsableRect(a) || !isUsableRect(b)) return false;
+  const pad = Math.max(0, Number(padding) || 0);
+  return a.x + a.width >= b.x + pad
+    && b.x + b.width >= a.x + pad
+    && a.y + a.height >= b.y + pad
+    && b.y + b.height >= a.y + pad;
+}
+
+function intersectRects(a, b) {
+  if (!isUsableRect(a) || !isUsableRect(b)) return null;
+  const left = Math.max(a.x, b.x);
+  const top = Math.max(a.y, b.y);
+  const right = Math.min(a.x + a.width, b.x + b.width);
+  const bottom = Math.min(a.y + a.height, b.y + b.height);
+  if (right - left <= 2 || bottom - top <= 2) return null;
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+
+function normalizePoint(point) {
+  if (!point) return null;
+  const x = Number(point.x);
+  const y = Number(point.y);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y };
+}
+
+function resolveViewportPoint(viewportPoint, viewport) {
+  if (!viewportPoint) return null;
+  if (viewport && ("xRatio" in viewportPoint || "yRatio" in viewportPoint)) {
+    const xRatio = Number(viewportPoint.xRatio ?? 0);
+    const yRatio = Number(viewportPoint.yRatio ?? 0);
+    if (Number.isFinite(xRatio) && Number.isFinite(yRatio)) {
+      return {
+        x: viewport.x + viewport.width * xRatio,
+        y: viewport.y + viewport.height * yRatio
+      };
+    }
+  }
+  return normalizePoint(viewportPoint);
+}
+
+async function getViewportRect(client) {
+  try {
+    const metrics = await client.Page.getLayoutMetrics();
+    const viewport = metrics.visualViewport || metrics.layoutViewport || metrics.cssVisualViewport || {};
+    const width = Number(viewport.clientWidth || viewport.width || metrics.layoutViewport?.clientWidth || 0);
+    const height = Number(viewport.clientHeight || viewport.height || metrics.layoutViewport?.clientHeight || 0);
+    const x = Number(viewport.pageX || viewport.x || 0);
+    const y = Number(viewport.pageY || viewport.y || 0);
+    if (width > 0 && height > 0) {
+      return { x, y, width, height };
+    }
+  } catch {
+    // Page.getLayoutMetrics is optional for fallback only.
+  }
+  return null;
+}
+
+async function collectUsableNodeBoxes(client, nodeIds = [], {
+  maxNodes = 80
+} = {}) {
+  const boxes = [];
+  const errors = [];
+  for (const nodeId of nodeIds.slice(0, Math.max(1, Number(maxNodes) || 80))) {
+    try {
+      const box = await getNodeBox(client, nodeId);
+      if (isUsableBox(box)) {
+        boxes.push({
+          node_id: nodeId,
+          box,
+          rect: box.rect
+        });
+      }
+    } catch (error) {
+      errors.push({
+        node_id: nodeId,
+        error: error?.message || String(error)
+      });
+    }
+  }
+  return { boxes, errors };
+}
+
+async function querySelectorBoxes(client, rootNodeId, selectors = [], {
+  maxNodes = 80
+} = {}) {
+  const attempts = [];
+  if (!rootNodeId) return { boxes: [], attempts };
+  for (const selector of selectors.filter(Boolean)) {
+    let nodeIds = [];
+    try {
+      nodeIds = await querySelectorAll(client, rootNodeId, selector);
+    } catch (error) {
+      attempts.push({
+        selector,
+        error: error?.message || String(error),
+        node_count: 0,
+        box_count: 0
+      });
+      continue;
+    }
+    const measured = await collectUsableNodeBoxes(client, nodeIds, { maxNodes });
+    attempts.push({
+      selector,
+      node_count: nodeIds.length,
+      box_count: measured.boxes.length,
+      errors: measured.errors
+    });
+    if (measured.boxes.length) {
+      return {
+        boxes: measured.boxes,
+        selector,
+        attempts
+      };
+    }
+  }
+  return { boxes: [], attempts };
+}
+
+export async function resolveInfiniteListFallbackPoint(client, {
+  rootNodeId = 0,
+  containerSelectors = [],
+  itemNodeIds = [],
+  itemSelectors = [],
+  allowedSources = ["container", "item_union", "viewport_ratio"],
+  containerXRatio = 0.5,
+  containerYRatio = 0.5,
+  itemXRatio = 0.5,
+  itemYRatio = 0.5,
+  viewportPoint = null,
+  validateViewportPoint = true,
+  maxProbeNodes = 80
+} = {}) {
+  const attempts = [];
+  const allowed = new Set(Array.isArray(allowedSources) && allowedSources.length
+    ? allowedSources.map((source) => String(source || ""))
+    : ["container", "item_union", "viewport_ratio"]);
+
+  const containerResult = await querySelectorBoxes(client, rootNodeId, containerSelectors, {
+    maxNodes: maxProbeNodes
+  });
+  attempts.push({
+    source: "container",
+    selector: containerResult.selector || null,
+    attempts: containerResult.attempts
+  });
+  const containerBox = containerResult.boxes
+    .slice()
+    .sort((a, b) => (b.rect.width * b.rect.height) - (a.rect.width * a.rect.height))[0];
+  const viewport = await getViewportRect(client);
+  const inputViewportRect = viewport
+    ? { x: 0, y: 0, width: viewport.width, height: viewport.height }
+    : null;
+  const visibleContainerRect = inputViewportRect && containerBox?.rect
+    ? intersectRects(containerBox.rect, inputViewportRect) || containerBox.rect
+    : containerBox?.rect;
+  const containerPoint = pointFromRect(visibleContainerRect, {
+    xRatio: containerXRatio,
+    yRatio: containerYRatio
+  });
+  if (containerPoint && allowed.has("container")) {
+    return {
+      ok: true,
+      source: "container",
+      point: containerPoint,
+      selector: containerResult.selector || null,
+      node_id: containerBox.node_id,
+      assist_node_id: itemNodeIds.slice(-1)[0] || null,
+      rect: visibleContainerRect,
+      full_rect: containerBox.rect,
+      attempts
+    };
+  }
+
+  let itemBoxes = [];
+  const itemProbeNodeIds = itemNodeIds.length > maxProbeNodes
+    ? itemNodeIds.slice(-maxProbeNodes)
+    : itemNodeIds;
+  const measuredItems = await collectUsableNodeBoxes(client, itemProbeNodeIds, { maxNodes: maxProbeNodes });
+  itemBoxes = measuredItems.boxes;
+  attempts.push({
+    source: "visible_items",
+    node_count: itemNodeIds.length,
+    box_count: measuredItems.boxes.length,
+    errors: measuredItems.errors
+  });
+  if (!itemBoxes.length) {
+    const queriedItems = await querySelectorBoxes(client, rootNodeId, itemSelectors, {
+      maxNodes: maxProbeNodes
+    });
+    itemBoxes = queriedItems.boxes;
+    attempts.push({
+      source: "item_selector",
+      selector: queriedItems.selector || null,
+      attempts: queriedItems.attempts
+    });
+  }
+  const itemValidationRects = [
+    inputViewportRect,
+    visibleContainerRect || containerBox?.rect || null
+  ].filter(isUsableRect);
+  const visibleItemBoxes = itemValidationRects.length
+    ? itemBoxes.filter((item) => itemValidationRects.every((rect) => rectsIntersect(item.rect, rect, { padding: 1 })))
+    : itemBoxes;
+  attempts.push({
+    source: "visible_item_filter",
+    input_box_count: itemBoxes.length,
+    output_box_count: visibleItemBoxes.length,
+    validation_rect_count: itemValidationRects.length
+  });
+  const unionSourceBoxes = visibleItemBoxes.length ? visibleItemBoxes : itemBoxes;
+  const rawItemUnion = unionRects(unionSourceBoxes.map((item) => item.rect));
+  const itemUnion = itemValidationRects.reduce(
+    (rect, limit) => intersectRects(rect, limit) || rect,
+    rawItemUnion
+  );
+  const itemPoint = pointFromRect(itemUnion, {
+    xRatio: itemXRatio,
+    yRatio: itemYRatio
+  });
+  if (itemPoint && allowed.has("item_union")) {
+    const assistItem = unionSourceBoxes
+      .slice()
+      .sort((a, b) => ((b.rect.y + b.rect.height) - (a.rect.y + a.rect.height)))[0];
+    return {
+      ok: true,
+      source: "item_union",
+      point: itemPoint,
+      rect: itemUnion,
+      full_rect: rawItemUnion,
+      item_box_count: unionSourceBoxes.length,
+      visible_item_box_count: visibleItemBoxes.length,
+      assist_node_id: assistItem?.node_id || itemNodeIds.slice(-1)[0] || null,
+      attempts
+    };
+  }
+
+  const viewportRatioPoint = resolveViewportPoint(viewportPoint, viewport);
+  const normalizedViewportPoint = normalizePoint(viewportRatioPoint);
+  if (normalizedViewportPoint && allowed.has("viewport_ratio")) {
+    if (!validateViewportPoint) {
+      return {
+        ok: true,
+        source: "viewport_ratio",
+        point: normalizedViewportPoint,
+        viewport,
+        validated: false,
+        attempts
+      };
+    }
+    const validationRects = [
+      ...containerResult.boxes.map((item) => item.rect),
+      ...itemBoxes.map((item) => item.rect)
+    ].filter(isUsableRect);
+    const validatedRect = validationRects.find((rect) => pointInsideRect(normalizedViewportPoint, rect, { padding: 4 }));
+    attempts.push({
+      source: "viewport_ratio",
+      point: normalizedViewportPoint,
+      viewport,
+      validation_rect_count: validationRects.length,
+      validated: Boolean(validatedRect)
+    });
+    if (validatedRect) {
+      return {
+        ok: true,
+        source: "viewport_ratio",
+        point: normalizedViewportPoint,
+        viewport,
+        rect: validatedRect,
+        validated: true,
+        assist_node_id: itemNodeIds.slice(-1)[0] || null,
+        attempts
+      };
+    }
+  }
+
+  return {
+    ok: false,
+    reason: "fallback_point_unavailable",
+    attempts
+  };
+}
+
 function shortHash(value) {
   return crypto.createHash("sha256").update(String(value || "")).digest("hex").slice(0, 16);
 }
@@ -561,6 +902,29 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
   }
 
   const errors = [];
+  const wheelDelta = Math.max(1, Number(wheelDeltaY) || 850);
+  async function synthesizeGesture(x, y) {
+    if (typeof client?.Input?.synthesizeScrollGesture !== "function") return null;
+    try {
+      const gestureDistance = -Math.min(1200, wheelDelta);
+      await client.Input.synthesizeScrollGesture({
+        x,
+        y,
+        yDistance: gestureDistance,
+        speed: 800,
+        repeatCount: 1
+      });
+      return {
+        ok: true,
+        y_distance: gestureDistance
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error?.message || String(error)
+      };
+    }
+  }
   for (const anchor of candidates.slice().reverse()) {
     try {
       await scrollNodeIntoView(client, anchor.node_id);
@@ -574,15 +938,17 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
         x,
         y,
         deltaX: 0,
-        deltaY: Math.max(1, Number(wheelDeltaY) || 850)
+        deltaY: wheelDelta
       });
+      const gesture = await synthesizeGesture(x, y);
       if (settleMs > 0) await sleep(settleMs);
       return {
         ok: true,
         anchor_key: anchor.key,
         anchor_node_id: anchor.node_id,
         point: { x, y },
-        wheel_delta_y: Math.max(1, Number(wheelDeltaY) || 850),
+        wheel_delta_y: wheelDelta,
+        gesture,
         settle_ms: settleMs,
         skipped_stale_anchor_count: errors.length
       };
@@ -595,23 +961,56 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
     }
   }
 
-  if (fallbackPoint && Number.isFinite(Number(fallbackPoint.x)) && Number.isFinite(Number(fallbackPoint.y))) {
-    const x = Number(fallbackPoint.x);
-    const y = Number(fallbackPoint.y);
+  const resolvedFallback = typeof fallbackPoint === "function"
+    ? await fallbackPoint({ client, items, errors })
+    : (fallbackPoint ? { ok: true, source: "static", point: fallbackPoint } : null);
+  const resolvedPoint = normalizePoint(resolvedFallback?.point || resolvedFallback);
+  if (resolvedPoint) {
+    const x = resolvedPoint.x;
+    const y = resolvedPoint.y;
+    let assist = null;
+    if (resolvedFallback?.assist_node_id) {
+      try {
+        await scrollNodeIntoView(client, resolvedFallback.assist_node_id);
+        await sleep(150);
+        assist = {
+          ok: true,
+          node_id: resolvedFallback.assist_node_id
+        };
+      } catch (error) {
+        assist = {
+          ok: false,
+          node_id: resolvedFallback.assist_node_id,
+          error: error?.message || String(error)
+        };
+      }
+    }
     await client.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" });
     await client.Input.dispatchMouseEvent({
       type: "mouseWheel",
       x,
       y,
       deltaX: 0,
-      deltaY: Math.max(1, Number(wheelDeltaY) || 850)
+      deltaY: wheelDelta
     });
+    const gesture = await synthesizeGesture(x, y);
     if (settleMs > 0) await sleep(settleMs);
     return {
       ok: true,
       mode: "fallback_point",
+      fallback: {
+        source: resolvedFallback?.source || "static",
+        selector: resolvedFallback?.selector || null,
+        node_id: resolvedFallback?.node_id || null,
+        assist_node_id: resolvedFallback?.assist_node_id || null,
+        rect: resolvedFallback?.rect || null,
+        validated: resolvedFallback?.validated ?? null,
+        reason: resolvedFallback?.reason || null
+      },
+      assist,
       point: { x, y },
-      wheel_delta_y: Math.max(1, Number(wheelDeltaY) || 850),
+      wheel_delta_y: wheelDelta,
+      gesture,
       settle_ms: settleMs,
       skipped_stale_anchor_count: errors.length,
       stale_anchor_errors: errors
@@ -621,7 +1020,8 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
   return {
     ok: false,
     reason: "scroll_anchor_unavailable",
-    errors
+    errors,
+    fallback: resolvedFallback || null
   };
 }
 

package/src/domains/chat/constants.js

@@ -8,6 +8,21 @@ export const CHAT_CARD_SELECTORS = Object.freeze([
   "div[role=\"listitem\"]"
 ]);
 
+export const CHAT_LIST_CONTAINER_SELECTORS = Object.freeze([
+  ".chat-list",
+  ".chat-list-content",
+  ".chat-left",
+  ".chat-left-main",
+  ".chat-message-list-left",
+  ".chat-conversation-list",
+  ".geek-list",
+  ".geek-list-wrap",
+  ".chat-list-wrap",
+  ".user-list",
+  ".conversation-list",
+  "div[role=\"list\"]"
+]);
+
 export const CHAT_BOTTOM_MARKER_SELECTORS = Object.freeze([
   "div[role=\"tfoot\"] .load-tips",
   "p.load-tips",

package/src/domains/chat/run-service.js

@@ -22,7 +22,8 @@ import {
   detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed,
-  resetInfiniteListForRefreshRound
+  resetInfiniteListForRefreshRound,
+  resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import { createRunLifecycleManager } from "../../core/run/index.js";
@@ -38,6 +39,8 @@ import {
 } from "../../core/screening/index.js";
 import {
   CHAT_BOTTOM_MARKER_SELECTORS,
+  CHAT_CARD_SELECTORS,
+  CHAT_LIST_CONTAINER_SELECTORS,
   CHAT_TARGET_URL
 } from "./constants.js";
 import {
@@ -682,6 +685,14 @@ export async function runChatWorkflow({
   const results = [];
   let cardNodeIds = [];
   let listEndReason = "";
+  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+    rootNodeId: rootState?.rootNodes?.top,
+    containerSelectors: CHAT_LIST_CONTAINER_SELECTORS,
+    itemNodeIds: items.map((item) => item.node_id).filter(Boolean),
+    itemSelectors: CHAT_CARD_SELECTORS,
+    viewportPoint: { xRatio: 0.16, yRatio: 0.4 },
+    validateViewportPoint: true
+  }));
   let requestedCount = 0;
   let requestSatisfiedCount = 0;
   let requestSkippedCount = 0;
@@ -921,7 +932,7 @@ export async function runChatWorkflow({
       stableSignatureLimit: listStableSignatureLimit,
       wheelDeltaY: listWheelDeltaY,
       settleMs: listSettleMs,
-      fallbackPoint: listFallbackPoint,
+      fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         const currentRootState = await ensureChatViewport(await getChatRoots(client), "candidate_find_nodes");
         rootState = currentRootState;

package/src/domains/recommend/constants.js

@@ -58,6 +58,19 @@ export const RECOMMEND_CARD_SELECTOR = [
   "a[data-geekid]"
 ].join(", ");
 
+export const RECOMMEND_LIST_CONTAINER_SELECTORS = Object.freeze([
+  ".recommend-list",
+  ".recommend-list-wrap",
+  ".candidate-list",
+  ".candidate-card-list",
+  ".candidate-card-wrap-list",
+  ".geek-list",
+  ".geek-list-wrap",
+  ".card-list",
+  ".list-wrap",
+  ".content-list"
+]);
+
 export const RECOMMEND_END_REFRESH_SELECTOR = [
   ".btn",
   "button",

package/src/domains/recommend/run-service.js

@@ -24,7 +24,8 @@ import {
   detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed,
-  resetInfiniteListForRefreshRound
+  resetInfiniteListForRefreshRound,
+  resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import {
@@ -57,7 +58,9 @@ import {
 } from "./scopes.js";
 import {
   RECOMMEND_BOTTOM_MARKER_SELECTORS,
-  RECOMMEND_END_REFRESH_SELECTOR
+  RECOMMEND_CARD_SELECTOR,
+  RECOMMEND_END_REFRESH_SELECTOR,
+  RECOMMEND_LIST_CONTAINER_SELECTORS
 } from "./constants.js";
 import {
   clickRecommendActionControl,
@@ -451,6 +454,14 @@ export async function runRecommendWorkflow({
   let filterResult = null;
   let cardNodeIds = [];
   let listEndReason = "";
+  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+    rootNodeId: rootState?.iframe?.documentNodeId,
+    containerSelectors: RECOMMEND_LIST_CONTAINER_SELECTORS,
+    itemNodeIds: items.map((item) => item.node_id).filter(Boolean),
+    itemSelectors: [RECOMMEND_CARD_SELECTOR],
+    viewportPoint: { xRatio: 0.28, yRatio: 0.5 },
+    validateViewportPoint: true
+  }));
 
   runControl.setPhase("recommend:cleanup");
   await closeRecommendDetail(client, { attemptsLimit: 2 });
@@ -567,7 +578,7 @@ export async function runRecommendWorkflow({
       stableSignatureLimit: listStableSignatureLimit,
       wheelDeltaY: listWheelDeltaY,
       settleMs: listSettleMs,
-      fallbackPoint: listFallbackPoint,
+      fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         let currentRootState = await getRecommendRoots(client);
         currentRootState = await ensureRecommendViewport(currentRootState, "candidate_find_nodes");

package/src/domains/recruit/constants.js

@@ -16,6 +16,18 @@ export const RECRUIT_CARD_SELECTOR = [
   "a[data-geekid]"
 ].join(", ");
 
+export const RECRUIT_LIST_CONTAINER_SELECTORS = Object.freeze([
+  ".search-list",
+  ".search-result-list",
+  ".candidate-list",
+  ".geek-list",
+  ".geek-list-wrap",
+  ".card-list",
+  ".list-wrap",
+  ".search-content",
+  ".search-container"
+]);
+
 export const RECRUIT_NO_DATA_SELECTORS = Object.freeze([
   "i.tip-nodata",
   ".tip-nodata",
@@ -26,12 +38,14 @@ export const RECRUIT_NO_DATA_SELECTORS = Object.freeze([
 
 export const RECRUIT_BOTTOM_MARKER_SELECTORS = Object.freeze([
   ".finished-wrap",
+  ".loadmore",
   ".load-tips",
   ".tip-nodata",
   ".empty-tip",
   ".empty-text",
   ".no-data",
   "[class*=\"finished\"]",
+  "[class*=\"loadmore\"]",
   "[class*=\"load-tips\"]",
   "[class*=\"empty\"]"
 ]);

package/src/domains/recruit/run-service.js

@@ -22,7 +22,8 @@ import {
   detectInfiniteListBottomMarker,
   getNextInfiniteListCandidate,
   markInfiniteListCandidateProcessed,
-  resetInfiniteListForRefreshRound
+  resetInfiniteListForRefreshRound,
+  resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import {
@@ -52,7 +53,9 @@ import { refreshRecruitSearchAtEnd } from "./refresh.js";
 import { getRecruitRoots } from "./roots.js";
 import {
   RECRUIT_BOTTOM_MARKER_SELECTORS,
-  RECRUIT_BOTTOM_REFRESH_SELECTORS
+  RECRUIT_BOTTOM_REFRESH_SELECTORS,
+  RECRUIT_CARD_SELECTOR,
+  RECRUIT_LIST_CONTAINER_SELECTORS
 } from "./constants.js";
 
 function compactScreening(screening) {
@@ -194,6 +197,14 @@ export async function runRecruitWorkflow({
   let refreshRounds = 0;
   let cardNodeIds = [];
   let listEndReason = "";
+  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+    rootNodeId: rootState?.iframe?.documentNodeId,
+    containerSelectors: RECRUIT_LIST_CONTAINER_SELECTORS,
+    itemNodeIds: items.map((item) => item.node_id).filter(Boolean),
+    itemSelectors: [RECRUIT_CARD_SELECTOR],
+    viewportPoint: { xRatio: 0.28, yRatio: 0.5 },
+    validateViewportPoint: true
+  }));
 
   runControl.setPhase("recruit:cleanup");
   await closeRecruitDetail(client, { attemptsLimit: 2 });
@@ -283,7 +294,7 @@ export async function runRecruitWorkflow({
       stableSignatureLimit: listStableSignatureLimit,
       wheelDeltaY: listWheelDeltaY,
       settleMs: listSettleMs,
-      fallbackPoint: listFallbackPoint,
+      fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         let currentRootState = await getRecruitRoots(client);
         currentRootState = await ensureRecruitViewport(currentRootState, "candidate_find_nodes");