@reconcrap/boss-recommend-mcp 1.2.0 → 1.2.2

package/package.json

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

package/src/index.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createRequire } from "node:module";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
 import { runRecommendPipeline } from "./pipeline.js";
 import {
   RUN_MODE_ASYNC,
@@ -34,13 +35,16 @@ const TOOL_PAUSE_RUN = "pause_recommend_pipeline_run";
 const TOOL_RESUME_RUN = "resume_recommend_pipeline_run";
 
 const SERVER_NAME = "boss-recommend-mcp";
-const FRAMING_UNKNOWN = "unknown";
-const FRAMING_HEADER = "header";
-const FRAMING_LINE = "line";
-
-const activeAsyncRuns = new Map();
-let runPipelineImpl = runRecommendPipeline;
-const TERMINAL_RUN_STATES = new Set([RUN_STATE_COMPLETED, RUN_STATE_FAILED, RUN_STATE_CANCELED]);
+const FRAMING_UNKNOWN = "unknown";
+const FRAMING_HEADER = "header";
+const FRAMING_LINE = "line";
+const DETACHED_WORKER_FLAG = "--detached-worker";
+const DETACHED_WORKER_RUN_ID_FLAG = "--run-id";
+const DETACHED_WORKER_RESUME_FLAG = "--resume";
+
+let runPipelineImpl = runRecommendPipeline;
+let spawnProcessImpl = spawn;
+const TERMINAL_RUN_STATES = new Set([RUN_STATE_COMPLETED, RUN_STATE_FAILED, RUN_STATE_CANCELED]);
 
 function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
@@ -470,9 +474,6 @@ function reconcileOrphanRunIfNeeded(runId, snapshot) {
   if (snapshot.state === RUN_STATE_PAUSED) {
     return snapshot;
   }
-  if (activeAsyncRuns.has(runId)) {
-    return snapshot;
-  }
   if (isProcessAlive(snapshot.pid)) {
     return snapshot;
   }
@@ -511,6 +512,71 @@ function reconcileOrphanRunIfNeeded(runId, snapshot) {
   });
   return recovered || readRunState(runId) || snapshot;
 }
+
+function parseDetachedWorkerOptions(argv = process.argv.slice(2)) {
+  if (!Array.isArray(argv) || !argv.includes(DETACHED_WORKER_FLAG)) {
+    return null;
+  }
+  const runIdFlagIndex = argv.indexOf(DETACHED_WORKER_RUN_ID_FLAG);
+  const runId = runIdFlagIndex >= 0 ? normalizeText(argv[runIdFlagIndex + 1]) : "";
+  return {
+    runId,
+    resumeRun: argv.includes(DETACHED_WORKER_RESUME_FLAG)
+  };
+}
+
+function launchDetachedRunWorker({ runId, resumeRun = false }) {
+  const childArgs = [thisFilePath, DETACHED_WORKER_FLAG, DETACHED_WORKER_RUN_ID_FLAG, String(runId)];
+  if (resumeRun) {
+    childArgs.push(DETACHED_WORKER_RESUME_FLAG);
+  }
+  const child = spawnProcessImpl(process.execPath, childArgs, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: process.env
+  });
+  if (typeof child?.unref === "function") {
+    child.unref();
+  }
+  return child;
+}
+
+function buildWorkerLaunchFailedPayload(message) {
+  return {
+    status: "FAILED",
+    error: {
+      code: "RUN_WORKER_LAUNCH_FAILED",
+      message,
+      retryable: true
+    }
+  };
+}
+
+function finalizeCanceledRun(runId, snapshot) {
+  const canceledResult = {
+    status: "FAILED",
+    error: {
+      code: "PIPELINE_CANCELED",
+      message: "流水线已取消。",
+      retryable: true
+    },
+    partial_result: snapshot?.result?.partial_result || snapshot?.result?.result || null
+  };
+  return safeUpdateRunState(runId, {
+    state: RUN_STATE_CANCELED,
+    stage: snapshot?.stage || RUN_STAGE_PREFLIGHT,
+    last_message: "流水线已取消。",
+    control: {
+      pause_requested: false,
+      pause_requested_at: null,
+      pause_requested_by: null,
+      cancel_requested: false
+    },
+    error: canceledResult.error,
+    result: canceledResult
+  }) || readRunState(runId) || snapshot;
+}
 
 function createRuntimeCallbacks(runId, heartbeatIntervalMs) {
   let lastStage = RUN_STAGE_PREFLIGHT;
@@ -735,14 +801,14 @@ async function executeTrackedPipeline({
   };
 }
 
-function initializeRunStateOrThrow(runId, mode, workspaceRoot, args) {
-  const artifacts = getRunArtifacts(runId);
-  const snapshot = createRunStateSnapshot({
-    runId,
-    mode,
-    state: "queued",
-    stage: RUN_STAGE_PREFLIGHT,
-    pid: process.pid,
+function initializeRunStateOrThrow(runId, mode, workspaceRoot, args, pid = process.pid) {
+  const artifacts = getRunArtifacts(runId);
+  const snapshot = createRunStateSnapshot({
+    runId,
+    mode,
+    state: "queued",
+    stage: RUN_STAGE_PREFLIGHT,
+    pid,
     lastMessage: "流水线任务已创建，等待执行。",
     context: buildRunContext(workspaceRoot, args),
     control: {
@@ -759,28 +825,59 @@ function initializeRunStateOrThrow(runId, mode, workspaceRoot, args) {
       last_resumed_at: null,
       last_paused_at: null
     }
-  });
-  return writeRunState(snapshot);
-}
-
-function launchAsyncRun({ runId, mode, workspaceRoot, args, resumeRun = false }) {
-  const abortController = new AbortController();
-  const promise = executeTrackedPipeline({
-    runId,
-    mode,
-    workspaceRoot,
-    args,
-    signal: abortController.signal,
-    resumeRun
-  }).finally(() => {
-    activeAsyncRuns.delete(runId);
-  });
-  activeAsyncRuns.set(runId, {
-    abortController,
-    promise
-  });
-  return { abortController, promise };
-}
+  });
+  return writeRunState(snapshot);
+}
+
+async function runDetachedWorker({ runId, resumeRun = false, workerPid = process.pid }) {
+  const normalizedRunId = normalizeText(runId);
+  if (!normalizedRunId) {
+    return { ok: false, error: "run_id is required" };
+  }
+  const snapshot = readRunState(normalizedRunId);
+  if (!snapshot) {
+    return { ok: false, error: `run_id=${normalizedRunId} not found` };
+  }
+
+  const executionContext = resolveRunContext(snapshot);
+  if (!executionContext) {
+    const failedPayload = {
+      code: "RUN_CONTEXT_MISSING",
+      message: "run 缺少可恢复的执行上下文，无法继续。",
+      retryable: false
+    };
+    safeUpdateRunState(normalizedRunId, {
+      state: RUN_STATE_FAILED,
+      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
+      last_message: failedPayload.message,
+      error: failedPayload,
+      result: {
+        status: "FAILED",
+        error: failedPayload
+      }
+    });
+    return { ok: false, error: failedPayload.message };
+  }
+
+  safeUpdateRunState(normalizedRunId, {
+    pid: Number.isInteger(workerPid) && workerPid > 0 ? workerPid : process.pid,
+    mode: RUN_MODE_ASYNC,
+    state: "queued",
+    last_message: resumeRun
+      ? "detached worker 已启动，准备恢复执行。"
+      : "detached worker 已启动，准备执行。"
+  });
+
+  await executeTrackedPipeline({
+    runId: normalizedRunId,
+    mode: RUN_MODE_ASYNC,
+    workspaceRoot: executionContext.workspaceRoot,
+    args: executionContext.args,
+    signal: new AbortController().signal,
+    resumeRun
+  });
+  return { ok: true };
+}
 
 async function handleStartRunTool({ workspaceRoot, args }) {
   const precheckArgs = buildAsyncPrecheckArgs(args);
@@ -814,36 +911,57 @@ async function handleStartRunTool({ workspaceRoot, args }) {
     return precheckResult;
   }
 
-  cleanupExpiredRuns();
-  const runId = createRunId();
-  try {
-    initializeRunStateOrThrow(runId, RUN_MODE_ASYNC, workspaceRoot, args);
-  } catch (error) {
-    return {
-      status: "FAILED",
+  cleanupExpiredRuns();
+  const runId = createRunId();
+  try {
+    initializeRunStateOrThrow(runId, RUN_MODE_ASYNC, workspaceRoot, args, process.pid);
+  } catch (error) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_STATE_IO_ERROR",
         message: `无法写入运行状态目录：${error.message || "unknown"}`,
         retryable: false
-      }
-    };
-  }
-
-  launchAsyncRun({
-    runId,
-    mode: RUN_MODE_ASYNC,
-    workspaceRoot,
-    args
-  });
-
-  return {
-    status: "ACCEPTED",
-    run_id: runId,
-    state: "queued",
-    poll_after_sec: getDefaultPollAfterSec(),
-    message: "异步流水线已启动。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
-  };
-}
+      }
+    };
+  }
+
+  let worker;
+  try {
+    worker = launchDetachedRunWorker({
+      runId,
+      resumeRun: false
+    });
+  } catch (error) {
+    const failedMessage = `无法启动 detached 运行进程：${error?.message || "unknown"}`;
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: RUN_STAGE_PREFLIGHT,
+      last_message: failedMessage,
+      error: {
+        code: "RUN_WORKER_LAUNCH_FAILED",
+        message: failedMessage,
+        retryable: true
+      },
+      result: buildWorkerLaunchFailedPayload(failedMessage)
+    });
+    return buildWorkerLaunchFailedPayload(failedMessage);
+  }
+
+  safeUpdateRunState(runId, {
+    pid: worker?.pid,
+    state: "queued",
+    last_message: "异步流水线已启动（detached）。"
+  });
+
+  return {
+    status: "ACCEPTED",
+    run_id: runId,
+    state: "queued",
+    poll_after_sec: getDefaultPollAfterSec(),
+    message: "异步流水线已启动（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
+  };
+}
 
 function handleGetRunTool(args) {
   cleanupExpiredRuns();
@@ -876,7 +994,7 @@ function handleGetRunTool(args) {
   };
 }
 
-function handleCancelRunTool(args) {
+function handleCancelRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -888,8 +1006,8 @@ function handleCancelRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -898,93 +1016,43 @@ function handleCancelRunTool(args) {
         retryable: false
       }
     };
-  }
-
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "CANCEL_IGNORED",
-      run: snapshot,
-      message: "目标任务已结束，无需取消。"
-    };
-  }
-
-  if (snapshot.state === RUN_STATE_PAUSED) {
-    const canceledResult = {
-      status: "FAILED",
-      error: {
-        code: "PIPELINE_CANCELED",
-        message: "流水线已取消。",
-        retryable: true
-      },
-      partial_result: snapshot.result?.partial_result || snapshot.result?.result || null
-    };
-    const canceledRun = safeUpdateRunState(runId, {
-      state: RUN_STATE_CANCELED,
-      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-      last_message: "流水线已取消。",
-      control: {
-        pause_requested: false,
-        pause_requested_at: null,
-        pause_requested_by: null,
-        cancel_requested: false
-      },
-      error: canceledResult.error,
-      result: canceledResult
-    }) || readRunState(runId) || snapshot;
-    return {
-      status: "CANCEL_REQUESTED",
-      run: canceledRun
-    };
-  }
-
-  const activeRun = activeAsyncRuns.get(runId);
-  if (!activeRun) {
-    const canceledResult = {
-      status: "FAILED",
-      error: {
-        code: "PIPELINE_CANCELED",
-        message: "流水线已取消。",
-        retryable: true
-      },
-      partial_result: snapshot.result?.partial_result || snapshot.result?.result || null
-    };
-    const canceledRun = safeUpdateRunState(runId, {
-      state: RUN_STATE_CANCELED,
-      stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-      last_message: "流水线已取消。",
-      control: {
-        pause_requested: false,
-        pause_requested_at: null,
-        pause_requested_by: null,
-        cancel_requested: false
-      },
-      error: canceledResult.error,
-      result: canceledResult
-    }) || readRunState(runId) || snapshot;
-    return {
-      status: "CANCEL_REQUESTED",
-      run: canceledRun
-    };
-  }
-  safeUpdateRunState(runId, {
-    stage: snapshot.stage || RUN_STAGE_PREFLIGHT,
-    last_message: "已收到取消请求，将在当前候选人处理完成后安全停止并落盘 CSV。",
-    control: {
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "CANCEL_IGNORED",
+      run: reconciled,
+      message: "目标任务已结束，无需取消。"
+    };
+  }
+
+  if (reconciled.state === RUN_STATE_PAUSED || !isProcessAlive(reconciled.pid)) {
+    const canceledRun = finalizeCanceledRun(runId, reconciled);
+    return {
+      status: "CANCEL_REQUESTED",
+      run: canceledRun
+    };
+  }
+  safeUpdateRunState(runId, {
+    stage: reconciled.stage || RUN_STAGE_PREFLIGHT,
+    last_message: "已收到取消请求，将在当前候选人处理完成后安全停止并落盘 CSV。",
+    control: {
       pause_requested: true,
       pause_requested_at: new Date().toISOString(),
       pause_requested_by: TOOL_CANCEL_RUN,
       cancel_requested: true
     }
-  });
-
-  const latest = readRunState(runId) || snapshot;
-  return {
-    status: "CANCEL_REQUESTED",
+  });
+
+  const latest = readRunState(runId) || reconciled;
+  return {
+    status: "CANCEL_REQUESTED",
     run: latest
   };
 }
 
-function handlePauseRunTool(args) {
+function handlePauseRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -996,8 +1064,8 @@ function handlePauseRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -1006,22 +1074,23 @@ function handlePauseRunTool(args) {
         retryable: false
       }
     };
-  }
-
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "PAUSE_IGNORED",
-      run: snapshot,
-      message: "目标任务已结束，无需暂停。"
-    };
-  }
-  if (snapshot.state === RUN_STATE_PAUSED) {
-    return {
-      status: "PAUSE_IGNORED",
-      run: snapshot,
-      message: "目标任务已经处于 paused 状态。"
-    };
-  }
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "PAUSE_IGNORED",
+      run: reconciled,
+      message: "目标任务已结束，无需暂停。"
+    };
+  }
+  if (reconciled.state === RUN_STATE_PAUSED) {
+    return {
+      status: "PAUSE_IGNORED",
+      run: reconciled,
+      message: "目标任务已经处于 paused 状态。"
+    };
+  }
 
   const requestedRun = safeUpdateRunState(runId, {
     control: {
@@ -1031,15 +1100,15 @@ function handlePauseRunTool(args) {
       cancel_requested: false
     },
     last_message: "已收到暂停请求，将在当前候选人处理完成后暂停。"
-  }) || readRunState(runId) || snapshot;
-  return {
+  }) || readRunState(runId) || reconciled;
+  return {
     status: "PAUSE_REQUESTED",
     run: requestedRun,
     message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
   };
 }
 
-function handleResumeRunTool(args) {
+function handleResumeRunTool(args) {
   const runId = normalizeText(args?.run_id);
   if (!runId) {
     return {
@@ -1051,8 +1120,8 @@ function handleResumeRunTool(args) {
       }
     };
   }
-  const snapshot = readRunState(runId);
-  if (!snapshot) {
+  const snapshot = readRunState(runId);
+  if (!snapshot) {
     return {
       status: "FAILED",
       error: {
@@ -1061,38 +1130,32 @@ function handleResumeRunTool(args) {
         retryable: false
       }
     };
-  }
-  if (TERMINAL_RUN_STATES.has(snapshot.state)) {
-    return {
-      status: "FAILED",
+  }
+  const reconciled = reconcileOrphanRunIfNeeded(runId, snapshot) || snapshot;
+  if (TERMINAL_RUN_STATES.has(reconciled.state)) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_ALREADY_TERMINATED",
         message: "目标任务已结束，无法继续。",
         retryable: false
       }
     };
-  }
-  if (snapshot.state !== RUN_STATE_PAUSED) {
-    return {
-      status: "FAILED",
+  }
+  if (reconciled.state !== RUN_STATE_PAUSED) {
+    return {
+      status: "FAILED",
       error: {
         code: "RUN_NOT_PAUSED",
         message: "仅 paused 状态的 run 才能继续。",
         retryable: true
       },
-      run: snapshot
-    };
-  }
-  if (activeAsyncRuns.has(runId)) {
-    return {
-      status: "RESUME_IGNORED",
-      run: snapshot,
-      message: "该 run 当前已在执行，无需继续。"
-    };
-  }
-
-  const executionContext = resolveRunContext(snapshot);
-  if (!executionContext) {
+      run: reconciled
+    };
+  }
+
+  const executionContext = resolveRunContext(reconciled);
+  if (!executionContext) {
     return {
       status: "FAILED",
       error: {
@@ -1119,23 +1182,43 @@ function handleResumeRunTool(args) {
       resume_count: Number.isInteger(current?.resume?.resume_count) ? current.resume.resume_count + 1 : 1,
       last_resumed_at: new Date().toISOString()
     }
-  })) || readRunState(runId) || snapshot;
-
-  launchAsyncRun({
-    runId,
-    mode: RUN_MODE_ASYNC,
-    workspaceRoot: executionContext.workspaceRoot,
-    args: executionContext.args,
-    resumeRun: true
-  });
-
-  return {
-    status: "RESUME_REQUESTED",
-    run: updated,
-    poll_after_sec: getDefaultPollAfterSec(),
-    message: "已恢复 Recommend 流水线。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
-  };
-}
+  })) || readRunState(runId) || reconciled;
+
+  let worker;
+  try {
+    worker = launchDetachedRunWorker({
+      runId,
+      resumeRun: true
+    });
+  } catch (error) {
+    const failedMessage = `无法启动 detached 恢复进程：${error?.message || "unknown"}`;
+    safeUpdateRunState(runId, {
+      state: RUN_STATE_FAILED,
+      stage: reconciled.stage || RUN_STAGE_PREFLIGHT,
+      last_message: failedMessage,
+      error: {
+        code: "RUN_WORKER_LAUNCH_FAILED",
+        message: failedMessage,
+        retryable: true
+      },
+      result: buildWorkerLaunchFailedPayload(failedMessage)
+    });
+    return buildWorkerLaunchFailedPayload(failedMessage);
+  }
+
+  const started = safeUpdateRunState(runId, {
+    pid: worker?.pid,
+    state: "queued",
+    last_message: "已恢复 Recommend 流水线（detached）。"
+  }) || readRunState(runId) || updated;
+
+  return {
+    status: "RESUME_REQUESTED",
+    run: started,
+    poll_after_sec: getDefaultPollAfterSec(),
+    message: "已恢复 Recommend 流水线（detached）。默认不自动轮询；如需进度请按需调用 get_recommend_pipeline_run。"
+  };
+}
 
 async function handleRequest(message, workspaceRoot) {
   if (!message || message.jsonrpc !== "2.0") {
@@ -1329,15 +1412,34 @@ export function startServer() {
   });
 }
 
-export const __testables = {
-  handleRequest,
-  activeAsyncRuns,
-  setRunPipelineImplForTests(nextImpl) {
-    runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
-  }
-};
-
-const thisFilePath = fileURLToPath(import.meta.url);
-if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
-  startServer();
-}
+export const __testables = {
+  handleRequest,
+  runDetachedWorkerForTests(options = {}) {
+    return runDetachedWorker(options);
+  },
+  setSpawnProcessImplForTests(nextImpl) {
+    spawnProcessImpl = typeof nextImpl === "function" ? nextImpl : spawn;
+  },
+  setRunPipelineImplForTests(nextImpl) {
+    runPipelineImpl = typeof nextImpl === "function" ? nextImpl : runRecommendPipeline;
+  }
+};
+
+const thisFilePath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === thisFilePath) {
+  const detachedWorkerOptions = parseDetachedWorkerOptions(process.argv.slice(2));
+  if (detachedWorkerOptions) {
+    runDetachedWorker({
+      runId: detachedWorkerOptions.runId,
+      resumeRun: detachedWorkerOptions.resumeRun
+    }).then((result) => {
+      if (!result?.ok) {
+        process.exitCode = 1;
+      }
+    }).catch(() => {
+      process.exitCode = 1;
+    });
+  } else {
+    startServer();
+  }
+}

package/src/test-index-async.js

@@ -6,7 +6,8 @@ import { __testables } from "./index.js";
 
 const {
   handleRequest,
-  activeAsyncRuns,
+  runDetachedWorkerForTests,
+  setSpawnProcessImplForTests,
   setRunPipelineImplForTests
 } = __testables;
 
@@ -141,6 +142,35 @@ function setupPipelineMock() {
   });
 }
 
+function parseDetachedSpawnArgs(argv = []) {
+  const normalized = Array.isArray(argv) ? argv.map((item) => String(item || "")) : [];
+  const runIdFlagIndex = normalized.indexOf("--run-id");
+  return {
+    runId: runIdFlagIndex >= 0 ? String(normalized[runIdFlagIndex + 1] || "").trim() : "",
+    resumeRun: normalized.includes("--resume")
+  };
+}
+
+function setupDetachedWorkerStub() {
+  setSpawnProcessImplForTests((command, argv = []) => {
+    assert.equal(typeof command, "string");
+    const { runId, resumeRun } = parseDetachedSpawnArgs(argv);
+    assert.equal(Boolean(runId), true, "detached worker spawn must include --run-id");
+    const pid = process.pid;
+    setTimeout(() => {
+      runDetachedWorkerForTests({
+        runId,
+        resumeRun,
+        workerPid: pid
+      }).catch(() => {});
+    }, 0);
+    return {
+      pid,
+      unref() {}
+    };
+  });
+}
+
 async function testPauseAndResumeFlow() {
   const runId = await startAcceptedRun("run for pause and resume", 11);
   await waitForRunState(runId, ["running"]);
@@ -170,9 +200,6 @@ async function testResumeAfterProcessRestartSimulation() {
   assert.equal(pausePayload.status, "PAUSE_REQUESTED");
   await waitForRunState(runId, ["paused"]);
 
-  // 模拟服务重启后内存态丢失：active map 为空，仅依赖 run-state 持久化恢复。
-  activeAsyncRuns.clear();
-
   const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 23);
   assert.equal(resumePayload.status, "RESUME_REQUESTED");
   assert.equal(resumePayload.run.run_id, runId);
@@ -214,6 +241,7 @@ async function main() {
   const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
   process.env.BOSS_RECOMMEND_HOME = tempHome;
   setupPipelineMock();
+  setupDetachedWorkerStub();
 
   try {
     await testPauseAndResumeFlow();
@@ -223,7 +251,7 @@ async function main() {
     console.log("index async tests passed");
   } finally {
     setRunPipelineImplForTests(null);
-    activeAsyncRuns.clear();
+    setSpawnProcessImplForTests(null);
     if (previousHome === undefined) {
       delete process.env.BOSS_RECOMMEND_HOME;
     } else {

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

@@ -13,11 +13,52 @@ const RESUME_CAPTURE_WAIT_MS = 60000;
 const RESUME_CAPTURE_MAX_ATTEMPTS = 4;
 const RESUME_CAPTURE_RETRY_DELAY_MS = 1200;
 const MAX_CONSECUTIVE_RESUME_CAPTURE_FAILURES = 10;
+const DEFAULT_VISION_MAX_IMAGE_PIXELS = 36000000;
+const DEFAULT_VISION_RETRY_MAX_IMAGE_PIXELS = 30000000;
+let visionSharpFactory = null;
 const PAGE_SCOPE_TAB_STATUS = {
   recommend: "0",
   latest: "1",
   featured: "3"
 };
+const BOTTOM_HINT_KEYWORDS = ["没有更多", "已显示全部", "已经到底", "暂无更多", "推荐完了", "没有更多人选"];
+const LOAD_MORE_HINT_KEYWORDS = ["滚动加载更多", "下滑加载更多", "继续下滑", "继续滑动", "滑动加载", "正在加载", "加载中"];
+
+function classifyFinishedWrapState(finishedWrapText, refreshButtonVisible = false) {
+  const normalizedText = normalizeText(finishedWrapText);
+  const matchedBottomKeyword = BOTTOM_HINT_KEYWORDS.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedBottomKeyword) {
+    return {
+      isBottom: true,
+      reason: matchedBottomKeyword,
+      matched_bottom_keyword: matchedBottomKeyword,
+      matched_load_more_keyword: null
+    };
+  }
+  const matchedLoadMoreKeyword = LOAD_MORE_HINT_KEYWORDS.find((keyword) => normalizedText.includes(keyword)) || null;
+  if (matchedLoadMoreKeyword) {
+    return {
+      isBottom: false,
+      reason: null,
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: matchedLoadMoreKeyword
+    };
+  }
+  if (refreshButtonVisible) {
+    return {
+      isBottom: true,
+      reason: "refresh_button_visible",
+      matched_bottom_keyword: null,
+      matched_load_more_keyword: null
+    };
+  }
+  return {
+    isBottom: false,
+    reason: null,
+    matched_bottom_keyword: null,
+    matched_load_more_keyword: null
+  };
+}
 
 function getCodexHome() {
   return process.env.CODEX_HOME
@@ -65,6 +106,35 @@ function parsePositiveInteger(raw) {
   return Number.isFinite(value) && value > 0 ? value : null;
 }
 
+function resolveVisionPixelLimitFromEnv(envName, fallback) {
+  const parsed = parsePositiveInteger(process.env[envName]);
+  return parsed || fallback;
+}
+
+function resolveVisionRetryPixelLimit(primaryLimit) {
+  const safePrimary = parsePositiveInteger(primaryLimit) || DEFAULT_VISION_MAX_IMAGE_PIXELS;
+  const fallback = Math.max(1, Math.floor(safePrimary * 0.8));
+  const parsed = resolveVisionPixelLimitFromEnv("BOSS_RECOMMEND_VISION_RETRY_MAX_IMAGE_PIXELS", DEFAULT_VISION_RETRY_MAX_IMAGE_PIXELS);
+  const candidate = parsePositiveInteger(parsed) || fallback;
+  return Math.min(Math.max(1, candidate), Math.max(1, safePrimary - 1));
+}
+
+function loadVisionSharp() {
+  if (!visionSharpFactory) {
+    visionSharpFactory = require("sharp");
+  }
+  return visionSharpFactory;
+}
+
+function isVisionImageSizeLimitMessage(message) {
+  const text = normalizeText(message).toLowerCase();
+  if (!text) return false;
+  return (
+    /(像素|pixel|pixels|too large|image size|image dimension|too many pixels|max(?:imum)?[^a-z0-9]{0,8}(?:pixel|image)|超过|超出|上限)/i.test(text)
+    || (text.includes("image") && text.includes("limit"))
+  );
+}
+
 function normalizePostAction(value) {
   const normalized = normalizeText(value).toLowerCase();
   if (!normalized) return null;
@@ -1041,7 +1111,8 @@ const jsDetectBottom = `(() => {
   const finishedWrap = Array.from(doc.querySelectorAll('.finished-wrap')).find((el) => isVisible(el)) || null;
   const refreshButton = Array.from(doc.querySelectorAll('.finished-wrap .btn.btn-refresh, .finished-wrap .btn-refresh, .no-data-refresh .btn-refresh'))
     .find((el) => isVisible(el)) || null;
-  const keywords = ['没有更多', '已显示全部', '已经到底', '暂无更多', '推荐完了', '没有更多人选'];
+  const keywords = ${JSON.stringify(BOTTOM_HINT_KEYWORDS)};
+  const loadMoreKeywords = ${JSON.stringify(LOAD_MORE_HINT_KEYWORDS)};
   const elements = Array.from(doc.querySelectorAll('div,span,p'));
   for (const el of elements) {
     if (el.offsetParent === null) continue;
@@ -1059,12 +1130,21 @@ const jsDetectBottom = `(() => {
       }
     }
   }
+  const finishedWrapText = finishedWrap ? String(finishedWrap.textContent || '').replace(/\s+/g, ' ').trim() : '';
+  const matchedBottomKeyword = keywords.find((keyword) => finishedWrapText.includes(keyword)) || null;
+  const matchedLoadMoreKeyword = loadMoreKeywords.find((keyword) => finishedWrapText.includes(keyword)) || null;
+  const inferredBottom = matchedBottomKeyword
+    ? true
+    : (Boolean(refreshButton) && !matchedLoadMoreKeyword);
   return {
-    isBottom: Boolean(finishedWrap),
-    reason: finishedWrap ? 'finished-wrap' : null,
+    isBottom: inferredBottom,
+    reason: matchedBottomKeyword || (inferredBottom ? 'refresh_button_visible' : null),
     finished_wrap_visible: Boolean(finishedWrap),
+    finished_wrap_text: finishedWrapText || null,
     refresh_button_visible: Boolean(refreshButton),
-    refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null
+    refresh_button_text: refreshButton ? String(refreshButton.textContent || '').replace(/\s+/g, ' ').trim() : null,
+    matched_bottom_keyword: matchedBottomKeyword,
+    matched_load_more_keyword: matchedLoadMoreKeyword
   };
 })()`;
 const jsWaitForDetail = `(() => {
@@ -2615,15 +2695,21 @@ class RecommendScreenCli {
         return { ok: false, error: 'NO_RECOMMEND_IFRAME' };
       }
       const doc = frame.contentDocument;
-      const inner = Array.from(doc.querySelectorAll('.card-inner[data-geekid]'))
+      const recommendInner = Array.from(doc.querySelectorAll('.card-inner[data-geekid]'))
         .find((item) => (item.getAttribute('data-geekid') || '') === String(candidateKey)) || null;
-      const featuredAnchor = inner
+      const latestInner = recommendInner
+        ? null
+        : Array.from(doc.querySelectorAll('.candidate-card-wrap .card-inner[data-geek], .candidate-card-wrap [data-geek]'))
+          .find((item) => (item.getAttribute('data-geek') || '') === String(candidateKey)) || null;
+      const featuredAnchor = (recommendInner || latestInner)
         ? null
         : Array.from(doc.querySelectorAll('li.geek-info-card a[data-geekid], a[data-geekid]'))
           .find((item) => (item.getAttribute('data-geekid') || '') === String(candidateKey)) || null;
-      const card = inner
-        ? (inner.closest('li.card-item') || inner.closest('.card-item'))
-        : (featuredAnchor ? (featuredAnchor.closest('li.geek-info-card') || featuredAnchor.closest('.geek-info-card')) : null);
+      const card = recommendInner
+        ? (recommendInner.closest('li.card-item') || recommendInner.closest('.card-item'))
+        : latestInner
+          ? (latestInner.closest('.candidate-card-wrap') || latestInner.closest('li.card-item') || latestInner.closest('.card-item'))
+          : (featuredAnchor ? (featuredAnchor.closest('li.geek-info-card') || featuredAnchor.closest('.geek-info-card')) : null);
       if (!card) {
         return { ok: false, error: 'CANDIDATE_CARD_NOT_FOUND' };
       }
@@ -2716,6 +2802,130 @@ class RecommendScreenCli {
   }
 
   async callVisionModel(imagePath) {
+    const primaryLimit = resolveVisionPixelLimitFromEnv(
+      "BOSS_RECOMMEND_VISION_MAX_IMAGE_PIXELS",
+      DEFAULT_VISION_MAX_IMAGE_PIXELS
+    );
+    const retryLimit = resolveVisionRetryPixelLimit(primaryLimit);
+    const preparedPrimary = await this.prepareVisionImageForModel(imagePath, primaryLimit, "primary");
+    try {
+      return await this.requestVisionModel(preparedPrimary.imagePath);
+    } catch (error) {
+      if (!isVisionImageSizeLimitMessage(error?.message || "")) {
+        throw error;
+      }
+      log(
+        `[VISION] 检测到图片尺寸超限，准备降采样重试: ` +
+        `primary_limit=${primaryLimit} source=${preparedPrimary.source} ` +
+        `source_pixels=${preparedPrimary.sourcePixels ?? "unknown"}`
+      );
+    }
+    const preparedRetry = await this.prepareVisionImageForModel(imagePath, retryLimit, "retry");
+    try {
+      return await this.requestVisionModel(preparedRetry.imagePath);
+    } catch (retryError) {
+      if (!isVisionImageSizeLimitMessage(retryError?.message || "")) {
+        throw retryError;
+      }
+      throw this.buildError(
+        "VISION_IMAGE_SIZE_LIMIT_EXCEEDED",
+        `Vision model still rejected image after retry downscale; ` +
+          `primary_limit=${primaryLimit}; retry_limit=${retryLimit}; ` +
+          `source_pixels=${preparedRetry.sourcePixels ?? "unknown"}; ` +
+          `retry_pixels=${preparedRetry.currentPixels ?? "unknown"}; ` +
+          `last_error=${normalizeText(retryError?.message || retryError)}`
+      );
+    }
+  }
+
+  async prepareVisionImageForModel(imagePath, maxPixels, attemptTag = "primary") {
+    const resolvedMaxPixels = parsePositiveInteger(maxPixels);
+    if (!resolvedMaxPixels) {
+      return {
+        imagePath,
+        source: "no_limit",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    let sharp;
+    try {
+      sharp = loadVisionSharp();
+    } catch (error) {
+      log(`[VISION] 加载 sharp 失败，跳过预缩放: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "sharp_unavailable",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    let metadata;
+    try {
+      metadata = await sharp(imagePath).metadata();
+    } catch (error) {
+      log(`[VISION] 读取图片尺寸失败，跳过预缩放: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "metadata_error",
+        sourcePixels: null,
+        currentPixels: null
+      };
+    }
+    const width = Number(metadata?.width || 0);
+    const height = Number(metadata?.height || 0);
+    const sourcePixels = width > 0 && height > 0 ? width * height : null;
+    if (!sourcePixels || sourcePixels <= resolvedMaxPixels) {
+      return {
+        imagePath,
+        source: "within_limit",
+        sourcePixels,
+        currentPixels: sourcePixels
+      };
+    }
+    const scale = Math.sqrt(resolvedMaxPixels / sourcePixels);
+    const targetWidth = Math.max(1, Math.floor(width * scale));
+    const targetHeight = Math.max(1, Math.floor(height * scale));
+    const parsedPath = path.parse(imagePath);
+    const resizedPath = path.join(
+      parsedPath.dir,
+      `${parsedPath.name}.${attemptTag}.max${resolvedMaxPixels}.png`
+    );
+    try {
+      await sharp(imagePath)
+        .resize({
+          width: targetWidth,
+          height: targetHeight,
+          fit: "inside",
+          withoutEnlargement: true
+        })
+        .png()
+        .toFile(resizedPath);
+      const resizedMeta = await sharp(resizedPath).metadata();
+      const resizedPixels = Number(resizedMeta?.width || 0) * Number(resizedMeta?.height || 0);
+      log(
+        `[VISION] 图片预缩放完成: ${width}x${height}(${sourcePixels}) -> ` +
+        `${resizedMeta?.width || "?"}x${resizedMeta?.height || "?"}(${resizedPixels || "?"}); ` +
+        `limit=${resolvedMaxPixels}; attempt=${attemptTag}`
+      );
+      return {
+        imagePath: resizedPath,
+        source: "resized",
+        sourcePixels,
+        currentPixels: resizedPixels || null
+      };
+    } catch (error) {
+      log(`[VISION] 预缩放失败，继续使用原图: ${error?.message || error}`);
+      return {
+        imagePath,
+        source: "resize_failed",
+        sourcePixels,
+        currentPixels: sourcePixels
+      };
+    }
+  }
+
+  async requestVisionModel(imagePath) {
     const imageBase64 = fs.readFileSync(imagePath, "base64");
     const rawBaseUrl = this.args.baseUrl;
     log(`[callVisionModel] baseUrl 原始值类型=${typeof rawBaseUrl}, 长度=${rawBaseUrl != null ? String(rawBaseUrl).length : "null/undefined"}, JSON编码=${JSON.stringify(rawBaseUrl)}`);
@@ -3361,9 +3571,28 @@ class RecommendScreenCli {
           } else {
             this.resetResumeCaptureFailureStreak();
           }
-          if (["VISION_MODEL_FAILED", "TEXT_MODEL_FAILED"].includes(error.code)) {
+          if (error.code === "TEXT_MODEL_FAILED") {
             throw error;
           }
+          if (error.code === "VISION_MODEL_FAILED") {
+            if (isVisionImageSizeLimitMessage(error?.message || "")) {
+              log(
+                `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 触发视觉模型像素限制，` +
+                "已在本轮跳过并继续处理下一位。"
+              );
+            } else {
+              log(
+                `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 视觉模型调用失败，` +
+                "已在本轮跳过并继续处理下一位。"
+              );
+            }
+          }
+          if (error.code === "VISION_IMAGE_SIZE_LIMIT_EXCEEDED") {
+            log(
+              `[候选人跳过] ${nextCandidate.name || nextCandidate.geek_id || "unknown"} 触发视觉模型像素限制，` +
+              "已完成预缩放和重试，仍失败，继续处理下一位。"
+            );
+          }
         } finally {
           const closed = await this.closeDetailPage();
           if (!closed) {
@@ -3485,7 +3714,8 @@ if (require.main === module) {
       parseFavoriteActionFromKnownRequest,
       parseFavoriteActionFromActionLog,
       parseFavoriteActionFromWsPayload,
-      isRecoverablePostActionError
+      isRecoverablePostActionError,
+      classifyFinishedWrapState
     }
   };
 }

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

@@ -382,6 +382,41 @@ async function testNetworkMissShouldFallbackToImageCapture() {
   assert.equal(result.result.resume_source, "image_fallback");
 }
 
+async function testVisionModelFailureShouldSkipCandidateAndContinue() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-vision-failure-skip-"));
+  const first = { key: "vision-fail-1", geek_id: "vision-fail-1", name: "vision-fail-1" };
+  const second = { key: "vision-pass-2", geek_id: "vision-pass-2", name: "vision-pass-2" };
+  const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
+    candidates: [first, second],
+    captureOutcomes: new Map([
+      ["vision-fail-1", { stitchedImage: path.join(tempDir, "vision-fail-1.png") }],
+      ["vision-pass-2", { stitchedImage: path.join(tempDir, "vision-pass-2.png") }]
+    ]),
+    screeningByKey: new Map([
+      ["vision-pass-2", { passed: true, reason: "ok", summary: "ok" }]
+    ])
+  });
+
+  cli.callVisionModel = async () => {
+    if (cli.lastCapturedCandidateKey === "vision-fail-1") {
+      const error = new Error("model backend timeout");
+      error.code = "VISION_MODEL_FAILED";
+      throw error;
+    }
+    return {
+      passed: true,
+      reason: "ok",
+      summary: "ok"
+    };
+  };
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.processed_count, 2);
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 1);
+}
+
 async function testFeaturedNetworkMissShouldSkipWithoutImageCapture() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-featured-network-only-"));
   const args = createArgs(tempDir);
@@ -551,6 +586,50 @@ function testFavoriteActionParserShouldOnlyTrustKnownRequestShapes() {
   assert.equal(userMark, "add");
 }
 
+function testFinishedWrapClassifierShouldNotTreatLoadMoreAsBottom() {
+  const loadMore = __testables.classifyFinishedWrapState("滚动加载更多", false);
+  const loading = __testables.classifyFinishedWrapState("正在加载数据...", false);
+  const noMore = __testables.classifyFinishedWrapState("没有更多人选", false);
+  const refreshOnly = __testables.classifyFinishedWrapState("", true);
+
+  assert.equal(loadMore.isBottom, false);
+  assert.equal(loadMore.matched_load_more_keyword, "滚动加载更多");
+  assert.equal(loading.isBottom, false);
+  assert.equal(loading.matched_load_more_keyword, "正在加载");
+  assert.equal(noMore.isBottom, true);
+  assert.equal(noMore.matched_bottom_keyword, "没有更多");
+  assert.equal(refreshOnly.isBottom, true);
+  assert.equal(refreshOnly.reason, "refresh_button_visible");
+}
+
+async function testGetCenteredCandidateClickPointShouldSupportLatestSelector() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-latest-click-locator-"));
+  const args = createArgs(tempDir);
+  args.pageScope = "latest";
+  const cli = new RecommendScreenCli(args);
+
+  let expressionCaptured = "";
+  cli.evaluate = async (expression) => {
+    expressionCaptured = String(expression || "");
+    return {
+      ok: true,
+      x: 100,
+      y: 100,
+      width: 120,
+      height: 64
+    };
+  };
+
+  const result = await cli.getCenteredCandidateClickPoint({
+    key: "latest-test-key",
+    geek_id: "latest-test-key"
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(expressionCaptured.includes(".candidate-card-wrap .card-inner[data-geek]"), true);
+  assert.equal(expressionCaptured.includes("getAttribute('data-geek')"), true);
+}
+
 async function testFeaturedPostActionFailureShouldStillRecordPassedCandidate() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-featured-action-failure-"));
   const args = createArgs(tempDir);
@@ -726,6 +805,7 @@ async function main() {
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldKeepImageCaptureEvenWhenNetworkResumeExists();
   await testNetworkMissShouldFallbackToImageCapture();
+  await testVisionModelFailureShouldSkipCandidateAndContinue();
   await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
   await testFeaturedFavoriteShouldNotUseDomFallback();
   await testFeaturedFavoriteShouldSkipClickWhenAlreadyInterested();
@@ -735,6 +815,8 @@ async function main() {
   testFavoriteActionParserShouldSupportFallbackRequestShape();
   testFavoriteActionParserShouldSupportWebSocketPayload();
   testFavoriteActionParserShouldOnlyTrustKnownRequestShapes();
+  testFinishedWrapClassifierShouldNotTreatLoadMoreAsBottom();
+  await testGetCenteredCandidateClickPointShouldSupportLatestSelector();
   await testFeaturedPostActionFailureShouldStillRecordPassedCandidate();
   await testStitchWithSharpShouldComposeExpectedImage();
   testStitchWithAvailablePythonShouldFallbackToPython();