@reconcrap/boss-recommend-mcp 2.0.43 → 2.0.44

package/src/core/capture/index.js

@@ -38,6 +38,76 @@ function withPadding(rect, padding = 0) {
   };
 }
 
+function normalizeRandom(random) {
+  return typeof random === "function" ? random : Math.random;
+}
+
+function randomBetween(random, min, max) {
+  const lower = Number(min) || 0;
+  const upper = Number(max) || lower;
+  if (upper <= lower) return lower;
+  return lower + normalizeRandom(random)() * (upper - lower);
+}
+
+function normalizeRatio(raw, fallback, { min = 0, max = 1 } = {}) {
+  const parsed = Number(raw);
+  const value = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.min(max, Math.max(min, value));
+}
+
+function normalizeScrollDeltaJitter({
+  enabled = false,
+  minRatio = 0.65,
+  maxRatio = 0.9,
+  minOverlapRatio = 0.2,
+  preserveCoverage = true,
+  random = Math.random
+} = {}) {
+  const safeMinRatio = normalizeRatio(minRatio, 0.65, { min: 0.1, max: 1 });
+  const safeMaxRatio = Math.max(safeMinRatio, normalizeRatio(maxRatio, 0.9, { min: safeMinRatio, max: 1 }));
+  return {
+    enabled: enabled === true,
+    min_ratio: safeMinRatio,
+    max_ratio: safeMaxRatio,
+    min_overlap_ratio: normalizeRatio(minOverlapRatio, 0.2, { min: 0, max: 0.8 }),
+    preserve_coverage: preserveCoverage !== false,
+    random: normalizeRandom(random)
+  };
+}
+
+function resolveCoverageSafeScrollDelta({
+  baseDelta,
+  clipHeight,
+  jitter
+} = {}) {
+  const safeBase = Math.max(1, Number(baseDelta) || 650);
+  if (!jitter?.enabled) {
+    return {
+      deltaY: safeBase,
+      jittered: false,
+      base_delta_y: safeBase
+    };
+  }
+  const safeClipHeight = Math.max(1, Number(clipHeight) || 1);
+  const maxDeltaForOverlap = Math.max(1, Math.floor(safeClipHeight * (1 - jitter.min_overlap_ratio)));
+  const upper = Math.max(1, Math.min(Math.round(safeBase * jitter.max_ratio), maxDeltaForOverlap));
+  const lower = Math.min(upper, Math.max(1, Math.round(safeBase * jitter.min_ratio)));
+  const deltaY = Math.max(1, Math.round(randomBetween(jitter.random, lower, upper)));
+  return {
+    deltaY,
+    jittered: true,
+    base_delta_y: safeBase,
+    min_delta_y: lower,
+    max_delta_y: upper,
+    min_ratio: jitter.min_ratio,
+    max_ratio: jitter.max_ratio,
+    min_overlap_ratio: jitter.min_overlap_ratio,
+    clip_height: safeClipHeight,
+    max_delta_for_overlap: maxDeltaForOverlap,
+    preserve_coverage: jitter.preserve_coverage
+  };
+}
+
 export async function captureNodeHtml(client, nodeId, {
   domain = "unknown",
   source = "dom",
@@ -709,6 +779,12 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   scrollAnchorSelector = DEFAULT_SCROLL_ANCHOR_SELECTOR,
   scrollAnchorMaxProbeNodes = 260,
   scrollAnchorMinGap = 180,
+  scrollDeltaJitterEnabled = false,
+  scrollDeltaJitterMinRatio = 0.65,
+  scrollDeltaJitterMaxRatio = 0.9,
+  scrollDeltaJitterMinOverlapRatio = 0.2,
+  scrollDeltaJitterPreserveCoverage = true,
+  scrollDeltaJitterRandom = Math.random,
   stopBoundarySelector = "",
   stopBoundaryTextPatterns = [],
   stopBoundaryMaxProbeNodes = 180,
@@ -721,10 +797,21 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   const sequenceStarted = Date.now();
   const normalizedScrollMethod = normalizeScrollMethod(scrollMethod);
   const maxScreenshotCount = Math.max(1, Number(maxScreenshots) || 1);
+  const scrollDeltaJitter = normalizeScrollDeltaJitter({
+    enabled: scrollDeltaJitterEnabled,
+    minRatio: scrollDeltaJitterMinRatio,
+    maxRatio: scrollDeltaJitterMaxRatio,
+    minOverlapRatio: scrollDeltaJitterMinOverlapRatio,
+    preserveCoverage: scrollDeltaJitterPreserveCoverage,
+    random: scrollDeltaJitterRandom
+  });
+  const maxCaptureIterations = scrollDeltaJitter.enabled && scrollDeltaJitter.preserve_coverage
+    ? Math.max(maxScreenshotCount, Math.ceil(maxScreenshotCount / scrollDeltaJitter.min_ratio))
+    : maxScreenshotCount;
   const anchorPlan = normalizedScrollMethod !== "input"
     ? await collectDomScrollAnchors(client, nodeId, {
         selector: scrollAnchorSelector,
-        maxScreenshots: maxScreenshotCount,
+        maxScreenshots: maxCaptureIterations,
         maxProbeNodes: scrollAnchorMaxProbeNodes,
         minAnchorGap: scrollAnchorMinGap,
         stepTimeoutMs
@@ -793,7 +880,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     }
   }
 
-  for (let index = 0; index < maxScreenshotCount; index += 1) {
+  for (let index = 0; index < maxCaptureIterations; index += 1) {
     assertCaptureTotalBudget(sequenceStarted, totalTimeoutMs, `capture_page_${index + 1}`);
     captureCount += 1;
     const captureStarted = Date.now();
@@ -920,7 +1007,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       break;
     }
 
-    if (index < maxScreenshotCount - 1) {
+    if (index < maxCaptureIterations - 1) {
       assertCaptureTotalBudget(sequenceStarted, totalTimeoutMs, `scroll_after_page_${index + 1}`);
       let scrolledByDomAnchor = false;
       const nextAnchor = anchorPlan?.anchors?.[index + 1] || null;
@@ -956,6 +1043,11 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       if (!scrolledByDomAnchor && normalizedScrollMethod !== "dom-anchor") {
         const x = box.center.x;
         const y = box.center.y;
+        const scrollDelta = resolveCoverageSafeScrollDelta({
+          baseDelta: wheelDeltaY,
+          clipHeight: effectiveClip.height,
+          jitter: scrollDeltaJitter
+        });
         await withCaptureTimeout(client.Input.dispatchMouseEvent({ type: "mouseMoved", x, y, button: "none" }), {
           label: `scroll_mouse_move_${index + 1}`,
           timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
@@ -965,7 +1057,7 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
           x,
           y,
           deltaX: 0,
-          deltaY: Math.max(1, Number(wheelDeltaY) || 650)
+          deltaY: scrollDelta.deltaY
         }), {
           label: `scroll_wheel_${index + 1}`,
           timeoutMs: Math.min(Math.max(3000, Number(stepTimeoutMs) || 45000), 10000)
@@ -973,7 +1065,10 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
         currentScrollMetadata = {
           before_capture: `wheel_down_${index + 1}`,
           method: "Input.dispatchMouseEvent",
-          fallback_from_dom_anchor: Boolean(anchorPlan && normalizedScrollMethod === "dom-anchor-fallback-input")
+          fallback_from_dom_anchor: Boolean(anchorPlan && normalizedScrollMethod === "dom-anchor-fallback-input"),
+          wheel_delta_y: scrollDelta.deltaY,
+          wheel_delta_base_y: scrollDelta.base_delta_y,
+          wheel_delta_jitter: scrollDelta.jittered ? scrollDelta : null
         };
       }
       if (settleMs > 0) await sleep(settleMs);
@@ -1031,15 +1126,24 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
       step_timeout_ms: Math.max(0, Number(stepTimeoutMs) || 0),
       total_timeout_ms: Math.max(0, Number(totalTimeoutMs) || 0),
       scroll_method: normalizedScrollMethod,
-    scroll_anchor_selector: scrollAnchorSelector,
-    scroll_anchor_max_probe_nodes: Math.max(1, Number(scrollAnchorMaxProbeNodes) || 260),
-    scroll_anchor_min_gap: Math.max(0, Number(scrollAnchorMinGap) || 0)
-  },
-  scroll_anchor_plan: anchorPlan,
-  stop_boundary_plan: stopBoundaryPlan,
-  stop_boundary_checks: stopBoundaryChecks,
-  stop_boundary_result: stopBoundaryResult,
-  file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
+      requested_max_screenshots: maxScreenshotCount,
+      effective_max_screenshots: maxCaptureIterations,
+      scroll_anchor_selector: scrollAnchorSelector,
+      scroll_anchor_max_probe_nodes: Math.max(1, Number(scrollAnchorMaxProbeNodes) || 260),
+      scroll_anchor_min_gap: Math.max(0, Number(scrollAnchorMinGap) || 0),
+      scroll_delta_jitter: {
+        enabled: scrollDeltaJitter.enabled,
+        min_ratio: scrollDeltaJitter.min_ratio,
+        max_ratio: scrollDeltaJitter.max_ratio,
+        min_overlap_ratio: scrollDeltaJitter.min_overlap_ratio,
+        preserve_coverage: scrollDeltaJitter.preserve_coverage
+      }
+    },
+    scroll_anchor_plan: anchorPlan,
+    stop_boundary_plan: stopBoundaryPlan,
+    stop_boundary_checks: stopBoundaryChecks,
+    stop_boundary_result: stopBoundaryResult,
+    file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,
     metadata
   };

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

@@ -180,6 +180,83 @@ function normalizePoint(point) {
   return { x, y };
 }
 
+function normalizeRandom(random) {
+  return typeof random === "function" ? random : Math.random;
+}
+
+function randomBetween(random, min, max) {
+  const lower = Number(min) || 0;
+  const upper = Number(max) || lower;
+  if (upper <= lower) return lower;
+  return lower + random() * (upper - lower);
+}
+
+function clampNumber(value, min, max) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return min;
+  return Math.min(max, Math.max(min, number));
+}
+
+export function resolveInfiniteListScrollTiming({
+  wheelDeltaY = 850,
+  settleMs = 1200,
+  listScrollJitterEnabled = false,
+  listScrollJitterMinRatio = 0.85,
+  listScrollJitterMaxRatio = 1.15,
+  listSettleJitterMinRatio = 0.75,
+  listSettleJitterMaxRatio = 1.35,
+  random = Math.random
+} = {}) {
+  const baseDeltaY = Math.max(1, Number(wheelDeltaY) || 850);
+  const baseSettleMs = Math.max(0, Number(settleMs) || 0);
+  if (listScrollJitterEnabled !== true) {
+    return {
+      wheelDeltaY: baseDeltaY,
+      settleMs: baseSettleMs,
+      wheel_delta_jitter: {
+        enabled: false,
+        base_delta_y: baseDeltaY,
+        actual_delta_y: baseDeltaY
+      },
+      settle_jitter: {
+        enabled: false,
+        base_settle_ms: baseSettleMs,
+        actual_settle_ms: baseSettleMs
+      }
+    };
+  }
+  const nextRandom = normalizeRandom(random);
+  const minDeltaRatio = clampNumber(listScrollJitterMinRatio, 0.5, 1.5);
+  const maxDeltaRatio = clampNumber(listScrollJitterMaxRatio, minDeltaRatio, 1.5);
+  const minSettleRatio = clampNumber(listSettleJitterMinRatio, 0.4, 2);
+  const maxSettleRatio = clampNumber(listSettleJitterMaxRatio, minSettleRatio, 2);
+  const deltaRatio = randomBetween(nextRandom, minDeltaRatio, maxDeltaRatio);
+  const settleRatio = randomBetween(nextRandom, minSettleRatio, maxSettleRatio);
+  const actualDeltaY = Math.max(1, Math.round(baseDeltaY * deltaRatio));
+  const actualSettleMs = Math.max(0, Math.round(baseSettleMs * settleRatio));
+  return {
+    wheelDeltaY: actualDeltaY,
+    settleMs: actualSettleMs,
+    wheel_delta_jitter: {
+      enabled: true,
+      preserve_coverage: true,
+      base_delta_y: baseDeltaY,
+      actual_delta_y: actualDeltaY,
+      ratio: deltaRatio,
+      min_ratio: minDeltaRatio,
+      max_ratio: maxDeltaRatio
+    },
+    settle_jitter: {
+      enabled: true,
+      base_settle_ms: baseSettleMs,
+      actual_settle_ms: actualSettleMs,
+      ratio: settleRatio,
+      min_ratio: minSettleRatio,
+      max_ratio: maxSettleRatio
+    }
+  };
+}
+
 function resolveViewportPoint(viewportPoint, viewport) {
   if (!viewportPoint) return null;
   if (viewport && ("xRatio" in viewportPoint || "yRatio" in viewportPoint)) {
@@ -891,7 +968,13 @@ export function firstUnseenInfiniteListItem(state, items = []) {
 export async function scrollInfiniteListByVisibleItems(client, items = [], {
   wheelDeltaY = 850,
   settleMs = 1200,
-  fallbackPoint = null
+  fallbackPoint = null,
+  listScrollJitterEnabled = false,
+  listScrollJitterMinRatio = 0.85,
+  listScrollJitterMaxRatio = 1.15,
+  listSettleJitterMinRatio = 0.75,
+  listSettleJitterMaxRatio = 1.35,
+  random = Math.random
 } = {}) {
   const candidates = items.filter((item) => item?.node_id);
   if (!candidates.length) {
@@ -902,7 +985,18 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
   }
 
   const errors = [];
-  const wheelDelta = Math.max(1, Number(wheelDeltaY) || 850);
+  const scrollTiming = resolveInfiniteListScrollTiming({
+    wheelDeltaY,
+    settleMs,
+    listScrollJitterEnabled,
+    listScrollJitterMinRatio,
+    listScrollJitterMaxRatio,
+    listSettleJitterMinRatio,
+    listSettleJitterMaxRatio,
+    random
+  });
+  const wheelDelta = scrollTiming.wheelDeltaY;
+  const actualSettleMs = scrollTiming.settleMs;
   async function synthesizeGesture(x, y) {
     if (typeof client?.Input?.synthesizeScrollGesture !== "function") return null;
     try {
@@ -941,15 +1035,19 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
         deltaY: wheelDelta
       });
       const gesture = await synthesizeGesture(x, y);
-      if (settleMs > 0) await sleep(settleMs);
+      if (actualSettleMs > 0) await sleep(actualSettleMs);
       return {
         ok: true,
         anchor_key: anchor.key,
         anchor_node_id: anchor.node_id,
         point: { x, y },
         wheel_delta_y: wheelDelta,
+        base_wheel_delta_y: Math.max(1, Number(wheelDeltaY) || 850),
+        wheel_delta_jitter: scrollTiming.wheel_delta_jitter,
         gesture,
-        settle_ms: settleMs,
+        settle_ms: actualSettleMs,
+        base_settle_ms: Math.max(0, Number(settleMs) || 0),
+        settle_jitter: scrollTiming.settle_jitter,
         skipped_stale_anchor_count: errors.length
       };
     } catch (error) {
@@ -994,7 +1092,7 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
       deltaY: wheelDelta
     });
     const gesture = await synthesizeGesture(x, y);
-    if (settleMs > 0) await sleep(settleMs);
+    if (actualSettleMs > 0) await sleep(actualSettleMs);
     return {
       ok: true,
       mode: "fallback_point",
@@ -1010,8 +1108,12 @@ export async function scrollInfiniteListByVisibleItems(client, items = [], {
       assist,
       point: { x, y },
       wheel_delta_y: wheelDelta,
+      base_wheel_delta_y: Math.max(1, Number(wheelDeltaY) || 850),
+      wheel_delta_jitter: scrollTiming.wheel_delta_jitter,
       gesture,
-      settle_ms: settleMs,
+      settle_ms: actualSettleMs,
+      base_settle_ms: Math.max(0, Number(settleMs) || 0),
+      settle_jitter: scrollTiming.settle_jitter,
       skipped_stale_anchor_count: errors.length,
       stale_anchor_errors: errors
     };
@@ -1037,7 +1139,13 @@ export async function getNextInfiniteListCandidate({
   minScrollsBeforeEnd = 3,
   wheelDeltaY = 850,
   settleMs = 1200,
-  fallbackPoint = null
+  fallbackPoint = null,
+  listScrollJitterEnabled = false,
+  listScrollJitterMinRatio = 0.85,
+  listScrollJitterMaxRatio = 1.15,
+  listSettleJitterMinRatio = 0.75,
+  listSettleJitterMaxRatio = 1.35,
+  random = Math.random
 } = {}) {
   if (!client) throw new Error("getNextInfiniteListCandidate requires client");
   if (!state) throw new Error("getNextInfiniteListCandidate requires state");
@@ -1173,7 +1281,13 @@ export async function getNextInfiniteListCandidate({
     const scrollResult = await scrollInfiniteListByVisibleItems(client, items, {
       wheelDeltaY,
       settleMs,
-      fallbackPoint
+      fallbackPoint,
+      listScrollJitterEnabled,
+      listScrollJitterMinRatio,
+      listScrollJitterMaxRatio,
+      listSettleJitterMinRatio,
+      listSettleJitterMaxRatio,
+      random
     });
     state.scroll_count += scrollResult.ok ? 1 : 0;
     attempts[attempts.length - 1].scroll_result = scrollResult;

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

@@ -2,7 +2,11 @@ import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
 import {
   clickPoint,
+  configureHumanInteraction,
+  createHumanRestController,
   getNodeBox,
+  humanDelay,
+  normalizeHumanBehaviorOptions,
   scrollNodeIntoView,
   sleep
 } from "../../core/browser/index.js";
@@ -685,9 +689,27 @@ export async function runChatWorkflow({
   listWheelDeltaY = 850,
   listSettleMs = 2200,
   listFallbackPoint = null,
-  imageOutputDir = ""
+  imageOutputDir = "",
+  humanRestEnabled = false,
+  humanBehavior = null
 } = {}, runControl) {
   if (!client) throw new Error("runChatWorkflow 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 normalizedDetailSource = normalizeDetailSource(detailSource);
   const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
   const useLlmScreening = normalizedScreeningMode !== "deterministic";
@@ -732,6 +754,33 @@ export async function runChatWorkflow({
   let requestSatisfiedCount = 0;
   let requestSkippedCount = 0;
   let contextSetup = {};
+  let lastHumanEvent = null;
+
+  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
+    });
+  }
 
   runControl.setPhase("chat:cleanup");
   let initialTopLevelState = await getChatTopLevelState(client);
@@ -870,7 +919,13 @@ export async function runChatWorkflow({
       scroll_count: compactInfiniteListState(listState).scroll_count,
       list_end_reason: listEndReason,
       viewport_checks: viewportGuard.getStats().checks,
-      viewport_recoveries: viewportGuard.getStats().recoveries
+      viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_count: humanRestController.getState().rest_count,
+      human_rest_ms: humanRestController.getState().total_rest_ms,
+      last_human_event: lastHumanEvent
     });
     runControl.setPhase("chat:done");
     return {
@@ -888,6 +943,9 @@ export async function runChatWorkflow({
         stats: viewportGuard.getStats(),
         events: viewportGuard.getEvents()
       },
+      human_behavior: effectiveHumanBehavior,
+      human_rest: humanRestController.getState(),
+      last_human_event: lastHumanEvent,
       list_end_reason: listEndReason,
       target_pass_count: passTarget,
       process_until_list_end: Boolean(processUntilListEnd),
@@ -993,6 +1051,7 @@ export async function runChatWorkflow({
       stableSignatureLimit: listStableSignatureLimit,
       wheelDeltaY: listWheelDeltaY,
       settleMs: listSettleMs,
+      listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
       fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         const currentRootState = await ensureChatViewport(await getChatRoots(client), "candidate_find_nodes");
@@ -1074,6 +1133,7 @@ export async function runChatWorkflow({
 
         detailStep = "select_candidate";
         networkRecorder.clear();
+        await maybeHumanActionCooldown("before_detail_open", timings);
         const selected = await measureTiming(timings, "candidate_click_ms", () => selectFreshChatCandidate(client, {
           cardNodeId,
           candidate: cardCandidate,
@@ -1178,6 +1238,7 @@ export async function runChatWorkflow({
           if (!detailResult) {
             detailStep = "open_online_resume";
             networkRecorder.clear();
+            await maybeHumanActionCooldown("before_resume_open", timings);
             const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
               timeoutMs: readyTimeoutMs
             }));
@@ -1332,6 +1393,7 @@ export async function runChatWorkflow({
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
                 scrollMethod: "dom-anchor-fallback-input",
+                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
                 stepTimeoutMs: 45000,
                 totalTimeoutMs: 90000,
                 duplicateStopCount: 1,
@@ -1479,6 +1541,7 @@ export async function runChatWorkflow({
               full_cv_evidence: fullCvEvidence
             });
             closeResult = await measureTiming(timings, "close_detail_ms", () => closeChatResumeModal(client));
+            await maybeHumanActionCooldown("after_detail_close", timings);
             if (!closeResult?.closed) {
               closeRecovery = await recoverAndReapplyChatContext(
                 "resume_modal_close_failed:close_resume_modal",
@@ -1575,6 +1638,7 @@ export async function runChatWorkflow({
         : screenCandidate(screeningCandidate, { criteria });
     let postAction = null;
     if (requestResumeForPassed && screening.passed) {
+      await maybeHumanActionCooldown("before_post_action", timings);
       postAction = await measureTiming(timings, "post_action_ms", () => requestChatResumeForPassedCandidate(client, {
         greetingText,
         dryRun: dryRunRequestCv
@@ -1627,6 +1691,12 @@ export async function runChatWorkflow({
       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: humanRestController.getState().rest_count,
+      human_rest_ms: humanRestController.getState().total_rest_ms,
+      last_human_event: lastHumanEvent,
       last_candidate_id: screeningCandidate.id || null,
       last_candidate_key: candidateKey,
       last_score: screening.score
@@ -1649,6 +1719,31 @@ export async function runChatWorkflow({
     });
     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;
+        runControl.updateProgress({
+          human_rest_enabled: effectiveHumanRestEnabled,
+          human_rest_count: humanRestController.getState().rest_count,
+          human_rest_ms: humanRestController.getState().total_rest_ms,
+          human_rest_last: restResult,
+          last_human_event: lastHumanEvent
+        });
+      }
+    }
+
     if (delayMs > 0) {
       const sleepStarted = Date.now();
       await runControl.sleep(delayMs);
@@ -1669,6 +1764,9 @@ export async function runChatWorkflow({
       stats: viewportGuard.getStats(),
       events: viewportGuard.getEvents()
     },
+    human_behavior: effectiveHumanBehavior,
+    human_rest: humanRestController.getState(),
+    last_human_event: lastHumanEvent,
     list_end_reason: listEndReason || null,
     target_pass_count: passTarget,
     process_until_list_end: Boolean(processUntilListEnd),
@@ -1730,6 +1828,8 @@ export function createChatRunService({
     listSettleMs = 2200,
     listFallbackPoint = null,
     imageOutputDir = "",
+    humanRestEnabled = false,
+    humanBehavior = null,
     name = "chat-domain-run"
   } = {}) {
     if (!client) throw new Error("startChatRun requires a guarded CDP client");
@@ -1737,6 +1837,10 @@ export function createChatRunService({
     const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
     const processedLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? processedLimit : 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: {
@@ -1769,7 +1873,11 @@ export function createChatRunService({
         list_settle_ms: listSettleMs,
         list_fallback_point: listFallbackPoint,
         online_resume_button_timeout_ms: onlineResumeButtonTimeoutMs,
-        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,
@@ -1784,7 +1892,13 @@ export function createChatRunService({
         skipped: 0,
         requested: 0,
         request_satisfied: 0,
-        request_skipped: 0
+        request_skipped: 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({
@@ -1821,7 +1935,9 @@ export function createChatRunService({
         listWheelDeltaY,
         listSettleMs,
         listFallbackPoint,
-        imageOutputDir
+        imageOutputDir,
+        humanRestEnabled: effectiveHumanRestEnabled,
+        humanBehavior: effectiveHumanBehavior
       }, runControl)
     });
   }