@reconcrap/boss-recommend-mcp 2.1.22 → 2.1.23

package/src/recommend-mcp.js

@@ -1,18 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
-import {
-  assertNoForbiddenCdpCalls,
-  bringPageToFront,
-  connectToChromeTargetOrOpen,
-  createBossLoginRequiredError,
-  detectBossLoginState,
-  enableDomains,
-  getMainFrameUrl,
-  isBossLoginUrl,
-  waitForMainFrameUrl,
-  sleep
-} from "./core/browser/index.js";
+import {
+  assertNoForbiddenCdpCalls,
+  bringPageToFront,
+  connectToChromeTargetOrOpen,
+  createBossLoginRequiredError,
+  detectBossLoginState,
+  enableDomains,
+  FORBIDDEN_CDP_METHODS,
+  getMainFrameUrl,
+  isBossLoginUrl,
+  waitForMainFrameUrl,
+  sleep
+} from "./core/browser/index.js";
 import {
   RUN_STATUS_CANCELING,
   RUN_STATUS_CANCELED,
@@ -277,13 +278,22 @@ function normalizeScreeningModeArg(args = {}) {
     : "llm";
 }
 
-function collectRecommendDebugTestOptions(args = {}, normalized = {}) {
-  const reasons = [];
+function collectRecommendDebugTestOptions(args = {}, normalized = {}) {
+  const reasons = [];
   if (normalizeScreeningModeArg(args) === "deterministic") reasons.push("deterministic_screening");
   if (args.allow_card_only_screening === true) reasons.push("allow_card_only_screening");
   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.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");
@@ -303,21 +313,39 @@ function resolveRecommendDetailLimit(args = {}, normalized = {}) {
   return requested;
 }
 
-function methodSummary(methodLog = []) {
-  const summary = {};
-  for (const entry of methodLog || []) {
-    summary[entry.method] = (summary[entry.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 methodSummary(methodLog = []) {
+  const summary = {};
+  for (const entry of methodLog || []) {
+    const method = compactCdpMethodName(entry?.method || entry || "");
+    if (!method) continue;
+    summary[method] = (summary[method] || 0) + 1;
+  }
+  return summary;
+}
+
+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) => ({
+      method: compactCdpMethodName(entry?.method || entry || ""),
+      at: compactCdpMethodTimestamp(entry?.at || "")
+    }))
+    .filter((entry) => Boolean(entry.method))
+    .slice(-STATUS_METHOD_LOG_TAIL_LIMIT);
+}
 
 function clonePlain(value, fallback = null) {
   try {
@@ -331,10 +359,130 @@ function plainRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
-function nonEmptyRecord(value) {
-  const record = plainRecord(value);
-  return Object.keys(record).length ? record : null;
-}
+function nonEmptyRecord(value) {
+  const record = plainRecord(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);
@@ -506,17 +654,28 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     : Number.isInteger(summary?.passed)
       ? summary.passed
       : 0;
-  return {
-    ...progress,
+  const normalized = {
+    ...progress,
     processed,
     inspected: processed,
     screened,
     passed,
     skipped: Number.isInteger(progress.skipped) ? progress.skipped : Math.max(processed - passed, 0),
-    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
-  };
-}
+    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
+    );
+  }
+  return normalized;
+}
 
 const STATUS_COUNT_KEYS = [
   "processed",
@@ -544,11 +703,73 @@ function compactPositiveInteger(value, fallback = null) {
   return Number.isInteger(value) && value >= 0 ? value : fallback;
 }
 
-function compactSmallRecord(value, fallback = null) {
+function compactSmallRecord(value, fallback = null) {
   const record = plainRecord(value);
   if (!Object.keys(record).length) return fallback;
-  return clonePlain(record, fallback);
-}
+  return clonePlain(record, fallback);
+}
+
+function compactListReadStaleDiagnosticForStatus(value) {
+  const source = plainRecord(value);
+  if (!Object.keys(source).length) return null;
+  const compact = {};
+  for (const key of ["code", "message", "phase", "cdp_method", "cdp_at", "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", "attempt"]) {
+    if (Number.isInteger(source[key]) && source[key] >= 0) compact[key] = source[key];
+  }
+  for (const key of ["exhausted", "recovery_applied", "recovered"]) {
+    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);
+  }
+  return Object.keys(compact).length ? compact : null;
+}
+
+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;
@@ -596,7 +817,7 @@ function compactRecommendSummaryForStatus(summary) {
       restLevel: normalizeText(summary.human_behavior.restLevel || summary.human_behavior.rest_level || "")
     };
   }
-  if (summary.human_rest) {
+  if (summary.human_rest) {
     const humanRest = plainRecord(summary.human_rest);
     compact.human_rest = {
       enabled: humanRest.enabled === true,
@@ -604,9 +825,25 @@ function compactRecommendSummaryForStatus(summary) {
       rest_count: compactPositiveInteger(humanRest.rest_count ?? humanRest.count, null),
       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;
+  return compact;
+}
 
 function compactRecommendCheckpointForStatus(checkpoint) {
   if (!checkpoint || typeof checkpoint !== "object" || Array.isArray(checkpoint)) return {};
@@ -619,11 +856,21 @@ function compactRecommendCheckpointForStatus(checkpoint) {
   } else if (Number.isInteger(checkpoint.results_count)) {
     compact.results_count = checkpoint.results_count;
   }
-  for (const key of STATUS_COUNT_KEYS) {
-    if (Number.isInteger(checkpoint[key])) compact[key] = checkpoint[key];
-  }
-  return compact;
-}
+  for (const key of STATUS_COUNT_KEYS) {
+    if (Number.isInteger(checkpoint[key])) compact[key] = checkpoint[key];
+  }
+  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;
+  }
+  return compact;
+}
 
 function compactRecommendResultForStatus(result) {
   if (!result || typeof result !== "object" || Array.isArray(result)) return result || null;
@@ -1021,12 +1268,16 @@ function persistRecommendRunSnapshot(snapshot, {
   const artifacts = getRecommendRunArtifacts(normalized.run_id);
   if (!artifacts) return normalized;
   const existing = readJsonFile(artifacts.run_state_path);
-  normalized.control = mergePersistedControlRequest(normalized, existing);
-  normalized = coerceCanceledTerminalSnapshot(normalized, existing);
-  if (persistActiveCheckpoint) {
-    persistRecommendCheckpointSnapshot(snapshot);
-  }
-  const payload = {
+  normalized.control = mergePersistedControlRequest(normalized, existing);
+  normalized = coerceCanceledTerminalSnapshot(normalized, existing);
+  if (persistActiveCheckpoint) {
+    persistRecommendCheckpointSnapshot(snapshot);
+  }
+  const cdpEvidence = buildPersistedCdpEvidence({
+    meta: getRecommendRunMeta(normalized.run_id),
+    persisted: existing || {}
+  });
+  const payload = {
     run_id: normalized.run_id,
     mode: normalized.mode,
     state: normalized.state,
@@ -1042,12 +1293,14 @@ function persistRecommendRunSnapshot(snapshot, {
     context: normalized.context,
     control: normalized.control,
     resume: normalized.resume,
-    error: normalized.error,
-    recovery: normalized.recovery,
-    result: normalized.result,
-    summary: normalized.summary,
-    artifacts: normalized.artifacts
-  };
+    error: normalized.error,
+    recovery: normalized.recovery,
+    result: normalized.result,
+    summary: normalized.summary,
+    checkpoint: normalized.checkpoint,
+    artifacts: normalized.artifacts,
+    ...cdpEvidence
+  };
   writeJsonAtomic(artifacts.run_state_path, payload);
   return normalized;
 }
@@ -1120,19 +1373,18 @@ function persistRecommendLifecycleSnapshot(snapshot, event = {}) {
   });
 }
 
-function attachMethodEvidence(payload, runId) {
-  const meta = getRecommendRunMeta(runId);
-  const methodLog = meta.methodLog || [];
-  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
-  };
-}
+function attachMethodEvidence(payload, runId) {
+  const meta = getRecommendRunMeta(runId);
+  const methodLog = meta.methodLog || [];
+  assertNoForbiddenCdpCalls(methodLog);
+  return {
+    ...payload,
+    ...buildPersistedCdpEvidence({
+      meta,
+      persisted: readRecommendRunState(runId) || {}
+    })
+  };
+}
 
 function compactRecommendJobListOption(option, index) {
   const label = normalizeText(option?.label);
@@ -1819,10 +2071,23 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
     ) || "low",
     imageOutputDir: resolveBossConfiguredOutputDir("", getRunsDir()),
     humanRestEnabled: humanBehavior.restEnabled,
-    humanBehavior,
-    skipRecentColleagueContacted: normalized.skipRecentColleagueContacted,
-    colleagueContactWindowDays: normalized.colleagueContactWindowDays,
-    name: "mcp-recommend-pipeline-run",
+    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
   };
 }
@@ -2114,22 +2379,19 @@ export function getRecommendPipelineRunTool({ args = {} } = {}) {
       run: compactRecommendRunForStatus(normalizedRun)
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted) {
-      const reconciled = compactRecommendRunForStatus(reconcilePersistedRecommendRunIfNeeded(persisted));
-      return {
-        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
-      };
+    const persisted = readRecommendRunState(runId);
+    if (persisted) {
+      const reconciled = compactRecommendRunForStatus(reconcilePersistedRecommendRunIfNeeded(persisted));
+      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
+        }
+      }, persistedEvidence);
     }
     return {
       status: "FAILED",
@@ -2170,17 +2432,13 @@ export function pauseRecommendPipelineRunTool({ args = {} } = {}) {
       message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
-        status: "PAUSE_IGNORED",
-        run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需暂停。",
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+    const persisted = readRecommendRunState(runId);
+    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      return attachPersistedCdpEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(persisted),
+        message: "目标任务已结束，无需暂停。"
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2228,11 +2486,11 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
       message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted) {
-      return {
-        status: "FAILED",
-        error: {
+    const persisted = readRecommendRunState(runId);
+    if (persisted) {
+      return attachPersistedCdpEvidence({
+        status: "FAILED",
+        error: {
           code: TERMINAL_STATUSES.has(persisted.state) ? "RUN_ALREADY_TERMINATED" : "RUN_NOT_ACTIVE",
           message: TERMINAL_STATUSES.has(persisted.state)
             ? "目标任务已结束，无法继续。"
@@ -2240,15 +2498,11 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
           retryable: !TERMINAL_STATUSES.has(persisted.state)
         },
         run: compactRecommendRunForStatus(persisted),
-        persistence: {
-          source: "disk",
-          active_control_available: false
-        },
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+        persistence: {
+          source: "disk",
+          active_control_available: false
+        }
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2274,17 +2528,13 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
       message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
-        status: "CANCEL_IGNORED",
-        run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需取消。",
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+    const persisted = readRecommendRunState(runId);
+    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      return attachPersistedCdpEvidence({
+        status: "CANCEL_IGNORED",
+        run: compactRecommendRunForStatus(persisted),
+        message: "目标任务已结束，无需取消。"
+      }, persisted);
     }
     const cancelMessage = "已收到取消请求，将由 detached worker 在下一个安全边界停止。";
     const patched = patchPersistedRecommendRunControl(runId, {
@@ -2294,22 +2544,18 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
       cancel_requested: true
     }, {
       message: cancelMessage
-    });
-    if (patched) {
-      return {
-        status: "CANCEL_REQUESTED",
-        run: compactRecommendRunForStatus(patched),
+    });
+    if (patched) {
+      return attachPersistedCdpEvidence({
+        status: "CANCEL_REQUESTED",
+        run: compactRecommendRunForStatus(patched),
         message: cancelMessage,
         persistence: {
           source: "disk",
-          active_control_available: false,
-          detached_control_requested: true
-        },
-        runtime_evaluate_used: false,
-        method_summary: {},
-        method_log: [],
-        chrome: null
-      };
+          active_control_available: false,
+          detached_control_requested: true
+        }
+      }, patched);
     }
     return getRecommendPipelineRunTool({ args });
   }