@reconcrap/boss-recommend-mcp 2.1.19 → 2.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.1.19",
+  "version": "2.1.21",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/core/browser/index.js

@@ -462,6 +462,9 @@ export function createHumanRestController({
   shortRestProbability = 0.08,
   shortRestMinMs = 3000,
   shortRestMaxMs = 7000,
+  perCandidateRestEnabled = false,
+  perCandidateRestMinMs = 0,
+  perCandidateRestMaxMs = 0,
   batchThresholdBase = 25,
   batchThresholdJitter = 8,
   batchRestMinMs = 15000,
@@ -470,7 +473,10 @@ export function createHumanRestController({
   const nextRandom = normalizeRandom(random);
   const readNow = typeof nowFn === "function" ? nowFn : Date.now;
   const normalizedRestLevel = normalizeHumanRestLevel(restLevel);
-  const budgetProfile = (shortRestEnabled !== false || batchRestEnabled !== false)
+  const perCandidateMinMs = Math.max(0, Number(perCandidateRestMinMs) || 0);
+  const perCandidateMaxMs = Math.max(perCandidateMinMs, Number(perCandidateRestMaxMs) || perCandidateMinMs);
+  const perCandidateEnabled = enabled === true && perCandidateRestEnabled === true && perCandidateMaxMs > 0;
+  const budgetProfile = !perCandidateEnabled && (shortRestEnabled !== false || batchRestEnabled !== false)
     ? HUMAN_REST_LEVEL_PROFILES[normalizedRestLevel] || null
     : null;
   const nextBudgetRestInterval = () => budgetProfile
@@ -479,6 +485,9 @@ export function createHumanRestController({
   const state = {
     enabled: enabled === true,
     rest_level: normalizedRestLevel,
+    per_candidate_rest_enabled: perCandidateEnabled,
+    per_candidate_rest_min_ms: perCandidateMinMs,
+    per_candidate_rest_max_ms: perCandidateMaxMs,
     short_rest_enabled: enabled === true && shortRestEnabled !== false,
     batch_rest_enabled: enabled === true && batchRestEnabled !== false,
     rest_counter: 0,
@@ -569,6 +578,40 @@ export function createHumanRestController({
     }
     const sleeper = typeof sleepFn === "function" ? sleepFn : sleep;
     updateActiveElapsed();
+    if (state.per_candidate_rest_enabled) {
+      state.rest_counter += 1;
+      state.processed_count += 1;
+      state.candidates_since_last_rest += 1;
+      const pauseMs = Math.round(randomBetween(
+        nextRandom,
+        state.per_candidate_rest_min_ms,
+        state.per_candidate_rest_max_ms
+      ));
+      await sleeper(pauseMs);
+      state.rest_count += 1;
+      state.total_rest_ms += pauseMs;
+      state.last_active_at_ms = Number(readNow()) || state.last_active_at_ms;
+      const event = {
+        kind: "per_candidate_rest",
+        rest_level: normalizedRestLevel,
+        pause_ms: pauseMs,
+        processed_since_last_rest: state.candidates_since_last_rest
+      };
+      state.candidates_since_last_rest = 0;
+      return {
+        enabled: true,
+        rested: true,
+        pause_ms: pauseMs,
+        rest_level: normalizedRestLevel,
+        rest_counter: state.rest_counter,
+        rest_threshold: state.rest_threshold,
+        processed_count: state.processed_count,
+        active_elapsed_ms: state.active_elapsed_ms,
+        rest_count: state.rest_count,
+        total_rest_ms: state.total_rest_ms,
+        events: [event]
+      };
+    }
     if (budgetProfile) {
       const budgetEvent = await takeBudgetBreakIfNeeded(sleeper);
       const pauseMs = budgetEvent?.pause_ms || 0;

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

@@ -88,11 +88,13 @@ import {
   makeForbiddenChatResumeNavigationError,
   recoverChatShell
 } from "./page-guard.js";
-import { getChatRoots } from "./roots.js";
-
-const DETAIL_SOURCES = new Set(["cascade", "network", "dom", "image"]);
-
-function normalizeDetailSource(value) {
+import { getChatRoots } from "./roots.js";
+
+const DETAIL_SOURCES = new Set(["cascade", "network", "dom", "image"]);
+const CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS = 5000;
+const CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS = 8000;
+
+function normalizeDetailSource(value) {
   const normalized = String(value || "").trim().toLowerCase();
   return DETAIL_SOURCES.has(normalized) ? normalized : "cascade";
 }
@@ -939,13 +941,18 @@ export async function runChatWorkflow({
   humanBehavior = null
 } = {}, runControl) {
   if (!client) throw new Error("runChatWorkflow requires a guarded CDP client");
-  const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
-    legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
-  });
-  const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
-  configureHumanInteraction(client, {
-    enabled: effectiveHumanBehavior.enabled,
-    clickMovementEnabled: effectiveHumanBehavior.clickMovement,
+  const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+    legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+  });
+  const normalizedDetailSource = normalizeDetailSource(detailSource);
+  const normalizedScreeningMode = normalizeText(criteria) ? normalizeScreeningMode(screeningMode) : "collect_cv";
+  const collectCvOnly = normalizedScreeningMode === "collect_cv" || !normalizeText(criteria);
+  const useLlmScreening = normalizedScreeningMode === "llm" && !collectCvOnly;
+  const collectCvPerCandidateRestEnabled = collectCvOnly && effectiveHumanBehavior.enabled;
+  const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled || collectCvPerCandidateRestEnabled;
+  configureHumanInteraction(client, {
+    enabled: effectiveHumanBehavior.enabled,
+    clickMovementEnabled: effectiveHumanBehavior.clickMovement,
     textEntryEnabled: effectiveHumanBehavior.textEntry,
     safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
     actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
@@ -954,13 +961,12 @@ export async function runChatWorkflow({
     enabled: effectiveHumanRestEnabled,
     shortRestEnabled: effectiveHumanBehavior.shortRest,
     batchRestEnabled: effectiveHumanBehavior.batchRest,
-    restLevel: effectiveHumanBehavior.restLevel
+    restLevel: effectiveHumanBehavior.restLevel,
+    perCandidateRestEnabled: collectCvPerCandidateRestEnabled,
+    perCandidateRestMinMs: CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS,
+    perCandidateRestMaxMs: CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS
   });
-  const normalizedDetailSource = normalizeDetailSource(detailSource);
-  const normalizedScreeningMode = normalizeText(criteria) ? normalizeScreeningMode(screeningMode) : "collect_cv";
-  const collectCvOnly = normalizedScreeningMode === "collect_cv" || !normalizeText(criteria);
-  const useLlmScreening = normalizedScreeningMode === "llm" && !collectCvOnly;
-  const processedLimit = Math.max(1, Number(maxCandidates) || 1);
+  const processedLimit = Math.max(1, Number(maxCandidates) || 1);
   const passTarget = Number.isFinite(Number(targetPassCount)) && Number(targetPassCount) > 0
     ? Number(targetPassCount)
     : null;
@@ -1177,11 +1183,14 @@ export async function runChatWorkflow({
       viewport_checks: viewportGuard.getStats().checks,
       viewport_recoveries: viewportGuard.getStats().recoveries,
       human_behavior_enabled: effectiveHumanBehavior.enabled,
-      human_behavior_profile: effectiveHumanBehavior.profile,
-      human_rest_level: effectiveHumanBehavior.restLevel,
-      human_rest_enabled: effectiveHumanRestEnabled,
-      human_rest_count: humanRestController.getState().rest_count,
-      human_rest_ms: humanRestController.getState().total_rest_ms,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_level: effectiveHumanBehavior.restLevel,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+      human_rest_per_candidate_min_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS : null,
+      human_rest_per_candidate_max_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS : null,
+      human_rest_count: humanRestController.getState().rest_count,
+      human_rest_ms: humanRestController.getState().total_rest_ms,
       last_human_event: lastHumanEvent
     });
     runControl.setPhase("chat:done");
@@ -1239,10 +1248,20 @@ export async function runChatWorkflow({
     screening_mode: normalizedScreeningMode,
     unique_seen: compactInfiniteListState(listState).seen_count,
     scroll_count: 0,
-    context_recoveries: contextRecoveryAttempts,
-    viewport_checks: viewportGuard.getStats().checks,
-    viewport_recoveries: viewportGuard.getStats().recoveries
-  });
+    context_recoveries: contextRecoveryAttempts,
+    viewport_checks: viewportGuard.getStats().checks,
+    viewport_recoveries: viewportGuard.getStats().recoveries,
+    human_behavior_enabled: effectiveHumanBehavior.enabled,
+    human_behavior_profile: effectiveHumanBehavior.profile,
+    human_rest_level: effectiveHumanBehavior.restLevel,
+    human_rest_enabled: effectiveHumanRestEnabled,
+    human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+    human_rest_per_candidate_min_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS : null,
+    human_rest_per_candidate_max_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS : null,
+    human_rest_count: humanRestController.getState().rest_count,
+    human_rest_ms: humanRestController.getState().total_rest_ms,
+    last_human_event: lastHumanEvent
+  });
 
   while (
     results.length < processedLimit
@@ -2027,11 +2046,14 @@ export async function runChatWorkflow({
       viewport_checks: viewportGuard.getStats().checks,
       viewport_recoveries: viewportGuard.getStats().recoveries,
       human_behavior_enabled: effectiveHumanBehavior.enabled,
-      human_behavior_profile: effectiveHumanBehavior.profile,
-      human_rest_level: effectiveHumanBehavior.restLevel,
-      human_rest_enabled: effectiveHumanRestEnabled,
-      human_rest_count: humanRestController.getState().rest_count,
-      human_rest_ms: humanRestController.getState().total_rest_ms,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_level: effectiveHumanBehavior.restLevel,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+      human_rest_per_candidate_min_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS : null,
+      human_rest_per_candidate_max_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS : null,
+      human_rest_count: humanRestController.getState().rest_count,
+      human_rest_ms: humanRestController.getState().total_rest_ms,
       last_human_event: lastHumanEvent,
       last_candidate_id: screeningCandidate.id || null,
       last_candidate_key: candidateKey,
@@ -2071,10 +2093,11 @@ export async function runChatWorkflow({
         addTiming(compactResult.timings, "human_rest_ms", restElapsed);
         compactResult.timings.total_ms = Date.now() - candidateStarted;
         runControl.updateProgress({
-          human_rest_enabled: effectiveHumanRestEnabled,
-          human_rest_level: effectiveHumanBehavior.restLevel,
-          human_rest_count: humanRestController.getState().rest_count,
-          human_rest_ms: humanRestController.getState().total_rest_ms,
+          human_rest_enabled: effectiveHumanRestEnabled,
+          human_rest_level: effectiveHumanBehavior.restLevel,
+          human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+          human_rest_count: humanRestController.getState().rest_count,
+          human_rest_ms: humanRestController.getState().total_rest_ms,
           human_rest_last: restResult,
           context_recoveries: contextRecoveryAttempts,
           last_human_event: lastHumanEvent
@@ -2175,12 +2198,14 @@ export function createChatRunService({
     if (!client) throw new Error("startChatRun requires a guarded CDP client");
     const normalizedDetailSource = normalizeDetailSource(detailSource);
     const normalizedScreeningMode = normalizeText(criteria) ? normalizeScreeningMode(screeningMode) : "collect_cv";
-    const processedLimit = Math.max(1, Number(maxCandidates) || 1);
-    const normalizedDetailLimit = detailLimit == null ? processedLimit : Math.max(0, Number(detailLimit) || 0);
-    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
-      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
-    });
-    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
+    const collectCvOnly = normalizedScreeningMode === "collect_cv" || !normalizeText(criteria);
+    const processedLimit = Math.max(1, Number(maxCandidates) || 1);
+    const normalizedDetailLimit = detailLimit == null ? processedLimit : Math.max(0, Number(detailLimit) || 0);
+    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+    });
+    const collectCvPerCandidateRestEnabled = collectCvOnly && effectiveHumanBehavior.enabled;
+    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled || collectCvPerCandidateRestEnabled;
     return manager.startRun({
       runId,
       name,
@@ -2206,10 +2231,10 @@ export function createChatRunService({
         llm_configured: Boolean(llmConfig),
         llm_timeout_ms: llmTimeoutMs,
         llm_image_limit: llmImageLimit,
-        llm_image_detail: llmImageDetail,
-        max_image_pages: maxImagePages,
-        image_wheel_delta_y: imageWheelDeltaY,
-        list_max_scrolls: listMaxScrolls,
+        llm_image_detail: llmImageDetail,
+        max_image_pages: maxImagePages,
+        image_wheel_delta_y: imageWheelDeltaY,
+        list_max_scrolls: listMaxScrolls,
         list_stable_signature_limit: listStableSignatureLimit,
         list_wheel_delta_y: listWheelDeltaY,
         list_settle_ms: listSettleMs,
@@ -2221,7 +2246,9 @@ export function createChatRunService({
         human_behavior: effectiveHumanBehavior,
         human_rest_level: effectiveHumanBehavior.restLevel,
         human_rest_enabled: effectiveHumanRestEnabled,
-        cv_collection_mode: normalizedScreeningMode === "collect_cv"
+        human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+        human_rest_per_candidate_min_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS : null,
+        human_rest_per_candidate_max_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS : null
       },
       progress: {
         card_count: 0,
@@ -2239,10 +2266,13 @@ export function createChatRunService({
         request_skipped: 0,
         context_recoveries: 0,
         human_behavior_enabled: effectiveHumanBehavior.enabled,
-        human_behavior_profile: effectiveHumanBehavior.profile,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled,
-        human_rest_count: 0,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled,
+        human_rest_per_candidate_enabled: collectCvPerCandidateRestEnabled,
+        human_rest_per_candidate_min_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MIN_MS : null,
+        human_rest_per_candidate_max_ms: collectCvPerCandidateRestEnabled ? CHAT_COLLECT_CV_PER_CANDIDATE_REST_MAX_MS : null,
+        human_rest_count: 0,
         human_rest_ms: 0,
         last_human_event: null
       },

package/src/recommend-mcp.js

@@ -54,6 +54,7 @@ import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
 const DEFAULT_RECOMMEND_HOST = "127.0.0.1";
 const DEFAULT_RECOMMEND_PORT = 9222;
 const DEFAULT_RECOMMEND_POLL_AFTER_SEC = 10;
+const STATUS_METHOD_LOG_TAIL_LIMIT = 25;
 const TARGET_COUNT_SEMANTICS = "target_count means candidates that pass screening; scan continues until that many candidates pass or the list ends";
 const RUN_MODE_ASYNC = "async";
 const REST_LEVEL_OPTIONS = ["low", "medium", "high"];
@@ -302,15 +303,23 @@ function resolveRecommendDetailLimit(args = {}, normalized = {}) {
   return requested;
 }
 
-function methodSummary(methodLog = []) {
+function methodSummary(methodLog = []) {
   const summary = {};
   for (const entry of methodLog || []) {
     summary[entry.method] = (summary[entry.method] || 0) + 1;
   }
-  return summary;
-}
-
-function clonePlain(value, fallback = null) {
+  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 clonePlain(value, fallback = null) {
   try {
     return value === undefined ? fallback : JSON.parse(JSON.stringify(value));
   } catch {
@@ -477,7 +486,7 @@ function secondsBetween(startedAt, endedAt) {
   return Math.max(1, Math.round((endMs - startMs) / 1000));
 }
 
-function normalizeLegacyProgress(progress = {}, summary = null) {
+function normalizeLegacyProgress(progress = {}, summary = null) {
   const processed = Number.isInteger(progress.processed)
     ? progress.processed
     : Number.isInteger(summary?.processed)
@@ -502,12 +511,146 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     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
-  };
-}
-
-function completionReason(status) {
-  if (status === RUN_STATUS_COMPLETED) return "completed";
-  if (status === RUN_STATUS_CANCELED) return "canceled_by_user";
+  };
+}
+
+const STATUS_COUNT_KEYS = [
+  "processed",
+  "screened",
+  "detail_opened",
+  "passed",
+  "skipped",
+  "llm_screened",
+  "greet_count",
+  "post_action_clicked",
+  "image_capture_failed",
+  "detail_open_failed",
+  "transient_recovered",
+  "colleague_contact_checked",
+  "recent_colleague_contact_skipped",
+  "colleague_contact_panel_missing",
+  "context_recoveries",
+  "human_rest_count",
+  "human_rest_ms",
+  "card_count",
+  "refresh_rounds"
+];
+
+function compactPositiveInteger(value, fallback = null) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function compactSmallRecord(value, fallback = null) {
+  const record = plainRecord(value);
+  if (!Object.keys(record).length) return fallback;
+  return clonePlain(record, fallback);
+}
+
+function compactRecommendSummaryForStatus(summary) {
+  if (!summary || typeof summary !== "object" || Array.isArray(summary)) return null;
+  const compact = {
+    domain: normalizeText(summary.domain || "recommend") || "recommend"
+  };
+  for (const key of STATUS_COUNT_KEYS) {
+    if (Number.isInteger(summary[key])) compact[key] = summary[key];
+  }
+  if (summary.target_url) compact.target_url = normalizeText(summary.target_url);
+  if (summary.list_end_reason) compact.list_end_reason = normalizeText(summary.list_end_reason);
+  if (Array.isArray(summary.results)) {
+    compact.results_count = summary.results.length;
+  } else if (Number.isInteger(summary.results_count)) {
+    compact.results_count = summary.results_count;
+  }
+  if (Array.isArray(summary.refresh_attempts)) {
+    compact.refresh_attempt_count = summary.refresh_attempts.length;
+  }
+  if (Array.isArray(summary.context_recoveries)) {
+    compact.context_recovery_count = summary.context_recoveries.length;
+  } else if (Number.isInteger(summary.context_recoveries)) {
+    compact.context_recoveries = summary.context_recoveries;
+  }
+  if (summary.job_selection) compact.job_selection = compactSmallRecord(summary.job_selection);
+  if (summary.page_scope) compact.page_scope = compactSmallRecord(summary.page_scope);
+  if (summary.filter) compact.filter = compactSmallRecord(summary.filter);
+  if (summary.candidate_list) {
+    const candidateList = plainRecord(summary.candidate_list);
+    compact.candidate_list = {
+      total_count: compactPositiveInteger(candidateList.total_count ?? candidateList.card_count, null),
+      visible_count: compactPositiveInteger(candidateList.visible_count, null),
+      list_end_reason: normalizeText(candidateList.list_end_reason || "")
+    };
+  }
+  if (summary.viewport_health?.stats) {
+    compact.viewport_health = {
+      stats: clonePlain(summary.viewport_health.stats, {})
+    };
+  }
+  if (summary.human_behavior) {
+    compact.human_behavior = {
+      enabled: summary.human_behavior.enabled === true,
+      profile: normalizeText(summary.human_behavior.profile || ""),
+      restLevel: normalizeText(summary.human_behavior.restLevel || summary.human_behavior.rest_level || "")
+    };
+  }
+  if (summary.human_rest) {
+    const humanRest = plainRecord(summary.human_rest);
+    compact.human_rest = {
+      enabled: humanRest.enabled === true,
+      restLevel: normalizeText(humanRest.restLevel || humanRest.rest_level || ""),
+      rest_count: compactPositiveInteger(humanRest.rest_count ?? humanRest.count, null),
+      total_pause_ms: compactPositiveInteger(humanRest.total_pause_ms ?? humanRest.pause_ms, null)
+    };
+  }
+  return compact;
+}
+
+function compactRecommendCheckpointForStatus(checkpoint) {
+  if (!checkpoint || typeof checkpoint !== "object" || Array.isArray(checkpoint)) return {};
+  const compact = {};
+  if (checkpoint.updatedAt || checkpoint.updated_at) {
+    compact.updatedAt = normalizeText(checkpoint.updatedAt || checkpoint.updated_at);
+  }
+  if (Array.isArray(checkpoint.results)) {
+    compact.results_count = checkpoint.results.length;
+  } 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;
+}
+
+function compactRecommendResultForStatus(result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return result || null;
+  const compact = {
+    ...result
+  };
+  if (Array.isArray(result.results)) {
+    compact.results_count = result.results.length;
+    compact.results_available = result.results.length > 0;
+  } else if (Number.isInteger(result.results_count)) {
+    compact.results_count = result.results_count;
+    compact.results_available = result.results_available === true || result.results_count > 0;
+  }
+  delete compact.results;
+  return compact;
+}
+
+export function compactRecommendRunForStatus(run) {
+  if (!run || typeof run !== "object" || Array.isArray(run)) return run || null;
+  const compact = {
+    ...run
+  };
+  if (compact.result) compact.result = compactRecommendResultForStatus(compact.result);
+  if (compact.summary) compact.summary = compactRecommendSummaryForStatus(compact.summary);
+  if (compact.checkpoint) compact.checkpoint = compactRecommendCheckpointForStatus(compact.checkpoint);
+  return compact;
+}
+
+function completionReason(status) {
+  if (status === RUN_STATUS_COMPLETED) return "completed";
+  if (status === RUN_STATUS_CANCELED) return "canceled_by_user";
   if (status === RUN_STATUS_FAILED) return "failed";
   if (status === RUN_STATUS_PAUSED) return "paused";
   return null;
@@ -685,13 +828,14 @@ function buildLegacyRecommendResult(snapshot) {
       effective_scope: meta.normalized?.pageScope || meta.parsed?.page_scope || "recommend"
     },
     search_params: clonePlain(meta.parsed?.searchParams || {}, {}),
-    screen_params: clonePlain(meta.parsed?.screenParams || {}, {}),
-    target_count_semantics: TARGET_COUNT_SEMANTICS,
-    error: snapshot.error || null,
-    recovery: buildConstrainedAgentRecovery(snapshot, meta, artifacts),
-    results: resultRows
-  };
-}
+    screen_params: clonePlain(meta.parsed?.screenParams || {}, {}),
+    target_count_semantics: TARGET_COUNT_SEMANTICS,
+    error: snapshot.error || null,
+    recovery: buildConstrainedAgentRecovery(snapshot, meta, artifacts),
+    results_count: resultRows.length,
+    results_available: resultRows.length > 0
+  };
+}
 
 function normalizeRunSnapshot(snapshot) {
   if (!snapshot) return null;
@@ -714,10 +858,12 @@ function normalizeRunSnapshot(snapshot) {
     follow_up: clonePlain(metaArgs.follow_up ?? snapshotContext.follow_up ?? null, null),
     target_count_semantics: TARGET_COUNT_SEMANTICS
   };
-  return {
-    ...snapshot,
-    progress,
-    run_id: snapshot.runId,
+  return {
+    ...snapshot,
+    checkpoint: compactRecommendCheckpointForStatus(snapshot.checkpoint),
+    summary: compactRecommendSummaryForStatus(summary),
+    progress,
+    run_id: snapshot.runId,
     mode: RUN_MODE_ASYNC,
     state: snapshot.status,
     stage: snapshot.phase,
@@ -874,7 +1020,7 @@ function persistRecommendRunSnapshot(snapshot, {
   normalized.control = mergePersistedControlRequest(normalized, existing);
   normalized = coerceCanceledTerminalSnapshot(normalized, existing);
   if (persistActiveCheckpoint) {
-    persistRecommendCheckpointSnapshot(normalized);
+    persistRecommendCheckpointSnapshot(snapshot);
   }
   const payload = {
     run_id: normalized.run_id,
@@ -970,17 +1116,19 @@ function persistRecommendLifecycleSnapshot(snapshot, event = {}) {
   });
 }
 
-function attachMethodEvidence(payload, runId) {
-  const meta = getRecommendRunMeta(runId);
-  assertNoForbiddenCdpCalls(meta.methodLog || []);
-  return {
-    ...payload,
-    runtime_evaluate_used: false,
-    method_summary: methodSummary(meta.methodLog || []),
-    method_log: meta.methodLog || [],
-    chrome: meta.chrome || null
-  };
-}
+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 compactRecommendJobListOption(option, index) {
   const label = normalizeText(option?.label);
@@ -1945,19 +2093,19 @@ export function getRecommendPipelineRunTool({ args = {} } = {}) {
     };
   }
   try {
-    const run = recommendRunService.getRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "RUN_STATUS",
-      run: normalizedRun
-    }, runId);
-  } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted) {
-      const reconciled = reconcilePersistedRecommendRunIfNeeded(persisted);
-      return {
-        status: "RUN_STATUS",
-        run: reconciled,
+    const run = recommendRunService.getRecommendRun(runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "RUN_STATUS",
+      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,
@@ -1985,36 +2133,36 @@ export function pauseRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "PAUSE_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已结束，无需暂停。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已结束，无需暂停。"
+      }, runId);
     }
     if (before.status === RUN_STATUS_PAUSED) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "PAUSE_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已经处于 paused 状态。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已经处于 paused 状态。"
+      }, runId);
     }
     const run = recommendRunService.pauseRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "PAUSE_REQUESTED",
-      run: normalizedRun,
-      message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
-    }, runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "PAUSE_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
+    }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
-        status: "PAUSE_IGNORED",
-        run: persisted,
-        message: "目标任务已结束，无需暂停。",
-        runtime_evaluate_used: false,
+      return {
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(persisted),
+        message: "目标任务已结束，无需暂停。",
+        runtime_evaluate_used: false,
         method_summary: {},
         method_log: [],
         chrome: null
@@ -2029,28 +2177,28 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "FAILED",
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "FAILED",
         error: {
           code: "RUN_ALREADY_TERMINATED",
           message: "目标任务已结束，无法继续。",
           retryable: false
         },
-        run: normalizedBefore
-      }, runId);
+        run: compactRecommendRunForStatus(normalizedBefore)
+      }, runId);
     }
     if (before.status !== RUN_STATUS_PAUSED) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "FAILED",
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "FAILED",
         error: {
           code: "RUN_NOT_PAUSED",
           message: "仅 paused 状态的 run 才能继续。",
           retryable: true
         },
-        run: normalizedBefore
-      }, runId);
+        run: compactRecommendRunForStatus(normalizedBefore)
+      }, runId);
     }
     const run = recommendRunService.resumeRecommendRun(runId);
     const meta = getRecommendRunMeta(runId);
@@ -2058,12 +2206,12 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
       meta.resumeCount = (meta.resumeCount || 0) + 1;
       meta.lastResumedAt = new Date().toISOString();
     }
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "RESUME_REQUESTED",
-      run: normalizedRun,
-      poll_after_sec: DEFAULT_RECOMMEND_POLL_AFTER_SEC,
-      message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "RESUME_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      poll_after_sec: DEFAULT_RECOMMEND_POLL_AFTER_SEC,
+      message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
     }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
@@ -2077,9 +2225,9 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
             : "该 run 只有磁盘快照，没有当前进程内的活动 CDP 会话，无法安全继续。",
           retryable: !TERMINAL_STATUSES.has(persisted.state)
         },
-        run: persisted,
-        persistence: {
-          source: "disk",
+        run: compactRecommendRunForStatus(persisted),
+        persistence: {
+          source: "disk",
           active_control_available: false
         },
         runtime_evaluate_used: false,
@@ -2097,28 +2245,28 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "CANCEL_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已结束，无需取消。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "CANCEL_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已结束，无需取消。"
+      }, runId);
     }
     const run = recommendRunService.cancelRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "CANCEL_REQUESTED",
-      run: normalizedRun,
-      message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
-    }, runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "CANCEL_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
+    }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
       return {
         status: "CANCEL_IGNORED",
-        run: persisted,
+        run: compactRecommendRunForStatus(persisted),
         message: "目标任务已结束，无需取消。",
-        runtime_evaluate_used: false,
+        runtime_evaluate_used: false,
         method_summary: {},
         method_log: [],
         chrome: null
@@ -2136,7 +2284,7 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
     if (patched) {
       return {
         status: "CANCEL_REQUESTED",
-        run: patched,
+        run: compactRecommendRunForStatus(patched),
         message: cancelMessage,
         persistence: {
           source: "disk",

package/src/recommend-scheduler.js

@@ -5,6 +5,7 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { getStateHome } from "./run-state.js";
 import {
+  compactRecommendRunForStatus,
   getRecommendPipelineRunTool,
   prepareRecommendPipelineRunTool,
   startRecommendPipelineRunTool
@@ -142,6 +143,19 @@ function writeSchedule(scheduleId, patch) {
   });
 }
 
+function compactScheduleForStatus(schedule) {
+  if (!schedule || typeof schedule !== "object" || Array.isArray(schedule)) return schedule || null;
+  const compact = clonePlain(schedule, schedule);
+  if (compact.run) compact.run = compactRecommendRunForStatus(compact.run);
+  if (compact.launch_payload?.run) {
+    compact.launch_payload = {
+      ...compact.launch_payload,
+      run: compactRecommendRunForStatus(compact.launch_payload.run)
+    };
+  }
+  return compact;
+}
+
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -355,7 +369,7 @@ export function getRecommendScheduledRunTool({ args = {} } = {}) {
   return {
     status: "OK",
     schedule_id: scheduleId,
-    schedule: next
+    schedule: compactScheduleForStatus(next)
   };
 }