@reconcrap/boss-recommend-mcp 2.0.42 → 2.0.44

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

@@ -8,7 +8,13 @@ import {
 } from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
-import { sleep } from "../../core/browser/index.js";
+import {
+  configureHumanInteraction,
+  createHumanRestController,
+  humanDelay,
+  normalizeHumanBehaviorOptions,
+  sleep
+} from "../../core/browser/index.js";
 import { GREET_CREDITS_EXHAUSTED_CODE } from "../../core/greet-quota/index.js";
 import {
   compactCvAcquisitionState,
@@ -420,17 +426,31 @@ export function countRecommendResultStatuses(results = [], {
   };
 }
 
-function countPassedResults(results = []) {
-  return countRecommendResultStatuses(results).passed;
-}
-
-function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
-  if (!error) return null;
-  return {
-    code: error.code || fallbackCode,
-    message: error.message || String(error)
-  };
-}
+function countPassedResults(results = []) {
+  return countRecommendResultStatuses(results).passed;
+}
+
+function compactCloseResult(closeResult) {
+  if (!closeResult) return null;
+  return {
+    closed: Boolean(closeResult.closed),
+    reason: closeResult.reason || null,
+    attempts: closeResult.attempts || [],
+    verification: closeResult.verification || null
+  };
+}
+
+function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
+  if (!error) return null;
+  const result = {
+    code: error.code || fallbackCode,
+    message: error.message || String(error)
+  };
+  if (error.close_result) {
+    result.close_result = compactCloseResult(error.close_result);
+  }
+  return result;
+}
 
 function createRecommendCloseFailureError(closeResult) {
   const error = new Error(closeResult?.reason || "Recommend detail did not close before recovery");
@@ -554,13 +574,31 @@ export async function runRecommendWorkflow({
   actionAfterClickDelayMs = 900,
   screeningMode = "llm",
   llmConfig = null,
-  llmTimeoutMs = 120000,
-  llmImageLimit = 8,
-  llmImageDetail = "high",
-  imageOutputDir = ""
-} = {}, runControl) {
-  if (!client) throw new Error("runRecommendWorkflow requires a guarded CDP client");
-  const normalizedFilter = normalizeFilter(filter);
+  llmTimeoutMs = 120000,
+  llmImageLimit = 8,
+  llmImageDetail = "high",
+  imageOutputDir = "",
+  humanRestEnabled = false,
+  humanBehavior = null
+} = {}, runControl) {
+  if (!client) throw new Error("runRecommendWorkflow requires a guarded CDP client");
+  const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+    legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+  });
+  const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
+  configureHumanInteraction(client, {
+    enabled: effectiveHumanBehavior.enabled,
+    clickMovementEnabled: effectiveHumanBehavior.clickMovement,
+    textEntryEnabled: effectiveHumanBehavior.textEntry,
+    safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
+    actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
+  });
+  const humanRestController = createHumanRestController({
+    enabled: effectiveHumanRestEnabled,
+    shortRestEnabled: effectiveHumanBehavior.shortRest,
+    batchRestEnabled: effectiveHumanBehavior.batchRest
+  });
+  const normalizedFilter = normalizeFilter(filter);
   const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
   const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
   const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
@@ -597,26 +635,54 @@ export async function runRecommendWorkflow({
   let greetCount = 0;
   const candidateRecoveryCounts = new Map();
   let jobSelection = null;
-  let pageScopeSelection = null;
-  let filterResult = null;
-  let cardNodeIds = [];
-  let listEndReason = "";
-  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+  let pageScopeSelection = null;
+  let filterResult = null;
+  let cardNodeIds = [];
+  let listEndReason = "";
+  let lastHumanEvent = null;
+  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
-  }));
-
-  function updateRecommendProgress(extra = {}) {
-    const counts = countRecommendResultStatuses(results, { greetCount });
-    const listSnapshot = compactInfiniteListState(listState);
-    runControl.updateProgress({
-      card_count: cardNodeIds.length,
-      target_count: targetPassCount,
-      target_count_semantics: "passed_candidates",
+  }));
+
+  function recordHumanEvent(event = null) {
+    if (!event) return lastHumanEvent;
+    lastHumanEvent = {
+      at: new Date().toISOString(),
+      ...event
+    };
+    return lastHumanEvent;
+  }
+
+  async function maybeHumanActionCooldown(phase, timings = {}) {
+    if (!effectiveHumanBehavior.actionCooldown) return null;
+    const pauseMs = humanDelay(280, 90, {
+      minMs: 80,
+      maxMs: 720
+    });
+    if (pauseMs > 0) {
+      await runControl.sleep(pauseMs);
+      addTiming(timings, `human_${phase}_pause_ms`, pauseMs);
+    }
+    return recordHumanEvent({
+      kind: "action_cooldown",
+      phase,
+      pause_ms: pauseMs
+    });
+  }
+
+  function updateRecommendProgress(extra = {}) {
+    const counts = countRecommendResultStatuses(results, { greetCount });
+    const listSnapshot = compactInfiniteListState(listState);
+    const humanRestState = humanRestController.getState();
+    runControl.updateProgress({
+      card_count: cardNodeIds.length,
+      target_count: targetPassCount,
+      target_count_semantics: "passed_candidates",
       ...counts,
       screening_mode: normalizedScreeningMode,
       unique_seen: listSnapshot.seen_count,
@@ -624,12 +690,18 @@ export async function runRecommendWorkflow({
       refresh_rounds: refreshRounds,
       refresh_attempts: refreshAttempts.length,
       context_recoveries: contextRecoveryAttempts,
-      list_end_reason: listEndReason || null,
-      viewport_checks: viewportGuard.getStats().checks,
-      viewport_recoveries: viewportGuard.getStats().recoveries,
-      ...extra
-    });
-  }
+      list_end_reason: listEndReason || null,
+      viewport_checks: viewportGuard.getStats().checks,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_count: humanRestState.rest_count,
+      human_rest_ms: humanRestState.total_rest_ms,
+      last_human_event: lastHumanEvent,
+      ...extra
+    });
+  }
 
   function checkpointInProgressCandidate({
     index = results.length,
@@ -821,10 +893,11 @@ export async function runRecommendWorkflow({
       client,
       state: listState,
       maxScrolls: listMaxScrolls,
-      stableSignatureLimit: listStableSignatureLimit,
-      wheelDeltaY: listWheelDeltaY,
-      settleMs: listSettleMs,
-      fallbackPoint: listFallbackResolver,
+      stableSignatureLimit: listStableSignatureLimit,
+      wheelDeltaY: listWheelDeltaY,
+      settleMs: listSettleMs,
+      listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+      fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         let currentRootState = await getRecommendRoots(client);
         currentRootState = await ensureRecommendViewport(currentRootState, "candidate_find_nodes");
@@ -926,10 +999,11 @@ export async function runRecommendWorkflow({
         runControl.setPhase("recommend:detail");
         detailStep = "ensure_viewport";
         rootState = await ensureRecommendViewport(rootState, "detail");
-        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
-        detailStep = "open_detail";
-        networkRecorder.clear();
-        const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        detailStep = "open_detail";
+        networkRecorder.clear();
+        await maybeHumanActionCooldown("before_detail_open", timings);
+        const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
           cardNodeId,
           candidateKey,
           cardCandidate,
@@ -1008,11 +1082,12 @@ export async function runRecommendWorkflow({
                 resizeMaxWidth: 1100,
                 captureViewport: false,
                 padding: 0,
-                maxScreenshots: maxImagePages,
-                wheelDeltaY: imageWheelDeltaY,
-                settleMs: 350,
-                scrollMethod: "dom-anchor-fallback-input",
-                stepTimeoutMs: 45000,
+                maxScreenshots: maxImagePages,
+                wheelDeltaY: imageWheelDeltaY,
+                settleMs: 350,
+                scrollMethod: "dom-anchor-fallback-input",
+                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+                stepTimeoutMs: 45000,
                 totalTimeoutMs: 90000,
                 duplicateStopCount: 1,
                 skipDuplicateScreenshots: true,
@@ -1146,9 +1221,10 @@ export async function runRecommendWorkflow({
     if (postActionEnabled && detailResult) {
       const postActionStarted = Date.now();
       await runControl.waitIfPaused();
-      runControl.throwIfCanceled();
-      runControl.setPhase("recommend:post-action");
-      actionDiscovery = await waitForRecommendDetailActionControls(client, {
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:post-action");
+      await maybeHumanActionCooldown("before_post_action", timings);
+      actionDiscovery = await waitForRecommendDetailActionControls(client, {
         timeoutMs: actionTimeoutMs,
         intervalMs: actionIntervalMs,
         requireAny: true
@@ -1167,10 +1243,11 @@ export async function runRecommendWorkflow({
         greetCount += 1;
       }
       addTiming(timings, "post_action_ms", Date.now() - postActionStarted);
-    }
-    if (detailResult && closeDetail) {
-      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
-      if (!detailResult.close_result?.closed) {
+    }
+    if (detailResult && closeDetail) {
+      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
+      await maybeHumanActionCooldown("after_detail_close", timings);
+      if (!detailResult.close_result?.closed) {
         const closeError = createRecommendCloseFailureError(detailResult.close_result);
         const recovery = await recoverAndReapplyRecommendContext("detail_close_failed", closeError, {
           forceRecentNotView: true
@@ -1239,16 +1316,37 @@ export async function runRecommendWorkflow({
     });
     addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
 
-    if (postActionResult?.stop_run) {
-      listEndReason = postActionResult.reason || "post_action_stop";
-      break;
-    }
-
-    if (delayMs > 0) {
-      const sleepStarted = Date.now();
-      await runControl.sleep(delayMs);
-      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
-      compactResult.timings.total_ms = Date.now() - candidateStarted;
+    if (postActionResult?.stop_run) {
+      listEndReason = postActionResult.reason || "post_action_stop";
+      break;
+    }
+
+    if (effectiveHumanRestEnabled) {
+      const restStarted = Date.now();
+      const restResult = await humanRestController.takeBreakIfNeeded({
+        sleepFn: (ms) => runControl.sleep(ms)
+      });
+      const restElapsed = Date.now() - restStarted;
+      if (restResult.rested) {
+        recordHumanEvent({
+          kind: "rest",
+          pause_ms: restResult.pause_ms || restElapsed,
+          events: restResult.events || []
+        });
+        compactResult.human_rest = restResult;
+        addTiming(compactResult.timings, "human_rest_ms", restElapsed);
+        compactResult.timings.total_ms = Date.now() - candidateStarted;
+        updateRecommendProgress({
+          human_rest_last: restResult
+        });
+      }
+    }
+
+    if (delayMs > 0) {
+      const sleepStarted = Date.now();
+      await runControl.sleep(delayMs);
+      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
+      compactResult.timings.total_ms = Date.now() - candidateStarted;
     }
   }
 
@@ -1261,11 +1359,14 @@ export async function runRecommendWorkflow({
     filter: compactFilterResult(filterResult),
     card_count: cardNodeIds.length,
     candidate_list: compactInfiniteListState(listState),
-    viewport_health: {
-      stats: viewportGuard.getStats(),
-      events: viewportGuard.getEvents()
-    },
-    list_end_reason: listEndReason || null,
+    viewport_health: {
+      stats: viewportGuard.getStats(),
+      events: viewportGuard.getEvents()
+    },
+    human_behavior: effectiveHumanBehavior,
+    human_rest: humanRestController.getState(),
+    last_human_event: lastHumanEvent,
+    list_end_reason: listEndReason || null,
     refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,
     context_recoveries: contextRecoveryAttempts,
@@ -1316,20 +1417,26 @@ export function createRecommendRunService({
     actionIntervalMs = 500,
     actionAfterClickDelayMs = 900,
     screeningMode = "llm",
-    llmConfig = null,
-    llmTimeoutMs = 120000,
-    llmImageLimit = 8,
-    llmImageDetail = "high",
-    imageOutputDir = "",
-    name = "recommend-domain-run"
-  } = {}) {
-    if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
-    const normalizedFilter = normalizeFilter(filter);
-    const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
-    const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
-    const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
-    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
-    const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
+    llmConfig = null,
+    llmTimeoutMs = 120000,
+    llmImageLimit = 8,
+    llmImageDetail = "high",
+    imageOutputDir = "",
+    humanRestEnabled = false,
+    humanBehavior = null,
+    name = "recommend-domain-run"
+  } = {}) {
+    if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
+    const normalizedFilter = normalizeFilter(filter);
+    const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
+    const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
+    const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
+    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+    });
+    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
+    const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? null : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
       runId,
@@ -1365,12 +1472,16 @@ export function createRecommendRunService({
         action_timeout_ms: actionTimeoutMs,
         screening_mode: normalizedScreeningMode,
         llm_configured: Boolean(llmConfig),
-        llm_timeout_ms: llmTimeoutMs,
-        llm_image_limit: llmImageLimit,
-        llm_image_detail: llmImageDetail,
-        image_output_dir: imageOutputDir || ""
-      },
-      progress: {
+        llm_timeout_ms: llmTimeoutMs,
+        llm_image_limit: llmImageLimit,
+        llm_image_detail: llmImageDetail,
+        image_output_dir: imageOutputDir || "",
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_behavior: effectiveHumanBehavior,
+        human_rest_enabled: effectiveHumanRestEnabled
+      },
+      progress: {
         card_count: 0,
         target_count: candidateLimit,
         target_count_semantics: "passed_candidates",
@@ -1381,11 +1492,17 @@ export function createRecommendRunService({
         passed: 0,
         greet_count: 0,
         post_action_clicked: 0,
-        image_capture_failed: 0,
-        detail_open_failed: 0,
-        transient_recovered: 0,
-        context_recoveries: 0
-      },
+        image_capture_failed: 0,
+        detail_open_failed: 0,
+        transient_recovered: 0,
+        context_recoveries: 0,
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_rest_enabled: effectiveHumanRestEnabled,
+        human_rest_count: 0,
+        human_rest_ms: 0,
+        last_human_event: null
+      },
       checkpoint: {},
       task: (runControl) => workflow({
         client,
@@ -1420,13 +1537,15 @@ export function createRecommendRunService({
         actionAfterClickDelayMs,
         screeningMode: normalizedScreeningMode,
         llmConfig,
-        llmTimeoutMs,
-        llmImageLimit,
-        llmImageDetail,
-        imageOutputDir
-      }, runControl)
-    });
-  }
+        llmTimeoutMs,
+        llmImageLimit,
+        llmImageDetail,
+        imageOutputDir,
+        humanRestEnabled: effectiveHumanRestEnabled,
+        humanBehavior: effectiveHumanBehavior
+      }, runControl)
+    });
+  }
 
   return {
     startRecommendRun,

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

@@ -8,6 +8,12 @@ import {
 } from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
+import {
+  configureHumanInteraction,
+  createHumanRestController,
+  humanDelay,
+  normalizeHumanBehaviorOptions
+} from "../../core/browser/index.js";
 import {
   compactCvAcquisitionState,
   countParsedNetworkProfiles,
@@ -291,9 +297,27 @@ export async function runRecruitWorkflow({
   llmTimeoutMs = 120000,
   llmImageLimit = 8,
   llmImageDetail = "high",
-  imageOutputDir = ""
+  imageOutputDir = "",
+  humanRestEnabled = false,
+  humanBehavior = null
 } = {}, runControl) {
   if (!client) throw new Error("runRecruitWorkflow requires a guarded CDP client");
+  const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+    legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+  });
+  const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
+  configureHumanInteraction(client, {
+    enabled: effectiveHumanBehavior.enabled,
+    clickMovementEnabled: effectiveHumanBehavior.clickMovement,
+    textEntryEnabled: effectiveHumanBehavior.textEntry,
+    safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
+    actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
+  });
+  const humanRestController = createHumanRestController({
+    enabled: effectiveHumanRestEnabled,
+    shortRestEnabled: effectiveHumanBehavior.shortRest,
+    batchRestEnabled: effectiveHumanBehavior.batchRest
+  });
   const normalizedSearchParams = normalizeSearchParams(searchParams);
   const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
   const useLlmScreening = normalizedScreeningMode !== "deterministic";
@@ -326,6 +350,7 @@ export async function runRecruitWorkflow({
   const candidateRecoveryCounts = new Map();
   let cardNodeIds = [];
   let listEndReason = "";
+  let lastHumanEvent = null;
   const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
     rootNodeId: rootState?.iframe?.documentNodeId,
     containerSelectors: RECRUIT_LIST_CONTAINER_SELECTORS,
@@ -335,9 +360,36 @@ export async function runRecruitWorkflow({
     validateViewportPoint: true
   }));
 
+  function recordHumanEvent(event = null) {
+    if (!event) return lastHumanEvent;
+    lastHumanEvent = {
+      at: new Date().toISOString(),
+      ...event
+    };
+    return lastHumanEvent;
+  }
+
+  async function maybeHumanActionCooldown(phase, timings = {}) {
+    if (!effectiveHumanBehavior.actionCooldown) return null;
+    const pauseMs = humanDelay(280, 90, {
+      minMs: 80,
+      maxMs: 720
+    });
+    if (pauseMs > 0) {
+      await runControl.sleep(pauseMs);
+      addTiming(timings, `human_${phase}_pause_ms`, pauseMs);
+    }
+    return recordHumanEvent({
+      kind: "action_cooldown",
+      phase,
+      pause_ms: pauseMs
+    });
+  }
+
   function updateRecruitProgress(extra = {}) {
     const counts = countRecruitResultStatuses(results);
     const listSnapshot = compactInfiniteListState(listState);
+    const humanRestState = humanRestController.getState();
     runControl.updateProgress({
       card_count: cardNodeIds.length,
       target_count: limit,
@@ -351,6 +403,12 @@ export async function runRecruitWorkflow({
       list_end_reason: listEndReason || null,
       viewport_checks: viewportGuard.getStats().checks,
       viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_count: humanRestState.rest_count,
+      human_rest_ms: humanRestState.total_rest_ms,
+      last_human_event: lastHumanEvent,
       ...extra
     });
   }
@@ -519,6 +577,7 @@ export async function runRecruitWorkflow({
       stableSignatureLimit: listStableSignatureLimit,
       wheelDeltaY: listWheelDeltaY,
       settleMs: listSettleMs,
+      listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
       fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         let currentRootState = await getRecruitRoots(client);
@@ -622,6 +681,7 @@ export async function runRecruitWorkflow({
         checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailStep = "open_detail";
         networkRecorder.clear();
+        await maybeHumanActionCooldown("before_detail_open", timings);
         const openedDetail = await openRecruitCardDetail(client, cardNodeId);
         addTiming(timings, "candidate_click_ms", openedDetail.timings?.candidate_click_ms);
         addTiming(timings, "detail_open_ms", openedDetail.timings?.detail_open_ms);
@@ -693,6 +753,7 @@ export async function runRecruitWorkflow({
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
                 scrollMethod: "dom-anchor-fallback-input",
+                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
                 stepTimeoutMs: 45000,
                 totalTimeoutMs: 90000,
                 duplicateStopCount: 1,
@@ -765,6 +826,7 @@ export async function runRecruitWorkflow({
         screeningCandidate = detailResult.candidate;
         if (closeDetail) {
           detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecruitDetail(client));
+          await maybeHumanActionCooldown("after_detail_close", timings);
           if (!detailResult.close_result?.closed) {
             const closeError = createRecruitCloseFailureError(detailResult.close_result);
             const recovery = await recoverAndReapplyRecruitContext("detail_close_failed", closeError, {
@@ -892,6 +954,27 @@ export async function runRecruitWorkflow({
     });
     addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
 
+    if (effectiveHumanRestEnabled) {
+      const restStarted = Date.now();
+      const restResult = await humanRestController.takeBreakIfNeeded({
+        sleepFn: (ms) => runControl.sleep(ms)
+      });
+      const restElapsed = Date.now() - restStarted;
+      if (restResult.rested) {
+        recordHumanEvent({
+          kind: "rest",
+          pause_ms: restResult.pause_ms || restElapsed,
+          events: restResult.events || []
+        });
+        compactResult.human_rest = restResult;
+        addTiming(compactResult.timings, "human_rest_ms", restElapsed);
+        compactResult.timings.total_ms = Date.now() - candidateStarted;
+        updateRecruitProgress({
+          human_rest_last: restResult
+        });
+      }
+    }
+
     if (delayMs > 0) {
       const sleepStarted = Date.now();
       await runControl.sleep(delayMs);
@@ -911,6 +994,9 @@ export async function runRecruitWorkflow({
       stats: viewportGuard.getStats(),
       events: viewportGuard.getEvents()
     },
+    human_behavior: effectiveHumanBehavior,
+    human_rest: humanRestController.getState(),
+    last_human_event: lastHumanEvent,
     list_end_reason: listEndReason || null,
     refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,
@@ -958,6 +1044,8 @@ export function createRecruitRunService({
     llmImageLimit = 8,
     llmImageDetail = "high",
     imageOutputDir = "",
+    humanRestEnabled = false,
+    humanBehavior = null,
     name = "recruit-domain-run"
   } = {}) {
     if (!client) throw new Error("startRecruitRun requires a guarded CDP client");
@@ -965,6 +1053,10 @@ export function createRecruitRunService({
     const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
     const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? candidateLimit : Math.max(0, Number(detailLimit) || 0);
+    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+    });
+    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
     return manager.startRun({
       name,
       context: {
@@ -994,7 +1086,11 @@ export function createRecruitRunService({
         llm_timeout_ms: llmTimeoutMs,
         llm_image_limit: llmImageLimit,
         llm_image_detail: llmImageDetail,
-        image_output_dir: imageOutputDir || ""
+        image_output_dir: imageOutputDir || "",
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_behavior: effectiveHumanBehavior,
+        human_rest_enabled: effectiveHumanRestEnabled
       },
       progress: {
         card_count: 0,
@@ -1007,7 +1103,13 @@ export function createRecruitRunService({
         image_capture_failed: 0,
         detail_open_failed: 0,
         transient_recovered: 0,
-        context_recoveries: 0
+        context_recoveries: 0,
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_rest_enabled: effectiveHumanRestEnabled,
+        human_rest_count: 0,
+        human_rest_ms: 0,
+        last_human_event: null
       },
       checkpoint: {},
       task: (runControl) => workflow({
@@ -1039,7 +1141,9 @@ export function createRecruitRunService({
         llmTimeoutMs,
         llmImageLimit,
         llmImageDetail,
-        imageOutputDir
+        imageOutputDir,
+        humanRestEnabled: effectiveHumanRestEnabled,
+        humanBehavior: effectiveHumanBehavior
       }, runControl)
     });
   }