@reconcrap/boss-recommend-mcp 2.1.23 → 2.1.25

package/src/recommend-mcp.js

@@ -1,19 +1,21 @@
-import fs from "node:fs";
+import crypto from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
-import {
-  assertNoForbiddenCdpCalls,
-  bringPageToFront,
-  connectToChromeTargetOrOpen,
-  createBossLoginRequiredError,
-  detectBossLoginState,
-  enableDomains,
-  FORBIDDEN_CDP_METHODS,
+import {
+  assertNoForbiddenCdpCalls,
+  bringPageToFront,
+  connectToChromeTargetOrOpen,
+  createBossLoginRequiredError,
+  detectBossLoginState,
+  enableDomains,
+  FORBIDDEN_CDP_METHODS,
   getMainFrameUrl,
-  isBossLoginUrl,
-  waitForMainFrameUrl,
-  sleep
-} from "./core/browser/index.js";
+  inspectChromeDebugCommandLine,
+  isBossLoginUrl,
+  waitForMainFrameUrl,
+  sleep
+} from "./core/browser/index.js";
 import {
   RUN_STATUS_CANCELING,
   RUN_STATUS_CANCELED,
@@ -33,14 +35,15 @@ import {
   runSelfHealCheck
 } from "./core/self-heal/index.js";
 import {
-  closeRecommendJobDropdown,
-  closeRecommendDetail,
-  createRecommendRunService,
-  getRecommendRoots,
-  listRecommendJobOptions,
-  RECOMMEND_TARGET_URL,
-  runRecommendWorkflow
-} from "./domains/recommend/index.js";
+  closeRecommendJobDropdown,
+  closeRecommendDetail,
+  createRecommendRunService,
+  getRecommendRoots,
+  inspectRecommendFilteredEmptyState,
+  listRecommendJobOptions,
+  RECOMMEND_TARGET_URL,
+  runRecommendWorkflow
+} from "./domains/recommend/index.js";
 import {
   parseRecommendInstruction
 } from "./parser.js";
@@ -77,7 +80,7 @@ let recommendRunService = createRecommendRunService({
 });
 const recommendRunMeta = new Map();
 
-function normalizeText(value) {
+function normalizeText(value) {
   return String(value || "").replace(/\s+/g, " ").trim();
 }
 
@@ -278,22 +281,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.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.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");
@@ -313,177 +316,347 @@ function resolveRecommendDetailLimit(args = {}, normalized = {}) {
   return requested;
 }
 
-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 {
-    return value === undefined ? fallback : JSON.parse(JSON.stringify(value));
-  } catch {
-    return fallback;
+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 plainRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+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 nonEmptyRecord(value) {
-  const record = plainRecord(value);
-  return Object.keys(record).length ? record : null;
+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 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 canonicalRecommendChromeHost(host = "") {
+  const normalized = String(host || "").trim().toLowerCase();
+  return ["", "localhost", "127.0.0.1", "::1"].includes(normalized)
+    ? "127.0.0.1"
+    : normalized;
 }
 
-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 readChromeCommandLineValue(args = [], name = "") {
+  const prefix = `--${name}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const value = String(args[index] || "");
+    if (value.startsWith(prefix)) return value.slice(prefix.length).trim();
+    if (value === `--${name}`) return String(args[index + 1] || "").trim();
   }
+  return "";
 }
 
-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];
+function resolveExactChromeProfileDirectory(userDataDir, explicitProfileDirectory = "") {
+  const resolvedUserDataDir = fs.realpathSync(path.resolve(userDataDir));
+  let profileDirectory = String(explicitProfileDirectory || "").trim();
+  if (!profileDirectory) {
+    const localStatePath = path.join(resolvedUserDataDir, "Local State");
+    const localState = JSON.parse(fs.readFileSync(localStatePath, "utf8"));
+    const lastActive = Array.isArray(localState?.profile?.last_active_profiles)
+      ? localState.profile.last_active_profiles.map((item) => String(item || "").trim()).filter(Boolean)
+      : [];
+    const cachedProfiles = Object.keys(localState?.profile?.info_cache || {}).filter(Boolean);
+    const candidates = Array.from(new Set([...lastActive, ...cachedProfiles]));
+    if (candidates.length !== 1) {
+      const error = new Error(
+        "Chrome profile directory is not explicit and Local State does not prove exactly one active profile"
+      );
+      error.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+      throw error;
+    }
+    profileDirectory = candidates[0];
   }
-  for (const key of ["close_method", "command_line_source"]) {
-    const text = normalizeText(source[key]);
-    if (text) compact[key] = text;
+  const resolvedProfileDir = fs.realpathSync(path.resolve(resolvedUserDataDir, profileDirectory));
+  const relativeProfile = path.relative(resolvedUserDataDir, resolvedProfileDir);
+  if (!relativeProfile || relativeProfile.startsWith("..") || path.isAbsolute(relativeProfile)) {
+    const error = new Error("Chrome profile directory is not a child of the exact user-data directory");
+    error.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+    throw error;
   }
-  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)
+    user_data_dir: process.platform === "win32" ? resolvedUserDataDir.toLowerCase() : resolvedUserDataDir,
+    profile_directory: relativeProfile.replaceAll("\\", "/")
   };
 }
 
-function attachPersistedCdpEvidence(payload, persisted = {}) {
+export async function resolveRecommendActionJournalScope({
+  host = DEFAULT_RECOMMEND_HOST,
+  port = DEFAULT_RECOMMEND_PORT,
+  session = null,
+  inspectCommandLine = inspectChromeDebugCommandLine,
+  strictFresh = false
+} = {}) {
+  const canonicalHost = canonicalRecommendChromeHost(host);
+  if (canonicalHost !== "127.0.0.1") {
+    const error = new Error("Live recommend greetings require a local canonical Chrome profile identity");
+    error.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+    throw error;
+  }
+  let userDataDir = "";
+  let profileDirectory = "";
+  let source = "";
+  if (strictFresh === true) {
+    let commandLine = null;
+    try {
+      commandLine = await inspectCommandLine({ host: canonicalHost, port });
+    } catch (error) {
+      const inspectionError = new Error(
+        "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED: fresh Chrome command-line inspection failed"
+      );
+      inspectionError.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+      inspectionError.retryable = false;
+      inspectionError.cause = error;
+      throw inspectionError;
+    }
+    const observedPort = Number(readChromeCommandLineValue(
+      commandLine?.arguments,
+      "remote-debugging-port"
+    ));
+    if (commandLine?.ok !== true || observedPort !== Number(port)) {
+      const inspectionError = new Error(
+        "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED: fresh Chrome process/port identity could not be proven"
+      );
+      inspectionError.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+      inspectionError.retryable = false;
+      inspectionError.expected_port = Number(port);
+      inspectionError.observed_port = Number.isFinite(observedPort) ? observedPort : null;
+      throw inspectionError;
+    }
+    userDataDir = readChromeCommandLineValue(commandLine.arguments, "user-data-dir");
+    profileDirectory = readChromeCommandLineValue(commandLine.arguments, "profile-directory");
+    source = `fresh_${commandLine.source || "chrome_command_line"}`;
+  } else {
+    const injected = session?.profile_identity;
+    if (injected?.verified === true) {
+      userDataDir = String(injected.user_data_dir || "").trim();
+      profileDirectory = String(injected.profile_directory || "").trim();
+      source = "session_verified_profile_identity";
+    } else {
+      let commandLine = null;
+      try {
+        commandLine = await inspectCommandLine({ host: canonicalHost, port });
+      } catch {
+        commandLine = null;
+      }
+      if (commandLine?.ok === true) {
+        userDataDir = readChromeCommandLineValue(commandLine.arguments, "user-data-dir");
+        profileDirectory = readChromeCommandLineValue(commandLine.arguments, "profile-directory");
+        source = commandLine.source || "chrome_command_line";
+      }
+      if (!userDataDir && session?.chrome?.launched === true) {
+        userDataDir = String(session.chrome.user_data_dir || "").trim();
+        source = "same_call_chrome_launch";
+      }
+    }
+  }
+  if (!userDataDir) {
+    const error = new Error(
+      "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED: exact Chrome user-data/profile directory could not be proven"
+    );
+    error.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+    error.retryable = false;
+    throw error;
+  }
+  let exactProfile;
+  try {
+    exactProfile = resolveExactChromeProfileDirectory(userDataDir, profileDirectory);
+  } catch (error) {
+    const safeError = new Error(
+      "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED: exact Chrome profile directory could not be proven"
+    );
+    safeError.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+    safeError.retryable = false;
+    throw safeError;
+  }
+  if (!exactProfile.user_data_dir || !exactProfile.profile_directory) {
+    const error = new Error("Exact Chrome user-data/profile directory could not be proven");
+    error.code = "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED";
+    throw error;
+  }
+  const profileHash = crypto.createHash("sha256")
+    .update(
+      `boss-chrome-profile-v1\u0000${exactProfile.user_data_dir}\u0000${exactProfile.profile_directory}`,
+      "utf8"
+    )
+    .digest("hex");
   return {
-    ...payload,
-    ...buildPersistedCdpEvidence({ persisted })
+    scope: `boss-recommend-profile-v2:${canonicalHost}:profile-sha256:${profileHash}`,
+    identity: {
+      verified: true,
+      source,
+      canonical_host: canonicalHost,
+      profile_sha256: profileHash,
+      profile_directory: exactProfile.profile_directory
+    }
   };
 }
 
+function clonePlain(value, fallback = null) {
+  try {
+    return value === undefined ? fallback : JSON.parse(JSON.stringify(value));
+  } catch {
+    return fallback;
+  }
+}
+
+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 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 "";
@@ -530,12 +703,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 : "不限"
   };
 }
 
@@ -574,12 +747,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 = {
@@ -654,26 +827,36 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     : Number.isInteger(summary?.passed)
       ? summary.passed
       : 0;
-  const normalized = {
-    ...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
-  };
-  if (Object.prototype.hasOwnProperty.call(normalized, "last_list_read_stale_diagnostic")) {
-    normalized.last_list_read_stale_diagnostic = compactListReadStaleDiagnosticForStatus(
-      normalized.last_list_read_stale_diagnostic
-    );
-  }
+    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;
 }
 
@@ -703,73 +886,236 @@ 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"]) {
+  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", "attempt"]) {
+  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"]) {
+  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();
-  }
+  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))
+    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 compactListReadStaleDiagnosticsForStatus(value) {
+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((item) => compactListReadStaleDiagnosticForStatus(item))
+    .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(-12);
+    .slice(-20);
 }
 
-function compactListReadStaleCheckpointEvent(value) {
+function compactDomStaleCandidateForStatus(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"]) {
+  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];
   }
-  if (source.recovery_error) {
-    const recoveryError = compactListReadStaleDiagnosticForStatus(source.recovery_error);
-    if (recoveryError) compact.recovery_error = recoveryError;
+  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;
   }
-  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];
-      }
-    }
+  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;
@@ -817,7 +1163,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,
@@ -825,23 +1171,27 @@ function compactRecommendSummaryForStatus(summary) {
       rest_count: compactPositiveInteger(humanRest.rest_count ?? humanRest.count, null),
       total_pause_ms: compactPositiveInteger(humanRest.total_pause_ms ?? humanRest.pause_ms, null)
     };
-  }
-  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;
+  }
+  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;
 }
 
@@ -856,19 +1206,23 @@ 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];
-  }
+  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"
-  ]) {
+    "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;
 }
 
@@ -1268,16 +1622,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 cdpEvidence = buildPersistedCdpEvidence({
-    meta: getRecommendRunMeta(normalized.run_id),
-    persisted: existing || {}
-  });
-  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,
@@ -1293,14 +1647,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,
-    checkpoint: normalized.checkpoint,
-    artifacts: normalized.artifacts,
-    ...cdpEvidence
-  };
+    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;
 }
@@ -1373,18 +1727,18 @@ function persistRecommendLifecycleSnapshot(snapshot, event = {}) {
   });
 }
 
-function attachMethodEvidence(payload, runId) {
-  const meta = getRecommendRunMeta(runId);
-  const methodLog = meta.methodLog || [];
-  assertNoForbiddenCdpCalls(methodLog);
-  return {
-    ...payload,
-    ...buildPersistedCdpEvidence({
-      meta,
-      persisted: readRecommendRunState(runId) || {}
-    })
-  };
-}
+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);
@@ -1539,51 +1893,239 @@ export async function listRecommendJobsTool({ workspaceRoot = "", args = {} } =
   }
 }
 
-function compactHealth(check) {
-  if (!check) return null;
-  return {
-    status: check.status,
-    summary: check.summary,
-    drift_report: check.drift_report,
-    probes: (check.probes || []).map((probe) => ({
-      id: probe.id,
-      type: probe.type,
-      status: probe.status,
+function compactHealth(check) {
+  if (!check) return null;
+  return {
+    status: check.status,
+    summary: check.summary,
+    drift_report: check.drift_report,
+    empty_bootstrap_refresh: check.empty_bootstrap_refresh || null,
+    accepted_empty_bootstrap: check.accepted_empty_bootstrap || null,
+    probes: (check.probes || []).map((probe) => ({
+      id: probe.id,
+      type: probe.type,
+      status: probe.status,
       count: probe.count,
       required: probe.required
     }))
-  };
-}
-
-async function waitForHealthyRecommend(client, config, {
-  timeoutMs = 90000,
-  intervalMs = 1000
-} = {}) {
-  const started = Date.now();
-  let lastCheck = null;
-  while (Date.now() - started <= timeoutMs) {
-    const loginDetection = await detectBossLoginState(client).catch(() => null);
-    if (loginDetection?.requires_login) {
-      return {
-        status: "login_required",
-        summary: "Boss login is required",
-        loginDetection
-      };
-    }
-    const roots = await resolveRecommendSelfHealRoots(client, config);
+  };
+}
+
+function hasOnlyCandidateCardsRequiredFailure(check) {
+  const failedRequiredIds = Array.isArray(check?.summary?.failed_required_ids)
+    ? check.summary.failed_required_ids
+    : [];
+  const blockedRequiredIds = Array.isArray(check?.summary?.blocked_required_ids)
+    ? check.summary.blocked_required_ids
+    : [];
+  return check?.status === HEALTH_STATUS.DEGRADED
+    && failedRequiredIds.length === 1
+    && failedRequiredIds[0] === "candidate_cards"
+    && blockedRequiredIds.length === 0;
+}
+
+function compactRecommendEmptyStateEvidence(emptyState) {
+  if (!emptyState) return null;
+  return {
+    verified: emptyState.verified === true,
+    reason: emptyState.reason || null,
+    text: emptyState.text || null,
+    node_id: emptyState.node_id ?? null,
+    box: emptyState.box || null,
+    accessibility: emptyState.accessibility ? {
+      available: emptyState.accessibility.available ?? null,
+      verified: emptyState.accessibility.verified === true,
+      reason: emptyState.accessibility.reason || null
+    } : null
+  };
+}
+
+function hasExactRecommendFilteredEmptyState(emptyState) {
+  return emptyState?.verified === true
+    && emptyState?.reason === "exact_visible_filtered_empty_state"
+    && emptyState?.accessibility?.verified === true;
+}
+
+function attachRecommendEmptyBootstrapRefreshEvidence(check, refreshEvidence, emptyState = null) {
+  if (!check || refreshEvidence?.attempted !== true) return check;
+  return {
+    ...check,
+    empty_bootstrap_refresh: {
+      ...refreshEvidence,
+      after: {
+        health: compactHealth(check),
+        empty_state: compactRecommendEmptyStateEvidence(emptyState)
+      }
+    }
+  };
+}
+
+export function getRecommendEmptyBootstrapPreflightAction(
+  check,
+  emptyState = null,
+  refreshEvidence = null
+) {
+  if (check?.status === HEALTH_STATUS.HEALTHY) return "accept_healthy";
+  if (!hasOnlyCandidateCardsRequiredFailure(check)) return "wait";
+  if (!hasExactRecommendFilteredEmptyState(emptyState)) return "wait";
+  if (refreshEvidence?.attempted !== true) return "refresh";
+  if (
+    refreshEvidence.completed !== true
+    || refreshEvidence.ok !== true
+    || refreshEvidence.method !== "Page.navigate"
+    || refreshEvidence.target_url !== RECOMMEND_TARGET_URL
+  ) return "wait";
+  return "accept_empty_bootstrap";
+}
+
+export function acceptRecommendEmptyBootstrapHealth(check, emptyState, refreshEvidence = null) {
+  if (
+    getRecommendEmptyBootstrapPreflightAction(check, emptyState, refreshEvidence)
+      !== "accept_empty_bootstrap"
+  ) return null;
+
+  const healthWithRefresh = attachRecommendEmptyBootstrapRefreshEvidence(
+    check,
+    refreshEvidence,
+    emptyState
+  );
+  return {
+    ...healthWithRefresh,
+    accepted_empty_bootstrap: {
+      accepted: true,
+      mode: "exact_filtered_empty_bootstrap",
+      reason: emptyState.reason,
+      original_health_status: check.status,
+      failed_required_ids: [...check.summary.failed_required_ids],
+      blocked_required_ids: [...check.summary.blocked_required_ids],
+      root: "frame",
+      empty_state: compactRecommendEmptyStateEvidence(emptyState),
+      refresh: healthWithRefresh.empty_bootstrap_refresh
+    }
+  };
+}
+
+export function isRecommendConnectorHealthAccepted(health) {
+  if (health?.status === HEALTH_STATUS.HEALTHY) return true;
+  const accepted = health?.accepted_empty_bootstrap;
+  return accepted?.accepted === true
+    && accepted.mode === "exact_filtered_empty_bootstrap"
+    && accepted.original_health_status === HEALTH_STATUS.DEGRADED
+    && getRecommendEmptyBootstrapPreflightAction(
+      health,
+      accepted.empty_state,
+      health.empty_bootstrap_refresh
+    ) === "accept_empty_bootstrap";
+}
+
+async function waitForHealthyRecommend(client, config, {
+  timeoutMs = 90000,
+  intervalMs = 1000,
+  refreshSettleMs = 5000,
+  refreshNavigationTimeoutMs = 20000
+} = {}) {
+  const started = Date.now();
+  let lastCheck = null;
+  let refreshEvidence = null;
+  while (Date.now() - started <= timeoutMs) {
+    const loginDetection = await detectBossLoginState(client).catch(() => null);
+    if (loginDetection?.requires_login) {
+      return attachRecommendEmptyBootstrapRefreshEvidence({
+        status: "login_required",
+        summary: "Boss login is required",
+        loginDetection
+      }, refreshEvidence);
+    }
+    const roots = await resolveRecommendSelfHealRoots(client, config);
     lastCheck = await runSelfHealCheck({
       client,
       domain: "recommend",
       roots: roots.roots,
       selectorProbes: config.selectorProbes,
-      accessibilityProbes: config.accessibilityProbes,
-      viewportProbes: config.viewportProbes
-    });
-    if (lastCheck.status === HEALTH_STATUS.HEALTHY) return lastCheck;
-    await sleep(intervalMs);
-  }
-  return lastCheck;
-}
+      accessibilityProbes: config.accessibilityProbes,
+      viewportProbes: config.viewportProbes
+    });
+    if (lastCheck.status === HEALTH_STATUS.HEALTHY) {
+      return attachRecommendEmptyBootstrapRefreshEvidence(lastCheck, refreshEvidence);
+    }
+    let emptyState = null;
+    if (hasOnlyCandidateCardsRequiredFailure(lastCheck) && roots.roots.frame) {
+      emptyState = await inspectRecommendFilteredEmptyState(
+        client,
+        roots.roots.frame
+      ).catch((error) => ({
+        verified: false,
+        reason: "filtered_empty_state_probe_failed",
+        error: error?.message || String(error)
+      }));
+    }
+    const action = getRecommendEmptyBootstrapPreflightAction(
+      lastCheck,
+      emptyState,
+      refreshEvidence
+    );
+    if (action === "refresh") {
+      const refreshStarted = Date.now();
+      refreshEvidence = {
+        attempted: true,
+        completed: false,
+        ok: false,
+        method: "Page.navigate",
+        target_url: RECOMMEND_TARGET_URL,
+        before: {
+          health: compactHealth(lastCheck),
+          empty_state: compactRecommendEmptyStateEvidence(emptyState)
+        }
+      };
+      try {
+        const navigationResult = await client.Page.navigate({ url: RECOMMEND_TARGET_URL });
+        if (navigationResult?.errorText) {
+          throw new Error(navigationResult.errorText);
+        }
+        const waited = await waitForMainFrameUrl(
+          client,
+          (url) => isBossLoginUrl(url) || !shouldNavigateToRecommend(url),
+          {
+            timeoutMs: refreshNavigationTimeoutMs,
+            intervalMs: Math.max(250, Math.min(1000, intervalMs))
+          }
+        );
+        if (refreshSettleMs > 0) await sleep(refreshSettleMs);
+        refreshEvidence = {
+          ...refreshEvidence,
+          completed: true,
+          ok: waited?.ok === true,
+          navigation: {
+            frame_id: navigationResult?.frameId || null,
+            loader_id: navigationResult?.loaderId || null,
+            observed_url: waited?.url || null,
+            observed_url_ok: waited?.ok === true
+          },
+          elapsed_ms: Date.now() - refreshStarted
+        };
+      } catch (error) {
+        refreshEvidence = {
+          ...refreshEvidence,
+          completed: true,
+          ok: false,
+          error: error?.message || String(error),
+          elapsed_ms: Date.now() - refreshStarted
+        };
+      }
+      continue;
+    }
+    if (action === "accept_empty_bootstrap") {
+      const accepted = acceptRecommendEmptyBootstrapHealth(
+        lastCheck,
+        emptyState,
+        refreshEvidence
+      );
+      if (accepted) return accepted;
+    }
+    await sleep(intervalMs);
+  }
+  return attachRecommendEmptyBootstrapRefreshEvidence(lastCheck, refreshEvidence);
+}
 
 function shouldNavigateToRecommend(url) {
   return !String(url || "").includes("/web/chat/recommend");
@@ -1677,10 +2219,12 @@ async function connectRecommendChromeSession({
   }
 
   const selfHealConfig = buildRecommendSelfHealConfig();
-  const health = await waitForHealthyRecommend(client, selfHealConfig, {
-    timeoutMs: slowLive ? 180000 : 90000,
-    intervalMs: slowLive ? 1200 : 800
-  });
+  const health = await waitForHealthyRecommend(client, selfHealConfig, {
+    timeoutMs: slowLive ? 180000 : 90000,
+    intervalMs: slowLive ? 1200 : 800,
+    refreshSettleMs: slowLive ? 12000 : 5000,
+    refreshNavigationTimeoutMs: slowLive ? 45000 : 20000
+  });
   if (health?.loginDetection?.requires_login) {
     await session.close?.();
     throw createBossLoginRequiredError({
@@ -1691,7 +2235,7 @@ async function connectRecommendChromeSession({
       chrome: session.chrome || null
     });
   }
-  if (!health || health.status !== HEALTH_STATUS.HEALTHY) {
+  if (!isRecommendConnectorHealthAccepted(health)) {
     const latestUrl = await getMainFrameUrl(client).catch(() => currentUrl);
     const latestLoginDetection = await detectBossLoginState(client, { currentUrl: latestUrl }).catch(() => ({
       requires_login: isBossLoginUrl(latestUrl),
@@ -1935,55 +2479,59 @@ 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({
-      group: "recentNotView",
-      labels: recentNotView,
-      selectAllLabels: true
-    });
+    groups.push({
+      group: "recentNotView",
+      labels: recentNotView,
+      selectAllLabels: true,
+      verifySticky: true
+    });
   }
 
   const degree = withoutUnlimited(parsed.searchParams?.degree);
   if (degree.length) {
-    groups.push({
-      group: "degree",
-      labels: degree,
-      selectAllLabels: true
-    });
+    groups.push({
+      group: "degree",
+      labels: degree,
+      selectAllLabels: true,
+      verifySticky: true
+    });
   }
 
   const gender = withoutUnlimited(parsed.searchParams?.gender);
   if (gender.length) {
-    groups.push({
-      group: "gender",
-      labels: gender,
-      selectAllLabels: true
-    });
+    groups.push({
+      group: "gender",
+      labels: gender,
+      selectAllLabels: true,
+      verifySticky: true
+    });
   }
 
   const school = withoutUnlimited(parsed.searchParams?.school_tag);
   if (school.length) {
-    groups.push({
-      group: "school",
-      labels: school,
-      selectAllLabels: true
-    });
+    groups.push({
+      group: "school",
+      labels: school,
+      selectAllLabels: true,
+      verifySticky: true
+    });
   }
 
-  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 || {};
@@ -2017,7 +2565,14 @@ function normalizeRecommendStartInput(args = {}, parsed, configResolution = null
   };
 }
 
-function getRunOptions(args, parsed, normalized, session, configResolution = null) {
+function getRunOptions(
+  args,
+  parsed,
+  normalized,
+  session,
+  configResolution = null,
+  actionJournalScope = ""
+) {
   const slowLive = args.slow_live === true;
   const executePostAction = args.dry_run_post_action === true
     ? false
@@ -2052,8 +2607,16 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
     maxGreetCount: normalized.maxGreetCount,
     executePostAction,
     actionTimeoutMs: parsePositiveInteger(args.action_timeout_ms, slowLive ? 12000 : 8000),
-    actionIntervalMs: parsePositiveInteger(args.action_interval_ms, 500),
-    actionAfterClickDelayMs: parseNonNegativeInteger(args.action_after_click_delay_ms, slowLive ? 1200 : 900),
+    actionIntervalMs: parsePositiveInteger(args.action_interval_ms, 500),
+    actionAfterClickDelayMs: parseNonNegativeInteger(args.action_after_click_delay_ms, slowLive ? 1200 : 900),
+    actionJournalScope,
+    reverifyActionJournalScope: actionJournalScope
+      ? async () => resolveRecommendActionJournalScope({
+          host: normalized.host,
+          port: normalized.port,
+          strictFresh: true
+        })
+      : null,
     screeningMode: normalized.screeningMode,
     llmConfig: normalized.screeningMode === "llm" && configResolution?.ok ? {
       ...configResolution.config
@@ -2071,23 +2634,23 @@ function getRunOptions(args, parsed, normalized, session, configResolution = nul
     ) || "low",
     imageOutputDir: resolveBossConfiguredOutputDir("", getRunsDir()),
     humanRestEnabled: humanBehavior.restEnabled,
-    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",
+    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
   };
 }
@@ -2135,14 +2698,27 @@ function prepareRecommendPipelineStart(args = {}, { workspaceRoot = "" } = {}) {
   };
 }
 
-async function closeRecommendRunSession(runId) {
-  const meta = recommendRunMeta.get(runId);
-  if (!meta || meta.closed) return;
-  try {
-    try {
-      if (meta.session?.client) {
-        await closeRecommendDetail(meta.session.client, { attemptsLimit: 2 });
-      }
+export function shouldPreserveRecommendDetailOnTerminal(snapshot = null) {
+  return snapshot?.checkpoint?.preserve_detail_on_terminal === true
+    && snapshot?.checkpoint?.action_result_critical_persisted !== true;
+}
+
+async function closeRecommendRunSession(runId) {
+  const meta = recommendRunMeta.get(runId);
+  if (!meta || meta.closed) return;
+  try {
+    try {
+      let preserveDetail = false;
+      try {
+        const snapshot = recommendRunService.getRecommendRun(runId);
+        preserveDetail = shouldPreserveRecommendDetailOnTerminal(snapshot);
+      } catch {
+        // If the in-memory run is unavailable, retain the existing best-effort cleanup policy.
+      }
+      meta.preserve_detail_on_terminal = preserveDetail;
+      if (meta.session?.client && !preserveDetail) {
+        await closeRecommendDetail(meta.session.client, { attemptsLimit: 2 });
+      }
     } catch {
       // Cleanup is best-effort once the run has settled.
     }
@@ -2222,12 +2798,46 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
       },
       chrome: error?.chrome || null
     };
-  }
-
-  let started;
-  try {
-    started = recommendRunService.startRecommendRun({
-      ...getRunOptions(args, parsed, normalized, session, configResolution),
+  }
+
+  let actionJournalScope = "";
+  let actionProfileIdentity = null;
+  const liveGreetingRequested = normalized.postAction === "greet"
+    && args.dry_run_post_action !== true
+    && args.execute_post_action !== false;
+  if (liveGreetingRequested) {
+    try {
+      const resolvedScope = await resolveRecommendActionJournalScope({
+        host: normalized.host,
+        port: normalized.port,
+        session
+      });
+      actionJournalScope = resolvedScope.scope;
+      actionProfileIdentity = resolvedScope.identity;
+    } catch (error) {
+      await session.close?.();
+      return {
+        status: "FAILED",
+        error: {
+          code: error?.code || "RECOMMEND_ACTION_PROFILE_IDENTITY_UNVERIFIED",
+          message: error?.message || "Exact Chrome profile identity could not be proven",
+          retryable: false
+        }
+      };
+    }
+  }
+
+  let started;
+  try {
+    started = recommendRunService.startRecommendRun({
+      ...getRunOptions(
+        args,
+        parsed,
+        normalized,
+        session,
+        configResolution,
+        actionJournalScope
+      ),
       runId: fixedRunId || undefined,
       pid: process.pid
     });
@@ -2254,8 +2864,9 @@ async function startRecommendPipelineRunInternal(args = {}, { workspaceRoot = ""
       host: normalized.host,
       port: normalized.port,
       target_url: session.navigation?.url || session.target?.url || RECOMMEND_TARGET_URL,
-      target_id: session.target?.id || null,
-      auto_launch: session.chrome || null
+      target_id: session.target?.id || null,
+      auto_launch: session.chrome || null,
+      action_profile_identity: actionProfileIdentity
     },
     health: session.health || null
   });
@@ -2379,19 +2990,19 @@ export function getRecommendPipelineRunTool({ args = {} } = {}) {
       run: compactRecommendRunForStatus(normalizedRun)
     }, runId);
   } catch {
-    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);
+    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",
@@ -2432,13 +3043,13 @@ export function pauseRecommendPipelineRunTool({ args = {} } = {}) {
       message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return attachPersistedCdpEvidence({
-        status: "PAUSE_IGNORED",
-        run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需暂停。"
-      }, persisted);
+    const persisted = readRecommendRunState(runId);
+    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
+      return attachPersistedCdpEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(persisted),
+        message: "目标任务已结束，无需暂停。"
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2486,11 +3097,11 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
       message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted) {
-      return attachPersistedCdpEvidence({
-        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)
             ? "目标任务已结束，无法继续。"
@@ -2498,11 +3109,11 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
           retryable: !TERMINAL_STATUSES.has(persisted.state)
         },
         run: compactRecommendRunForStatus(persisted),
-        persistence: {
-          source: "disk",
-          active_control_available: false
-        }
-      }, persisted);
+        persistence: {
+          source: "disk",
+          active_control_available: false
+        }
+      }, persisted);
     }
     return getRecommendPipelineRunTool({ args });
   }
@@ -2528,13 +3139,13 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
       message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
     }, runId);
   } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return attachPersistedCdpEvidence({
-        status: "CANCEL_IGNORED",
-        run: compactRecommendRunForStatus(persisted),
-        message: "目标任务已结束，无需取消。"
-      }, persisted);
+    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, {
@@ -2544,18 +3155,18 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
       cancel_requested: true
     }, {
       message: cancelMessage
-    });
-    if (patched) {
-      return attachPersistedCdpEvidence({
-        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
-        }
-      }, patched);
+          active_control_available: false,
+          detached_control_requested: true
+        }
+      }, patched);
     }
     return getRecommendPipelineRunTool({ args });
   }