@reconcrap/boss-recommend-mcp 2.1.22 → 2.1.24

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

@@ -16,16 +16,25 @@ import {
   sleep
 } from "../../core/browser/index.js";
 import { GREET_CREDITS_EXHAUSTED_CODE } from "../../core/greet-quota/index.js";
-import {
-  compactCvAcquisitionState,
+import {
+  attemptImageCaptureCheckpointResume,
+  compactCvAcquisitionState,
+  createImageCaptureWorkflowRetryTracker,
+  createRequiredImageEvidenceFailure,
+  imageCaptureResumeCheckpoint,
   countParsedNetworkProfiles,
   createCvAcquisitionState,
   DEFAULT_MAX_IMAGE_PAGES,
-  getCvNetworkWaitPlan,
-  recordCvImageFallback,
+  getCvNetworkWaitPlan,
+  isFailedClosedImageAcquisition,
+  isIncompleteImageEvidence,
+  isRecoverableImageCaptureWorkflowError,
+  recordCvImageFallback,
   recordCvNetworkHit,
-  recordCvNetworkMiss,
-  summarizeImageEvidence,
+  recordCvNetworkMiss,
+  reacquireImageCaptureResumeTarget,
+  requireCompleteImageEvidence,
+  summarizeImageEvidence,
   waitForCvNetworkEvents
 } from "../../core/cv-acquisition/index.js";
 import {
@@ -55,22 +64,23 @@ import {
   extractRecommendDetailCandidate,
   isRecommendDetailOpenMissError,
   isStaleRecommendNodeError,
-  openRecommendCardDetailWithFreshRetry,
-  waitForRecommendDetailNetworkEvents
+  openRecommendCardDetailWithFreshRetry,
+  waitForRecommendDetail,
+  waitForRecommendDetailNetworkEvents
 } from "./detail.js";
-import {
-  readRecommendCardCandidate,
-  waitForRecommendCardNodeIds
-} from "./cards.js";
-import { selectAndConfirmFirstSafeFilter } from "./filters.js";
-import { ensureRecommendCurrentCityOnly } from "./location.js";
-import {
-  applyRecommendFilterEnvelopeStages,
-  buildRecommendFilterSelectionOptions,
-  refreshRecommendListAtEnd
-} from "./refresh.js";
-import { selectRecommendJob } from "./jobs.js";
-import {
+import {
+  readRecommendCardCandidate,
+  waitForRecommendCardNodeIds
+} from "./cards.js";
+import { selectAndConfirmFirstSafeFilter } from "./filters.js";
+import { ensureRecommendCurrentCityOnly } from "./location.js";
+import {
+  applyRecommendFilterEnvelopeStages,
+  buildRecommendFilterSelectionOptions,
+  refreshRecommendListAtEnd
+} from "./refresh.js";
+import { selectRecommendJob } from "./jobs.js";
+import {
   normalizeRecommendPageScope,
   selectRecommendPageScope
 } from "./scopes.js";
@@ -90,6 +100,427 @@ import {
 } from "./actions.js";
 import { getRecommendRoots } from "./roots.js";
 
+const RECOMMEND_DEBUG_BOUNDARY_MODES = Object.freeze({
+  list_end: "debug_force_list_end_after_processed",
+  context_recovery: "debug_force_context_recovery_after_processed",
+  cdp_reconnect: "debug_force_cdp_reconnect_after_processed"
+});
+
+function hasOwn(source, key) {
+  return Boolean(source && Object.prototype.hasOwnProperty.call(source, key));
+}
+
+function readDebugBoundaryValue(source, snakeKey, camelKey) {
+  if (hasOwn(source, snakeKey)) return source[snakeKey];
+  if (hasOwn(source, camelKey)) return source[camelKey];
+  return null;
+}
+
+function normalizeDebugBoundaryThreshold(raw, field) {
+  if (raw === undefined || raw === null || raw === "") return null;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    const error = new Error(`${field} must be a positive integer`);
+    error.code = "INVALID_RECOMMEND_DEBUG_BOUNDARY";
+    throw error;
+  }
+  return parsed;
+}
+
+export function normalizeRecommendDebugBoundaryOptions(source = {}) {
+  const debugTestMode = source.debugTestMode === true || source.debug_test_mode === true;
+  const thresholds = {
+    list_end: normalizeDebugBoundaryThreshold(
+      readDebugBoundaryValue(
+        source,
+        RECOMMEND_DEBUG_BOUNDARY_MODES.list_end,
+        "debugForceListEndAfterProcessed"
+      ),
+      RECOMMEND_DEBUG_BOUNDARY_MODES.list_end
+    ),
+    context_recovery: normalizeDebugBoundaryThreshold(
+      readDebugBoundaryValue(
+        source,
+        RECOMMEND_DEBUG_BOUNDARY_MODES.context_recovery,
+        "debugForceContextRecoveryAfterProcessed"
+      ),
+      RECOMMEND_DEBUG_BOUNDARY_MODES.context_recovery
+    ),
+    cdp_reconnect: normalizeDebugBoundaryThreshold(
+      readDebugBoundaryValue(
+        source,
+        RECOMMEND_DEBUG_BOUNDARY_MODES.cdp_reconnect,
+        "debugForceCdpReconnectAfterProcessed"
+      ),
+      RECOMMEND_DEBUG_BOUNDARY_MODES.cdp_reconnect
+    )
+  };
+  const configured = Object.entries(thresholds).filter(([, threshold]) => threshold !== null);
+  if (configured.length > 1) {
+    const error = new Error(
+      `${configured.map(([mode]) => RECOMMEND_DEBUG_BOUNDARY_MODES[mode]).join(", ")} are mutually exclusive`
+    );
+    error.code = "RECOMMEND_DEBUG_BOUNDARIES_MUTUALLY_EXCLUSIVE";
+    throw error;
+  }
+  if (configured.length && !debugTestMode) {
+    const error = new Error(
+      `${RECOMMEND_DEBUG_BOUNDARY_MODES[configured[0][0]]} requires debug_test_mode=true`
+    );
+    error.code = "DEBUG_TEST_MODE_REQUIRED";
+    throw error;
+  }
+  const [configuredEntry = null] = configured;
+  return {
+    debugTestMode,
+    mode: configuredEntry?.[0] || null,
+    field: configuredEntry ? RECOMMEND_DEBUG_BOUNDARY_MODES[configuredEntry[0]] : null,
+    threshold: configuredEntry?.[1] ?? null,
+    debugForceListEndAfterProcessed: thresholds.list_end,
+    debugForceContextRecoveryAfterProcessed: thresholds.context_recovery,
+    debugForceCdpReconnectAfterProcessed: thresholds.cdp_reconnect
+  };
+}
+
+export function createRecommendDebugBoundaryController(source = {}) {
+  const config = normalizeRecommendDebugBoundaryOptions(source);
+  let triggered = false;
+  let triggerCount = 0;
+  return {
+    config,
+    take(processedCount) {
+      const processed = Math.max(0, Number(processedCount) || 0);
+      if (triggered || !config.mode || processed < config.threshold) return null;
+      triggered = true;
+      triggerCount += 1;
+      return {
+        mode: config.mode,
+        field: config.field,
+        threshold: config.threshold,
+        processed,
+        trigger_count: triggerCount
+      };
+    },
+    getState() {
+      return {
+        ...config,
+        triggered,
+        trigger_count: triggerCount
+      };
+    }
+  };
+}
+
+function readErrorChainField(error, key) {
+  const seen = new Set();
+  let current = error;
+  for (let depth = 0; current && depth < 6; depth += 1) {
+    if ((typeof current === "object" || typeof current === "function") && seen.has(current)) break;
+    if (typeof current === "object" || typeof current === "function") seen.add(current);
+    if (current?.[key] !== undefined && current?.[key] !== null) return current[key];
+    current = current?.cause || null;
+  }
+  return undefined;
+}
+
+function compactCdpFailureDiagnostic(error, {
+  fallbackCode = "RECOMMEND_DOM_STALE",
+  fallbackPhase = ""
+} = {}) {
+  const message = String(readErrorChainField(error, "message") || error || "DOM node became stale");
+  const diagnostic = {
+    name: String(readErrorChainField(error, "name") || "Error").slice(0, 100),
+    code: String(readErrorChainField(error, "code") || fallbackCode).slice(0, 160),
+    message: message.slice(0, 500),
+    phase: String(readErrorChainField(error, "phase") || fallbackPhase || "").slice(0, 200) || null,
+    cdp_method: String(readErrorChainField(error, "cdp_method") || "").slice(0, 200) || null,
+    cdp_at: String(readErrorChainField(error, "cdp_at") || "").slice(0, 100) || null,
+    cdp_search_id: String(readErrorChainField(error, "cdp_search_id") || "").slice(0, 200) || null,
+    cdp_replay_policy: String(readErrorChainField(error, "cdp_replay_policy") || "").slice(0, 100) || null,
+    cdp_reconnect_error: String(readErrorChainField(error, "cdp_reconnect_error") || "").slice(0, 300) || null
+  };
+  for (const key of [
+    "cdp_node_id",
+    "cdp_backend_node_id",
+    "cdp_connection_epoch",
+    "cdp_reconnected_epoch"
+  ]) {
+    const value = Number(readErrorChainField(error, key));
+    diagnostic[key] = Number.isInteger(value) && value >= 0 ? value : null;
+  }
+  for (const key of [
+    "cdp_reconnected",
+    "cdp_replayed_after_reconnect",
+    "cdp_replay_suppressed",
+    "cdp_outcome_unknown"
+  ]) {
+    const value = readErrorChainField(error, key);
+    diagnostic[key] = typeof value === "boolean" ? value : null;
+  }
+  const paramKeys = readErrorChainField(error, "cdp_param_keys");
+  diagnostic.cdp_param_keys = Array.isArray(paramKeys)
+    ? paramKeys
+      .map((key) => String(key || "").trim())
+      .filter((key) => /^[A-Za-z][A-Za-z0-9_]*$/.test(key))
+      .slice(0, 20)
+    : [];
+  return diagnostic;
+}
+
+export function compactRecommendDomRootIdentity(rootState = null, connectionEpoch = null) {
+  const epoch = Number(connectionEpoch);
+  const topNodeId = Number(rootState?.rootNodes?.top || rootState?.topRoot?.nodeId || 0);
+  const frameOwnerNodeId = Number(rootState?.rootNodes?.frameOwner || rootState?.iframe?.nodeId || 0);
+  const frameDocumentNodeId = Number(
+    rootState?.rootNodes?.frame || rootState?.iframe?.documentNodeId || 0
+  );
+  return {
+    connection_epoch: Number.isInteger(epoch) && epoch > 0 ? epoch : null,
+    top_document_node_id: Number.isInteger(topNodeId) && topNodeId > 0 ? topNodeId : null,
+    iframe_owner_node_id: Number.isInteger(frameOwnerNodeId) && frameOwnerNodeId > 0
+      ? frameOwnerNodeId
+      : null,
+    iframe_document_node_id: Number.isInteger(frameDocumentNodeId) && frameDocumentNodeId > 0
+      ? frameDocumentNodeId
+      : null,
+    iframe_selector: String(rootState?.iframe?.selector || "").slice(0, 300) || null
+  };
+}
+
+function latestInfiniteListReadError(listState = null) {
+  const ledger = Array.isArray(listState?.ledger) ? listState.ledger : [];
+  for (let index = ledger.length - 1; index >= 0; index -= 1) {
+    const item = ledger[index];
+    if (item?.event !== "candidate_read_error") continue;
+    return {
+      at: item.at || null,
+      node_id: Number.isInteger(item.node_id) ? item.node_id : null,
+      visible_index: Number.isInteger(item.visible_index) ? item.visible_index : null,
+      error: String(item.error || "").slice(0, 500) || null
+    };
+  }
+  return null;
+}
+
+export function createRecommendDomStaleForensicEvent(error, {
+  eventId = "",
+  phase = "",
+  operation = "",
+  detailStep = "",
+  candidateIndex = null,
+  candidateKey = "",
+  cardNodeId = null,
+  rootState = null,
+  connectionEpoch = null,
+  listState = null,
+  counters = null,
+  timeline = []
+} = {}) {
+  const at = new Date().toISOString();
+  const listReadError = latestInfiniteListReadError(listState);
+  return {
+    schema_version: 1,
+    event_id: String(eventId || `recommend_dom_stale_${Date.now()}`).slice(0, 160),
+    event_type: "dom_stale",
+    at,
+    phase: String(phase || "").slice(0, 200) || null,
+    operation: String(operation || "").slice(0, 200) || null,
+    detail_step: String(detailStep || "").slice(0, 200) || null,
+    candidate: {
+      index: Number.isInteger(candidateIndex) && candidateIndex >= 0 ? candidateIndex : null,
+      key: String(candidateKey || "").slice(0, 300) || null,
+      card_node_id: Number.isInteger(cardNodeId) && cardNodeId > 0 ? cardNodeId : null,
+      visible_index: listReadError?.visible_index ?? null,
+      failing_list_node_id: listReadError?.node_id ?? null
+    },
+    error: compactCdpFailureDiagnostic(error, {
+      fallbackCode: "RECOMMEND_DOM_STALE",
+      fallbackPhase: phase
+    }),
+    pre_recovery_roots: compactRecommendDomRootIdentity(rootState, connectionEpoch),
+    candidate_list: compactInfiniteListState(listState || {}),
+    counters: counters && typeof counters === "object" ? counters : null,
+    lifecycle_timeline: Array.isArray(timeline) ? timeline.slice(-20) : []
+  };
+}
+
+function compactListReadStaleDiagnostic(error, {
+  attempt = 0,
+  exhausted = false
+} = {}) {
+  const cdp = compactCdpFailureDiagnostic(error, {
+    fallbackCode: "RECOMMEND_LIST_READ_STALE_NODE",
+    fallbackPhase: "recommend:list-read"
+  });
+  return {
+    ...cdp,
+    code: error?.code || cdp.code || "RECOMMEND_LIST_READ_STALE_NODE",
+    message: String(error?.message || cdp.message || error || "Stale recommend list node").slice(0, 500),
+    phase: "recommend:list-read",
+    attempt,
+    exhausted: Boolean(exhausted),
+    at: new Date().toISOString()
+  };
+}
+
+function annotateListReadStaleFailure(error, diagnostics, {
+  exhausted = false,
+  recoveryFailed = false
+} = {}) {
+  if (!error || typeof error !== "object") return error;
+  error.phase = error.phase || "recommend:list-read";
+  error.list_read_stale_recovery_attempts = diagnostics;
+  if (exhausted) error.list_read_stale_recovery_exhausted = true;
+  if (recoveryFailed) error.list_read_stale_recovery_failed = true;
+  return error;
+}
+
+export async function acquireRecommendListReadWithStaleRecovery({
+  acquire,
+  recover,
+  maxRetries = 2,
+  onStale = null,
+  onRecoveryApplied = null,
+  onRecovered = null,
+  onExhausted = null
+} = {}) {
+  if (typeof acquire !== "function") {
+    throw new Error("acquireRecommendListReadWithStaleRecovery requires acquire");
+  }
+  if (typeof recover !== "function") {
+    throw new Error("acquireRecommendListReadWithStaleRecovery requires recover");
+  }
+  const retryLimit = Math.max(0, Number.isInteger(maxRetries) ? maxRetries : 2);
+  const diagnostics = [];
+  let acquireAttempt = 0;
+  let pendingRecoveryDiagnostic = null;
+  while (true) {
+    acquireAttempt += 1;
+    try {
+      const result = await acquire({
+        acquireAttempt,
+        recoveryCount: diagnostics.filter((item) => item.recovered === true).length
+      });
+      if (pendingRecoveryDiagnostic) {
+        pendingRecoveryDiagnostic.recovered = true;
+        pendingRecoveryDiagnostic.recovered_at = new Date().toISOString();
+        if (typeof onRecovered === "function") {
+          await onRecovered({
+            diagnostic: pendingRecoveryDiagnostic,
+            diagnostics: diagnostics.slice()
+          });
+        }
+        pendingRecoveryDiagnostic = null;
+      }
+      return {
+        result,
+        acquire_attempts: acquireAttempt,
+        stale_diagnostics: diagnostics
+      };
+    } catch (error) {
+      if (!isStaleRecommendNodeError(error)) throw error;
+      pendingRecoveryDiagnostic = null;
+      const staleAttempt = diagnostics.length + 1;
+      const exhausted = staleAttempt > retryLimit;
+      const diagnostic = compactListReadStaleDiagnostic(error, {
+        attempt: staleAttempt,
+        exhausted
+      });
+      diagnostics.push(diagnostic);
+      if (exhausted) {
+        if (typeof onExhausted === "function") {
+          await onExhausted({ error, diagnostic, diagnostics: diagnostics.slice() });
+        }
+        throw annotateListReadStaleFailure(error, diagnostics, { exhausted: true });
+      }
+      if (typeof onStale === "function") {
+        await onStale({ error, diagnostic, diagnostics: diagnostics.slice() });
+      }
+      let recoveryResult = null;
+      try {
+        recoveryResult = await recover({ error, diagnostic, diagnostics: diagnostics.slice() });
+      } catch (recoveryError) {
+        if (recoveryError && typeof recoveryError === "object" && !recoveryError.cause) {
+          recoveryError.cause = error;
+        }
+        throw annotateListReadStaleFailure(recoveryError, diagnostics, {
+          recoveryFailed: true
+        });
+      }
+      diagnostic.recovery_applied = true;
+      diagnostic.recovery_mode = recoveryResult?.recovery_mode || "unknown";
+      diagnostic.recovery_applied_at = new Date().toISOString();
+      pendingRecoveryDiagnostic = diagnostic;
+      if (typeof onRecoveryApplied === "function") {
+        await onRecoveryApplied({
+          error,
+          diagnostic,
+          recoveryResult,
+          diagnostics: diagnostics.slice()
+        });
+      }
+    }
+  }
+}
+
+export async function recoverRecommendListReadStaleContext({
+  staleAttempt = 1,
+  listState,
+  rootReacquire,
+  contextReapply
+} = {}) {
+  if (typeof rootReacquire !== "function") {
+    throw new Error("recoverRecommendListReadStaleContext requires rootReacquire");
+  }
+  if (typeof contextReapply !== "function") {
+    throw new Error("recoverRecommendListReadStaleContext requires contextReapply");
+  }
+  const processedKeys = new Set(listState?.processed_keys || []);
+  try {
+    if (Number(staleAttempt) <= 1) {
+      try {
+        const rootResult = await rootReacquire();
+        if (Number(rootResult?.card_count) <= 0) {
+          const noCardsError = new Error("Recommend list root reacquire returned no candidate cards");
+          noCardsError.code = "RECOMMEND_LIST_ROOT_REACQUIRE_NO_CARDS";
+          throw noCardsError;
+        }
+        resetInfiniteListForRefreshRound(listState, {
+          reason: "list_read_stale_node_root_reacquire",
+          round: 1,
+          method: "root_reacquire",
+          metadata: {
+            card_count: Number(rootResult?.card_count) || 0,
+            processed_count: processedKeys.size
+          }
+        });
+        return {
+          recovery_mode: "root_reacquire",
+          root_reacquire: rootResult || null
+        };
+      } catch (rootReacquireError) {
+        const contextResult = await contextReapply({ rootReacquireError });
+        return {
+          recovery_mode: "context_reapply",
+          escalated_from: "root_reacquire",
+          root_reacquire_error: compactListReadStaleDiagnostic(rootReacquireError, {
+            attempt: 1
+          }),
+          context_reapply: contextResult || null
+        };
+      }
+    }
+    const contextResult = await contextReapply({ rootReacquireError: null });
+    return {
+      recovery_mode: "context_reapply",
+      escalated_from: "repeated_stale",
+      context_reapply: contextResult || null
+    };
+  } finally {
+    for (const key of processedKeys) listState?.processed_keys?.add(key);
+  }
+}
+
 function normalizeLabels(labels = []) {
   return labels.map((label) => String(label || "").trim()).filter(Boolean);
 }
@@ -106,46 +537,46 @@ function isRefreshableListStall(reason = "") {
 function normalizeFilter(filter = {}) {
   const filterGroups = Array.isArray(filter.filterGroups)
     ? filter.filterGroups
-    : Array.isArray(filter.groups)
-      ? filter.groups
-      : [];
-  return {
-    enabled: filter.enabled !== false,
-    currentCityOnly: filter.currentCityOnly === true || filter.current_city_only === true,
-    group: String(filter.group || ""),
-    labels: normalizeLabels(filter.labels || filter.filterLabels || []),
-    selectAllLabels: Boolean(filter.selectAllLabels),
-    allowUnlimited: filter.allowUnlimited === true,
-    verifySticky: filter.verifySticky === true,
-    filterGroups: filterGroups.map((group) => ({
-      group: String(group?.group || ""),
-      labels: normalizeLabels(group?.labels || group?.filterLabels || []),
-      selectAllLabels: group?.selectAllLabels !== false,
-      allowUnlimited: group?.allowUnlimited === true,
-      verifySticky: group?.verifySticky === true
-    })).filter((group) => group.group || group.labels.length)
-  };
-}
-
-export function compactFilterResult(filterResult) {
-  if (!filterResult) return null;
-  return {
-    opened_panel: Boolean(filterResult.opened_panel),
-    requested_groups: (filterResult.requested_groups || []).map((group) => ({
-      group: group.group,
-      labels: group.labels || [],
-      select_all_labels: group.select_all_labels !== false,
-      allow_unlimited: Boolean(group.allow_unlimited),
-      verify_sticky: Boolean(group.verify_sticky)
-    })),
-    effective_groups: (filterResult.sticky_verification?.groups || []).map((group) => ({
-      group: group.group,
-      requested_labels: group.requested_labels || [],
-      active_labels: group.active_labels || [],
-      verified: Boolean(group.verified),
-      unavailable: Boolean(group.unavailable),
-      reason: group.reason || null
-    })),
+    : Array.isArray(filter.groups)
+      ? filter.groups
+      : [];
+  return {
+    enabled: filter.enabled !== false,
+    currentCityOnly: filter.currentCityOnly === true || filter.current_city_only === true,
+    group: String(filter.group || ""),
+    labels: normalizeLabels(filter.labels || filter.filterLabels || []),
+    selectAllLabels: Boolean(filter.selectAllLabels),
+    allowUnlimited: filter.allowUnlimited === true,
+    verifySticky: filter.verifySticky === true,
+    filterGroups: filterGroups.map((group) => ({
+      group: String(group?.group || ""),
+      labels: normalizeLabels(group?.labels || group?.filterLabels || []),
+      selectAllLabels: group?.selectAllLabels !== false,
+      allowUnlimited: group?.allowUnlimited === true,
+      verifySticky: group?.verifySticky === true
+    })).filter((group) => group.group || group.labels.length)
+  };
+}
+
+export function compactFilterResult(filterResult) {
+  if (!filterResult) return null;
+  return {
+    opened_panel: Boolean(filterResult.opened_panel),
+    requested_groups: (filterResult.requested_groups || []).map((group) => ({
+      group: group.group,
+      labels: group.labels || [],
+      select_all_labels: group.select_all_labels !== false,
+      allow_unlimited: Boolean(group.allow_unlimited),
+      verify_sticky: Boolean(group.verify_sticky)
+    })),
+    effective_groups: (filterResult.sticky_verification?.groups || []).map((group) => ({
+      group: group.group,
+      requested_labels: group.requested_labels || [],
+      active_labels: group.active_labels || [],
+      verified: Boolean(group.verified),
+      unavailable: Boolean(group.unavailable),
+      reason: group.reason || null
+    })),
     selected_option: filterResult.selected_option
       ? {
           group: filterResult.selected_option.group,
@@ -155,71 +586,71 @@ export function compactFilterResult(filterResult) {
         }
       : null,
     selected_options: (filterResult.selected_options || []).map((option) => ({
-      group: option.group,
-      label: option.label,
-      was_active: Boolean(option.was_active),
-      clicked: option.clicked !== false
-    })),
-    unavailable: Boolean(filterResult.unavailable),
-    unavailable_groups: filterResult.unavailable_groups || [],
-    confirmed: Boolean(filterResult.confirmed),
-    sticky_verification: filterResult.sticky_verification || null,
-    attempts: {
-      initial_close: filterResult.initial_close_attempts || [],
-      open: (filterResult.open_attempts || []).map((attempt) => ({
-        selector: attempt.selector || null,
-        node_id: attempt.node_id || null,
-        click_target: attempt.click_target || null
-      })),
-      confirmation: (filterResult.confirm_attempts || []).map((attempt) => ({
-        node_id: attempt.node_id || null,
-        label: attempt.label || null,
-        clicked: Boolean(attempt.clicked),
-        errors: (attempt.errors || []).map((error) => ({
-          node_id: error.node_id || null,
-          message: error.message || String(error)
-        }))
-      }))
-    },
-    before_counts: filterResult.before_counts,
-    after_confirm_counts: filterResult.after_confirm_counts
-  };
-}
-
-function compactCurrentCityOnlyResult(result) {
-  if (!result) return null;
-  return {
-    requested: Boolean(result.requested),
-    effective: typeof result.effective === "boolean" ? result.effective : null,
-    available: result.available !== false,
-    unavailable: Boolean(result.unavailable),
-    reason: result.reason || null,
-    clicked: Boolean(result.clicked),
-    current_city_label: result.current_city_label || null,
-    before: result.before || null,
-    after_toggle: result.after_toggle || null,
-    confirmation: result.confirmation || null,
-    sticky_verification: result.sticky_verification
-      ? {
-          verified: Boolean(result.sticky_verification.verified),
-          expected: Boolean(result.sticky_verification.expected),
-          actual: typeof result.sticky_verification.actual === "boolean"
-            ? result.sticky_verification.actual
-            : null,
-          state_source: result.sticky_verification.state_source || null,
-          close_confirmation: result.sticky_verification.close_confirmation || null
-        }
-      : null,
-    attempts: Array.isArray(result.attempts) ? result.attempts : [],
-    evidence: result.evidence || null
-  };
-}
-
-function compactJobSelection(jobSelection) {
-  if (!jobSelection) return null;
-  return {
-    requested: jobSelection.requested || "",
-    selected: Boolean(jobSelection.selected),
+      group: option.group,
+      label: option.label,
+      was_active: Boolean(option.was_active),
+      clicked: option.clicked !== false
+    })),
+    unavailable: Boolean(filterResult.unavailable),
+    unavailable_groups: filterResult.unavailable_groups || [],
+    confirmed: Boolean(filterResult.confirmed),
+    sticky_verification: filterResult.sticky_verification || null,
+    attempts: {
+      initial_close: filterResult.initial_close_attempts || [],
+      open: (filterResult.open_attempts || []).map((attempt) => ({
+        selector: attempt.selector || null,
+        node_id: attempt.node_id || null,
+        click_target: attempt.click_target || null
+      })),
+      confirmation: (filterResult.confirm_attempts || []).map((attempt) => ({
+        node_id: attempt.node_id || null,
+        label: attempt.label || null,
+        clicked: Boolean(attempt.clicked),
+        errors: (attempt.errors || []).map((error) => ({
+          node_id: error.node_id || null,
+          message: error.message || String(error)
+        }))
+      }))
+    },
+    before_counts: filterResult.before_counts,
+    after_confirm_counts: filterResult.after_confirm_counts
+  };
+}
+
+function compactCurrentCityOnlyResult(result) {
+  if (!result) return null;
+  return {
+    requested: Boolean(result.requested),
+    effective: typeof result.effective === "boolean" ? result.effective : null,
+    available: result.available !== false,
+    unavailable: Boolean(result.unavailable),
+    reason: result.reason || null,
+    clicked: Boolean(result.clicked),
+    current_city_label: result.current_city_label || null,
+    before: result.before || null,
+    after_toggle: result.after_toggle || null,
+    confirmation: result.confirmation || null,
+    sticky_verification: result.sticky_verification
+      ? {
+          verified: Boolean(result.sticky_verification.verified),
+          expected: Boolean(result.sticky_verification.expected),
+          actual: typeof result.sticky_verification.actual === "boolean"
+            ? result.sticky_verification.actual
+            : null,
+          state_source: result.sticky_verification.state_source || null,
+          close_confirmation: result.sticky_verification.close_confirmation || null
+        }
+      : null,
+    attempts: Array.isArray(result.attempts) ? result.attempts : [],
+    evidence: result.evidence || null
+  };
+}
+
+function compactJobSelection(jobSelection) {
+  if (!jobSelection) return null;
+  return {
+    requested: jobSelection.requested || "",
+    selected: Boolean(jobSelection.selected),
     already_current: Boolean(jobSelection.already_current),
     reason: jobSelection.reason || null,
     selected_option: jobSelection.selected_option || null,
@@ -454,6 +885,7 @@ function compactRefreshAttempt(refreshAttempt) {
     method: refreshAttempt.method || "",
     reason: refreshAttempt.reason || null,
     error: refreshAttempt.error || null,
+    error_diagnostic: refreshAttempt.error_diagnostic || null,
     forced_recent_not_view: Boolean(refreshAttempt.forced_recent_not_view),
     target_url: refreshAttempt.target_url || null,
     card_count: refreshAttempt.card_count || 0,
@@ -470,36 +902,40 @@ function compactRefreshAttempt(refreshAttempt) {
       ok: Boolean(attempt.ok),
       method: attempt.method || "",
       reason: attempt.reason || null,
-      error: attempt.error || null,
-      label: attempt.label || null,
-      before_card_count: attempt.before_card_count || 0,
-      after_card_count: attempt.after_card_count || 0,
-      card_count: attempt.card_count || 0,
-      elapsed_ms: attempt.elapsed_ms || 0,
-      current_city_only: compactCurrentCityOnlyResult(attempt.current_city_only),
-      current_city_only_attempts: (attempt.current_city_only_attempts || []).map((cityAttempt) => ({
-        ok: Boolean(cityAttempt.ok),
-        method: cityAttempt.method || "current_city_only_reapply",
-        reason: cityAttempt.reason || null,
-        error: cityAttempt.error || null,
-        attempt: cityAttempt.attempt || 0,
-        result: compactCurrentCityOnlyResult(cityAttempt.result)
-      })),
-      filter: compactFilterResult(attempt.filter)
-    })),
-    current_city_only_attempts: (refreshAttempt.current_city_only_attempts || []).map((attempt) => ({
-      ok: Boolean(attempt.ok),
-      method: attempt.method || "current_city_only_reapply",
-      reason: attempt.reason || null,
-      error: attempt.error || null,
-      attempt: attempt.attempt || 0,
-      result: compactCurrentCityOnlyResult(attempt.result)
-    })),
-    filter_reapply_attempts: (refreshAttempt.filter_reapply_attempts || []).map((attempt) => ({
-      ok: Boolean(attempt.ok),
-      method: attempt.method || "filter_reapply",
-      reason: attempt.reason || null,
       error: attempt.error || null,
+      error_diagnostic: attempt.error_diagnostic || null,
+      label: attempt.label || null,
+      before_card_count: attempt.before_card_count || 0,
+      after_card_count: attempt.after_card_count || 0,
+      card_count: attempt.card_count || 0,
+      elapsed_ms: attempt.elapsed_ms || 0,
+      current_city_only: compactCurrentCityOnlyResult(attempt.current_city_only),
+      current_city_only_attempts: (attempt.current_city_only_attempts || []).map((cityAttempt) => ({
+        ok: Boolean(cityAttempt.ok),
+        method: cityAttempt.method || "current_city_only_reapply",
+        reason: cityAttempt.reason || null,
+        error: cityAttempt.error || null,
+        error_diagnostic: cityAttempt.error_diagnostic || null,
+        attempt: cityAttempt.attempt || 0,
+        result: compactCurrentCityOnlyResult(cityAttempt.result)
+      })),
+      filter: compactFilterResult(attempt.filter)
+    })),
+    current_city_only_attempts: (refreshAttempt.current_city_only_attempts || []).map((attempt) => ({
+      ok: Boolean(attempt.ok),
+      method: attempt.method || "current_city_only_reapply",
+      reason: attempt.reason || null,
+      error: attempt.error || null,
+      error_diagnostic: attempt.error_diagnostic || null,
+      attempt: attempt.attempt || 0,
+      result: compactCurrentCityOnlyResult(attempt.result)
+    })),
+    filter_reapply_attempts: (refreshAttempt.filter_reapply_attempts || []).map((attempt) => ({
+      ok: Boolean(attempt.ok),
+      method: attempt.method || "filter_reapply",
+      reason: attempt.reason || null,
+      error: attempt.error || null,
+      error_diagnostic: attempt.error_diagnostic || null,
       attempt: attempt.attempt || 0
     })),
     job_selection_attempts: (refreshAttempt.job_selection_attempts || []).map((attempt) => ({
@@ -507,19 +943,20 @@ function compactRefreshAttempt(refreshAttempt) {
       method: attempt.method || "job_select",
       reason: attempt.reason || null,
       error: attempt.error || null,
+      error_diagnostic: attempt.error_diagnostic || null,
       attempt: attempt.attempt || 0,
       iframe_document_node_id: attempt.iframe_document_node_id || 0,
-      selected: Boolean(attempt.selected),
-      selection_reason: attempt.selection_reason || null
-    })),
-    job_selection: compactJobSelection(refreshAttempt.job_selection),
-    page_scope: compactPageScopeSelection(refreshAttempt.page_scope),
-    current_city_only: compactCurrentCityOnlyResult(refreshAttempt.current_city_only),
-    filter: compactFilterResult(refreshAttempt.filter)
-  };
-}
-
-export function countRecommendResultStatuses(results = [], {
+      selected: Boolean(attempt.selected),
+      selection_reason: attempt.selection_reason || null
+    })),
+    job_selection: compactJobSelection(refreshAttempt.job_selection),
+    page_scope: compactPageScopeSelection(refreshAttempt.page_scope),
+    current_city_only: compactCurrentCityOnlyResult(refreshAttempt.current_city_only),
+    filter: compactFilterResult(refreshAttempt.filter)
+  };
+}
+
+export function countRecommendResultStatuses(results = [], {
   greetCount = 0
 } = {}) {
   return {
@@ -573,12 +1010,16 @@ function compactCloseResult(closeResult) {
   return result;
 }
 
-function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
-  if (!error) return null;
-  const result = {
-    code: error.code || fallbackCode,
-    message: error.message || String(error)
-  };
+function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
+  if (!error) return null;
+  const cdpDiagnostic = compactCdpFailureDiagnostic(error, {
+    fallbackCode,
+    fallbackPhase: error?.phase || ""
+  });
+  const result = {
+    code: error.code || fallbackCode,
+    message: error.message || String(error)
+  };
   if (error.close_result) {
     result.close_result = compactCloseResult(error.close_result);
   }
@@ -588,6 +1029,15 @@ function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
   if (error.refresh_attempt) {
     result.refresh_attempt = error.refresh_attempt;
   }
+  if (error.error_diagnostic) {
+    result.error_diagnostic = error.error_diagnostic;
+  } else if (
+    cdpDiagnostic.cdp_method
+    || cdpDiagnostic.cdp_connection_epoch !== null
+    || cdpDiagnostic.cdp_node_id !== null
+  ) {
+    result.error_diagnostic = cdpDiagnostic;
+  }
   if (error.list_end_reason) {
     result.list_end_reason = error.list_end_reason;
   }
@@ -628,7 +1078,45 @@ function createRecommendBlockingPanelCloseFailureError(closeResult, phase = "")
   return error;
 }
 
-function createRecommendRefreshFailureError(refreshAttempt, {
+function findRecommendRefreshErrorDiagnostic(refreshAttempt) {
+  if (!refreshAttempt || typeof refreshAttempt !== "object") return null;
+  if (refreshAttempt.error_diagnostic) return refreshAttempt.error_diagnostic;
+  const candidates = [
+    ...(refreshAttempt.attempts || []),
+    ...(refreshAttempt.current_city_only_attempts || []),
+    ...(refreshAttempt.filter_reapply_attempts || []),
+    ...(refreshAttempt.job_selection_attempts || [])
+  ].reverse();
+  for (const attempt of candidates) {
+    if (attempt?.error_diagnostic) return attempt.error_diagnostic;
+    const nestedCityAttempts = (attempt?.current_city_only_attempts || []).slice().reverse();
+    for (const cityAttempt of nestedCityAttempts) {
+      if (cityAttempt?.error_diagnostic) return cityAttempt.error_diagnostic;
+    }
+  }
+  return null;
+}
+
+function attachRecommendRefreshErrorDiagnostic(error, refreshAttempt) {
+  const diagnostic = findRecommendRefreshErrorDiagnostic(refreshAttempt);
+  if (!error || !diagnostic) return error;
+  error.error_diagnostic = diagnostic;
+  for (const key of [
+    "cdp_method",
+    "cdp_at",
+    "cdp_node_id",
+    "cdp_backend_node_id",
+    "cdp_search_id",
+    "cdp_param_keys"
+  ]) {
+    if (diagnostic[key] !== undefined && error[key] === undefined) {
+      error[key] = diagnostic[key];
+    }
+  }
+  return error;
+}
+
+export function createRecommendRefreshFailureError(refreshAttempt, {
   listEndReason = "",
   targetCount = 0,
   passedCount = 0
@@ -641,15 +1129,21 @@ function createRecommendRefreshFailureError(refreshAttempt, {
   error.list_end_reason = listEndReason || null;
   error.target_count = targetCount;
   error.passed_count = passedCount;
-  return error;
+  return attachRecommendRefreshErrorDiagnostic(error, refreshAttempt);
 }
 
-export function isRecoverableImageCaptureError(error) {
-  const code = String(error?.code || "");
-  if (code === "IMAGE_CAPTURE_TIMEOUT" || code === "IMAGE_CAPTURE_TOTAL_TIMEOUT") return true;
-  if (isStaleRecommendNodeError(error)) return true;
-  return /Image fallback capture timed out/i.test(String(error?.message || error || ""));
-}
+export function isRecoverableImageCaptureError(error) {
+  if (isRecoverableImageCaptureWorkflowError(error)) return true;
+  if (isStaleRecommendNodeError(error)) return true;
+  return /Image fallback capture timed out/i.test(String(error?.message || error || ""));
+}
+
+export function shouldFailClosedRecommendImageAcquisition(detailResult = null) {
+  return isFailedClosedImageAcquisition({
+    source: detailResult?.cv_acquisition?.source,
+    imageEvidence: detailResult?.image_evidence
+  });
+}
 
 function collectPartialImageEvidencePaths(basePath = "", extension = "jpg", maxCount = 12) {
   const resolved = String(basePath || "").trim();
@@ -781,9 +1275,19 @@ export async function runRecommendWorkflow({
   humanRestEnabled = false,
   humanBehavior = null,
   skipRecentColleagueContacted = true,
-  colleagueContactWindowDays = 14
+  colleagueContactWindowDays = 14,
+  debugTestMode = false,
+  debugForceListEndAfterProcessed = null,
+  debugForceContextRecoveryAfterProcessed = null,
+  debugForceCdpReconnectAfterProcessed = null
 } = {}, runControl) {
   if (!client) throw new Error("runRecommendWorkflow requires a guarded CDP client");
+  const debugBoundary = createRecommendDebugBoundaryController({
+    debugTestMode,
+    debugForceListEndAfterProcessed,
+    debugForceContextRecoveryAfterProcessed,
+    debugForceCdpReconnectAfterProcessed
+  });
   const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
     legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
   });
@@ -837,25 +1341,164 @@ export async function runRecommendWorkflow({
   const results = [];
   const refreshAttempts = [];
   let refreshRounds = 0;
-  let contextRecoveryAttempts = 0;
+  let contextRecoveryAttempts = 0;
   let greetCount = 0;
   const candidateRecoveryCounts = new Map();
-  let jobSelection = null;
-  let pageScopeSelection = null;
-  let currentCityOnlyResult = null;
-  let filterResult = null;
-  let rootState = null;
-  let cardNodeIds = [];
-  let listEndReason = "";
-  let lastHumanEvent = null;
-  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+  const imageCaptureWorkflowRetries = createImageCaptureWorkflowRetryTracker();
+  let jobSelection = null;
+  let pageScopeSelection = null;
+  let currentCityOnlyResult = null;
+  let filterResult = null;
+  let rootState = null;
+  let cardNodeIds = [];
+  let listEndReason = "";
+  let lastHumanEvent = null;
+  let debugForceReconnectPending = null;
+  let listReadStaleRecoveryAttempts = 0;
+  let listReadStaleRecoveryApplied = 0;
+  let listReadStaleRecoveries = 0;
+  let lastListReadStaleDiagnostic = null;
+  let lastListReadRecoveryMode = null;
+  const listReadStaleDiagnostics = [];
+  let domStaleEventCount = 0;
+  let currentDomOperation = "recommend:initialize";
+  const domLifecycleTimeline = [];
+  const domStaleForensics = [];
+  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
-  }));
+    validateViewportPoint: true
+  }));
+
+  function currentConnectionEpoch() {
+    const epoch = Number(client?.__connectionEpoch);
+    return Number.isInteger(epoch) && epoch > 0 ? epoch : null;
+  }
+
+  function compactLifecycleUrl(value = "") {
+    const text = String(value || "").trim();
+    if (!text) return null;
+    try {
+      const parsed = new URL(text);
+      return `${parsed.origin}${parsed.pathname}`.slice(0, 500);
+    } catch {
+      return text.split(/[?#]/, 1)[0].slice(0, 500) || null;
+    }
+  }
+
+  function recordDomLifecycleEvent(type, payload = {}) {
+    const frame = payload?.frame || payload || {};
+    const event = {
+      at: new Date().toISOString(),
+      type: String(type || "unknown").slice(0, 100),
+      operation: currentDomOperation,
+      connection_epoch: currentConnectionEpoch(),
+      frame_id: String(frame?.id || payload?.frameId || "").slice(0, 200) || null,
+      parent_frame_id: String(frame?.parentId || "").slice(0, 200) || null,
+      loader_id: String(frame?.loaderId || "").slice(0, 200) || null,
+      url: compactLifecycleUrl(frame?.url || "")
+    };
+    domLifecycleTimeline.push(event);
+    if (domLifecycleTimeline.length > 40) domLifecycleTimeline.splice(0, domLifecycleTimeline.length - 40);
+    return event;
+  }
+
+  function subscribeDomLifecycleEvents() {
+    const subscriptions = [
+      [client?.DOM, "documentUpdated", "DOM.documentUpdated"],
+      [client?.Page, "frameNavigated", "Page.frameNavigated"],
+      [client?.Page, "frameDetached", "Page.frameDetached"],
+      [client?.Page, "frameStartedLoading", "Page.frameStartedLoading"],
+      [client?.Page, "frameStoppedLoading", "Page.frameStoppedLoading"]
+    ];
+    for (const [domain, eventName, label] of subscriptions) {
+      if (typeof domain?.[eventName] !== "function") continue;
+      try {
+        domain[eventName]((payload = {}) => recordDomLifecycleEvent(label, payload));
+      } catch {
+        // Lifecycle observation is diagnostic-only and must not alter the run.
+      }
+    }
+  }
+
+  function checkpointDomStaleForensic(error, {
+    phase = "",
+    operation = currentDomOperation,
+    detailStep = "",
+    candidateIndex = null,
+    candidateKey = "",
+    cardNodeId = null
+  } = {}) {
+    if (!isStaleRecommendNodeError(error)) return null;
+    domStaleEventCount += 1;
+    const event = createRecommendDomStaleForensicEvent(error, {
+      eventId: `recommend_dom_stale_${runControl?.runId || "run"}_${domStaleEventCount}`,
+      phase,
+      operation,
+      detailStep,
+      candidateIndex,
+      candidateKey,
+      cardNodeId,
+      rootState,
+      connectionEpoch: currentConnectionEpoch(),
+      listState,
+      counters: countRecommendResultStatuses(results, { greetCount }),
+      timeline: domLifecycleTimeline
+    });
+    domStaleForensics.push(event);
+    if (domStaleForensics.length > 12) domStaleForensics.splice(0, domStaleForensics.length - 12);
+    runControl.checkpoint({
+      dom_stale_forensic: event,
+      dom_stale_forensics: domStaleForensics.slice(),
+      candidate_list: compactInfiniteListState(listState)
+    });
+    updateRecommendProgress({
+      dom_stale_events: domStaleEventCount,
+      last_dom_stale_phase: phase || null,
+      last_dom_stale_operation: operation || null
+    });
+    return event;
+  }
+
+  function checkpointDomStaleRecovery(event, {
+    status = "unknown",
+    recoveryResult = null,
+    recoveryError = null
+  } = {}) {
+    if (!event) return null;
+    event.recovery = {
+      status: String(status || "unknown").slice(0, 100),
+      at: new Date().toISOString(),
+      mode: String(recoveryResult?.recovery_mode || recoveryResult?.method || "").slice(0, 100) || null,
+      escalated_from: String(recoveryResult?.escalated_from || "").slice(0, 100) || null,
+      ok: recoveryResult?.ok === undefined ? null : Boolean(recoveryResult.ok),
+      method: String(recoveryResult?.method || recoveryResult?.context_reapply?.method || "").slice(0, 100) || null,
+      card_count: Number.isInteger(recoveryResult?.card_count)
+        ? recoveryResult.card_count
+        : Number.isInteger(recoveryResult?.root_reacquire?.card_count)
+        ? recoveryResult.root_reacquire.card_count
+        : Number.isInteger(recoveryResult?.context_reapply?.card_count)
+        ? recoveryResult.context_reapply.card_count
+        : null,
+      error: recoveryError ? compactCdpFailureDiagnostic(recoveryError, {
+        fallbackCode: "RECOMMEND_DOM_STALE_RECOVERY_FAILED",
+        fallbackPhase: "recommend:recover-context"
+      }) : null
+    };
+    event.post_recovery_roots = compactRecommendDomRootIdentity(rootState, currentConnectionEpoch());
+    event.lifecycle_timeline = domLifecycleTimeline.slice(-20);
+    runControl.checkpoint({
+      dom_stale_forensic: event,
+      dom_stale_forensics: domStaleForensics.slice(),
+      candidate_list: compactInfiniteListState(listState)
+    });
+    return event;
+  }
+
+  subscribeDomLifecycleEvents();
 
   function recordHumanEvent(event = null) {
     if (!event) return lastHumanEvent;
@@ -892,6 +1535,7 @@ export async function runRecommendWorkflow({
       target_count: targetPassCount,
       target_count_semantics: "passed_candidates",
       ...counts,
+      transient_recovered: counts.transient_recovered + listReadStaleRecoveries,
       screening_mode: normalizedScreeningMode,
       unique_seen: listSnapshot.seen_count,
       scroll_count: listSnapshot.scroll_count,
@@ -902,19 +1546,28 @@ export async function runRecommendWorkflow({
       viewport_checks: viewportGuard.getStats().checks,
       viewport_recoveries: viewportGuard.getStats().recoveries,
       human_behavior_enabled: effectiveHumanBehavior.enabled,
-      human_behavior_profile: effectiveHumanBehavior.profile,
-      human_rest_level: effectiveHumanBehavior.restLevel,
-      human_rest_enabled: effectiveHumanRestEnabled,
-      skip_recent_colleague_contacted: shouldSkipRecentColleagueContacted,
-      colleague_contact_window_days: normalizedColleagueContactWindowDays,
-      current_city_only_requested: normalizedFilter.currentCityOnly,
-      current_city_only_effective: currentCityOnlyResult?.effective ?? null,
-      current_city_only_unavailable: Boolean(currentCityOnlyResult?.unavailable),
-      human_rest_count: humanRestState.rest_count,
-      human_rest_ms: humanRestState.total_rest_ms,
-      last_human_event: lastHumanEvent,
-      ...extra
-    });
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_level: effectiveHumanBehavior.restLevel,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      skip_recent_colleague_contacted: shouldSkipRecentColleagueContacted,
+      colleague_contact_window_days: normalizedColleagueContactWindowDays,
+      current_city_only_requested: normalizedFilter.currentCityOnly,
+      current_city_only_effective: currentCityOnlyResult?.effective ?? null,
+      current_city_only_unavailable: Boolean(currentCityOnlyResult?.unavailable),
+      human_rest_count: humanRestState.rest_count,
+      human_rest_ms: humanRestState.total_rest_ms,
+      last_human_event: lastHumanEvent,
+      debug_boundary_mode: debugBoundary.config.mode,
+      debug_boundary_threshold: debugBoundary.config.threshold,
+      debug_boundary_triggered: debugBoundary.getState().triggered,
+      debug_boundary_trigger_count: debugBoundary.getState().trigger_count,
+      list_read_stale_recovery_attempts: listReadStaleRecoveryAttempts,
+      list_read_stale_recovery_applied: listReadStaleRecoveryApplied,
+      list_read_stale_recoveries: listReadStaleRecoveries,
+      last_list_read_recovery_mode: lastListReadRecoveryMode,
+      last_list_read_stale_diagnostic: lastListReadStaleDiagnostic,
+      ...extra
+    });
   }
 
   function checkpointInProgressCandidate({
@@ -951,27 +1604,27 @@ export async function runRecommendWorkflow({
   async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
     forceRecentNotView = true
   } = {}) {
-    await runControl.waitIfPaused();
-    runControl.throwIfCanceled();
-    const started = Date.now();
-    runControl.setPhase("recommend:recover-context");
-    contextRecoveryAttempts += 1;
-    const effectiveForceRecentNotView = normalizedFilter.enabled && forceRecentNotView;
-    const refreshResult = await refreshRecommendListAtEnd(client, {
-      rootState,
-      jobLabel,
-      pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
-      fallbackPageScope: normalizedFallbackPageScope,
-      filter: normalizedFilter,
-      preferEndRefreshButton: false,
-      forceNavigate: true,
-      targetUrl: targetUrl || RECOMMEND_TARGET_URL,
-      forceRecentNotView: effectiveForceRecentNotView,
-      cardTimeoutMs,
-      buttonSettleMs: refreshButtonSettleMs,
-      reloadSettleMs: refreshReloadSettleMs
-    });
-    let blockingPanelClose = null;
+    await runControl.waitIfPaused();
+    runControl.throwIfCanceled();
+    const started = Date.now();
+    runControl.setPhase("recommend:recover-context");
+    contextRecoveryAttempts += 1;
+    const effectiveForceRecentNotView = normalizedFilter.enabled && forceRecentNotView;
+    const refreshResult = await refreshRecommendListAtEnd(client, {
+      rootState,
+      jobLabel,
+      pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
+      fallbackPageScope: normalizedFallbackPageScope,
+      filter: normalizedFilter,
+      preferEndRefreshButton: false,
+      forceNavigate: true,
+      targetUrl: targetUrl || RECOMMEND_TARGET_URL,
+      forceRecentNotView: effectiveForceRecentNotView,
+      cardTimeoutMs,
+      buttonSettleMs: refreshButtonSettleMs,
+      reloadSettleMs: refreshReloadSettleMs
+    });
+    let blockingPanelClose = null;
     if (refreshResult.ok) {
       blockingPanelClose = await closeRecommendBlockingPanels(client, {
         attemptsLimit: 2,
@@ -995,27 +1648,33 @@ export async function runRecommendWorkflow({
         refresh: compactRefresh,
         counters: countRecommendResultStatuses(results, { greetCount })
       },
-      candidate_list: compactInfiniteListState(listState)
-    });
-    if (!refreshResult.ok) {
-      updateRecommendProgress({
-        refresh_method: refreshResult.method || null,
-        refresh_forced_recent_not_view: effectiveForceRecentNotView,
-        recovery_reason: reason
-      });
-      throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
-    }
-    if (refreshResult.current_city_only) {
-      currentCityOnlyResult = refreshResult.current_city_only;
-    }
-    if (refreshResult.filter) {
-      filterResult = refreshResult.filter;
-    }
-    if (!blockingPanelClose?.closed) {
-      const panelError = createRecommendBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
-      panelError.refresh_attempt = compactRefresh;
-      throw panelError;
-    }
+      candidate_list: compactInfiniteListState(listState)
+    });
+    if (!refreshResult.ok) {
+      updateRecommendProgress({
+        refresh_method: refreshResult.method || null,
+        refresh_forced_recent_not_view: effectiveForceRecentNotView,
+        recovery_reason: reason
+      });
+      const recoveryError = new Error(
+        `Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`
+      );
+      recoveryError.code = "RECOMMEND_CONTEXT_RECOVERY_FAILED";
+      recoveryError.refresh_attempt = compactRefresh;
+      recoveryError.recovery_reason = reason;
+      throw attachRecommendRefreshErrorDiagnostic(recoveryError, compactRefresh);
+    }
+    if (refreshResult.current_city_only) {
+      currentCityOnlyResult = refreshResult.current_city_only;
+    }
+    if (refreshResult.filter) {
+      filterResult = refreshResult.filter;
+    }
+    if (!blockingPanelClose?.closed) {
+      const panelError = createRecommendBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
+      panelError.refresh_attempt = compactRefresh;
+      throw panelError;
+    }
     rootState = refreshResult.root_state || await getRecommendRoots(client);
     rootState = await ensureRecommendViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
@@ -1023,25 +1682,25 @@ export async function runRecommendWorkflow({
       intervalMs: 300
     });
     resetInfiniteListForRefreshRound(listState, {
-      reason: `context_recovery:${reason}`,
-      round: contextRecoveryAttempts,
-      method: refreshResult.method,
-      metadata: {
-        card_count: cardNodeIds.length,
-        forced_recent_not_view: effectiveForceRecentNotView,
-        counters: countRecommendResultStatuses(results, { greetCount })
-      }
-    });
-    listEndReason = "";
-    updateRecommendProgress({
-      card_count: cardNodeIds.length,
-      refresh_method: refreshResult.method || null,
-      refresh_forced_recent_not_view: effectiveForceRecentNotView,
-      recovery_reason: reason
-    });
-    return refreshResult;
-  }
-
+      reason: `context_recovery:${reason}`,
+      round: contextRecoveryAttempts,
+      method: refreshResult.method,
+      metadata: {
+        card_count: cardNodeIds.length,
+        forced_recent_not_view: effectiveForceRecentNotView,
+        counters: countRecommendResultStatuses(results, { greetCount })
+      }
+    });
+    listEndReason = "";
+    updateRecommendProgress({
+      card_count: cardNodeIds.length,
+      refresh_method: refreshResult.method || null,
+      refresh_forced_recent_not_view: effectiveForceRecentNotView,
+      recovery_reason: reason
+    });
+    return refreshResult;
+  }
+
   runControl.setPhase("recommend:cleanup");
   await closeRecommendDetail(client, { attemptsLimit: 2 });
   await closeRecommendAvatarPreview(client, { attemptsLimit: 2 });
@@ -1088,55 +1747,55 @@ export async function runRecommendWorkflow({
     throw new Error(`Recommend page scope was not selected: ${pageScopeSelection.reason || pageScopeSelection.effective_scope || requestedPageScope}`);
   }
   rootState = await getRecommendRoots(client);
-  rootState = await ensureRecommendViewport(rootState, "page_scope");
-  runControl.checkpoint({
-    page_scope: compactPageScopeSelection(pageScopeSelection)
-  });
-
-  const initialFilterStages = await applyRecommendFilterEnvelopeStages(normalizedFilter, {
-    applyCurrentCityOnly: async () => {
-      await runControl.waitIfPaused();
-      runControl.throwIfCanceled();
-      runControl.setPhase("recommend:current-city-only");
-      const result = await ensureRecommendCurrentCityOnly(
-        client,
-        rootState.iframe.documentNodeId,
-        { enabled: normalizedFilter.currentCityOnly }
-      );
-      rootState = await getRecommendRoots(client);
-      rootState = await ensureRecommendViewport(rootState, "current_city_only");
-      runControl.checkpoint({
-        current_city_only: compactCurrentCityOnlyResult(result)
-      });
-      return result;
-    },
-    applyFilterPanel: async () => {
-      await runControl.waitIfPaused();
-      runControl.throwIfCanceled();
-      runControl.setPhase("recommend:filter");
-      const result = await selectAndConfirmFirstSafeFilter(
-        client,
-        rootState.iframe.documentNodeId,
-        buildRecommendFilterSelectionOptions(normalizedFilter)
-      );
-      if (!result.confirmed) {
-        throw new Error("Recommend run filter selection was not confirmed");
-      }
-      rootState = await getRecommendRoots(client);
-      rootState = await ensureRecommendViewport(rootState, "filter");
-      runControl.checkpoint({
-        filter: compactFilterResult(result)
-      });
-      return result;
-    }
-  });
-  currentCityOnlyResult = initialFilterStages.current_city_only;
-  filterResult = initialFilterStages.filter;
-
-  await runControl.waitIfPaused();
-  runControl.throwIfCanceled();
-  runControl.setPhase("recommend:cards");
-  rootState = await ensureRecommendViewport(rootState, "cards");
+  rootState = await ensureRecommendViewport(rootState, "page_scope");
+  runControl.checkpoint({
+    page_scope: compactPageScopeSelection(pageScopeSelection)
+  });
+
+  const initialFilterStages = await applyRecommendFilterEnvelopeStages(normalizedFilter, {
+    applyCurrentCityOnly: async () => {
+      await runControl.waitIfPaused();
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:current-city-only");
+      const result = await ensureRecommendCurrentCityOnly(
+        client,
+        rootState.iframe.documentNodeId,
+        { enabled: normalizedFilter.currentCityOnly }
+      );
+      rootState = await getRecommendRoots(client);
+      rootState = await ensureRecommendViewport(rootState, "current_city_only");
+      runControl.checkpoint({
+        current_city_only: compactCurrentCityOnlyResult(result)
+      });
+      return result;
+    },
+    applyFilterPanel: async () => {
+      await runControl.waitIfPaused();
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:filter");
+      const result = await selectAndConfirmFirstSafeFilter(
+        client,
+        rootState.iframe.documentNodeId,
+        buildRecommendFilterSelectionOptions(normalizedFilter)
+      );
+      if (!result.confirmed) {
+        throw new Error("Recommend run filter selection was not confirmed");
+      }
+      rootState = await getRecommendRoots(client);
+      rootState = await ensureRecommendViewport(rootState, "filter");
+      runControl.checkpoint({
+        filter: compactFilterResult(result)
+      });
+      return result;
+    }
+  });
+  currentCityOnlyResult = initialFilterStages.current_city_only;
+  filterResult = initialFilterStages.filter;
+
+  await runControl.waitIfPaused();
+  runControl.throwIfCanceled();
+  runControl.setPhase("recommend:cards");
+  rootState = await ensureRecommendViewport(rootState, "cards");
   cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
     timeoutMs: cardTimeoutMs,
     intervalMs: 300
@@ -1149,50 +1808,308 @@ export async function runRecommendWorkflow({
     list_end_reason: null
   });
 
-  while (countPassedResults(results) < targetPassCount) {
-    const candidateStarted = Date.now();
-    const timings = {};
+  while (countPassedResults(results) < targetPassCount) {
+    const candidateStarted = Date.now();
+    const timings = {};
     await runControl.waitIfPaused();
-    runControl.throwIfCanceled();
-    runControl.setPhase("recommend:candidate");
-    rootState = await ensureRecommendViewport(rootState, "candidate_loop");
-
-    const nextCandidateResult = await measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
-      client,
-      state: listState,
-      maxScrolls: listMaxScrolls,
-      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");
-        rootState = currentRootState;
-        const currentCardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
-          timeoutMs: Math.min(cardTimeoutMs, 5000),
-          intervalMs: 300
+    runControl.throwIfCanceled();
+    runControl.setPhase("recommend:list-read");
+    currentDomOperation = "candidate:list-read";
+    const debugBoundaryAction = debugBoundary.take(results.length);
+    let debugForcedListEnd = false;
+    if (debugBoundaryAction) {
+      const debugProgress = {
+        debug_boundary_mode: debugBoundaryAction.mode,
+        debug_boundary_threshold: debugBoundaryAction.threshold,
+        debug_boundary_triggered: true,
+        debug_boundary_trigger_count: debugBoundaryAction.trigger_count,
+        debug_boundary_processed: debugBoundaryAction.processed
+      };
+      updateRecommendProgress(debugProgress);
+      runControl.checkpoint({
+        debug_boundary: {
+          ...debugProgress,
+          field: debugBoundaryAction.field,
+          triggered_at: new Date().toISOString()
+        }
+      });
+      if (debugBoundaryAction.mode === "context_recovery") {
+        runControl.setPhase("recommend:debug-force-context-recovery");
+        await recoverAndReapplyRecommendContext("debug_force_context_recovery_after_processed", null, {
+          forceRecentNotView: true
+        });
+        updateRecommendProgress({
+          debug_force_context_recovery_count: debugBoundaryAction.trigger_count
         });
-        cardNodeIds = currentCardNodeIds;
-        return currentCardNodeIds;
+        runControl.setPhase("recommend:list-read");
+      } else if (debugBoundaryAction.mode === "cdp_reconnect") {
+        debugForceReconnectPending = debugBoundaryAction;
+        updateRecommendProgress({
+          debug_force_cdp_reconnect_pending: true
+        });
+      } else if (debugBoundaryAction.mode === "list_end") {
+        debugForcedListEnd = true;
+        updateRecommendProgress({
+          debug_force_list_end_count: debugBoundaryAction.trigger_count
+        });
+      }
+    }
+    const listReadAcquisition = await acquireRecommendListReadWithStaleRecovery({
+      maxRetries: 2,
+      acquire: async () => {
+        await runControl.waitIfPaused();
+        runControl.throwIfCanceled();
+        runControl.setPhase("recommend:list-read");
+        rootState = await ensureRecommendViewport(rootState, "candidate_loop");
+        if (debugForcedListEnd) {
+          return {
+            ok: false,
+            end_reached: true,
+            reason: "debug_forced_list_end"
+          };
+        }
+        return measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
+          client,
+          state: listState,
+          maxScrolls: listMaxScrolls,
+          stableSignatureLimit: listStableSignatureLimit,
+          wheelDeltaY: listWheelDeltaY,
+          settleMs: listSettleMs,
+          listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+          fallbackPoint: listFallbackResolver,
+          findNodeIds: async () => {
+            currentDomOperation = "candidate:list-find-nodes";
+            let currentRootState = await getRecommendRoots(client);
+            currentRootState = await ensureRecommendViewport(currentRootState, "candidate_find_nodes");
+            rootState = currentRootState;
+            if (debugForceReconnectPending) {
+              runControl.setPhase("recommend:debug-force-cdp-reconnect");
+              const rawClient = client.__rawClient;
+              if (!rawClient || typeof rawClient.close !== "function") {
+                const error = new Error("Guarded CDP client does not expose a closable __rawClient");
+                error.code = "RECOMMEND_DEBUG_RAW_CDP_UNAVAILABLE";
+                throw error;
+              }
+              const forcedReconnectAction = debugForceReconnectPending;
+              debugForceReconnectPending = null;
+              await rawClient.close();
+              runControl.checkpoint({
+                debug_cdp_reconnect: {
+                  raw_connection_closed: true,
+                  processed: forcedReconnectAction.processed,
+                  threshold: forcedReconnectAction.threshold,
+                  closed_at: new Date().toISOString()
+                }
+              });
+              updateRecommendProgress({
+                debug_force_cdp_reconnect_pending: false,
+                debug_force_cdp_reconnect_count: forcedReconnectAction.trigger_count
+              });
+              runControl.setPhase("recommend:list-read");
+            }
+            const currentCardNodeIds = await waitForRecommendCardNodeIds(
+              client,
+              currentRootState.iframe.documentNodeId,
+              {
+                timeoutMs: Math.min(cardTimeoutMs, 5000),
+                intervalMs: 300
+              }
+            );
+            cardNodeIds = currentCardNodeIds;
+            return currentCardNodeIds;
+          },
+          readCandidate: async (nodeId, { visibleIndex }) => {
+            currentDomOperation = "candidate:list-read-card";
+            return readRecommendCardCandidate(client, nodeId, {
+              targetUrl,
+              source: "recommend-run-card",
+              metadata: {
+                run_candidate_index: results.length,
+                visible_index: visibleIndex
+              }
+            });
+          },
+          shouldRethrowReadError: isStaleRecommendNodeError,
+          detectBottomMarker: async ({ scrollAttempt = 0, signature = {} } = {}) => {
+            currentDomOperation = "candidate:list-bottom-probe";
+            return detectInfiniteListBottomMarker(client, {
+              rootNodeId: rootState?.iframe?.documentNodeId,
+              markerSelectors: RECOMMEND_BOTTOM_MARKER_SELECTORS,
+              refreshSelectors: [RECOMMEND_END_REFRESH_SELECTOR],
+              textScanSelectors: scrollAttempt > 0 || (signature?.stable_signature_count || 0) >= 2 ? undefined : [],
+              maxTextScanNodes: 500
+            });
+          }
+        }));
+      },
+      onStale: async ({ error, diagnostic }) => {
+        listReadStaleRecoveryAttempts += 1;
+        const forensic = checkpointDomStaleForensic(error, {
+          phase: "recommend:list-read",
+          operation: currentDomOperation,
+          candidateIndex: results.length
+        });
+        if (forensic) {
+          diagnostic.forensic_event_id = forensic.event_id;
+          diagnostic.pre_recovery_roots = forensic.pre_recovery_roots;
+          diagnostic.failing_candidate = forensic.candidate;
+        }
+        lastListReadStaleDiagnostic = diagnostic;
+        listReadStaleDiagnostics.push(diagnostic);
+        runControl.checkpoint({
+          list_read_stale_recovery: {
+            diagnostic,
+            recent_diagnostics: listReadStaleDiagnostics.slice(-12),
+            counters: countRecommendResultStatuses(results, { greetCount }),
+            candidate_list: compactInfiniteListState(listState)
+          }
+        });
+        updateRecommendProgress();
       },
-      readCandidate: async (nodeId, { visibleIndex }) => readRecommendCardCandidate(client, nodeId, {
-        targetUrl,
-        source: "recommend-run-card",
-        metadata: {
-          run_candidate_index: results.length,
-          visible_index: visibleIndex
+      recover: async ({ error, diagnostic }) => {
+        try {
+          return await recoverRecommendListReadStaleContext({
+            staleAttempt: diagnostic.attempt,
+            listState,
+            rootReacquire: async () => {
+              await runControl.waitIfPaused();
+              runControl.throwIfCanceled();
+              runControl.setPhase("recommend:list-read-root-reacquire");
+              let freshRootState = await getRecommendRoots(client);
+              freshRootState = await ensureRecommendViewport(
+                freshRootState,
+                "list_read_stale_root_reacquire"
+              );
+              const freshCardNodeIds = await waitForRecommendCardNodeIds(
+                client,
+                freshRootState.iframe.documentNodeId,
+                {
+                  timeoutMs: Math.min(cardTimeoutMs, 10000),
+                  intervalMs: 300
+                }
+              );
+              rootState = freshRootState;
+              cardNodeIds = freshCardNodeIds;
+              return {
+                card_count: freshCardNodeIds.length,
+                iframe_document_node_id: freshRootState.iframe.documentNodeId,
+                root_identity: compactRecommendDomRootIdentity(
+                  freshRootState,
+                  currentConnectionEpoch()
+                )
+              };
+            },
+            contextReapply: async ({ rootReacquireError }) => {
+              await runControl.waitIfPaused();
+              runControl.throwIfCanceled();
+              const recovery = await recoverAndReapplyRecommendContext(
+                "list_read_stale_node",
+                rootReacquireError || error,
+                { forceRecentNotView: true }
+              );
+              return {
+                ok: Boolean(recovery?.ok),
+                method: recovery?.method || null,
+                card_count: recovery?.card_count || 0,
+                root_identity: compactRecommendDomRootIdentity(
+                  rootState,
+                  currentConnectionEpoch()
+                )
+              };
+            }
+          });
+        } catch (recoveryError) {
+          const forensic = domStaleForensics.find((item) => (
+            item.event_id === diagnostic.forensic_event_id
+          ));
+          checkpointDomStaleRecovery(forensic, {
+            status: "recovery_failed",
+            recoveryError
+          });
+          updateRecommendProgress({
+            list_read_stale_recovery_failed: true
+          });
+          runControl.checkpoint({
+            list_read_stale_recovery_failed: {
+              trigger: lastListReadStaleDiagnostic,
+              recent_diagnostics: listReadStaleDiagnostics.slice(-12),
+              recovery_error: compactError(recoveryError, "RECOMMEND_LIST_READ_RECOVERY_FAILED"),
+              candidate_list: compactInfiniteListState(listState)
+            }
+          });
+          throw recoveryError;
         }
-      }),
-      detectBottomMarker: async ({ scrollAttempt = 0, signature = {} } = {}) => detectInfiniteListBottomMarker(client, {
-        rootNodeId: rootState?.iframe?.documentNodeId,
-        markerSelectors: RECOMMEND_BOTTOM_MARKER_SELECTORS,
-        refreshSelectors: [RECOMMEND_END_REFRESH_SELECTOR],
-        textScanSelectors: scrollAttempt > 0 || (signature?.stable_signature_count || 0) >= 2 ? undefined : [],
-        maxTextScanNodes: 500
-      })
-    }));
+      },
+      onRecoveryApplied: async ({ diagnostic, recoveryResult }) => {
+        listReadStaleRecoveryApplied += 1;
+        lastListReadStaleDiagnostic = diagnostic;
+        lastListReadRecoveryMode = diagnostic.recovery_mode || null;
+        const forensic = domStaleForensics.find((item) => (
+          item.event_id === diagnostic.forensic_event_id
+        ));
+        checkpointDomStaleRecovery(forensic, {
+          status: "recovery_applied",
+          recoveryResult
+        });
+        updateRecommendProgress();
+        runControl.checkpoint({
+          list_read_stale_recovery_applied: {
+            diagnostic,
+            recovery_applied_count: listReadStaleRecoveryApplied,
+            candidate_list: compactInfiniteListState(listState)
+          }
+        });
+      },
+      onRecovered: async ({ diagnostic }) => {
+        listReadStaleRecoveries += 1;
+        lastListReadStaleDiagnostic = diagnostic;
+        const forensic = domStaleForensics.find((item) => (
+          item.event_id === diagnostic.forensic_event_id
+        ));
+        checkpointDomStaleRecovery(forensic, {
+          status: "recovered",
+          recoveryResult: {
+            recovery_mode: diagnostic.recovery_mode,
+            ok: true
+          }
+        });
+        updateRecommendProgress();
+        runControl.checkpoint({
+          list_read_stale_recovered: {
+            diagnostic,
+            recovery_count: listReadStaleRecoveries,
+            candidate_list: compactInfiniteListState(listState)
+          }
+        });
+      },
+      onExhausted: async ({ error, diagnostic }) => {
+        listReadStaleRecoveryAttempts += 1;
+        const forensic = checkpointDomStaleForensic(error, {
+          phase: "recommend:list-read",
+          operation: currentDomOperation,
+          candidateIndex: results.length
+        });
+        if (forensic) {
+          diagnostic.forensic_event_id = forensic.event_id;
+          diagnostic.pre_recovery_roots = forensic.pre_recovery_roots;
+          diagnostic.failing_candidate = forensic.candidate;
+          checkpointDomStaleRecovery(forensic, { status: "exhausted" });
+        }
+        lastListReadStaleDiagnostic = diagnostic;
+        listReadStaleDiagnostics.push(diagnostic);
+        updateRecommendProgress({
+          list_read_stale_recovery_exhausted: true
+        });
+        runControl.checkpoint({
+          list_read_stale_recovery_exhausted: {
+            diagnostic,
+            recent_diagnostics: listReadStaleDiagnostics.slice(-12),
+            candidate_list: compactInfiniteListState(listState)
+          }
+        });
+      }
+    });
+    const nextCandidateResult = listReadAcquisition.result;
     if (!nextCandidateResult.ok) {
       listEndReason = nextCandidateResult.reason || "list_exhausted";
       if (
@@ -1202,57 +2119,79 @@ export async function runRecommendWorkflow({
           && refreshRounds < Math.max(0, Number(maxRefreshRounds) || 0)
       ) {
         await runControl.waitIfPaused();
-        runControl.throwIfCanceled();
-        runControl.setPhase("recommend:refresh");
-        refreshRounds += 1;
-        const refreshResult = await refreshRecommendListAtEnd(client, {
-          rootState,
-          jobLabel,
-          pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
-          fallbackPageScope: normalizedFallbackPageScope,
-          filter: normalizedFilter,
-          forceRecentNotView: normalizedFilter.enabled,
-          cardTimeoutMs,
-          buttonSettleMs: refreshButtonSettleMs,
-          reloadSettleMs: refreshReloadSettleMs
-        });
-        const compactRefresh = compactRefreshAttempt(refreshResult);
+        runControl.throwIfCanceled();
+        runControl.setPhase("recommend:refresh");
+        currentDomOperation = "candidate:list-end-refresh";
+        refreshRounds += 1;
+        let refreshResult;
+        try {
+          refreshResult = await refreshRecommendListAtEnd(client, {
+            rootState,
+            jobLabel,
+            pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
+            fallbackPageScope: normalizedFallbackPageScope,
+            filter: normalizedFilter,
+            preferEndRefreshButton: debugForcedListEnd ? false : undefined,
+            forceRecentNotView: normalizedFilter.enabled,
+            cardTimeoutMs,
+            buttonSettleMs: refreshButtonSettleMs,
+            reloadSettleMs: refreshReloadSettleMs
+          });
+        } catch (error) {
+          checkpointDomStaleForensic(error, {
+            phase: "recommend:refresh",
+            operation: currentDomOperation,
+            candidateIndex: results.length
+          });
+          throw error;
+        }
+        const compactRefresh = compactRefreshAttempt(refreshResult);
         refreshAttempts.push(compactRefresh);
         runControl.checkpoint({
           refresh_round: refreshRounds,
-          refresh: compactRefresh
-        });
-        updateRecommendProgress({
-          card_count: refreshResult.card_count || cardNodeIds.length,
-          refresh_method: refreshResult.method || null,
-          refresh_forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view),
-          list_end_reason: listEndReason
-        });
+          refresh: compactRefresh
+        });
+        updateRecommendProgress({
+          card_count: refreshResult.card_count || cardNodeIds.length,
+          refresh_method: refreshResult.method || null,
+          refresh_forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view),
+          list_end_reason: listEndReason
+        });
         if (refreshResult.ok) {
-          if (refreshResult.current_city_only) {
-            currentCityOnlyResult = refreshResult.current_city_only;
-          }
-          if (refreshResult.filter) {
-            filterResult = refreshResult.filter;
+          if (refreshResult.current_city_only) {
+            currentCityOnlyResult = refreshResult.current_city_only;
+          }
+          if (refreshResult.filter) {
+            filterResult = refreshResult.filter;
+          }
+          try {
+            currentDomOperation = "candidate:list-end-refresh-reacquire";
+            rootState = refreshResult.root_state || await getRecommendRoots(client);
+            rootState = await ensureRecommendViewport(rootState, "refresh_after");
+            cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
+              timeoutMs: cardTimeoutMs,
+              intervalMs: 300
+            });
+          } catch (error) {
+            checkpointDomStaleForensic(error, {
+              phase: "recommend:refresh",
+              operation: currentDomOperation,
+              candidateIndex: results.length
+            });
+            throw error;
           }
-          rootState = refreshResult.root_state || await getRecommendRoots(client);
-          rootState = await ensureRecommendViewport(rootState, "refresh_after");
-          cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
-            timeoutMs: cardTimeoutMs,
-            intervalMs: 300
-          });
           resetInfiniteListForRefreshRound(listState, {
-            reason: listEndReason,
-            round: refreshRounds,
-            method: refreshResult.method,
-            metadata: {
-              card_count: cardNodeIds.length,
-              forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view)
-            }
-          });
-          listEndReason = "";
-          continue;
-        }
+            reason: listEndReason,
+            round: refreshRounds,
+            method: refreshResult.method,
+            metadata: {
+              card_count: cardNodeIds.length,
+              forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view)
+            }
+          });
+          listEndReason = "";
+          continue;
+        }
         throw createRecommendRefreshFailureError(compactRefresh, {
           listEndReason,
           targetCount: targetPassCount,
@@ -1262,6 +2201,7 @@ export async function runRecommendWorkflow({
       break;
     }
 
+    runControl.setPhase("recommend:candidate");
     const index = results.length;
     let cardNodeId = nextCandidateResult.item.node_id;
     const candidateKey = nextCandidateResult.item.key;
@@ -1276,11 +2216,13 @@ export async function runRecommendWorkflow({
     if (index < effectiveDetailLimit) {
       try {
         await runControl.waitIfPaused();
-        runControl.throwIfCanceled();
-        runControl.setPhase("recommend:detail");
-        detailStep = "ensure_viewport";
-        rootState = await ensureRecommendViewport(rootState, "detail");
-        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
+        runControl.throwIfCanceled();
+        runControl.setPhase("recommend:detail");
+        detailStep = "ensure_viewport";
+        currentDomOperation = "candidate:detail-ensure-viewport";
+        rootState = await ensureRecommendViewport(rootState, "detail");
+        currentDomOperation = "candidate:detail-close-blocking-panels";
+        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
           attemptsLimit: 2,
           rootState
         });
@@ -1298,10 +2240,12 @@ export async function runRecommendWorkflow({
         }
         if (blockingPanelClose.already_closed === false) {
           timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
-        }
-        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
-        detailStep = "open_detail";
-        networkRecorder.clear();
+        }
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        detailStep = "open_detail";
+        currentDomOperation = "candidate:detail-open";
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        networkRecorder.clear();
         await maybeHumanActionCooldown("before_detail_open", timings);
         const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
           cardNodeId,
@@ -1317,8 +2261,10 @@ export async function runRecommendWorkflow({
         cardNodeId = openedDetail.card_node_id || cardNodeId;
         cardCandidate = openedDetail.card_candidate || cardCandidate;
         screeningCandidate = cardCandidate;
-        if (shouldSkipRecentColleagueContacted) {
-          detailStep = "check_colleague_contact";
+        if (shouldSkipRecentColleagueContacted) {
+          detailStep = "check_colleague_contact";
+          currentDomOperation = "candidate:detail-colleague-contact";
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
           try {
             colleagueContact = await measureTiming(timings, "colleague_contact_check_ms", () => inspectRecentColleagueContact(
               client,
@@ -1356,9 +2302,11 @@ export async function runRecommendWorkflow({
             };
           }
         }
-        if (!skipRecentColleagueContact) {
-          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-        detailStep = "wait_network";
+        if (!skipRecentColleagueContact) {
+          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
+        detailStep = "wait_network";
+        currentDomOperation = "candidate:detail-network-wait";
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         const networkWait = await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
           waitForRecommendDetailNetworkEvents,
           networkRecorder,
@@ -1371,8 +2319,10 @@ export async function runRecommendWorkflow({
         ));
         if (networkWait?.elapsed_ms != null) {
           timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
-        }
-        detailStep = "extract_detail";
+        }
+        detailStep = "extract_detail";
+        currentDomOperation = "candidate:detail-extract";
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
         detailResult = await extractRecommendDetailCandidate(client, {
           cardCandidate,
           cardNodeId,
@@ -1396,8 +2346,10 @@ export async function runRecommendWorkflow({
             parsedNetworkProfileCount,
             waitResult: networkWait
           });
-        } else {
-          detailStep = "wait_capture_target";
+        } else {
+          detailStep = "wait_capture_target";
+          currentDomOperation = "candidate:detail-wait-capture-target";
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
           captureTargetWait = await waitForCvCaptureTarget(client, openedDetail.detail_state, {
             domain: "recommend",
             timeoutMs: 6000,
@@ -1406,70 +2358,206 @@ export async function runRecommendWorkflow({
           captureTarget = captureTargetWait.target || null;
           const captureNodeId = captureTarget?.node_id || null;
           if (captureNodeId) {
-            const imageEvidencePath = imageEvidenceFilePath({
-              imageOutputDir,
-              domain: "recommend",
-              runId: runControl?.runId,
-              index,
-              extension: "jpg"
-            });
-            try {
-              detailStep = "capture_image";
-              imageEvidence = await measureTiming(timings, "screenshot_capture_ms", () => captureScrolledNodeScreenshots(client, captureNodeId, {
-                filePath: imageEvidencePath,
-                format: "jpeg",
-                quality: 72,
-                optimize: true,
-                resizeMaxWidth: 1100,
-                captureViewport: false,
-                padding: 0,
-                maxScreenshots: maxImagePages,
-                wheelDeltaY: imageWheelDeltaY,
-                settleMs: 350,
-                scrollMethod: "dom-anchor-fallback-input",
-                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
-                stepTimeoutMs: 45000,
-                totalTimeoutMs: 90000,
-                duplicateStopCount: 1,
-                skipDuplicateScreenshots: true,
-                composeForLlm: true,
-                llmPagesPerImage: 3,
-                llmResizeMaxWidth: 1100,
-                llmQuality: 72,
-                metadata: {
-                  domain: "recommend",
-                  capture_mode: "scroll_sequence",
-                  acquisition_reason: "network_miss_image_fallback",
-                  run_candidate_index: index,
-                  candidate_key: candidateKey,
-                  capture_target: captureTarget,
-                  capture_target_wait: captureTargetWait
-                }
-              }));
-              source = "image";
-            } catch (error) {
-              if (!isRecoverableImageCaptureError(error)) throw error;
-              const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
-              if (recoveryCount < 1) {
-                candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
-                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-                await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
-                await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
-                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
-                  forceRecentNotView: true
-                });
-                continue;
-              }
-              imageEvidence = createRecoverableImageCaptureEvidence(error, {
-                elapsedMs: timings.screenshot_capture_ms,
-                filePath: imageEvidencePath,
-                extension: "jpg",
-                maxScreenshots: maxImagePages
-              });
-              source = "image_capture_failed";
-            }
+            const imageEvidencePath = imageEvidenceFilePath({
+              imageOutputDir,
+              domain: "recommend",
+              runId: runControl?.runId,
+              index,
+              extension: "jpg"
+            });
+            const captureImageForTarget = (target, targetWait, resumeCheckpoint = null) => captureScrolledNodeScreenshots(
+              client,
+              target.node_id,
+              {
+                filePath: imageEvidencePath,
+                format: "jpeg",
+                quality: 72,
+                optimize: true,
+                resizeMaxWidth: 1100,
+                captureViewport: false,
+                iframeOwnerNodeId: target?.iframe_node_id || null,
+                padding: 0,
+                maxScreenshots: maxImagePages,
+                wheelDeltaY: imageWheelDeltaY,
+                settleMs: 350,
+                scrollMethod: "dom-anchor-fallback-input",
+                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+                stepTimeoutMs: 45000,
+                totalTimeoutMs: 90000,
+                duplicateStopCount: 2,
+                skipDuplicateScreenshots: true,
+                requireTerminalProof: true,
+                composeForLlm: true,
+                llmPagesPerImage: 3,
+                llmResizeMaxWidth: 1100,
+                llmQuality: 72,
+                resumeCheckpoint,
+                metadata: {
+                  domain: "recommend",
+                  capture_mode: "scroll_sequence",
+                  acquisition_reason: "network_miss_image_fallback",
+                  run_candidate_index: index,
+                  candidate_key: candidateKey,
+                  capture_target: target,
+                  capture_target_wait: targetWait,
+                  resumed_from_checkpoint: Boolean(resumeCheckpoint)
+                }
+              }
+            );
+            try {
+              detailStep = "capture_image";
+              currentDomOperation = "candidate:detail-capture-image";
+              checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+              imageEvidence = await measureTiming(
+                timings,
+                "screenshot_capture_ms",
+                () => captureImageForTarget(captureTarget, captureTargetWait)
+              );
+              imageEvidence = requireCompleteImageEvidence(imageEvidence, {
+                code: "IMAGE_CAPTURE_EVIDENCE_MISSING",
+                message: "Recommend CV capture returned no complete persisted evidence",
+                metadata: { domain: "recommend", candidate_key: candidateKey }
+              });
+              source = isIncompleteImageEvidence(imageEvidence) ? "image_capture_failed" : "image";
+            } catch (error) {
+              if (!isRecoverableImageCaptureError(error)) throw error;
+              const retryReservation = imageCaptureWorkflowRetries.consume(candidateKey);
+              if (retryReservation.allowed) {
+                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
+                timings.image_capture_workflow_retry = retryReservation;
+                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+                const resumeCheckpoint = imageCaptureResumeCheckpoint(error);
+                if (resumeCheckpoint) {
+                  detailStep = "resume_image_capture_reacquire";
+                  const resumeAttempt = await attemptImageCaptureCheckpointResume({
+                    checkpoint: resumeCheckpoint,
+                    reacquire: () => reacquireImageCaptureResumeTarget({
+                      domain: "recommend",
+                      getRoots: () => getRecommendRoots(client),
+                      ensureViewport: (freshRoots) => ensureRecommendViewport(
+                        freshRoots,
+                        "image_capture_resume_reacquire"
+                      ),
+                      getDetailState: () => waitForRecommendDetail(client, {
+                        timeoutMs: 4000,
+                        intervalMs: 200
+                      }),
+                      isDetailAvailable: (state) => Boolean(state?.popup || state?.resumeIframe),
+                      waitForTarget: (detailState) => waitForCvCaptureTarget(client, detailState, {
+                        domain: "recommend",
+                        timeoutMs: 4000,
+                        intervalMs: 200
+                      })
+                    }),
+                    capture: (reacquired) => {
+                      rootState = reacquired.root_state;
+                      captureTarget = reacquired.target;
+                      captureTargetWait = reacquired.target_wait;
+                      detailStep = "resume_image_capture";
+                      return measureTiming(
+                        timings,
+                        "screenshot_capture_ms",
+                        () => captureImageForTarget(captureTarget, captureTargetWait, resumeCheckpoint)
+                      );
+                    }
+                  });
+                  if (resumeAttempt.outcome === "reacquire_failed") {
+                    const reacquireError = resumeAttempt.error;
+                    imageEvidence = {
+                      ...createRecoverableImageCaptureEvidence(reacquireError, {
+                        elapsedMs: timings.screenshot_capture_ms,
+                        filePath: imageEvidencePath,
+                        extension: "jpg",
+                        maxScreenshots: maxImagePages
+                      }),
+                      coverage_complete: false,
+                      resumed_from_checkpoint: true,
+                      resume_checkpoint_id: resumeCheckpoint.checkpoint_id || null,
+                      coverage_checkpoint: resumeCheckpoint
+                    };
+                    source = "image_capture_failed";
+                    timings.image_capture_resume = {
+                      attempted: true,
+                      ok: false,
+                      phase: "reacquire",
+                      checkpoint_id: resumeCheckpoint.checkpoint_id || null,
+                      error: compactError(reacquireError, "IMAGE_CAPTURE_RESUME_REACQUIRE_FAILED")
+                    };
+                  }
+                  if (resumeAttempt.outcome === "completed") {
+                    imageEvidence = requireCompleteImageEvidence(resumeAttempt.evidence, {
+                      code: "IMAGE_CAPTURE_RESUME_EVIDENCE_MISSING",
+                      message: "Recommend resumed CV capture returned no complete persisted evidence",
+                      metadata: { domain: "recommend", candidate_key: candidateKey }
+                    });
+                    source = isIncompleteImageEvidence(imageEvidence) ? "image_capture_failed" : "image";
+                    timings.image_capture_resume = {
+                      attempted: true,
+                      ok: !isIncompleteImageEvidence(imageEvidence),
+                      phase: "capture",
+                      checkpoint_id: resumeCheckpoint.checkpoint_id || null,
+                      confirmed_screenshot_count: resumeCheckpoint.unique_screenshot_count || 0
+                    };
+                  } else if (resumeAttempt.outcome === "capture_failed") {
+                    const resumeError = resumeAttempt.error;
+                    imageEvidence = {
+                      ...createRecoverableImageCaptureEvidence(resumeError, {
+                        elapsedMs: timings.screenshot_capture_ms,
+                        filePath: imageEvidencePath,
+                        extension: "jpg",
+                        maxScreenshots: maxImagePages
+                      }),
+                      coverage_complete: false,
+                      resumed_from_checkpoint: true,
+                      resume_checkpoint_id: resumeCheckpoint.checkpoint_id || null,
+                      coverage_checkpoint: resumeError.capture_checkpoint || resumeCheckpoint
+                    };
+                    source = "image_capture_failed";
+                    timings.image_capture_resume = {
+                      attempted: true,
+                      ok: false,
+                      phase: "capture",
+                      checkpoint_id: resumeCheckpoint.checkpoint_id || null,
+                      error: compactError(resumeError, "IMAGE_CAPTURE_RESUME_FAILED")
+                    };
+                  }
+                } else {
+                  imageEvidence = {
+                    ...createRecoverableImageCaptureEvidence(error, {
+                      elapsedMs: timings.screenshot_capture_ms,
+                      filePath: imageEvidencePath,
+                      extension: "jpg",
+                      maxScreenshots: maxImagePages
+                    }),
+                    coverage_complete: false
+                  };
+                  source = "image_capture_failed";
+                  timings.image_capture_resume = {
+                    attempted: false,
+                    ok: false,
+                    phase: "checkpoint",
+                    error: {
+                      code: "IMAGE_CAPTURE_CHECKPOINT_UNAVAILABLE",
+                      message: "Capture failed without a resumable checkpoint"
+                    }
+                  };
+                }
+              } else {
+                imageEvidence = {
+                  ...createRecoverableImageCaptureEvidence(error, {
+                    elapsedMs: timings.screenshot_capture_ms,
+                    filePath: imageEvidencePath,
+                    extension: "jpg",
+                    maxScreenshots: maxImagePages
+                  }),
+                  coverage_complete: false,
+                  metadata: {
+                    image_capture_workflow_retry: retryReservation
+                  }
+                };
+                source = "image_capture_failed";
+              }
+            }
             recordCvImageFallback(cvAcquisitionState, {
               reason: source === "image_capture_failed"
                 ? "network_miss_image_capture_failed"
@@ -1478,9 +2566,18 @@ export async function runRecommendWorkflow({
               waitResult: networkWait,
               imageEvidence
             });
-          } else {
-            source = "missing_capture_node";
-            recordCvNetworkMiss(cvAcquisitionState, {
+          } else {
+            source = "missing_capture_node";
+            imageEvidence = createRequiredImageEvidenceFailure({
+              code: "IMAGE_CAPTURE_TARGET_UNAVAILABLE",
+              message: "Recommend CV capture target was unavailable after the network fallback missed",
+              metadata: {
+                domain: "recommend",
+                candidate_key: candidateKey,
+                capture_target_wait: captureTargetWait || null
+              }
+            });
+            recordCvNetworkMiss(cvAcquisitionState, {
               reason: "network_miss_no_capture_node",
               parsedNetworkProfileCount,
               waitResult: networkWait
@@ -1501,21 +2598,42 @@ export async function runRecommendWorkflow({
         };
         screeningCandidate = detailResult.candidate;
         }
-      } catch (error) {
-        if (!isRecoverableRecommendDetailError(error)) throw error;
-        const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
-        if (recoveryCount < 1) {
+      } catch (error) {
+        if (!isRecoverableRecommendDetailError(error)) throw error;
+        const staleForensic = checkpointDomStaleForensic(error, {
+          phase: "recommend:detail",
+          operation: currentDomOperation,
+          detailStep,
+          candidateIndex: index,
+          candidateKey,
+          cardNodeId
+        });
+        const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
+        if (recoveryCount < 1) {
           candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
           timings.detail_recovery_trigger = compactRecoverableDetailError(error);
           checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-          await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
-          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
-          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
-            forceRecentNotView: true
-          });
-          continue;
-        }
+          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+          try {
+            const recovery = await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
+              forceRecentNotView: true
+            });
+            checkpointDomStaleRecovery(staleForensic, {
+              status: "recovered",
+              recoveryResult: recovery
+            });
+          } catch (recoveryError) {
+            checkpointDomStaleRecovery(staleForensic, {
+              status: "recovery_failed",
+              recoveryError
+            });
+            throw recoveryError;
+          }
+          continue;
+        }
+        checkpointDomStaleRecovery(staleForensic, { status: "candidate_failed_closed" });
         recoverableDetailError = error;
         detailResult = null;
         timings.detail_recovered_error = compactRecoverableDetailError(error);
@@ -1526,11 +2644,12 @@ export async function runRecommendWorkflow({
     }
 
     await runControl.waitIfPaused();
-    runControl.throwIfCanceled();
-    runControl.setPhase("recommend:screening");
-    let llmResult = null;
-    if (useLlmScreening) {
-      if (skipRecentColleagueContact || recoverableDetailError || detailResult?.image_evidence?.ok === false) {
+    runControl.throwIfCanceled();
+    runControl.setPhase("recommend:screening");
+    let llmResult = null;
+    const imageAcquisitionFailed = shouldFailClosedRecommendImageAcquisition(detailResult);
+    if (useLlmScreening) {
+      if (skipRecentColleagueContact || recoverableDetailError || imageAcquisitionFailed) {
         llmResult = null;
       } else if (!llmConfig) {
         llmResult = createMissingLlmConfigResult();
@@ -1564,47 +2683,85 @@ export async function runRecommendWorkflow({
       ? createRecentColleagueContactSkipScreening(screeningCandidate, colleagueContact)
       : recoverableDetailError
       ? createRecoverableDetailFailureScreening(screeningCandidate, recoverableDetailError)
-      : detailResult?.image_evidence?.ok === false
-      ? createImageCaptureFailureScreening(screeningCandidate, {
-        code: detailResult.image_evidence.error_code,
-        message: detailResult.image_evidence.error
-      })
+      : imageAcquisitionFailed
+      ? createImageCaptureFailureScreening(screeningCandidate, {
+        code: detailResult?.image_evidence?.error_code || "IMAGE_CAPTURE_EVIDENCE_MISSING",
+        message: detailResult?.image_evidence?.error || "Required CV image evidence is unavailable"
+      })
       : useLlmScreening
         ? llmResultToScreening(llmResult, screeningCandidate)
         : screenCandidate(screeningCandidate, { criteria });
     let actionDiscovery = null;
     let postActionResult = null;
-    let closeFailureError = null;
-    let closeRecoveryFailure = null;
-    if (postActionEnabled && detailResult && !skipRecentColleagueContact) {
-      const postActionStarted = Date.now();
-      await runControl.waitIfPaused();
-      runControl.throwIfCanceled();
-      runControl.setPhase("recommend:post-action");
-      await maybeHumanActionCooldown("before_post_action", timings);
-      actionDiscovery = await waitForRecommendDetailActionControls(client, {
-        timeoutMs: actionTimeoutMs,
-        intervalMs: actionIntervalMs,
-        requireAny: true
-      });
-      postActionResult = await runRecommendPostAction({
-        client,
-        screening,
-        actionDiscovery,
-        postAction: normalizedPostAction,
-        greetCount,
-        maxGreetCount: Number.isInteger(maxGreetCount) ? maxGreetCount : null,
-        executePostAction,
-        afterClickDelayMs: actionAfterClickDelayMs
-      });
-      if (postActionResult.counted_as_greet && postActionResult.action_clicked) {
-        greetCount += 1;
-      }
-      addTiming(timings, "post_action_ms", Date.now() - postActionStarted);
-    }
-    if (detailResult && closeDetail && !detailResult.close_result?.closed) {
-      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
-      await maybeHumanActionCooldown("after_detail_close", timings);
+    let closeFailureError = null;
+    let closeRecoveryFailure = null;
+    if (postActionEnabled && detailResult && !skipRecentColleagueContact) {
+      try {
+        const postActionStarted = Date.now();
+        await runControl.waitIfPaused();
+        runControl.throwIfCanceled();
+        runControl.setPhase("recommend:post-action");
+        detailStep = "post_action_discovery";
+        currentDomOperation = "candidate:post-action-discovery";
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        await maybeHumanActionCooldown("before_post_action", timings);
+        actionDiscovery = await waitForRecommendDetailActionControls(client, {
+          timeoutMs: actionTimeoutMs,
+          intervalMs: actionIntervalMs,
+          requireAny: true
+        });
+        detailStep = "post_action_execute";
+        currentDomOperation = "candidate:post-action-execute";
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        postActionResult = await runRecommendPostAction({
+          client,
+          screening,
+          actionDiscovery,
+          postAction: normalizedPostAction,
+          greetCount,
+          maxGreetCount: Number.isInteger(maxGreetCount) ? maxGreetCount : null,
+          executePostAction,
+          afterClickDelayMs: actionAfterClickDelayMs
+        });
+        if (postActionResult.counted_as_greet && postActionResult.action_clicked) {
+          greetCount += 1;
+        }
+        addTiming(timings, "post_action_ms", Date.now() - postActionStarted);
+      } catch (error) {
+        checkpointDomStaleForensic(error, {
+          phase: "recommend:post-action",
+          operation: currentDomOperation,
+          detailStep,
+          candidateIndex: index,
+          candidateKey,
+          cardNodeId
+        });
+        throw error;
+      }
+    }
+    if (detailResult && closeDetail && !detailResult.close_result?.closed) {
+      runControl.setPhase("recommend:close-detail");
+      detailStep = "close_detail";
+      currentDomOperation = "candidate:close-detail";
+      checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+      try {
+        detailResult.close_result = await measureTiming(
+          timings,
+          "close_detail_ms",
+          () => closeRecommendDetail(client)
+        );
+      } catch (error) {
+        checkpointDomStaleForensic(error, {
+          phase: "recommend:close-detail",
+          operation: currentDomOperation,
+          detailStep,
+          candidateIndex: index,
+          candidateKey,
+          cardNodeId
+        });
+        throw error;
+      }
+      await maybeHumanActionCooldown("after_detail_close", timings);
       if (!detailResult.close_result?.closed) {
         closeFailureError = createRecommendCloseFailureError(detailResult.close_result);
         try {
@@ -1623,17 +2780,17 @@ export async function runRecommendWorkflow({
         } catch (error) {
           closeRecoveryFailure = error;
           detailResult.cv_acquisition = {
-            ...(detailResult.cv_acquisition || {}),
-            close_recovery: {
-              ok: false,
-              reason: "context_recovery_failed",
-              error: error?.message || String(error),
-              forced_recent_not_view: Boolean(normalizedFilter.enabled)
-            }
-          };
-        }
-      }
-    }
+            ...(detailResult.cv_acquisition || {}),
+            close_recovery: {
+              ok: false,
+              reason: "context_recovery_failed",
+              error: error?.message || String(error),
+              forced_recent_not_view: Boolean(normalizedFilter.enabled)
+            }
+          };
+        }
+      }
+    }
     timings.total_ms = Date.now() - candidateStarted;
     const compactResult = {
       index,
@@ -1670,9 +2827,10 @@ export async function runRecommendWorkflow({
       last_candidate_key: candidateKey,
       last_score: screening.score
     });
-    const checkpointStarted = Date.now();
-    runControl.checkpoint({
-      results,
+    const checkpointStarted = Date.now();
+    runControl.checkpoint({
+      in_progress_candidate: null,
+      results,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -1729,17 +2887,17 @@ export async function runRecommendWorkflow({
   }
 
   runControl.setPhase("recommend:done");
-  return {
-    domain: "recommend",
-    target_url: targetUrl,
-    job_selection: compactJobSelection(jobSelection),
-    page_scope: compactPageScopeSelection(pageScopeSelection),
-    current_city_only: compactCurrentCityOnlyResult(currentCityOnlyResult),
-    filter: compactFilterResult(filterResult),
-    card_count: cardNodeIds.length,
-    candidate_list: compactInfiniteListState(listState),
-    viewport_health: {
-      stats: viewportGuard.getStats(),
+  return {
+    domain: "recommend",
+    target_url: targetUrl,
+    job_selection: compactJobSelection(jobSelection),
+    page_scope: compactPageScopeSelection(pageScopeSelection),
+    current_city_only: compactCurrentCityOnlyResult(currentCityOnlyResult),
+    filter: compactFilterResult(filterResult),
+    card_count: cardNodeIds.length,
+    candidate_list: compactInfiniteListState(listState),
+    viewport_health: {
+      stats: viewportGuard.getStats(),
       events: viewportGuard.getEvents()
     },
     human_behavior: effectiveHumanBehavior,
@@ -1749,7 +2907,19 @@ export async function runRecommendWorkflow({
     refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,
     context_recoveries: contextRecoveryAttempts,
-    ...countRecommendResultStatuses(results, { greetCount }),
+    debug_boundary: debugBoundary.getState(),
+    list_read_stale_recovery_attempts: listReadStaleRecoveryAttempts,
+    list_read_stale_recovery_applied: listReadStaleRecoveryApplied,
+    list_read_stale_recoveries: listReadStaleRecoveries,
+    last_list_read_recovery_mode: lastListReadRecoveryMode,
+    last_list_read_stale_diagnostic: lastListReadStaleDiagnostic,
+    list_read_stale_diagnostics: listReadStaleDiagnostics.slice(-12),
+    dom_stale_events: domStaleEventCount,
+    dom_stale_forensics: domStaleForensics.slice(-12),
+    dom_lifecycle_timeline: domLifecycleTimeline.slice(-20),
+    ...countRecommendResultStatuses(results, { greetCount }),
+    transient_recovered: countRecommendResultStatuses(results, { greetCount }).transient_recovered
+      + listReadStaleRecoveries,
     results
   };
 }
@@ -1805,6 +2975,10 @@ export function createRecommendRunService({
     humanBehavior = null,
     skipRecentColleagueContacted = true,
     colleagueContactWindowDays = 14,
+    debugTestMode = undefined,
+    debugForceListEndAfterProcessed = undefined,
+    debugForceContextRecoveryAfterProcessed = undefined,
+    debugForceCdpReconnectAfterProcessed = undefined,
     name = "recommend-domain-run"
   } = {}) {
     if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
@@ -1821,6 +2995,12 @@ export function createRecommendRunService({
     const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
     const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? null : Math.max(0, Number(detailLimit) || 0);
+    const debugBoundaryOptions = normalizeRecommendDebugBoundaryOptions({
+      debugTestMode: debugTestMode === true,
+      debugForceListEndAfterProcessed: debugForceListEndAfterProcessed ?? null,
+      debugForceContextRecoveryAfterProcessed: debugForceContextRecoveryAfterProcessed ?? null,
+      debugForceCdpReconnectAfterProcessed: debugForceCdpReconnectAfterProcessed ?? null
+    });
     return manager.startRun({
       runId,
       name,
@@ -1828,17 +3008,17 @@ export function createRecommendRunService({
       context: {
         domain: "recommend",
         target_url: targetUrl,
-        criteria_present: Boolean(criteria),
-        job_label: jobLabel || "",
-        requested_page_scope: requestedPageScope,
-        fallback_page_scope: normalizedFallbackPageScope,
-        filter: normalizedFilter,
-        current_city_only_requested: normalizedFilter.currentCityOnly,
-        max_candidates: maxCandidates,
-        max_candidates_semantics: "passed_candidates",
-        detail_limit: normalizedDetailLimit,
-        close_detail: closeDetail,
-        cv_acquisition_mode: cvAcquisitionMode,
+        criteria_present: Boolean(criteria),
+        job_label: jobLabel || "",
+        requested_page_scope: requestedPageScope,
+        fallback_page_scope: normalizedFallbackPageScope,
+        filter: normalizedFilter,
+        current_city_only_requested: normalizedFilter.currentCityOnly,
+        max_candidates: maxCandidates,
+        max_candidates_semantics: "passed_candidates",
+        detail_limit: normalizedDetailLimit,
+        close_detail: closeDetail,
+        cv_acquisition_mode: cvAcquisitionMode,
         max_image_pages: maxImagePages,
         image_wheel_delta_y: imageWheelDeltaY,
         list_max_scrolls: listMaxScrolls,
@@ -1866,7 +3046,10 @@ export function createRecommendRunService({
         human_behavior_profile: effectiveHumanBehavior.profile,
         human_behavior: effectiveHumanBehavior,
         human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled
+        human_rest_enabled: effectiveHumanRestEnabled,
+        debug_test_mode: debugBoundaryOptions.debugTestMode,
+        debug_boundary_mode: debugBoundaryOptions.mode,
+        debug_boundary_threshold: debugBoundaryOptions.threshold
       },
       progress: {
         card_count: 0,
@@ -1882,21 +3065,25 @@ export function createRecommendRunService({
         post_action_clicked: 0,
         image_capture_failed: 0,
         detail_open_failed: 0,
-        transient_recovered: 0,
-        colleague_contact_checked: 0,
-        recent_colleague_contact_skipped: 0,
-        colleague_contact_panel_missing: 0,
-        context_recoveries: 0,
-        current_city_only_requested: normalizedFilter.currentCityOnly,
-        current_city_only_effective: null,
-        current_city_only_unavailable: false,
-        human_behavior_enabled: effectiveHumanBehavior.enabled,
-        human_behavior_profile: effectiveHumanBehavior.profile,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled,
-        human_rest_count: 0,
+        transient_recovered: 0,
+        colleague_contact_checked: 0,
+        recent_colleague_contact_skipped: 0,
+        colleague_contact_panel_missing: 0,
+        context_recoveries: 0,
+        current_city_only_requested: normalizedFilter.currentCityOnly,
+        current_city_only_effective: null,
+        current_city_only_unavailable: false,
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled,
+        human_rest_count: 0,
         human_rest_ms: 0,
-        last_human_event: null
+        last_human_event: null,
+        debug_boundary_mode: debugBoundaryOptions.mode,
+        debug_boundary_threshold: debugBoundaryOptions.threshold,
+        debug_boundary_triggered: false,
+        debug_boundary_trigger_count: 0
       },
       checkpoint: {},
       task: (runControl) => workflow({
@@ -1939,7 +3126,11 @@ export function createRecommendRunService({
         humanRestEnabled: effectiveHumanRestEnabled,
         humanBehavior: effectiveHumanBehavior,
         skipRecentColleagueContacted: shouldSkipRecentColleagueContacted,
-        colleagueContactWindowDays: normalizedColleagueContactWindowDays
+        colleagueContactWindowDays: normalizedColleagueContactWindowDays,
+        debugTestMode: debugBoundaryOptions.debugTestMode,
+        debugForceListEndAfterProcessed: debugBoundaryOptions.debugForceListEndAfterProcessed,
+        debugForceContextRecoveryAfterProcessed: debugBoundaryOptions.debugForceContextRecoveryAfterProcessed,
+        debugForceCdpReconnectAfterProcessed: debugBoundaryOptions.debugForceCdpReconnectAfterProcessed
       }, runControl)
     });
   }