@reconcrap/boss-recommend-mcp 2.1.22 → 2.1.24

package/src/recommend-mcp.js

@@ -8,6 +8,7 @@ import {
   createBossLoginRequiredError,
   detectBossLoginState,
   enableDomains,
+  FORBIDDEN_CDP_METHODS,
   getMainFrameUrl,
   isBossLoginUrl,
   waitForMainFrameUrl,
@@ -284,6 +285,15 @@ function collectRecommendDebugTestOptions(args = {}, normalized = {}) {
   if (parseNonNegativeInteger(args.detail_limit, null) === 0) reasons.push("detail_limit=0");
   if (args.no_filter === true) reasons.push("no_filter");
   if (args.filter_enabled === false) reasons.push("filter_enabled=false");
+  if (args.debug_force_list_end_after_processed != null) {
+    reasons.push("debug_force_list_end_after_processed");
+  }
+  if (args.debug_force_context_recovery_after_processed != null) {
+    reasons.push("debug_force_context_recovery_after_processed");
+  }
+  if (args.debug_force_cdp_reconnect_after_processed != null) {
+    reasons.push("debug_force_cdp_reconnect_after_processed");
+  }
   if (args.dry_run_post_action === true) reasons.push("dry_run_post_action");
   if (args.execute_post_action === false && normalized.postAction && normalized.postAction !== "none") {
     reasons.push("execute_post_action=false");
@@ -306,18 +316,44 @@ function resolveRecommendDetailLimit(args = {}, normalized = {}) {
 function methodSummary(methodLog = []) {
   const summary = {};
   for (const entry of methodLog || []) {
-    summary[entry.method] = (summary[entry.method] || 0) + 1;
+    const method = compactCdpMethodName(entry?.method || entry || "");
+    if (!method) continue;
+    summary[method] = (summary[method] || 0) + 1;
   }
   return summary;
 }
 
-function compactMethodLogForStatus(methodLog = []) {
-  if (!Array.isArray(methodLog)) return [];
-  return methodLog.slice(-STATUS_METHOD_LOG_TAIL_LIMIT).map((entry) => ({
-    method: normalizeText(entry?.method || entry || ""),
-    at: normalizeText(entry?.at || "")
-  }));
-}
+function compactCdpMethodName(value) {
+  const method = normalizeText(value);
+  return /^[A-Za-z][A-Za-z0-9_]*\.[A-Za-z][A-Za-z0-9_]*(?::retry_after_reconnect)?$/.test(method)
+    ? method
+    : "";
+}
+
+function compactCdpMethodTimestamp(value) {
+  const timestamp = normalizeText(value);
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? new Date(parsed).toISOString() : "";
+}
+
+function compactMethodLogForStatus(methodLog = []) {
+  if (!Array.isArray(methodLog)) return [];
+  return methodLog
+    .map((entry) => {
+      const compact = {
+        method: compactCdpMethodName(entry?.method || entry || ""),
+        at: compactCdpMethodTimestamp(entry?.at || "")
+      };
+      for (const key of ["connection_epoch", "replay_of_connection_epoch"]) {
+        if (Number.isInteger(entry?.[key]) && entry[key] >= 0) compact[key] = entry[key];
+      }
+      const replayPolicy = normalizeText(entry?.replay_policy || "");
+      if (replayPolicy) compact.replay_policy = replayPolicy.slice(0, 100);
+      return compact;
+    })
+    .filter((entry) => Boolean(entry.method))
+    .slice(-STATUS_METHOD_LOG_TAIL_LIMIT);
+}
 
 function clonePlain(value, fallback = null) {
   try {
@@ -336,6 +372,126 @@ function nonEmptyRecord(value) {
   return Object.keys(record).length ? record : null;
 }
 
+function compactMethodSummaryForStatus(value = {}) {
+  const compact = {};
+  for (const [rawMethod, rawCount] of Object.entries(plainRecord(value))) {
+    const method = compactCdpMethodName(rawMethod);
+    const count = Number(rawCount);
+    if (!method || !Number.isInteger(count) || count < 1) continue;
+    compact[method] = count;
+  }
+  return compact;
+}
+
+function compactChromeEvidenceUrl(value) {
+  const text = normalizeText(value);
+  if (!text) return null;
+  try {
+    const parsed = new URL(text);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return text.split(/[?#]/, 1)[0] || null;
+  }
+}
+
+function compactChromeAutoLaunchEvidence(value = {}) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  const booleanKeys = [
+    "launched",
+    "reused",
+    "guard_checked",
+    "required_flags_ok",
+    "replaced",
+    "target_created",
+    "fallback_target",
+    "fallback_any_page"
+  ];
+  for (const key of booleanKeys) {
+    if (typeof source[key] === "boolean") compact[key] = source[key];
+  }
+  for (const key of ["port", "target_count", "command_line_args_count"]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  for (const key of ["close_method", "command_line_source"]) {
+    const text = normalizeText(source[key]);
+    if (text) compact[key] = text;
+  }
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactChromeEvidence(value = {}) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  const host = normalizeText(source.host);
+  const targetId = normalizeText(source.target_id);
+  const targetUrl = compactChromeEvidenceUrl(source.target_url);
+  if (host) compact.host = host;
+  if (Number.isInteger(source.port) && source.port > 0) compact.port = source.port;
+  if (targetUrl) compact.target_url = targetUrl;
+  if (targetId) compact.target_id = targetId;
+  const autoLaunch = compactChromeAutoLaunchEvidence(source.auto_launch);
+  if (autoLaunch) compact.auto_launch = autoLaunch;
+  return Object.keys(compact).length ? compact : null;
+}
+
+function methodEvidenceFlags(methodSummaryValue = {}) {
+  const methods = Object.keys(methodSummaryValue);
+  return {
+    runtime_evaluate_used: methods.some((method) => method.split(".", 1)[0] === "Runtime"),
+    script_injection_used: methods.some((method) => (
+      FORBIDDEN_CDP_METHODS.has(method.replace(/:retry_after_reconnect$/, ""))
+    ))
+  };
+}
+
+function buildPersistedCdpEvidence({ meta = {}, persisted = {} } = {}) {
+  const hasLiveMethodLog = Array.isArray(meta.methodLog);
+  const persistedMethodLog = compactMethodLogForStatus(persisted.method_log);
+  const methodLog = hasLiveMethodLog
+    ? compactMethodLogForStatus(meta.methodLog)
+    : persistedMethodLog;
+  const persistedSummary = compactMethodSummaryForStatus(persisted.method_summary);
+  const summary = hasLiveMethodLog
+    ? methodSummary(meta.methodLog)
+    : Object.keys(persistedSummary).length
+      ? persistedSummary
+      : methodSummary(methodLog);
+  const liveTotal = hasLiveMethodLog ? meta.methodLog.length : null;
+  const persistedTotal = Number(persisted.method_log_total);
+  const methodLogTotal = Number.isInteger(liveTotal)
+    ? liveTotal
+    : Number.isInteger(persistedTotal) && persistedTotal >= methodLog.length
+      ? persistedTotal
+      : methodLog.length;
+  const inferredFlags = methodEvidenceFlags(summary);
+  return {
+    runtime_evaluate_used: hasLiveMethodLog
+      ? inferredFlags.runtime_evaluate_used
+      : persisted.runtime_evaluate_used === true || inferredFlags.runtime_evaluate_used,
+    script_injection_used: hasLiveMethodLog
+      ? inferredFlags.script_injection_used
+      : persisted.script_injection_used === true || inferredFlags.script_injection_used,
+    method_summary: summary,
+    method_log: methodLog,
+    method_log_total: methodLogTotal,
+    chrome: compactChromeEvidence(meta.chrome || persisted.chrome)
+  };
+}
+
+function attachPersistedCdpEvidence(payload, persisted = {}) {
+  return {
+    ...payload,
+    ...buildPersistedCdpEvidence({ persisted })
+  };
+}
+
 function normalizeRunId(runId) {
   const normalized = normalizeText(runId);
   if (!normalized || normalized.includes("/") || normalized.includes("\\")) return "";
@@ -382,12 +538,12 @@ function readJsonFile(filePath) {
 
 function recommendSearchParamsForCsv(searchParams = {}) {
   return {
-    school_tag: Object.prototype.hasOwnProperty.call(searchParams, "school_tag") ? searchParams.school_tag : "不限",
-    degree: Object.prototype.hasOwnProperty.call(searchParams, "degree") ? searchParams.degree : "不限",
-    gender: Object.prototype.hasOwnProperty.call(searchParams, "gender") ? searchParams.gender : "不限",
-    recent_not_view: Object.prototype.hasOwnProperty.call(searchParams, "recent_not_view") ? searchParams.recent_not_view : "不限",
-    current_city_only: Object.prototype.hasOwnProperty.call(searchParams, "current_city_only") ? searchParams.current_city_only : false,
-    activity_level: Object.prototype.hasOwnProperty.call(searchParams, "activity_level") ? searchParams.activity_level : "不限"
+    school_tag: Object.prototype.hasOwnProperty.call(searchParams, "school_tag") ? searchParams.school_tag : "不限",
+    degree: Object.prototype.hasOwnProperty.call(searchParams, "degree") ? searchParams.degree : "不限",
+    gender: Object.prototype.hasOwnProperty.call(searchParams, "gender") ? searchParams.gender : "不限",
+    recent_not_view: Object.prototype.hasOwnProperty.call(searchParams, "recent_not_view") ? searchParams.recent_not_view : "不限",
+    current_city_only: Object.prototype.hasOwnProperty.call(searchParams, "current_city_only") ? searchParams.current_city_only : false,
+    activity_level: Object.prototype.hasOwnProperty.call(searchParams, "activity_level") ? searchParams.activity_level : "不限"
   };
 }
 
@@ -426,12 +582,12 @@ function selectedRecommendJobForCsv(meta = {}, snapshot = {}) {
 function buildRecommendCsvInputRows(snapshot = {}, meta = {}) {
   const { context, confirmation, overrides, followUp, shared } = getSnapshotRequestContext(snapshot);
   const searchParams = recommendSearchParamsForCsv(meta.parsed?.searchParams || {
-    school_tag: overrides.school_tag ?? confirmation.school_tag_value,
-    degree: overrides.degree ?? confirmation.degree_value,
-    gender: overrides.gender ?? confirmation.gender_value,
-    recent_not_view: overrides.recent_not_view ?? confirmation.recent_not_view_value,
-    current_city_only: overrides.current_city_only ?? false,
-    activity_level: overrides.activity_level ?? "不限"
+    school_tag: overrides.school_tag ?? confirmation.school_tag_value,
+    degree: overrides.degree ?? confirmation.degree_value,
+    gender: overrides.gender ?? confirmation.gender_value,
+    recent_not_view: overrides.recent_not_view ?? confirmation.recent_not_view_value,
+    current_city_only: overrides.current_city_only ?? false,
+    activity_level: overrides.activity_level ?? "不限"
   });
   const parsedScreenParams = meta.parsed?.screenParams || {};
   const screenParams = {
@@ -506,7 +662,7 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     : Number.isInteger(summary?.passed)
       ? summary.passed
       : 0;
-  return {
+  const normalized = {
     ...progress,
     processed,
     inspected: processed,
@@ -516,7 +672,28 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     greet_count: Number.isInteger(progress.greet_count) ? progress.greet_count : 0,
     post_action_clicked: Number.isInteger(progress.post_action_clicked) ? progress.post_action_clicked : 0
   };
-}
+  if (Object.prototype.hasOwnProperty.call(normalized, "last_list_read_stale_diagnostic")) {
+    normalized.last_list_read_stale_diagnostic = compactListReadStaleDiagnosticForStatus(
+      normalized.last_list_read_stale_diagnostic
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(normalized, "list_read_stale_diagnostics")) {
+    normalized.list_read_stale_diagnostics = compactListReadStaleDiagnosticsForStatus(
+      normalized.list_read_stale_diagnostics
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(normalized, "dom_stale_forensic")) {
+    normalized.dom_stale_forensic = compactDomStaleForensicForStatus(
+      normalized.dom_stale_forensic
+    );
+  }
+  if (Object.prototype.hasOwnProperty.call(normalized, "dom_stale_forensics")) {
+    normalized.dom_stale_forensics = compactDomStaleForensicsForStatus(
+      normalized.dom_stale_forensics
+    );
+  }
+  return normalized;
+}
 
 const STATUS_COUNT_KEYS = [
   "processed",
@@ -550,6 +727,231 @@ function compactSmallRecord(value, fallback = null) {
   return clonePlain(record, fallback);
 }
 
+function compactListReadStaleDiagnosticForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const key of [
+    "name",
+    "code",
+    "message",
+    "phase",
+    "cdp_method",
+    "cdp_at",
+    "cdp_search_id",
+    "cdp_replay_policy",
+    "recovery_mode"
+  ]) {
+    const text = normalizeText(source[key] || "");
+    if (text) compact[key] = text.slice(0, key === "message" ? 500 : 200);
+  }
+  for (const key of [
+    "cdp_node_id",
+    "cdp_backend_node_id",
+    "cdp_connection_epoch",
+    "cdp_reconnected_epoch",
+    "attempt"
+  ]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  for (const key of [
+    "exhausted",
+    "recovery_applied",
+    "recovered",
+    "cdp_replay_suppressed",
+    "cdp_outcome_unknown",
+    "cdp_reconnected",
+    "cdp_replayed_after_reconnect"
+  ]) {
+    if (typeof source[key] === "boolean") compact[key] = source[key];
+  }
+  for (const key of ["at", "recovery_applied_at", "recovered_at"]) {
+    const text = normalizeText(source[key] || "");
+    if (text && Number.isFinite(Date.parse(text))) compact[key] = new Date(text).toISOString();
+  }
+  if (Array.isArray(source.cdp_param_keys)) {
+    compact.cdp_param_keys = source.cdp_param_keys
+      .map((key) => normalizeText(key))
+      .filter((key) => /^[A-Za-z][A-Za-z0-9_]*$/.test(key))
+      .slice(0, 20);
+  }
+  if (source.cdp_reconnect_error !== undefined && source.cdp_reconnect_error !== null) {
+    const reconnectError = plainRecord(source.cdp_reconnect_error);
+    if (Object.keys(reconnectError).length) {
+      const safeReconnectError = {};
+      for (const key of ["name", "code", "message"]) {
+        const text = normalizeText(reconnectError[key] || "");
+        if (text) safeReconnectError[key] = text.slice(0, key === "message" ? 500 : 200);
+      }
+      if (Object.keys(safeReconnectError).length) compact.cdp_reconnect_error = safeReconnectError;
+    } else {
+      const reconnectErrorText = normalizeText(source.cdp_reconnect_error);
+      if (reconnectErrorText) compact.cdp_reconnect_error = reconnectErrorText.slice(0, 500);
+    }
+  }
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleRootIdentityForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const key of [
+    "connection_epoch",
+    "top_document_node_id",
+    "iframe_owner_node_id",
+    "iframe_document_node_id"
+  ]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  const iframeSelector = normalizeText(source.iframe_selector || "");
+  if (iframeSelector) compact.iframe_selector = iframeSelector.slice(0, 300);
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleNumericRecordForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const [key, rawValue] of Object.entries(source)) {
+    if (!/^[a-z][a-z0-9_]*$/i.test(key)) continue;
+    if (!Number.isInteger(rawValue) || rawValue < 0) continue;
+    compact[key] = rawValue;
+    if (Object.keys(compact).length >= 30) break;
+  }
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleLifecycleTimelineForStatus(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((rawEntry) => {
+      const entry = plainRecord(rawEntry);
+      const compact = {};
+      const at = compactCdpMethodTimestamp(entry.at || "");
+      if (at) compact.at = at;
+      for (const key of ["type", "operation", "frame_id", "parent_frame_id", "loader_id"]) {
+        const text = normalizeText(entry[key] || "");
+        if (text) compact[key] = text.slice(0, 300);
+      }
+      if (Number.isInteger(entry.connection_epoch) && entry.connection_epoch >= 0) {
+        compact.connection_epoch = entry.connection_epoch;
+      }
+      const url = compactChromeEvidenceUrl(entry.url);
+      if (url) compact.url = url;
+      return Object.keys(compact).length ? compact : null;
+    })
+    .filter(Boolean)
+    .slice(-20);
+}
+
+function compactDomStaleCandidateForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const key of ["index", "card_node_id", "visible_index", "failing_list_node_id"]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  const candidateKey = normalizeText(source.key || "");
+  if (candidateKey) compact.key = candidateKey.slice(0, 300);
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleRecoveryForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const key of ["status", "mode", "escalated_from", "method"]) {
+    const text = normalizeText(source[key] || "");
+    if (text) compact[key] = text.slice(0, 200);
+  }
+  const at = compactCdpMethodTimestamp(source.at || "");
+  if (at) compact.at = at;
+  if (typeof source.ok === "boolean") compact.ok = source.ok;
+  if (Number.isInteger(source.card_count) && source.card_count >= 0) {
+    compact.card_count = source.card_count;
+  }
+  const error = compactListReadStaleDiagnosticForStatus(source.error);
+  if (error) compact.error = error;
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleForensicForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  if (Number.isInteger(source.schema_version) && source.schema_version >= 0) {
+    compact.schema_version = source.schema_version;
+  }
+  for (const key of ["event_id", "event_type", "phase", "operation", "detail_step"]) {
+    const text = normalizeText(source[key] || "");
+    if (text) compact[key] = text.slice(0, key === "event_id" ? 300 : 200);
+  }
+  const at = compactCdpMethodTimestamp(source.at || "");
+  if (at) compact.at = at;
+
+  const candidate = compactDomStaleCandidateForStatus(source.candidate);
+  if (candidate) compact.candidate = candidate;
+  const error = compactListReadStaleDiagnosticForStatus(source.error);
+  if (error) compact.error = error;
+  const preRecoveryRoots = compactDomStaleRootIdentityForStatus(source.pre_recovery_roots);
+  if (preRecoveryRoots) compact.pre_recovery_roots = preRecoveryRoots;
+  const postRecoveryRoots = compactDomStaleRootIdentityForStatus(source.post_recovery_roots);
+  if (postRecoveryRoots) compact.post_recovery_roots = postRecoveryRoots;
+  const candidateList = compactDomStaleNumericRecordForStatus(source.candidate_list);
+  if (candidateList) compact.candidate_list = candidateList;
+  const counters = compactDomStaleNumericRecordForStatus(source.counters);
+  if (counters) compact.counters = counters;
+  const lifecycleTimeline = compactDomStaleLifecycleTimelineForStatus(source.lifecycle_timeline);
+  if (lifecycleTimeline.length) compact.lifecycle_timeline = lifecycleTimeline;
+  const recovery = compactDomStaleRecoveryForStatus(source.recovery);
+  if (recovery) compact.recovery = recovery;
+  return Object.keys(compact).length ? compact : null;
+}
+
+function compactDomStaleForensicsForStatus(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => compactDomStaleForensicForStatus(item))
+    .filter(Boolean)
+    .slice(-12);
+}
+
+function compactListReadStaleDiagnosticsForStatus(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => compactListReadStaleDiagnosticForStatus(item))
+    .filter(Boolean)
+    .slice(-12);
+}
+
+function compactListReadStaleCheckpointEvent(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  const diagnostic = compactListReadStaleDiagnosticForStatus(source.diagnostic || source.trigger);
+  if (diagnostic) compact.diagnostic = diagnostic;
+  const recentDiagnostics = compactListReadStaleDiagnosticsForStatus(source.recent_diagnostics);
+  if (recentDiagnostics.length) compact.recent_diagnostics = recentDiagnostics;
+  for (const key of ["recovery_count", "recovery_applied_count"]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  if (source.recovery_error) {
+    const recoveryError = compactListReadStaleDiagnosticForStatus(source.recovery_error);
+    if (recoveryError) compact.recovery_error = recoveryError;
+  }
+  if (source.candidate_list) {
+    const candidateList = plainRecord(source.candidate_list);
+    compact.candidate_list = {};
+    for (const key of ["seen_count", "queued_count", "processed_count", "read_error_count", "scroll_count"]) {
+      if (Number.isInteger(candidateList[key]) && candidateList[key] >= 0) {
+        compact.candidate_list[key] = candidateList[key];
+      }
+    }
+  }
+  return Object.keys(compact).length ? compact : null;
+}
+
 function compactRecommendSummaryForStatus(summary) {
   if (!summary || typeof summary !== "object" || Array.isArray(summary)) return null;
   const compact = {
@@ -605,8 +1007,28 @@ function compactRecommendSummaryForStatus(summary) {
       total_pause_ms: compactPositiveInteger(humanRest.total_pause_ms ?? humanRest.pause_ms, null)
     };
   }
-  return compact;
-}
+  for (const key of [
+    "list_read_stale_recovery_attempts",
+    "list_read_stale_recovery_applied",
+    "list_read_stale_recoveries"
+  ]) {
+    if (Number.isInteger(summary[key]) && summary[key] >= 0) compact[key] = summary[key];
+  }
+  if (summary.last_list_read_recovery_mode) {
+    compact.last_list_read_recovery_mode = normalizeText(summary.last_list_read_recovery_mode).slice(0, 100);
+  }
+  const lastStaleDiagnostic = compactListReadStaleDiagnosticForStatus(
+    summary.last_list_read_stale_diagnostic
+  );
+  if (lastStaleDiagnostic) compact.last_list_read_stale_diagnostic = lastStaleDiagnostic;
+  const staleDiagnostics = compactListReadStaleDiagnosticsForStatus(summary.list_read_stale_diagnostics);
+  if (staleDiagnostics.length) compact.list_read_stale_diagnostics = staleDiagnostics;
+  const domStaleForensic = compactDomStaleForensicForStatus(summary.dom_stale_forensic);
+  if (domStaleForensic) compact.dom_stale_forensic = domStaleForensic;
+  const domStaleForensics = compactDomStaleForensicsForStatus(summary.dom_stale_forensics);
+  if (domStaleForensics.length) compact.dom_stale_forensics = domStaleForensics;
+  return compact;
+}
 
 function compactRecommendCheckpointForStatus(checkpoint) {
   if (!checkpoint || typeof checkpoint !== "object" || Array.isArray(checkpoint)) return {};
@@ -622,8 +1044,22 @@ function compactRecommendCheckpointForStatus(checkpoint) {
   for (const key of STATUS_COUNT_KEYS) {
     if (Number.isInteger(checkpoint[key])) compact[key] = checkpoint[key];
   }
-  return compact;
-}
+  for (const key of [
+    "list_read_stale_recovery",
+    "list_read_stale_recovery_applied",
+    "list_read_stale_recovered",
+    "list_read_stale_recovery_exhausted",
+    "list_read_stale_recovery_failed"
+  ]) {
+    const event = compactListReadStaleCheckpointEvent(checkpoint[key]);
+    if (event) compact[key] = event;
+  }
+  const domStaleForensic = compactDomStaleForensicForStatus(checkpoint.dom_stale_forensic);
+  if (domStaleForensic) compact.dom_stale_forensic = domStaleForensic;
+  const domStaleForensics = compactDomStaleForensicsForStatus(checkpoint.dom_stale_forensics);
+  if (domStaleForensics.length) compact.dom_stale_forensics = domStaleForensics;
+  return compact;
+}
 
 function compactRecommendResultForStatus(result) {
   if (!result || typeof result !== "object" || Array.isArray(result)) return result || null;
@@ -1026,6 +1462,10 @@ function persistRecommendRunSnapshot(snapshot, {
   if (persistActiveCheckpoint) {
     persistRecommendCheckpointSnapshot(snapshot);
   }
+  const cdpEvidence = buildPersistedCdpEvidence({
+    meta: getRecommendRunMeta(normalized.run_id),
+    persisted: existing || {}
+  });
   const payload = {
     run_id: normalized.run_id,
     mode: normalized.mode,
@@ -1046,7 +1486,9 @@ function persistRecommendRunSnapshot(snapshot, {
     recovery: normalized.recovery,
     result: normalized.result,
     summary: normalized.summary,
-    artifacts: normalized.artifacts
+    checkpoint: normalized.checkpoint,
+    artifacts: normalized.artifacts,
+    ...cdpEvidence
   };
   writeJsonAtomic(artifacts.run_state_path, payload);
   return normalized;
@@ -1126,11 +1568,10 @@ function attachMethodEvidence(payload, runId) {
   assertNoForbiddenCdpCalls(methodLog);
   return {
     ...payload,
-    runtime_evaluate_used: false,
-    method_summary: methodSummary(methodLog),
-    method_log: compactMethodLogForStatus(methodLog),
-    method_log_total: Array.isArray(methodLog) ? methodLog.length : 0,
-    chrome: meta.chrome || null
+    ...buildPersistedCdpEvidence({
+      meta,
+      persisted: readRecommendRunState(runId) || {}
+    })
   };
 }
 
@@ -1683,13 +2124,13 @@ function buildRecommendFilter(parsed, args = {}) {
     return { enabled: false };
   }
 
-  const groups = [{
-    group: "activity",
-    labels: [parsed.searchParams?.activity_level || "不限"],
-    selectAllLabels: false,
-    allowUnlimited: true,
-    verifySticky: true
-  }];
+  const groups = [{
+    group: "activity",
+    labels: [parsed.searchParams?.activity_level || "不限"],
+    selectAllLabels: false,
+    allowUnlimited: true,
+    verifySticky: true
+  }];
   const recentNotView = withoutUnlimited(parsed.searchParams?.recent_not_view);
   if (recentNotView.length) {
     groups.push({
@@ -1726,12 +2167,12 @@ function buildRecommendFilter(parsed, args = {}) {
     });
   }
 
-  return {
-    enabled: true,
-    currentCityOnly: parsed.searchParams?.current_city_only === true,
-    filterGroups: groups
-  };
-}
+  return {
+    enabled: true,
+    currentCityOnly: parsed.searchParams?.current_city_only === true,
+    filterGroups: groups
+  };
+}
 
 function normalizeRecommendStartInput(args = {}, parsed, configResolution = null) {
   const confirmation = args.confirmation || {};
@@ -1822,6 +2263,19 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
     humanBehavior,
     skipRecentColleagueContacted: normalized.skipRecentColleagueContacted,
     colleagueContactWindowDays: normalized.colleagueContactWindowDays,
+    debugTestMode: isDebugTestMode(args),
+    debugForceListEndAfterProcessed: parsePositiveInteger(
+      args.debug_force_list_end_after_processed,
+      null
+    ),
+    debugForceContextRecoveryAfterProcessed: parsePositiveInteger(
+      args.debug_force_context_recovery_after_processed,
+      null
+    ),
+    debugForceCdpReconnectAfterProcessed: parsePositiveInteger(
+      args.debug_force_cdp_reconnect_after_processed,
+      null
+    ),
     name: "mcp-recommend-pipeline-run",
     parsed
   };
@@ -2117,19 +2571,16 @@ export function getRecommendPipelineRunTool({ args = {} } = {}) {
     const persisted = readRecommendRunState(runId);
     if (persisted) {
       const reconciled = compactRecommendRunForStatus(reconcilePersistedRecommendRunIfNeeded(persisted));
-      return {
+      const persistedEvidence = readRecommendRunState(runId) || persisted;
+      return attachPersistedCdpEvidence({
         status: "RUN_STATUS",
         run: reconciled,
         persistence: {
           source: "disk",
           active_control_available: false,
           stale_process_reconciled: reconciled?.state !== persisted.state
-        },
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        }
+      }, persistedEvidence);
     }
     return {
       status: "FAILED",
@@ -2172,15 +2623,11 @@ export function pauseRecommendPipelineRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
+      return attachPersistedCdpEvidence({
         status: "PAUSE_IGNORED",
         run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需暂停。",
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        message: "目标任务已结束，无需暂停。"
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2230,7 +2677,7 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted) {
-      return {
+      return attachPersistedCdpEvidence({
         status: "FAILED",
         error: {
           code: TERMINAL_STATUSES.has(persisted.state) ? "RUN_ALREADY_TERMINATED" : "RUN_NOT_ACTIVE",
@@ -2243,12 +2690,8 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
         persistence: {
           source: "disk",
           active_control_available: false
-        },
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        }
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2276,15 +2719,11 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
+      return attachPersistedCdpEvidence({
         status: "CANCEL_IGNORED",
         run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需取消。",
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        message: "目标任务已结束，无需取消。"
+      }, persisted);
     }
     const cancelMessage = "已收到取消请求，将由 detached worker 在下一个安全边界停止。";
     const patched = patchPersistedRecommendRunControl(runId, {
@@ -2296,7 +2735,7 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
       message: cancelMessage
     });
     if (patched) {
-      return {
+      return attachPersistedCdpEvidence({
         status: "CANCEL_REQUESTED",
         run: compactRecommendRunForStatus(patched),
         message: cancelMessage,
@@ -2304,12 +2743,8 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
           source: "disk",
           active_control_available: false,
           detached_control_requested: true
-        },
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        }
+      }, patched);
     }
     return getRecommendPipelineRunTool({ args });
   }