@web-auto/webauto 0.1.13 → 0.1.15

package/modules/camo-runtime/src/autoscript/action-providers/xhs/comments.mjs

@@ -1,7 +1,11 @@
 export function buildCommentsHarvestScript(params = {}) {
   const maxRounds = Math.max(1, Number(params.maxRounds ?? params.maxScrollRounds ?? 14) || 14);
-  const scrollStep = Math.max(120, Number(params.scrollStep ?? 420) || 420);
-  const settleMs = Math.max(80, Number(params.settleMs ?? 180) || 180);
+  const scrollStepMin = Math.max(120, Number(params.scrollStepMin ?? params.scrollStep ?? 420) || 420);
+  const scrollStepMax = Math.max(scrollStepMin, Number(params.scrollStepMax ?? scrollStepMin) || scrollStepMin);
+  const scrollStepBase = Math.max(scrollStepMin, Math.floor((scrollStepMin + scrollStepMax) / 2));
+  const settleMinMs = Math.max(80, Number(params.settleMinMs ?? params.settleMs ?? 180) || 180);
+  const settleMaxMs = Math.max(settleMinMs, Number(params.settleMaxMs ?? settleMinMs) || settleMinMs);
+  const settleMs = settleMinMs;
   const stallRounds = Math.max(1, Number(params.stallRounds ?? 2) || 2);
   const requireBottom = params.requireBottom !== false;
   const includeComments = params.includeComments !== false;
@@ -10,12 +14,12 @@ export function buildCommentsHarvestScript(params = {}) {
   const recoveryUpRounds = Math.max(1, Number(params.recoveryUpRounds ?? 2) || 2);
   const recoveryDownRounds = Math.max(1, Number(params.recoveryDownRounds ?? 3) || 3);
   const maxRecoveries = Math.max(0, Number(params.maxRecoveries ?? 3) || 3);
-  const recoveryUpStep = Math.max(80, Number(params.recoveryUpStep ?? Math.floor(scrollStep * 0.75)) || Math.floor(scrollStep * 0.75));
-  const recoveryDownStep = Math.max(120, Number(params.recoveryDownStep ?? Math.floor(scrollStep * 1.3)) || Math.floor(scrollStep * 1.3));
+  const recoveryUpStep = Math.max(80, Number(params.recoveryUpStep ?? Math.floor(scrollStepBase * 0.75)) || Math.floor(scrollStepBase * 0.75));
+  const recoveryDownStep = Math.max(120, Number(params.recoveryDownStep ?? Math.floor(scrollStepBase * 1.3)) || Math.floor(scrollStepBase * 1.3));
   const recoveryNoProgressRounds = Math.max(1, Number(params.recoveryNoProgressRounds ?? 3) || 3);
   const progressDiffThreshold = Math.max(2, Number(
-    params.progressDiffThreshold ?? Math.max(12, Math.floor(scrollStep * 0.08)),
-  ) || Math.max(12, Math.floor(scrollStep * 0.08)));
+    params.progressDiffThreshold ?? Math.max(12, Math.floor(scrollStepBase * 0.08)),
+  ) || Math.max(12, Math.floor(scrollStepBase * 0.08)));
   const recoveryDownBoostPerAttempt = Math.max(0, Number(params.recoveryDownBoostPerAttempt ?? 1) || 1);
   const maxRecoveryDownBoost = Math.max(0, Number(params.maxRecoveryDownBoost ?? 2) || 2);
   const adaptiveMaxRounds = params.adaptiveMaxRounds !== false;
@@ -29,6 +33,13 @@ export function buildCommentsHarvestScript(params = {}) {
     const metricsState = state.metrics && typeof state.metrics === 'object' ? state.metrics : {};
     state.metrics = metricsState;
     metricsState.searchCount = Number(metricsState.searchCount || 0);
+    const actionTrace = [];
+    const pushTrace = (payload) => {
+      actionTrace.push({
+        ts: new Date().toISOString(),
+        ...payload,
+      });
+    };
     const detailSelectors = [
       '.note-detail-mask',
       '.note-detail-page',
@@ -158,7 +169,10 @@ export function buildCommentsHarvestScript(params = {}) {
     };
 
     const configuredMaxRounds = Number(${maxRounds});
-    const scrollStep = Number(${scrollStep});
+    const scrollStepMin = Number(${scrollStepMin});
+    const scrollStepMax = Number(${scrollStepMax});
+    const settleMinMs = Number(${settleMinMs});
+    const settleMaxMs = Number(${settleMaxMs});
     const settleMs = Number(${settleMs});
     const stallRounds = Number(${stallRounds});
     const requireBottom = ${requireBottom ? 'true' : 'false'};
@@ -179,6 +193,12 @@ export function buildCommentsHarvestScript(params = {}) {
     const adaptiveBufferRounds = Number(${adaptiveBufferRounds});
     const adaptiveMinBoostRounds = Number(${adaptiveMinBoostRounds});
     const adaptiveMaxRoundsCap = Number(${adaptiveMaxRoundsCap});
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
     let maxRounds = configuredMaxRounds;
     let maxRoundsSource = 'configured';
     let budgetExpectedCommentsCount = null;
@@ -208,13 +228,23 @@ export function buildCommentsHarvestScript(params = {}) {
       no_effect: 0,
       no_new_comments: 0,
     };
-    const performScroll = async (deltaY, waitMs = settleMs) => {
+    const performScroll = async (deltaY, waitMs = settleMs, meta = {}) => {
+      const waitFloor = Math.max(settleMinMs, Math.floor(Number(waitMs) || settleMinMs));
+      const waitCeil = Math.max(waitFloor, Math.max(settleMaxMs, Math.floor(Number(waitMs) || settleMaxMs)));
+      const waitActual = randomBetween(waitFloor, waitCeil);
+      pushTrace({
+        kind: 'scroll',
+        stage: 'xhs_comments_harvest',
+        deltaY: Number(deltaY),
+        waitMs: waitActual,
+        ...meta,
+      });
       if (typeof scroller?.scrollBy === 'function') {
         scroller.scrollBy({ top: deltaY, behavior: 'auto' });
       } else {
         window.scrollBy({ top: deltaY, behavior: 'auto' });
       }
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      await new Promise((resolve) => setTimeout(resolve, waitActual));
     };
 
     for (let round = 1; round <= maxRounds; round += 1) {
@@ -240,18 +270,27 @@ export function buildCommentsHarvestScript(params = {}) {
       }
 
       const prevTop = beforeMetrics.scrollTop;
-      if (typeof scroller?.scrollBy === 'function') {
-        scroller.scrollBy({ top: scrollStep, behavior: 'auto' });
-      } else {
-        window.scrollBy({ top: scrollStep, behavior: 'auto' });
-      }
-      await new Promise((resolve) => setTimeout(resolve, settleMs));
+      const roundScrollStep = randomBetween(scrollStepMin, scrollStepMax);
+      await performScroll(roundScrollStep, settleMs, {
+        round,
+        reason: 'main_scroll',
+      });
       collect(round);
       let afterMetrics = readMetrics();
       let moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;
       if (!moved && typeof window.scrollBy === 'function') {
-        window.scrollBy({ top: Math.max(120, Math.floor(scrollStep / 2)), behavior: 'auto' });
-        await new Promise((resolve) => setTimeout(resolve, settleMs));
+        const fallbackStep = Math.max(120, Math.floor(roundScrollStep / 2));
+        const fallbackWaitMs = randomBetween(settleMinMs, settleMaxMs);
+        pushTrace({
+          kind: 'scroll',
+          stage: 'xhs_comments_harvest',
+          round,
+          reason: 'fallback_scroll',
+          deltaY: Number(fallbackStep),
+          waitMs: fallbackWaitMs,
+        });
+        window.scrollBy({ top: fallbackStep, behavior: 'auto' });
+        await new Promise((resolve) => setTimeout(resolve, fallbackWaitMs));
         collect(round);
         afterMetrics = readMetrics();
         moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;
@@ -298,13 +337,23 @@ export function buildCommentsHarvestScript(params = {}) {
         recoveries += 1;
         recoveryReasonCounts[recoveryTrigger] += 1;
         for (let i = 0; i < recoveryUpRounds; i += 1) {
-          await performScroll(-recoveryUpStep, settleMs + 120);
+          await performScroll(-recoveryUpStep, settleMs + 120, {
+            round,
+            reason: 'recovery_up',
+            recoveryTrigger,
+            recoveryStep: i + 1,
+          });
           collect(round);
         }
         const downBoost = Math.min(maxRecoveryDownBoost, Math.max(0, recoveries - 1) * recoveryDownBoostPerAttempt);
         const downRounds = recoveryDownRounds + downBoost;
         for (let i = 0; i < downRounds; i += 1) {
-          await performScroll(recoveryDownStep, settleMs + 180);
+          await performScroll(recoveryDownStep, settleMs + 180, {
+            round,
+            reason: 'recovery_down',
+            recoveryTrigger,
+            recoveryStep: i + 1,
+          });
           collect(round);
         }
         const recoveredMetrics = readMetrics();
@@ -405,6 +454,7 @@ export function buildCommentsHarvestScript(params = {}) {
       budgetExpectedCommentsCount,
       scroll: metrics,
     };
+    payload.actionTrace = actionTrace;
     if (includeComments) {
       const bounded = commentsLimit > 0 ? comments.slice(0, commentsLimit) : comments;
       payload.comments = bounded;

package/modules/camo-runtime/src/autoscript/action-providers/xhs/interaction.mjs

@@ -165,9 +165,16 @@ function buildCollectLikeTargetsScript() {
 function buildClickLikeByIndexScript(index, highlight, skipAlreadyCheck = false) {
   return `(async () => {
     const idx = Number(${JSON.stringify(index)});
+    const actionTrace = [];
+    const pushTrace = (payload) => {
+      actionTrace.push({
+        ts: new Date().toISOString(),
+        ...payload,
+      });
+    };
     const items = Array.from(document.querySelectorAll('.comment-item'));
     const item = items[idx];
-    if (!item) return { clicked: false, reason: 'comment_item_not_found', index: idx };
+    if (!item) return { clicked: false, reason: 'comment_item_not_found', index: idx, actionTrace };
     const findLikeControl = (node) => {
       const selectors = [
         '.like-wrapper',
@@ -195,12 +202,14 @@ function buildClickLikeByIndexScript(index, highlight, skipAlreadyCheck = false)
     };
 
     const likeControl = findLikeControl(item);
-    if (!likeControl) return { clicked: false, reason: 'like_control_not_found', index: idx };
+    if (!likeControl) return { clicked: false, reason: 'like_control_not_found', index: idx, actionTrace };
     const beforeLiked = isAlreadyLiked(likeControl);
     if (beforeLiked && !${skipAlreadyCheck ? 'true' : 'false'}) {
-      return { clicked: false, alreadyLiked: true, reason: 'already_liked', index: idx };
+      return { clicked: false, alreadyLiked: true, reason: 'already_liked', index: idx, actionTrace };
     }
+    pushTrace({ kind: 'scroll', stage: 'xhs_comment_like', index: idx, target: 'comment_item', via: 'scrollIntoView' });
     item.scrollIntoView({ behavior: 'auto', block: 'center' });
+    pushTrace({ kind: 'scroll', stage: 'xhs_comment_like', index: idx, target: 'like_control', via: 'scrollIntoView' });
     likeControl.scrollIntoView({ behavior: 'auto', block: 'center' });
     await new Promise((resolve) => setTimeout(resolve, 120));
     if (${highlight ? 'true' : 'false'}) {
@@ -208,6 +217,7 @@ function buildClickLikeByIndexScript(index, highlight, skipAlreadyCheck = false)
       likeControl.style.outline = '2px solid #00d6ff';
       setTimeout(() => { likeControl.style.outline = prev; }, 450);
     }
+    pushTrace({ kind: 'click', stage: 'xhs_comment_like', index: idx, target: 'like_control' });
     likeControl.click();
     await new Promise((resolve) => setTimeout(resolve, 220));
     return {
@@ -216,6 +226,7 @@ function buildClickLikeByIndexScript(index, highlight, skipAlreadyCheck = false)
       likedAfter: isAlreadyLiked(likeControl),
       reason: 'clicked',
       index: idx,
+      actionTrace,
     };
   })()`;
 }
@@ -231,7 +242,28 @@ async function captureScreenshotToFile({ profileId, filePath }) {
   }
 }
 
-export async function executeCommentLikeOperation({ profileId, params = {} }) {
+function emitProgress(context, payload = {}) {
+  const emit = context?.emitProgress;
+  if (typeof emit !== 'function') return;
+  emit(payload);
+}
+
+function emitActionTrace(context, actionTrace = [], extra = {}) {
+  if (!Array.isArray(actionTrace) || actionTrace.length === 0) return;
+  for (let i = 0; i < actionTrace.length; i += 1) {
+    const row = actionTrace[i];
+    if (!row || typeof row !== 'object') continue;
+    const kind = String(row.kind || row.action || '').trim().toLowerCase() || 'trace';
+    emitProgress(context, {
+      kind,
+      step: i + 1,
+      ...extra,
+      ...row,
+    });
+  }
+}
+
+export async function executeCommentLikeOperation({ profileId, params = {}, context = {} }) {
   const maxLikes = Math.max(1, Number(params.maxLikes ?? params.maxLikesPerRound ?? 1) || 1);
   const rawKeywords = normalizeArray(params.keywords || params.likeKeywords);
   const rules = compileLikeRules(rawKeywords);
@@ -353,6 +385,16 @@ export async function executeCommentLikeOperation({ profileId, params = {} }) {
       highlight: false,
     });
     const clickResult = extractEvaluateResultData(clickRaw) || {};
+    const clickTrace = Array.isArray(clickResult.actionTrace) ? clickResult.actionTrace : [];
+    if (clickTrace.length > 0) {
+      emitActionTrace(context, clickTrace, {
+        stage: 'xhs_comment_like',
+        noteId: output.noteId,
+        commentIndex: Number(row.index),
+        fallback: false,
+      });
+      delete clickResult.actionTrace;
+    }
 
     const afterPath = saveEvidence
       ? await captureScreenshotToFile({
@@ -454,6 +496,16 @@ export async function executeCommentLikeOperation({ profileId, params = {} }) {
         highlight: false,
       });
       const clickResult = extractEvaluateResultData(clickRaw) || {};
+      const clickTrace = Array.isArray(clickResult.actionTrace) ? clickResult.actionTrace : [];
+      if (clickTrace.length > 0) {
+        emitActionTrace(context, clickTrace, {
+          stage: 'xhs_comment_like',
+          noteId: output.noteId,
+          commentIndex: Number(row.index),
+          fallback: true,
+        });
+        delete clickResult.actionTrace;
+      }
       const afterPath = saveEvidence
         ? await captureScreenshotToFile({
           profileId,

package/modules/camo-runtime/src/autoscript/action-providers/xhs/search.mjs

@@ -1,15 +1,39 @@
 export function buildSubmitSearchScript(params = {}) {
   const keyword = String(params.keyword || '').trim();
+  const method = String(params.method || params.submitMethod || 'click').trim().toLowerCase();
+  const actionDelayMinMs = Math.max(20, Number(params.actionDelayMinMs ?? 180) || 180);
+  const actionDelayMaxMs = Math.max(actionDelayMinMs, Number(params.actionDelayMaxMs ?? 620) || 620);
+  const settleMinMs = Math.max(60, Number(params.settleMinMs ?? 1200) || 1200);
+  const settleMaxMs = Math.max(settleMinMs, Number(params.settleMaxMs ?? 2600) || 2600);
   return `(async () => {
     const state = window.__camoXhsState || (window.__camoXhsState = {});
     const metrics = state.metrics && typeof state.metrics === 'object' ? state.metrics : {};
     state.metrics = metrics;
     metrics.searchCount = Number(metrics.searchCount || 0) + 1;
     metrics.lastSearchAt = new Date().toISOString();
+    const actionTrace = [];
+    const pushTrace = (payload) => {
+      actionTrace.push({
+        ts: new Date().toISOString(),
+        ...payload,
+      });
+    };
     const input = document.querySelector('#search-input, input.search-input');
     if (!(input instanceof HTMLInputElement)) {
       throw new Error('SEARCH_INPUT_NOT_FOUND');
     }
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
+    const waitRandom = async (min, max, stage) => {
+      const waitMs = randomBetween(min, max);
+      pushTrace({ kind: 'wait', stage, waitMs });
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      return waitMs;
+    };
     const targetKeyword = ${JSON.stringify(keyword)};
     if (targetKeyword && input.value !== targetKeyword) {
       input.focus();
@@ -17,35 +41,65 @@ export function buildSubmitSearchScript(params = {}) {
       input.dispatchEvent(new Event('input', { bubbles: true }));
       input.dispatchEvent(new Event('change', { bubbles: true }));
     }
-    const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+    const requestedMethod = ${JSON.stringify(method)};
+    const normalizedMethod = ['click', 'enter', 'form'].includes(requestedMethod) ? requestedMethod : 'click';
     const beforeUrl = window.location.href;
     input.focus();
-    input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
-    input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
-    input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
     const candidates = ['.input-button .search-icon', '.input-button', 'button.min-width-search-icon'];
+    let methodUsed = normalizedMethod;
     let clickedSelector = null;
-    for (const selector of candidates) {
-      const button = document.querySelector(selector);
-      if (!button) continue;
-      if (button instanceof HTMLElement) button.scrollIntoView({ behavior: 'auto', block: 'center' });
-      await new Promise((resolve) => setTimeout(resolve, 80));
-      button.click();
-      clickedSelector = selector;
-      break;
-    }
     const form = input.closest('form');
-    if (form) {
-      if (typeof form.requestSubmit === 'function') form.requestSubmit();
-      else form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+    if (normalizedMethod === 'click') {
+      let clicked = false;
+      for (const selector of candidates) {
+        const button = document.querySelector(selector);
+        if (!button) continue;
+        if (button instanceof HTMLElement) {
+          pushTrace({ kind: 'scroll', stage: 'submit_search', selector, via: 'scrollIntoView' });
+          button.scrollIntoView({ behavior: 'auto', block: 'center' });
+        }
+        await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_click');
+        pushTrace({ kind: 'click', stage: 'submit_search', selector });
+        button.click();
+        clickedSelector = selector;
+        clicked = true;
+        break;
+      }
+      if (!clicked) {
+        methodUsed = 'form';
+      }
     }
-    await new Promise((resolve) => setTimeout(resolve, 320));
+    if (methodUsed === 'enter') {
+      await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_enter');
+      const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+      pushTrace({ kind: 'key', stage: 'submit_search', key: 'Enter' });
+      input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
+      input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
+      input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
+    } else if (methodUsed === 'form') {
+      await waitRandom(${actionDelayMinMs}, ${actionDelayMaxMs}, 'submit_pre_form');
+      if (form) {
+        pushTrace({ kind: 'submit', stage: 'submit_search', via: 'form' });
+        if (typeof form.requestSubmit === 'function') form.requestSubmit();
+        else form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+      } else {
+        methodUsed = 'enter';
+        const enterEvent = { key: 'Enter', code: 'Enter', keyCode: 13, which: 13, bubbles: true, cancelable: true };
+        pushTrace({ kind: 'key', stage: 'submit_search', key: 'Enter', fallback: true });
+        input.dispatchEvent(new KeyboardEvent('keydown', enterEvent));
+        input.dispatchEvent(new KeyboardEvent('keypress', enterEvent));
+        input.dispatchEvent(new KeyboardEvent('keyup', enterEvent));
+      }
+    }
+    await waitRandom(${settleMinMs}, ${settleMaxMs}, 'submit_settle');
     return {
       submitted: true,
-      via: clickedSelector || 'enter_or_form_submit',
+      via: clickedSelector || methodUsed,
       beforeUrl,
       afterUrl: window.location.href,
+      method: methodUsed,
       searchCount: metrics.searchCount,
+      actionTrace,
     };
   })()`;
 }
@@ -67,9 +121,21 @@ export function buildOpenDetailScript(params = {}) {
   const nextSeekRounds = Math.max(0, Number(params.nextSeekRounds || 8) || 8);
   const nextSeekStep = Math.max(0, Number(params.nextSeekStep || 0) || 0);
   const nextSeekSettleMs = Math.max(120, Number(params.nextSeekSettleMs || 320) || 320);
+  const preClickDelayMinMs = Math.max(60, Number(params.preClickDelayMinMs ?? 220) || 220);
+  const preClickDelayMaxMs = Math.max(preClickDelayMinMs, Number(params.preClickDelayMaxMs ?? 700) || 700);
+  const pollDelayMinMs = Math.max(80, Number(params.pollDelayMinMs ?? 130) || 130);
+  const pollDelayMaxMs = Math.max(pollDelayMinMs, Number(params.pollDelayMaxMs ?? 320) || 320);
+  const postOpenDelayMinMs = Math.max(120, Number(params.postOpenDelayMinMs ?? 420) || 420);
+  const postOpenDelayMaxMs = Math.max(postOpenDelayMinMs, Number(params.postOpenDelayMaxMs ?? 1100) || 1100);
 
   return `(async () => {
     const STATE_KEY = '__camoXhsState';
+    const randomBetween = (min, max) => {
+      const lo = Math.max(0, Math.floor(Number(min) || 0));
+      const hi = Math.max(lo, Math.floor(Number(max) || 0));
+      if (hi <= lo) return lo;
+      return lo + Math.floor(Math.random() * (hi - lo + 1));
+    };
     const normalizeVisited = (value) => {
       if (!Array.isArray(value)) return [];
       return value
@@ -100,6 +166,13 @@ export function buildOpenDetailScript(params = {}) {
     };
 
     const state = loadState();
+    const actionTrace = [];
+    const pushTrace = (payload) => {
+      actionTrace.push({
+        ts: new Date().toISOString(),
+        ...payload,
+      });
+    };
     if (!Array.isArray(state.visitedNoteIds)) state.visitedNoteIds = [];
     const requestedKeyword = ${JSON.stringify(keyword)};
     const mode = ${JSON.stringify(mode)};
@@ -156,11 +229,23 @@ export function buildOpenDetailScript(params = {}) {
       const maxRounds = Number(${seedCollectMaxRounds});
       const targetCount = Number(${seedCollectCount});
       for (let round = 0; round < maxRounds && seedCollectedSet.size < targetCount; round += 1) {
+        pushTrace({
+          kind: 'scroll',
+          stage: 'seed_collect',
+          round: round + 1,
+          deltaY: Number(${seedCollectStep}),
+        });
         window.scrollBy({ top: Number(${seedCollectStep}), left: 0, behavior: 'auto' });
         await new Promise((resolve) => setTimeout(resolve, Number(${seedCollectSettleMs})));
         collectVisible();
       }
       if (${seedResetToTop ? 'true' : 'false'}) {
+        pushTrace({
+          kind: 'scroll',
+          stage: 'seed_collect',
+          round: 'reset_to_top',
+          toTop: true,
+        });
         window.scrollTo({ top: 0, behavior: 'auto' });
         await new Promise((resolve) => setTimeout(resolve, Number(${seedCollectSettleMs})));
       }
@@ -190,6 +275,12 @@ export function buildOpenDetailScript(params = {}) {
       let stagnantRounds = 0;
       for (let round = 0; !next && round < Number(${nextSeekRounds}); round += 1) {
         const beforeTop = window.scrollY || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        pushTrace({
+          kind: 'scroll',
+          stage: 'seek_next_detail',
+          round: round + 1,
+          deltaY: seekStep,
+        });
         window.scrollBy({ top: seekStep, left: 0, behavior: 'auto' });
         await new Promise((resolve) => setTimeout(resolve, Number(${nextSeekSettleMs})));
         nodes = mapNodes();
@@ -238,9 +329,23 @@ export function buildOpenDetailScript(params = {}) {
       return !searchVisible;
     };
 
+    pushTrace({
+      kind: 'scroll',
+      stage: 'open_detail',
+      noteId: next.noteId,
+      via: 'scrollIntoView',
+    });
     next.cover.scrollIntoView({ behavior: 'auto', block: 'center' });
-    await new Promise((resolve) => setTimeout(resolve, 140));
+    const preClickDelay = randomBetween(${preClickDelayMinMs}, ${preClickDelayMaxMs});
+    pushTrace({ kind: 'wait', stage: 'open_detail_pre_click', noteId: next.noteId, waitMs: preClickDelay });
+    await new Promise((resolve) => setTimeout(resolve, preClickDelay));
     const beforeUrl = window.location.href;
+    pushTrace({
+      kind: 'click',
+      stage: 'open_detail',
+      noteId: next.noteId,
+      selector: 'a.cover',
+    });
     next.cover.click();
 
     let detailReady = false;
@@ -249,12 +354,15 @@ export function buildOpenDetailScript(params = {}) {
         detailReady = true;
         break;
       }
-      await new Promise((resolve) => setTimeout(resolve, 120));
+      const pollDelay = randomBetween(${pollDelayMinMs}, ${pollDelayMaxMs});
+      await new Promise((resolve) => setTimeout(resolve, pollDelay));
     }
     if (!detailReady) {
       throw new Error('DETAIL_OPEN_TIMEOUT');
     }
-    await new Promise((resolve) => setTimeout(resolve, 220));
+    const postOpenDelay = randomBetween(${postOpenDelayMinMs}, ${postOpenDelayMaxMs});
+    pushTrace({ kind: 'wait', stage: 'open_detail_post_open', noteId: next.noteId, waitMs: postOpenDelay });
+    await new Promise((resolve) => setTimeout(resolve, postOpenDelay));
     const afterUrl = window.location.href;
 
     if (!state.visitedNoteIds.includes(next.noteId)) state.visitedNoteIds.push(next.noteId);
@@ -274,6 +382,7 @@ export function buildOpenDetailScript(params = {}) {
       excludedCount: excludedNoteIds.size,
       seedCollectedCount: seedCollectedSet.size,
       seedCollectedNoteIds: Array.from(seedCollectedSet),
+      actionTrace,
     };
   })()`;
 }