@reconcrap/boss-recommend-mcp 2.1.21 → 2.1.22

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

@@ -8,13 +8,13 @@ import {
 } from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import { waitForCvCaptureTarget } from "../../core/cv-capture-target/index.js";
-import {
-  configureHumanInteraction,
-  createHumanRestController,
-  humanDelay,
-  normalizeHumanBehaviorOptions,
-  sleep
-} from "../../core/browser/index.js";
+import {
+  configureHumanInteraction,
+  createHumanRestController,
+  humanDelay,
+  normalizeHumanBehaviorOptions,
+  sleep
+} from "../../core/browser/index.js";
 import { GREET_CREDITS_EXHAUSTED_CODE } from "../../core/greet-quota/index.js";
 import {
   compactCvAcquisitionState,
@@ -38,41 +38,43 @@ import {
   resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
-import {
-  callScreeningLlm,
-  compactScreeningLlmResult,
-  createFatalLlmRunError,
-  createFailedLlmScreeningResult,
-  isFatalLlmProviderError,
-  llmResultToScreening,
-  screenCandidate
-} from "../../core/screening/index.js";
-import {
-  closeRecommendBlockingPanels,
-  closeRecommendAvatarPreview,
-  closeRecommendDetail,
-  createRecommendDetailNetworkRecorder,
-  extractRecommendDetailCandidate,
-  isRecommendDetailOpenMissError,
-  isStaleRecommendNodeError,
-  openRecommendCardDetailWithFreshRetry,
-  waitForRecommendDetailNetworkEvents
-} from "./detail.js";
 import {
-  readRecommendCardCandidate,
-  waitForRecommendCardNodeIds
-} from "./cards.js";
-import { selectAndConfirmFirstSafeFilter } from "./filters.js";
+  callScreeningLlm,
+  compactScreeningLlmResult,
+  createFatalLlmRunError,
+  createFailedLlmScreeningResult,
+  isFatalLlmProviderError,
+  llmResultToScreening,
+  screenCandidate
+} from "../../core/screening/index.js";
 import {
-  buildRecommendFilterSelectionOptions,
-  refreshRecommendListAtEnd
-} from "./refresh.js";
-import { selectRecommendJob } from "./jobs.js";
+  closeRecommendBlockingPanels,
+  closeRecommendAvatarPreview,
+  closeRecommendDetail,
+  createRecommendDetailNetworkRecorder,
+  extractRecommendDetailCandidate,
+  isRecommendDetailOpenMissError,
+  isStaleRecommendNodeError,
+  openRecommendCardDetailWithFreshRetry,
+  waitForRecommendDetailNetworkEvents
+} from "./detail.js";
 import {
-  normalizeRecommendPageScope,
-  selectRecommendPageScope
-} from "./scopes.js";
-import { inspectRecentColleagueContact } from "./colleague-contact.js";
+  readRecommendCardCandidate,
+  waitForRecommendCardNodeIds
+} from "./cards.js";
+import { selectAndConfirmFirstSafeFilter } from "./filters.js";
+import { ensureRecommendCurrentCityOnly } from "./location.js";
+import {
+  applyRecommendFilterEnvelopeStages,
+  buildRecommendFilterSelectionOptions,
+  refreshRecommendListAtEnd
+} from "./refresh.js";
+import { selectRecommendJob } from "./jobs.js";
+import {
+  normalizeRecommendPageScope,
+  selectRecommendPageScope
+} from "./scopes.js";
+import { inspectRecentColleagueContact } from "./colleague-contact.js";
 import {
   RECOMMEND_BOTTOM_MARKER_SELECTORS,
   RECOMMEND_CARD_SELECTOR,
@@ -104,26 +106,46 @@ function isRefreshableListStall(reason = "") {
 function normalizeFilter(filter = {}) {
   const filterGroups = Array.isArray(filter.filterGroups)
     ? filter.filterGroups
-    : Array.isArray(filter.groups)
-      ? filter.groups
-      : [];
-  return {
-    enabled: filter.enabled !== false,
-    group: String(filter.group || ""),
-    labels: normalizeLabels(filter.labels || filter.filterLabels || []),
-    selectAllLabels: Boolean(filter.selectAllLabels),
-    filterGroups: filterGroups.map((group) => ({
-      group: String(group?.group || ""),
-      labels: normalizeLabels(group?.labels || group?.filterLabels || []),
-      selectAllLabels: group?.selectAllLabels !== false
-    })).filter((group) => group.group || group.labels.length)
-  };
-}
-
-function compactFilterResult(filterResult) {
-  if (!filterResult) return null;
-  return {
-    opened_panel: Boolean(filterResult.opened_panel),
+    : Array.isArray(filter.groups)
+      ? filter.groups
+      : [];
+  return {
+    enabled: filter.enabled !== false,
+    currentCityOnly: filter.currentCityOnly === true || filter.current_city_only === true,
+    group: String(filter.group || ""),
+    labels: normalizeLabels(filter.labels || filter.filterLabels || []),
+    selectAllLabels: Boolean(filter.selectAllLabels),
+    allowUnlimited: filter.allowUnlimited === true,
+    verifySticky: filter.verifySticky === true,
+    filterGroups: filterGroups.map((group) => ({
+      group: String(group?.group || ""),
+      labels: normalizeLabels(group?.labels || group?.filterLabels || []),
+      selectAllLabels: group?.selectAllLabels !== false,
+      allowUnlimited: group?.allowUnlimited === true,
+      verifySticky: group?.verifySticky === true
+    })).filter((group) => group.group || group.labels.length)
+  };
+}
+
+export function compactFilterResult(filterResult) {
+  if (!filterResult) return null;
+  return {
+    opened_panel: Boolean(filterResult.opened_panel),
+    requested_groups: (filterResult.requested_groups || []).map((group) => ({
+      group: group.group,
+      labels: group.labels || [],
+      select_all_labels: group.select_all_labels !== false,
+      allow_unlimited: Boolean(group.allow_unlimited),
+      verify_sticky: Boolean(group.verify_sticky)
+    })),
+    effective_groups: (filterResult.sticky_verification?.groups || []).map((group) => ({
+      group: group.group,
+      requested_labels: group.requested_labels || [],
+      active_labels: group.active_labels || [],
+      verified: Boolean(group.verified),
+      unavailable: Boolean(group.unavailable),
+      reason: group.reason || null
+    })),
     selected_option: filterResult.selected_option
       ? {
           group: filterResult.selected_option.group,
@@ -133,49 +155,98 @@ function compactFilterResult(filterResult) {
         }
       : null,
     selected_options: (filterResult.selected_options || []).map((option) => ({
-      group: option.group,
-      label: option.label,
-      was_active: Boolean(option.was_active),
-      clicked: option.clicked !== false
-    })),
-    confirmed: Boolean(filterResult.confirmed),
-    before_counts: filterResult.before_counts,
-    after_confirm_counts: filterResult.after_confirm_counts
-  };
-}
-
-function compactJobSelection(jobSelection) {
-  if (!jobSelection) return null;
-  return {
-    requested: jobSelection.requested || "",
-    selected: Boolean(jobSelection.selected),
-    already_current: Boolean(jobSelection.already_current),
-    reason: jobSelection.reason || null,
-    selected_option: jobSelection.selected_option || null,
-    menu_close: jobSelection.menu_close
-      ? {
-          ok: Boolean(jobSelection.menu_close.ok),
-          closed: Boolean(jobSelection.menu_close.closed),
-          reason: jobSelection.menu_close.reason || ""
-        }
-      : null,
-    sticky_verification: jobSelection.sticky_verification
+      group: option.group,
+      label: option.label,
+      was_active: Boolean(option.was_active),
+      clicked: option.clicked !== false
+    })),
+    unavailable: Boolean(filterResult.unavailable),
+    unavailable_groups: filterResult.unavailable_groups || [],
+    confirmed: Boolean(filterResult.confirmed),
+    sticky_verification: filterResult.sticky_verification || null,
+    attempts: {
+      initial_close: filterResult.initial_close_attempts || [],
+      open: (filterResult.open_attempts || []).map((attempt) => ({
+        selector: attempt.selector || null,
+        node_id: attempt.node_id || null,
+        click_target: attempt.click_target || null
+      })),
+      confirmation: (filterResult.confirm_attempts || []).map((attempt) => ({
+        node_id: attempt.node_id || null,
+        label: attempt.label || null,
+        clicked: Boolean(attempt.clicked),
+        errors: (attempt.errors || []).map((error) => ({
+          node_id: error.node_id || null,
+          message: error.message || String(error)
+        }))
+      }))
+    },
+    before_counts: filterResult.before_counts,
+    after_confirm_counts: filterResult.after_confirm_counts
+  };
+}
+
+function compactCurrentCityOnlyResult(result) {
+  if (!result) return null;
+  return {
+    requested: Boolean(result.requested),
+    effective: typeof result.effective === "boolean" ? result.effective : null,
+    available: result.available !== false,
+    unavailable: Boolean(result.unavailable),
+    reason: result.reason || null,
+    clicked: Boolean(result.clicked),
+    current_city_label: result.current_city_label || null,
+    before: result.before || null,
+    after_toggle: result.after_toggle || null,
+    confirmation: result.confirmation || null,
+    sticky_verification: result.sticky_verification
       ? {
-          verified: Boolean(jobSelection.sticky_verification.verified),
-          current_label: jobSelection.sticky_verification.current_label_without_salary
-            || jobSelection.sticky_verification.current_label
-            || "",
-          visible_option_count: jobSelection.sticky_verification.visible_option_count || 0,
-          menu_close: jobSelection.sticky_verification.menu_close
-            ? {
-                ok: Boolean(jobSelection.sticky_verification.menu_close.ok),
-                closed: Boolean(jobSelection.sticky_verification.menu_close.closed),
-                reason: jobSelection.sticky_verification.menu_close.reason || ""
-              }
-            : null
+          verified: Boolean(result.sticky_verification.verified),
+          expected: Boolean(result.sticky_verification.expected),
+          actual: typeof result.sticky_verification.actual === "boolean"
+            ? result.sticky_verification.actual
+            : null,
+          state_source: result.sticky_verification.state_source || null,
+          close_confirmation: result.sticky_verification.close_confirmation || null
         }
       : null,
-    options: (jobSelection.options || []).map((option) => ({
+    attempts: Array.isArray(result.attempts) ? result.attempts : [],
+    evidence: result.evidence || null
+  };
+}
+
+function compactJobSelection(jobSelection) {
+  if (!jobSelection) return null;
+  return {
+    requested: jobSelection.requested || "",
+    selected: Boolean(jobSelection.selected),
+    already_current: Boolean(jobSelection.already_current),
+    reason: jobSelection.reason || null,
+    selected_option: jobSelection.selected_option || null,
+    menu_close: jobSelection.menu_close
+      ? {
+          ok: Boolean(jobSelection.menu_close.ok),
+          closed: Boolean(jobSelection.menu_close.closed),
+          reason: jobSelection.menu_close.reason || ""
+        }
+      : null,
+    sticky_verification: jobSelection.sticky_verification
+      ? {
+          verified: Boolean(jobSelection.sticky_verification.verified),
+          current_label: jobSelection.sticky_verification.current_label_without_salary
+            || jobSelection.sticky_verification.current_label
+            || "",
+          visible_option_count: jobSelection.sticky_verification.visible_option_count || 0,
+          menu_close: jobSelection.sticky_verification.menu_close
+            ? {
+                ok: Boolean(jobSelection.sticky_verification.menu_close.ok),
+                closed: Boolean(jobSelection.sticky_verification.menu_close.closed),
+                reason: jobSelection.sticky_verification.menu_close.reason || ""
+              }
+            : null
+        }
+      : null,
+    options: (jobSelection.options || []).map((option) => ({
       label: option.label,
       label_without_salary: option.label_without_salary,
       current: Boolean(option.current),
@@ -225,20 +296,20 @@ function compactCandidate(candidate) {
   };
 }
 
-function compactDetail(detailResult) {
-  if (!detailResult) return null;
-  return {
-    popup_text_length: detailResult.detail?.popup_text?.length || 0,
-    resume_text_length: detailResult.detail?.resume_text?.length || 0,
+function compactDetail(detailResult) {
+  if (!detailResult) return null;
+  return {
+    popup_text_length: detailResult.detail?.popup_text?.length || 0,
+    resume_text_length: detailResult.detail?.resume_text?.length || 0,
     network_body_count: detailResult.network_bodies?.filter((item) => item.body).length || 0,
     parsed_network_profile_count: detailResult.parsed_network_profiles?.filter((item) => item.ok).length || 0,
-    cv_acquisition: detailResult.cv_acquisition || null,
-    colleague_contact: detailResult.colleague_contact || null,
-    image_evidence: summarizeImageEvidence(detailResult.image_evidence),
-    llm_screening: compactScreeningLlmResult(detailResult.llm_result),
-    close_result: detailResult.close_result
-  };
-}
+    cv_acquisition: detailResult.cv_acquisition || null,
+    colleague_contact: detailResult.colleague_contact || null,
+    image_evidence: summarizeImageEvidence(detailResult.image_evidence),
+    llm_screening: compactScreeningLlmResult(detailResult.llm_result),
+    close_result: detailResult.close_result
+  };
+}
 
 function normalizeScreeningMode(value) {
   const normalized = String(value || "llm").trim().toLowerCase();
@@ -287,22 +358,22 @@ async function runRecommendPostAction({
     reason: ""
   };
 
-  if (!screening?.passed) {
-    result.reason = "screening_not_passed";
-    return result;
-  }
-  if (plan.effective === "none") {
-    result.reason = plan.reason === "greet_limit_reached" ? "greet_limit_reached" : "post_action_none";
-    return result;
-  }
-
-  const summary = actionDiscovery?.summary || {};
-  const control = summary.greet;
-  if (!control?.found) {
-    result.reason = `${plan.effective}_control_not_found`;
-    return result;
-  }
-  result.control = control;
+  if (!screening?.passed) {
+    result.reason = "screening_not_passed";
+    return result;
+  }
+  if (plan.effective === "none") {
+    result.reason = plan.reason === "greet_limit_reached" ? "greet_limit_reached" : "post_action_none";
+    return result;
+  }
+
+  const summary = actionDiscovery?.summary || {};
+  const control = summary.greet;
+  if (!control?.found) {
+    result.reason = `${plan.effective}_control_not_found`;
+    return result;
+  }
+  result.control = control;
 
   if (plan.effective === "greet" && control.continue_chat) {
     result.reason = "already_connected_continue_chat";
@@ -319,10 +390,10 @@ async function runRecommendPostAction({
     result.reason = "greet_control_not_available";
     return result;
   }
-  if (control.disabled) {
-    result.reason = `${plan.effective}_control_disabled`;
-    return result;
-  }
+  if (control.disabled) {
+    result.reason = `${plan.effective}_control_disabled`;
+    return result;
+  }
   if (!executePostAction) {
     result.reason = "dry_run_post_action";
     result.would_click = true;
@@ -357,18 +428,18 @@ async function runRecommendPostAction({
       timeoutMs: 2500,
       intervalMs: 300,
       requireAny: false
-    });
-    const afterSummary = afterDiscovery?.summary || {};
-    const afterControl = afterSummary.greet;
-    result.action_discovery_after = compactActionDiscovery(afterDiscovery);
-    result.control_after = afterControl || null;
-    if (plan.effective === "greet") {
-      result.verified_after_click = Boolean(
-        afterControl?.continue_chat
-        || String(afterControl?.label || "").includes("继续沟通")
-      );
-    }
-  } catch (error) {
+    });
+    const afterSummary = afterDiscovery?.summary || {};
+    const afterControl = afterSummary.greet;
+    result.action_discovery_after = compactActionDiscovery(afterDiscovery);
+    result.control_after = afterControl || null;
+    if (plan.effective === "greet") {
+      result.verified_after_click = Boolean(
+        afterControl?.continue_chat
+        || String(afterControl?.label || "").includes("继续沟通")
+      );
+    }
+  } catch (error) {
     result.verify_error = {
       message: error?.message || String(error)
     };
@@ -383,176 +454,195 @@ function compactRefreshAttempt(refreshAttempt) {
     method: refreshAttempt.method || "",
     reason: refreshAttempt.reason || null,
     error: refreshAttempt.error || null,
-    forced_recent_not_view: Boolean(refreshAttempt.forced_recent_not_view),
-    target_url: refreshAttempt.target_url || null,
-    card_count: refreshAttempt.card_count || 0,
-    elapsed_ms: refreshAttempt.elapsed_ms || 0,
-    recovery_settle: refreshAttempt.recovery_settle
-      ? {
-          ok: Boolean(refreshAttempt.recovery_settle.ok),
-          status: refreshAttempt.recovery_settle.status || "",
-          reason: refreshAttempt.recovery_settle.reason || "",
-          elapsed_ms: refreshAttempt.recovery_settle.elapsed_ms || 0
-        }
-      : null,
-    attempts: (refreshAttempt.attempts || []).map((attempt) => ({
+    forced_recent_not_view: Boolean(refreshAttempt.forced_recent_not_view),
+    target_url: refreshAttempt.target_url || null,
+    card_count: refreshAttempt.card_count || 0,
+    elapsed_ms: refreshAttempt.elapsed_ms || 0,
+    recovery_settle: refreshAttempt.recovery_settle
+      ? {
+          ok: Boolean(refreshAttempt.recovery_settle.ok),
+          status: refreshAttempt.recovery_settle.status || "",
+          reason: refreshAttempt.recovery_settle.reason || "",
+          elapsed_ms: refreshAttempt.recovery_settle.elapsed_ms || 0
+        }
+      : null,
+    attempts: (refreshAttempt.attempts || []).map((attempt) => ({
       ok: Boolean(attempt.ok),
       method: attempt.method || "",
       reason: attempt.reason || null,
-      error: attempt.error || null,
-      label: attempt.label || null,
+      error: attempt.error || null,
+      label: attempt.label || null,
       before_card_count: attempt.before_card_count || 0,
       after_card_count: attempt.after_card_count || 0,
       card_count: attempt.card_count || 0,
-      elapsed_ms: attempt.elapsed_ms || 0
+      elapsed_ms: attempt.elapsed_ms || 0,
+      current_city_only: compactCurrentCityOnlyResult(attempt.current_city_only),
+      current_city_only_attempts: (attempt.current_city_only_attempts || []).map((cityAttempt) => ({
+        ok: Boolean(cityAttempt.ok),
+        method: cityAttempt.method || "current_city_only_reapply",
+        reason: cityAttempt.reason || null,
+        error: cityAttempt.error || null,
+        attempt: cityAttempt.attempt || 0,
+        result: compactCurrentCityOnlyResult(cityAttempt.result)
+      })),
+      filter: compactFilterResult(attempt.filter)
     })),
-    filter_reapply_attempts: (refreshAttempt.filter_reapply_attempts || []).map((attempt) => ({
+    current_city_only_attempts: (refreshAttempt.current_city_only_attempts || []).map((attempt) => ({
       ok: Boolean(attempt.ok),
-      method: attempt.method || "filter_reapply",
+      method: attempt.method || "current_city_only_reapply",
       reason: attempt.reason || null,
       error: attempt.error || null,
-      attempt: attempt.attempt || 0
+      attempt: attempt.attempt || 0,
+      result: compactCurrentCityOnlyResult(attempt.result)
     })),
-    job_selection_attempts: (refreshAttempt.job_selection_attempts || []).map((attempt) => ({
+    filter_reapply_attempts: (refreshAttempt.filter_reapply_attempts || []).map((attempt) => ({
       ok: Boolean(attempt.ok),
-      method: attempt.method || "job_select",
+      method: attempt.method || "filter_reapply",
       reason: attempt.reason || null,
-      error: attempt.error || null,
-      attempt: attempt.attempt || 0,
-      iframe_document_node_id: attempt.iframe_document_node_id || 0,
+      error: attempt.error || null,
+      attempt: attempt.attempt || 0
+    })),
+    job_selection_attempts: (refreshAttempt.job_selection_attempts || []).map((attempt) => ({
+      ok: Boolean(attempt.ok),
+      method: attempt.method || "job_select",
+      reason: attempt.reason || null,
+      error: attempt.error || null,
+      attempt: attempt.attempt || 0,
+      iframe_document_node_id: attempt.iframe_document_node_id || 0,
       selected: Boolean(attempt.selected),
       selection_reason: attempt.selection_reason || null
     })),
     job_selection: compactJobSelection(refreshAttempt.job_selection),
     page_scope: compactPageScopeSelection(refreshAttempt.page_scope),
+    current_city_only: compactCurrentCityOnlyResult(refreshAttempt.current_city_only),
     filter: compactFilterResult(refreshAttempt.filter)
   };
 }
-
+
 export function countRecommendResultStatuses(results = [], {
-  greetCount = 0
-} = {}) {
-  return {
-    processed: results.length,
-    screened: results.length,
-    detail_opened: results.filter((item) => item.detail).length,
-    passed: results.filter((item) => item.screening?.passed).length,
-    skipped: results.filter((item) => item.screening?.passed === false).length,
-    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
-    greet_count: greetCount,
-    post_action_clicked: results.filter((item) => item.post_action?.action_clicked).length,
-    image_capture_failed: results.filter((item) => item.detail?.image_evidence?.ok === false).length,
+  greetCount = 0
+} = {}) {
+  return {
+    processed: results.length,
+    screened: results.length,
+    detail_opened: results.filter((item) => item.detail).length,
+    passed: results.filter((item) => item.screening?.passed).length,
+    skipped: results.filter((item) => item.screening?.passed === false).length,
+    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
+    greet_count: greetCount,
+    post_action_clicked: results.filter((item) => item.post_action?.action_clicked).length,
+    image_capture_failed: results.filter((item) => item.detail?.image_evidence?.ok === false).length,
     detail_open_failed: results.filter((item) => (
       item.error?.code === "DETAIL_STALE_NODE"
       || item.error?.code === "DETAIL_OPEN_FAILED"
-    )).length,
-    transient_recovered: results.filter((item) => (
-      item.error?.code === "DETAIL_STALE_NODE"
-      || item.error?.code === "DETAIL_OPEN_FAILED"
-      || item.error?.code === "IMAGE_CAPTURE_STALE_NODE"
-      || item.error?.code === "IMAGE_CAPTURE_TIMEOUT"
-      || item.error?.code === "IMAGE_CAPTURE_TOTAL_TIMEOUT"
-    )).length,
-    colleague_contact_checked: results.filter((item) => item.detail?.colleague_contact?.checked).length,
-    recent_colleague_contact_skipped: results.filter((item) => (
-      item.screening?.status === "skip"
-      && item.screening?.reasons?.includes("skipped_recent_colleague_contact")
-    )).length,
-    colleague_contact_panel_missing: results.filter((item) => (
-      item.detail?.colleague_contact?.reason === "panel_missing"
-    )).length
-  };
-}
+    )).length,
+    transient_recovered: results.filter((item) => (
+      item.error?.code === "DETAIL_STALE_NODE"
+      || item.error?.code === "DETAIL_OPEN_FAILED"
+      || item.error?.code === "IMAGE_CAPTURE_STALE_NODE"
+      || item.error?.code === "IMAGE_CAPTURE_TIMEOUT"
+      || item.error?.code === "IMAGE_CAPTURE_TOTAL_TIMEOUT"
+    )).length,
+    colleague_contact_checked: results.filter((item) => item.detail?.colleague_contact?.checked).length,
+    recent_colleague_contact_skipped: results.filter((item) => (
+      item.screening?.status === "skip"
+      && item.screening?.reasons?.includes("skipped_recent_colleague_contact")
+    )).length,
+    colleague_contact_panel_missing: results.filter((item) => (
+      item.detail?.colleague_contact?.reason === "panel_missing"
+    )).length
+  };
+}
 
-function countPassedResults(results = []) {
-  return countRecommendResultStatuses(results).passed;
-}
-
-function compactCloseResult(closeResult) {
-  if (!closeResult) return null;
-  const result = {
-    closed: Boolean(closeResult.closed),
-    reason: closeResult.reason || null,
-    probe: closeResult.probe || null,
-    attempts: closeResult.attempts || [],
-    verification: closeResult.verification || null
-  };
-  if (closeResult.already_closed !== undefined) {
-    result.already_closed = Boolean(closeResult.already_closed);
-  }
-  return result;
-}
-
-function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
-  if (!error) return null;
-  const result = {
-    code: error.code || fallbackCode,
-    message: error.message || String(error)
-  };
-  if (error.close_result) {
-    result.close_result = compactCloseResult(error.close_result);
-  }
-  if (error.phase) {
-    result.phase = error.phase;
-  }
-  if (error.refresh_attempt) {
-    result.refresh_attempt = error.refresh_attempt;
-  }
-  if (error.list_end_reason) {
-    result.list_end_reason = error.list_end_reason;
-  }
-  if (error.target_count != null) {
-    result.target_count = error.target_count;
-  }
-  if (error.passed_count != null) {
-    result.passed_count = error.passed_count;
-  }
-  if (Array.isArray(error.recommend_detail_open_attempts)) {
-    result.recommend_detail_open_attempts = error.recommend_detail_open_attempts;
-  }
-  if (Array.isArray(error.click_attempts)) {
-    result.click_attempts = error.click_attempts;
-  }
-  if (error.avatar_preview) {
-    result.avatar_preview = {
-      open: Boolean(error.avatar_preview.open),
-      selector: error.avatar_preview.preview?.selector || null,
-      rect: error.avatar_preview.preview?.rect || null
-    };
-  }
-  return result;
-}
+function countPassedResults(results = []) {
+  return countRecommendResultStatuses(results).passed;
+}
 
-function createRecommendCloseFailureError(closeResult) {
-  const error = new Error(closeResult?.reason || "Recommend detail did not close before recovery");
-  error.code = "DETAIL_CLOSE_FAILED";
-  error.close_result = closeResult || null;
-  return error;
-}
-
-function createRecommendBlockingPanelCloseFailureError(closeResult, phase = "") {
-  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
-  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
-  error.close_result = closeResult || null;
-  error.phase = phase || null;
-  return error;
-}
-
-function createRecommendRefreshFailureError(refreshAttempt, {
-  listEndReason = "",
-  targetCount = 0,
-  passedCount = 0
-} = {}) {
-  const reason = refreshAttempt?.reason || "refresh_failed";
-  const detail = refreshAttempt?.error ? `: ${refreshAttempt.error}` : "";
-  const error = new Error(`Recommend refresh failed before target was reached (${reason}${detail})`);
-  error.code = "RECOMMEND_END_REFRESH_FAILED";
-  error.refresh_attempt = refreshAttempt || null;
-  error.list_end_reason = listEndReason || null;
-  error.target_count = targetCount;
-  error.passed_count = passedCount;
-  return error;
-}
+function compactCloseResult(closeResult) {
+  if (!closeResult) return null;
+  const result = {
+    closed: Boolean(closeResult.closed),
+    reason: closeResult.reason || null,
+    probe: closeResult.probe || null,
+    attempts: closeResult.attempts || [],
+    verification: closeResult.verification || null
+  };
+  if (closeResult.already_closed !== undefined) {
+    result.already_closed = Boolean(closeResult.already_closed);
+  }
+  return result;
+}
+
+function compactError(error, fallbackCode = "RECOMMEND_RUN_ERROR") {
+  if (!error) return null;
+  const result = {
+    code: error.code || fallbackCode,
+    message: error.message || String(error)
+  };
+  if (error.close_result) {
+    result.close_result = compactCloseResult(error.close_result);
+  }
+  if (error.phase) {
+    result.phase = error.phase;
+  }
+  if (error.refresh_attempt) {
+    result.refresh_attempt = error.refresh_attempt;
+  }
+  if (error.list_end_reason) {
+    result.list_end_reason = error.list_end_reason;
+  }
+  if (error.target_count != null) {
+    result.target_count = error.target_count;
+  }
+  if (error.passed_count != null) {
+    result.passed_count = error.passed_count;
+  }
+  if (Array.isArray(error.recommend_detail_open_attempts)) {
+    result.recommend_detail_open_attempts = error.recommend_detail_open_attempts;
+  }
+  if (Array.isArray(error.click_attempts)) {
+    result.click_attempts = error.click_attempts;
+  }
+  if (error.avatar_preview) {
+    result.avatar_preview = {
+      open: Boolean(error.avatar_preview.open),
+      selector: error.avatar_preview.preview?.selector || null,
+      rect: error.avatar_preview.preview?.rect || null
+    };
+  }
+  return result;
+}
+
+function createRecommendCloseFailureError(closeResult) {
+  const error = new Error(closeResult?.reason || "Recommend detail did not close before recovery");
+  error.code = "DETAIL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  return error;
+}
+
+function createRecommendBlockingPanelCloseFailureError(closeResult, phase = "") {
+  const error = new Error(closeResult?.reason || "Boss account-rights panel did not close before recovery");
+  error.code = "ACCOUNT_RIGHTS_PANEL_CLOSE_FAILED";
+  error.close_result = closeResult || null;
+  error.phase = phase || null;
+  return error;
+}
+
+function createRecommendRefreshFailureError(refreshAttempt, {
+  listEndReason = "",
+  targetCount = 0,
+  passedCount = 0
+} = {}) {
+  const reason = refreshAttempt?.reason || "refresh_failed";
+  const detail = refreshAttempt?.error ? `: ${refreshAttempt.error}` : "";
+  const error = new Error(`Recommend refresh failed before target was reached (${reason}${detail})`);
+  error.code = "RECOMMEND_END_REFRESH_FAILED";
+  error.refresh_attempt = refreshAttempt || null;
+  error.list_end_reason = listEndReason || null;
+  error.target_count = targetCount;
+  error.passed_count = passedCount;
+  return error;
+}
 
 export function isRecoverableImageCaptureError(error) {
   const code = String(error?.code || "");
@@ -615,41 +705,41 @@ function createImageCaptureFailureScreening(candidate, error) {
   };
 }
 
-export function isRecoverableRecommendDetailError(error) {
-  return isStaleRecommendNodeError(error) || isRecommendDetailOpenMissError(error);
-}
+export function isRecoverableRecommendDetailError(error) {
+  return isStaleRecommendNodeError(error) || isRecommendDetailOpenMissError(error);
+}
 
 function compactRecoverableDetailError(error) {
   return compactError(error, isStaleRecommendNodeError(error) ? "DETAIL_STALE_NODE" : "DETAIL_OPEN_FAILED");
 }
 
-function createRecoverableDetailFailureScreening(candidate, error) {
-  return {
-    status: "fail",
-    passed: false,
-    score: 0,
-    reasons: isStaleRecommendNodeError(error)
-      ? ["detail_open_failed", "stale_node"]
-      : isRecommendDetailOpenMissError(error)
-      ? ["detail_open_failed", "detail_open_miss"]
-      : ["detail_open_failed"],
+function createRecoverableDetailFailureScreening(candidate, error) {
+  return {
+    status: "fail",
+    passed: false,
+    score: 0,
+    reasons: isStaleRecommendNodeError(error)
+      ? ["detail_open_failed", "stale_node"]
+      : isRecommendDetailOpenMissError(error)
+      ? ["detail_open_failed", "detail_open_miss"]
+      : ["detail_open_failed"],
     error: compactRecoverableDetailError(error),
-    candidate
-  };
-}
-
-function createRecentColleagueContactSkipScreening(candidate, colleagueContact) {
-  const matched = colleagueContact?.matched_row || null;
-  return {
-    status: "skip",
-    passed: false,
-    score: 0,
-    reasons: ["skipped_recent_colleague_contact"],
-    reason: matched?.text || "Candidate has recent colleague contact history",
-    matched_colleague_contact: matched,
-    candidate
-  };
-}
+    candidate
+  };
+}
+
+function createRecentColleagueContactSkipScreening(candidate, colleagueContact) {
+  const matched = colleagueContact?.matched_row || null;
+  return {
+    status: "skip",
+    passed: false,
+    score: 0,
+    reasons: ["skipped_recent_colleague_contact"],
+    reason: matched?.text || "Candidate has recent colleague contact history",
+    matched_colleague_contact: matched,
+    candidate
+  };
+}
 
 export async function runRecommendWorkflow({
   client,
@@ -681,47 +771,47 @@ export async function runRecommendWorkflow({
   executePostAction = true,
   actionTimeoutMs = 8000,
   actionIntervalMs = 500,
-  actionAfterClickDelayMs = 900,
-  screeningMode = "llm",
-  llmConfig = null,
-  llmTimeoutMs = 120000,
-  llmImageLimit = 8,
-  llmImageDetail = "high",
-  imageOutputDir = "",
-  humanRestEnabled = false,
-  humanBehavior = null,
-  skipRecentColleagueContacted = true,
-  colleagueContactWindowDays = 14
-} = {}, runControl) {
-  if (!client) throw new Error("runRecommendWorkflow 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,
-    textEntryEnabled: effectiveHumanBehavior.textEntry,
-    safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
-    actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
-  });
-  const humanRestController = createHumanRestController({
-    enabled: effectiveHumanRestEnabled,
-    shortRestEnabled: effectiveHumanBehavior.shortRest,
-    batchRestEnabled: effectiveHumanBehavior.batchRest,
-    restLevel: effectiveHumanBehavior.restLevel
-  });
-  const normalizedFilter = normalizeFilter(filter);
+  actionAfterClickDelayMs = 900,
+  screeningMode = "llm",
+  llmConfig = null,
+  llmTimeoutMs = 120000,
+  llmImageLimit = 8,
+  llmImageDetail = "high",
+  imageOutputDir = "",
+  humanRestEnabled = false,
+  humanBehavior = null,
+  skipRecentColleagueContacted = true,
+  colleagueContactWindowDays = 14
+} = {}, runControl) {
+  if (!client) throw new Error("runRecommendWorkflow 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,
+    textEntryEnabled: effectiveHumanBehavior.textEntry,
+    safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
+    actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
+  });
+  const humanRestController = createHumanRestController({
+    enabled: effectiveHumanRestEnabled,
+    shortRestEnabled: effectiveHumanBehavior.shortRest,
+    batchRestEnabled: effectiveHumanBehavior.batchRest,
+    restLevel: effectiveHumanBehavior.restLevel
+  });
+  const normalizedFilter = normalizeFilter(filter);
   const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
   const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
   const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
-  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
-  const useLlmScreening = normalizedScreeningMode !== "deterministic";
-  const postActionEnabled = normalizedPostAction !== "none";
-  const shouldSkipRecentColleagueContacted = skipRecentColleagueContacted !== false;
-  const normalizedColleagueContactWindowDays = Math.max(1, Number(colleagueContactWindowDays) || 14);
-  const colleagueContactReferenceDate = new Date();
-  const targetPassCount = Math.max(1, Number(maxCandidates) || 1);
+  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+  const useLlmScreening = normalizedScreeningMode !== "deterministic";
+  const postActionEnabled = normalizedPostAction !== "none";
+  const shouldSkipRecentColleagueContacted = skipRecentColleagueContacted !== false;
+  const normalizedColleagueContactWindowDays = Math.max(1, Number(colleagueContactWindowDays) || 14);
+  const colleagueContactReferenceDate = new Date();
+  const targetPassCount = Math.max(1, Number(maxCandidates) || 1);
   const detailCountLimit = detailLimit == null ? Number.POSITIVE_INFINITY : Math.max(0, Number(detailLimit) || 0);
   const effectiveDetailLimit = postActionEnabled ? Number.POSITIVE_INFINITY : detailCountLimit;
   const networkRecorder = effectiveDetailLimit > 0
@@ -747,59 +837,60 @@ export async function runRecommendWorkflow({
   const results = [];
   const refreshAttempts = [];
   let refreshRounds = 0;
-  let contextRecoveryAttempts = 0;
-  let greetCount = 0;
+  let contextRecoveryAttempts = 0;
+  let greetCount = 0;
   const candidateRecoveryCounts = new Map();
   let jobSelection = null;
   let pageScopeSelection = null;
+  let currentCityOnlyResult = null;
   let filterResult = null;
   let rootState = null;
   let cardNodeIds = [];
   let listEndReason = "";
   let lastHumanEvent = null;
-  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
+  const listFallbackResolver = listFallbackPoint || (async ({ items = [] } = {}) => resolveInfiniteListFallbackPoint(client, {
     rootNodeId: rootState?.iframe?.documentNodeId,
     containerSelectors: RECOMMEND_LIST_CONTAINER_SELECTORS,
     itemNodeIds: items.map((item) => item.node_id).filter(Boolean),
     itemSelectors: [RECOMMEND_CARD_SELECTOR],
     viewportPoint: { xRatio: 0.28, yRatio: 0.5 },
     validateViewportPoint: true
-  }));
-
-  function recordHumanEvent(event = null) {
-    if (!event) return lastHumanEvent;
-    lastHumanEvent = {
-      at: new Date().toISOString(),
-      ...event
-    };
-    return lastHumanEvent;
-  }
-
-  async function maybeHumanActionCooldown(phase, timings = {}) {
-    if (!effectiveHumanBehavior.actionCooldown) return null;
-    const pauseMs = humanDelay(280, 90, {
-      minMs: 80,
-      maxMs: 720
-    });
-    if (pauseMs > 0) {
-      await runControl.sleep(pauseMs);
-      addTiming(timings, `human_${phase}_pause_ms`, pauseMs);
-    }
-    return recordHumanEvent({
-      kind: "action_cooldown",
-      phase,
-      pause_ms: pauseMs
-    });
-  }
-
-  function updateRecommendProgress(extra = {}) {
-    const counts = countRecommendResultStatuses(results, { greetCount });
-    const listSnapshot = compactInfiniteListState(listState);
-    const humanRestState = humanRestController.getState();
-    runControl.updateProgress({
-      card_count: cardNodeIds.length,
-      target_count: targetPassCount,
-      target_count_semantics: "passed_candidates",
+  }));
+
+  function recordHumanEvent(event = null) {
+    if (!event) return lastHumanEvent;
+    lastHumanEvent = {
+      at: new Date().toISOString(),
+      ...event
+    };
+    return lastHumanEvent;
+  }
+
+  async function maybeHumanActionCooldown(phase, timings = {}) {
+    if (!effectiveHumanBehavior.actionCooldown) return null;
+    const pauseMs = humanDelay(280, 90, {
+      minMs: 80,
+      maxMs: 720
+    });
+    if (pauseMs > 0) {
+      await runControl.sleep(pauseMs);
+      addTiming(timings, `human_${phase}_pause_ms`, pauseMs);
+    }
+    return recordHumanEvent({
+      kind: "action_cooldown",
+      phase,
+      pause_ms: pauseMs
+    });
+  }
+
+  function updateRecommendProgress(extra = {}) {
+    const counts = countRecommendResultStatuses(results, { greetCount });
+    const listSnapshot = compactInfiniteListState(listState);
+    const humanRestState = humanRestController.getState();
+    runControl.updateProgress({
+      card_count: cardNodeIds.length,
+      target_count: targetPassCount,
+      target_count_semantics: "passed_candidates",
       ...counts,
       screening_mode: normalizedScreeningMode,
       unique_seen: listSnapshot.seen_count,
@@ -807,25 +898,28 @@ export async function runRecommendWorkflow({
       refresh_rounds: refreshRounds,
       refresh_attempts: refreshAttempts.length,
       context_recoveries: contextRecoveryAttempts,
-      list_end_reason: listEndReason || null,
-      viewport_checks: viewportGuard.getStats().checks,
-      viewport_recoveries: viewportGuard.getStats().recoveries,
-      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      list_end_reason: listEndReason || null,
+      viewport_checks: viewportGuard.getStats().checks,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
       human_behavior_profile: effectiveHumanBehavior.profile,
       human_rest_level: effectiveHumanBehavior.restLevel,
       human_rest_enabled: effectiveHumanRestEnabled,
       skip_recent_colleague_contacted: shouldSkipRecentColleagueContacted,
       colleague_contact_window_days: normalizedColleagueContactWindowDays,
+      current_city_only_requested: normalizedFilter.currentCityOnly,
+      current_city_only_effective: currentCityOnlyResult?.effective ?? null,
+      current_city_only_unavailable: Boolean(currentCityOnlyResult?.unavailable),
       human_rest_count: humanRestState.rest_count,
       human_rest_ms: humanRestState.total_rest_ms,
       last_human_event: lastHumanEvent,
       ...extra
     });
-  }
+  }
 
-  function checkpointInProgressCandidate({
-    index = results.length,
-    candidateKey = "",
+  function checkpointInProgressCandidate({
+    index = results.length,
+    candidateKey = "",
     cardNodeId = null,
     detailStep = "",
     error = null
@@ -839,58 +933,59 @@ export async function runRecommendWorkflow({
         counters: countRecommendResultStatuses(results, { greetCount }),
         error: compactError(error, "RECOMMEND_IN_PROGRESS_ERROR")
       },
-      candidate_list: compactInfiniteListState(listState)
-    });
-  }
-
-  async function closeRecommendBlockingPanelsForRun(phase = "cleanup") {
-    const result = await closeRecommendBlockingPanels(client, {
-      attemptsLimit: 2,
-      rootState
-    });
-    if (!result?.closed) {
-      throw createRecommendBlockingPanelCloseFailureError(result, phase);
-    }
-    return result;
-  }
-
-  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
+      candidate_list: compactInfiniteListState(listState)
+    });
+  }
+
+  async function closeRecommendBlockingPanelsForRun(phase = "cleanup") {
+    const result = await closeRecommendBlockingPanels(client, {
+      attemptsLimit: 2,
+      rootState
+    });
+    if (!result?.closed) {
+      throw createRecommendBlockingPanelCloseFailureError(result, phase);
+    }
+    return result;
+  }
+
+  async function recoverAndReapplyRecommendContext(reason = "context_recovery", error = null, {
     forceRecentNotView = true
   } = {}) {
-    await runControl.waitIfPaused();
-    runControl.throwIfCanceled();
-    const started = Date.now();
-    runControl.setPhase("recommend:recover-context");
-    contextRecoveryAttempts += 1;
+    await runControl.waitIfPaused();
+    runControl.throwIfCanceled();
+    const started = Date.now();
+    runControl.setPhase("recommend:recover-context");
+    contextRecoveryAttempts += 1;
+    const effectiveForceRecentNotView = normalizedFilter.enabled && forceRecentNotView;
     const refreshResult = await refreshRecommendListAtEnd(client, {
       rootState,
       jobLabel,
-      pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
-      fallbackPageScope: normalizedFallbackPageScope,
-      filter: normalizedFilter,
-      preferEndRefreshButton: false,
-      forceNavigate: true,
-      targetUrl: targetUrl || RECOMMEND_TARGET_URL,
-      forceRecentNotView,
-      cardTimeoutMs,
+      pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
+      fallbackPageScope: normalizedFallbackPageScope,
+      filter: normalizedFilter,
+      preferEndRefreshButton: false,
+      forceNavigate: true,
+      targetUrl: targetUrl || RECOMMEND_TARGET_URL,
+      forceRecentNotView: effectiveForceRecentNotView,
+      cardTimeoutMs,
       buttonSettleMs: refreshButtonSettleMs,
       reloadSettleMs: refreshReloadSettleMs
     });
     let blockingPanelClose = null;
-    if (refreshResult.ok) {
-      blockingPanelClose = await closeRecommendBlockingPanels(client, {
-        attemptsLimit: 2,
-        rootState: refreshResult.root_state || rootState
-      });
-    }
-    const compactRefresh = {
-      ...compactRefreshAttempt(refreshResult),
-      context_recovery: true,
-      recovery_reason: reason,
-      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
-      account_rights_panel_close: compactCloseResult(blockingPanelClose),
-      elapsed_ms: Date.now() - started
-    };
+    if (refreshResult.ok) {
+      blockingPanelClose = await closeRecommendBlockingPanels(client, {
+        attemptsLimit: 2,
+        rootState: refreshResult.root_state || rootState
+      });
+    }
+    const compactRefresh = {
+      ...compactRefreshAttempt(refreshResult),
+      context_recovery: true,
+      recovery_reason: reason,
+      trigger_error: compactError(error, "RECOMMEND_CONTEXT_RECOVERY_TRIGGER"),
+      account_rights_panel_close: compactCloseResult(blockingPanelClose),
+      elapsed_ms: Date.now() - started
+    };
     refreshAttempts.push(compactRefresh);
     runControl.checkpoint({
       context_recovery: {
@@ -900,56 +995,62 @@ export async function runRecommendWorkflow({
         refresh: compactRefresh,
         counters: countRecommendResultStatuses(results, { greetCount })
       },
-      candidate_list: compactInfiniteListState(listState)
-    });
-    if (!refreshResult.ok) {
-      updateRecommendProgress({
-        refresh_method: refreshResult.method || null,
-        refresh_forced_recent_not_view: forceRecentNotView,
-        recovery_reason: reason
+      candidate_list: compactInfiniteListState(listState)
+    });
+    if (!refreshResult.ok) {
+      updateRecommendProgress({
+        refresh_method: refreshResult.method || null,
+        refresh_forced_recent_not_view: effectiveForceRecentNotView,
+        recovery_reason: reason
       });
       throw new Error(`Recommend context recovery failed after ${reason}: ${refreshResult.reason || refreshResult.error || "refresh returned no cards"}`);
     }
+    if (refreshResult.current_city_only) {
+      currentCityOnlyResult = refreshResult.current_city_only;
+    }
+    if (refreshResult.filter) {
+      filterResult = refreshResult.filter;
+    }
     if (!blockingPanelClose?.closed) {
       const panelError = createRecommendBlockingPanelCloseFailureError(blockingPanelClose, `recover:${reason}`);
       panelError.refresh_attempt = compactRefresh;
       throw panelError;
     }
-    rootState = refreshResult.root_state || await getRecommendRoots(client);
+    rootState = refreshResult.root_state || await getRecommendRoots(client);
     rootState = await ensureRecommendViewport(rootState, "recover_after");
     cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
       timeoutMs: cardTimeoutMs,
       intervalMs: 300
     });
     resetInfiniteListForRefreshRound(listState, {
-      reason: `context_recovery:${reason}`,
-      round: contextRecoveryAttempts,
-      method: refreshResult.method,
-      metadata: {
-        card_count: cardNodeIds.length,
-        forced_recent_not_view: forceRecentNotView,
-        counters: countRecommendResultStatuses(results, { greetCount })
-      }
-    });
-    listEndReason = "";
-    updateRecommendProgress({
-      card_count: cardNodeIds.length,
-      refresh_method: refreshResult.method || null,
-      refresh_forced_recent_not_view: forceRecentNotView,
-      recovery_reason: reason
-    });
-    return refreshResult;
+      reason: `context_recovery:${reason}`,
+      round: contextRecoveryAttempts,
+      method: refreshResult.method,
+      metadata: {
+        card_count: cardNodeIds.length,
+        forced_recent_not_view: effectiveForceRecentNotView,
+        counters: countRecommendResultStatuses(results, { greetCount })
+      }
+    });
+    listEndReason = "";
+    updateRecommendProgress({
+      card_count: cardNodeIds.length,
+      refresh_method: refreshResult.method || null,
+      refresh_forced_recent_not_view: effectiveForceRecentNotView,
+      recovery_reason: reason
+    });
+    return refreshResult;
   }
 
-  runControl.setPhase("recommend:cleanup");
-  await closeRecommendDetail(client, { attemptsLimit: 2 });
-  await closeRecommendAvatarPreview(client, { attemptsLimit: 2 });
-  await closeRecommendBlockingPanelsForRun("cleanup");
-
-  await runControl.waitIfPaused();
-  runControl.throwIfCanceled();
-  runControl.setPhase("recommend:roots");
-  rootState = await getRecommendRoots(client);
+  runControl.setPhase("recommend:cleanup");
+  await closeRecommendDetail(client, { attemptsLimit: 2 });
+  await closeRecommendAvatarPreview(client, { attemptsLimit: 2 });
+  await closeRecommendBlockingPanelsForRun("cleanup");
+
+  await runControl.waitIfPaused();
+  runControl.throwIfCanceled();
+  runControl.setPhase("recommend:roots");
+  rootState = await getRecommendRoots(client);
   rootState = await ensureRecommendViewport(rootState, "roots");
   runControl.checkpoint({
     iframe_selector: rootState.iframe.selector,
@@ -987,34 +1088,55 @@ export async function runRecommendWorkflow({
     throw new Error(`Recommend page scope was not selected: ${pageScopeSelection.reason || pageScopeSelection.effective_scope || requestedPageScope}`);
   }
   rootState = await getRecommendRoots(client);
-  rootState = await ensureRecommendViewport(rootState, "page_scope");
-  runControl.checkpoint({
-    page_scope: compactPageScopeSelection(pageScopeSelection)
-  });
-
-  if (normalizedFilter.enabled) {
-    await runControl.waitIfPaused();
-    runControl.throwIfCanceled();
-    runControl.setPhase("recommend:filter");
-    filterResult = await selectAndConfirmFirstSafeFilter(
-      client,
-      rootState.iframe.documentNodeId,
-      buildRecommendFilterSelectionOptions(normalizedFilter)
-    );
-    if (!filterResult.confirmed) {
-      throw new Error("Recommend run filter selection was not confirmed");
-    }
-    rootState = await getRecommendRoots(client);
-    rootState = await ensureRecommendViewport(rootState, "filter");
-    runControl.checkpoint({
-      filter: compactFilterResult(filterResult)
-    });
-  }
-
-  await runControl.waitIfPaused();
-  runControl.throwIfCanceled();
-  runControl.setPhase("recommend:cards");
-  rootState = await ensureRecommendViewport(rootState, "cards");
+  rootState = await ensureRecommendViewport(rootState, "page_scope");
+  runControl.checkpoint({
+    page_scope: compactPageScopeSelection(pageScopeSelection)
+  });
+
+  const initialFilterStages = await applyRecommendFilterEnvelopeStages(normalizedFilter, {
+    applyCurrentCityOnly: async () => {
+      await runControl.waitIfPaused();
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:current-city-only");
+      const result = await ensureRecommendCurrentCityOnly(
+        client,
+        rootState.iframe.documentNodeId,
+        { enabled: normalizedFilter.currentCityOnly }
+      );
+      rootState = await getRecommendRoots(client);
+      rootState = await ensureRecommendViewport(rootState, "current_city_only");
+      runControl.checkpoint({
+        current_city_only: compactCurrentCityOnlyResult(result)
+      });
+      return result;
+    },
+    applyFilterPanel: async () => {
+      await runControl.waitIfPaused();
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:filter");
+      const result = await selectAndConfirmFirstSafeFilter(
+        client,
+        rootState.iframe.documentNodeId,
+        buildRecommendFilterSelectionOptions(normalizedFilter)
+      );
+      if (!result.confirmed) {
+        throw new Error("Recommend run filter selection was not confirmed");
+      }
+      rootState = await getRecommendRoots(client);
+      rootState = await ensureRecommendViewport(rootState, "filter");
+      runControl.checkpoint({
+        filter: compactFilterResult(result)
+      });
+      return result;
+    }
+  });
+  currentCityOnlyResult = initialFilterStages.current_city_only;
+  filterResult = initialFilterStages.filter;
+
+  await runControl.waitIfPaused();
+  runControl.throwIfCanceled();
+  runControl.setPhase("recommend:cards");
+  rootState = await ensureRecommendViewport(rootState, "cards");
   cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
     timeoutMs: cardTimeoutMs,
     intervalMs: 300
@@ -1039,11 +1161,11 @@ export async function runRecommendWorkflow({
       client,
       state: listState,
       maxScrolls: listMaxScrolls,
-      stableSignatureLimit: listStableSignatureLimit,
-      wheelDeltaY: listWheelDeltaY,
-      settleMs: listSettleMs,
-      listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
-      fallbackPoint: listFallbackResolver,
+      stableSignatureLimit: listStableSignatureLimit,
+      wheelDeltaY: listWheelDeltaY,
+      settleMs: listSettleMs,
+      listScrollJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+      fallbackPoint: listFallbackResolver,
       findNodeIds: async () => {
         let currentRootState = await getRecommendRoots(client);
         currentRootState = await ensureRecommendViewport(currentRootState, "candidate_find_nodes");
@@ -1084,55 +1206,61 @@ export async function runRecommendWorkflow({
         runControl.setPhase("recommend:refresh");
         refreshRounds += 1;
         const refreshResult = await refreshRecommendListAtEnd(client, {
-          rootState,
-          jobLabel,
-          pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
-          fallbackPageScope: normalizedFallbackPageScope,
-          filter: normalizedFilter,
-          forceRecentNotView: true,
-          cardTimeoutMs,
-          buttonSettleMs: refreshButtonSettleMs,
-          reloadSettleMs: refreshReloadSettleMs
-        });
-        const compactRefresh = compactRefreshAttempt(refreshResult);
+          rootState,
+          jobLabel,
+          pageScope: pageScopeSelection?.effective_scope || requestedPageScope,
+          fallbackPageScope: normalizedFallbackPageScope,
+          filter: normalizedFilter,
+          forceRecentNotView: normalizedFilter.enabled,
+          cardTimeoutMs,
+          buttonSettleMs: refreshButtonSettleMs,
+          reloadSettleMs: refreshReloadSettleMs
+        });
+        const compactRefresh = compactRefreshAttempt(refreshResult);
         refreshAttempts.push(compactRefresh);
         runControl.checkpoint({
           refresh_round: refreshRounds,
-          refresh: compactRefresh
-        });
-        updateRecommendProgress({
-          card_count: refreshResult.card_count || cardNodeIds.length,
-          refresh_method: refreshResult.method || null,
-          refresh_forced_recent_not_view: true,
-          list_end_reason: listEndReason
-        });
+          refresh: compactRefresh
+        });
+        updateRecommendProgress({
+          card_count: refreshResult.card_count || cardNodeIds.length,
+          refresh_method: refreshResult.method || null,
+          refresh_forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view),
+          list_end_reason: listEndReason
+        });
         if (refreshResult.ok) {
+          if (refreshResult.current_city_only) {
+            currentCityOnlyResult = refreshResult.current_city_only;
+          }
+          if (refreshResult.filter) {
+            filterResult = refreshResult.filter;
+          }
           rootState = refreshResult.root_state || await getRecommendRoots(client);
           rootState = await ensureRecommendViewport(rootState, "refresh_after");
-          cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
-            timeoutMs: cardTimeoutMs,
-            intervalMs: 300
+          cardNodeIds = await waitForRecommendCardNodeIds(client, rootState.iframe.documentNodeId, {
+            timeoutMs: cardTimeoutMs,
+            intervalMs: 300
           });
           resetInfiniteListForRefreshRound(listState, {
-            reason: listEndReason,
-            round: refreshRounds,
-            method: refreshResult.method,
-            metadata: {
-              card_count: cardNodeIds.length,
-              forced_recent_not_view: true
-            }
-          });
+            reason: listEndReason,
+            round: refreshRounds,
+            method: refreshResult.method,
+            metadata: {
+              card_count: cardNodeIds.length,
+              forced_recent_not_view: Boolean(refreshResult.forced_recent_not_view)
+            }
+          });
           listEndReason = "";
           continue;
         }
-        throw createRecommendRefreshFailureError(compactRefresh, {
-          listEndReason,
-          targetCount: targetPassCount,
-          passedCount: countPassedResults(results)
-        });
-      }
-      break;
-    }
+        throw createRecommendRefreshFailureError(compactRefresh, {
+          listEndReason,
+          targetCount: targetPassCount,
+          passedCount: countPassedResults(results)
+        });
+      }
+      break;
+    }
 
     const index = results.length;
     let cardNodeId = nextCandidateResult.item.node_id;
@@ -1140,42 +1268,42 @@ export async function runRecommendWorkflow({
     let cardCandidate = nextCandidateResult.item.candidate;
 
     let screeningCandidate = cardCandidate;
-    let detailResult = null;
-    let recoverableDetailError = null;
-    let colleagueContact = null;
-    let skipRecentColleagueContact = false;
-    let detailStep = "not_started";
+    let detailResult = null;
+    let recoverableDetailError = null;
+    let colleagueContact = null;
+    let skipRecentColleagueContact = false;
+    let detailStep = "not_started";
     if (index < effectiveDetailLimit) {
       try {
         await runControl.waitIfPaused();
         runControl.throwIfCanceled();
-        runControl.setPhase("recommend:detail");
-        detailStep = "ensure_viewport";
-        rootState = await ensureRecommendViewport(rootState, "detail");
-        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
-          attemptsLimit: 2,
-          rootState
-        });
-        if (!blockingPanelClose?.closed) {
-          const panelError = createRecommendBlockingPanelCloseFailureError(
-            blockingPanelClose,
-            "before_detail_open"
-          );
-          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
-          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
-          await recoverAndReapplyRecommendContext("account_rights_panel_before_detail", panelError, {
-            forceRecentNotView: true
-          });
-          continue;
-        }
-        if (blockingPanelClose.already_closed === false) {
-          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
-        }
-        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
-        detailStep = "open_detail";
-        networkRecorder.clear();
-        await maybeHumanActionCooldown("before_detail_open", timings);
-        const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
+        runControl.setPhase("recommend:detail");
+        detailStep = "ensure_viewport";
+        rootState = await ensureRecommendViewport(rootState, "detail");
+        const blockingPanelClose = await closeRecommendBlockingPanels(client, {
+          attemptsLimit: 2,
+          rootState
+        });
+        if (!blockingPanelClose?.closed) {
+          const panelError = createRecommendBlockingPanelCloseFailureError(
+            blockingPanelClose,
+            "before_detail_open"
+          );
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error: panelError });
+          await recoverAndReapplyRecommendContext("account_rights_panel_before_detail", panelError, {
+            forceRecentNotView: true
+          });
+          continue;
+        }
+        if (blockingPanelClose.already_closed === false) {
+          timings.account_rights_panel_close = compactCloseResult(blockingPanelClose);
+        }
+        checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep });
+        detailStep = "open_detail";
+        networkRecorder.clear();
+        await maybeHumanActionCooldown("before_detail_open", timings);
+        const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
           cardNodeId,
           candidateKey,
           cardCandidate,
@@ -1186,52 +1314,52 @@ export async function runRecommendWorkflow({
         });
         addTiming(timings, "candidate_click_ms", openedDetail.timings?.candidate_click_ms);
         addTiming(timings, "detail_open_ms", openedDetail.timings?.detail_open_ms);
-        cardNodeId = openedDetail.card_node_id || cardNodeId;
-        cardCandidate = openedDetail.card_candidate || cardCandidate;
-        screeningCandidate = cardCandidate;
-        if (shouldSkipRecentColleagueContacted) {
-          detailStep = "check_colleague_contact";
-          try {
-            colleagueContact = await measureTiming(timings, "colleague_contact_check_ms", () => inspectRecentColleagueContact(
-              client,
-              openedDetail.detail_state,
-              {
-                referenceDate: colleagueContactReferenceDate,
-                windowDays: normalizedColleagueContactWindowDays
-              }
-            ));
-            if (colleagueContact?.recent) {
-              skipRecentColleagueContact = true;
-              detailResult = {
-                candidate: screeningCandidate,
-                detail: {
-                  popup_text: "",
-                  resume_text: ""
-                },
-                colleague_contact: colleagueContact,
-                cv_acquisition: {
-                  source: "skipped_recent_colleague_contact",
-                  skipped: true,
-                  reason: "skipped_recent_colleague_contact"
-                }
-              };
-              detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
-              await maybeHumanActionCooldown("after_detail_close", timings);
-            }
-          } catch (error) {
-            colleagueContact = {
-              checked: false,
-              recent: false,
-              reason: "inspection_failed",
-              error: error?.message || String(error),
-              window_days: normalizedColleagueContactWindowDays
-            };
-          }
-        }
-        if (!skipRecentColleagueContact) {
-          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-        detailStep = "wait_network";
-        const networkWait = await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
+        cardNodeId = openedDetail.card_node_id || cardNodeId;
+        cardCandidate = openedDetail.card_candidate || cardCandidate;
+        screeningCandidate = cardCandidate;
+        if (shouldSkipRecentColleagueContacted) {
+          detailStep = "check_colleague_contact";
+          try {
+            colleagueContact = await measureTiming(timings, "colleague_contact_check_ms", () => inspectRecentColleagueContact(
+              client,
+              openedDetail.detail_state,
+              {
+                referenceDate: colleagueContactReferenceDate,
+                windowDays: normalizedColleagueContactWindowDays
+              }
+            ));
+            if (colleagueContact?.recent) {
+              skipRecentColleagueContact = true;
+              detailResult = {
+                candidate: screeningCandidate,
+                detail: {
+                  popup_text: "",
+                  resume_text: ""
+                },
+                colleague_contact: colleagueContact,
+                cv_acquisition: {
+                  source: "skipped_recent_colleague_contact",
+                  skipped: true,
+                  reason: "skipped_recent_colleague_contact"
+                }
+              };
+              detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
+              await maybeHumanActionCooldown("after_detail_close", timings);
+            }
+          } catch (error) {
+            colleagueContact = {
+              checked: false,
+              recent: false,
+              reason: "inspection_failed",
+              error: error?.message || String(error),
+              window_days: normalizedColleagueContactWindowDays
+            };
+          }
+        }
+        if (!skipRecentColleagueContact) {
+          const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
+        detailStep = "wait_network";
+        const networkWait = await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
           waitForRecommendDetailNetworkEvents,
           networkRecorder,
           {
@@ -1255,10 +1383,10 @@ export async function runRecommendWorkflow({
           networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
           networkParseIntervalMs: 250
         });
-        addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
-        if (colleagueContact) detailResult.colleague_contact = colleagueContact;
-
-        const parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+        addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+        if (colleagueContact) detailResult.colleague_contact = colleagueContact;
+
+        const parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
         let source = "network";
         let imageEvidence = null;
         let captureTarget = null;
@@ -1295,12 +1423,12 @@ export async function runRecommendWorkflow({
                 resizeMaxWidth: 1100,
                 captureViewport: false,
                 padding: 0,
-                maxScreenshots: maxImagePages,
-                wheelDeltaY: imageWheelDeltaY,
-                settleMs: 350,
-                scrollMethod: "dom-anchor-fallback-input",
-                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
-                stepTimeoutMs: 45000,
+                maxScreenshots: maxImagePages,
+                wheelDeltaY: imageWheelDeltaY,
+                settleMs: 350,
+                scrollMethod: "dom-anchor-fallback-input",
+                scrollDeltaJitterEnabled: effectiveHumanBehavior.listScrollJitter,
+                stepTimeoutMs: 45000,
                 totalTimeoutMs: 90000,
                 duplicateStopCount: 1,
                 skipDuplicateScreenshots: true,
@@ -1324,14 +1452,14 @@ export async function runRecommendWorkflow({
               const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
               if (recoveryCount < 1) {
                 candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
-                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-                await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
-                await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
-                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
-                  forceRecentNotView: true
-                });
+                timings.image_capture_recovery_trigger = compactError(error, "IMAGE_CAPTURE_FAILED");
+                checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+                await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+                await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+                await recoverAndReapplyRecommendContext(`image_capture:${detailStep}`, error, {
+                  forceRecentNotView: true
+                });
                 continue;
               }
               imageEvidence = createRecoverableImageCaptureEvidence(error, {
@@ -1370,73 +1498,73 @@ export async function runRecommendWorkflow({
           image_evidence: summarizeImageEvidence(imageEvidence),
           capture_target: captureTarget || null,
           capture_target_wait: captureTargetWait
-        };
-        screeningCandidate = detailResult.candidate;
-        }
-      } catch (error) {
+        };
+        screeningCandidate = detailResult.candidate;
+        }
+      } catch (error) {
         if (!isRecoverableRecommendDetailError(error)) throw error;
         const recoveryCount = candidateRecoveryCounts.get(candidateKey) || 0;
         if (recoveryCount < 1) {
-          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
-          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
-          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
-          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-          await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
-          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
-          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
-            forceRecentNotView: true
-          });
+          candidateRecoveryCounts.set(candidateKey, recoveryCount + 1);
+          timings.detail_recovery_trigger = compactRecoverableDetailError(error);
+          checkpointInProgressCandidate({ index, candidateKey, cardNodeId, detailStep, error });
+          await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+          await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+          await recoverAndReapplyRecommendContext(`detail:${detailStep}`, error, {
+            forceRecentNotView: true
+          });
           continue;
         }
-        recoverableDetailError = error;
-        detailResult = null;
-        timings.detail_recovered_error = compactRecoverableDetailError(error);
-        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
-        await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
-        await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
-      }
+        recoverableDetailError = error;
+        detailResult = null;
+        timings.detail_recovered_error = compactRecoverableDetailError(error);
+        await closeRecommendDetail(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecommendAvatarPreview(client, { attemptsLimit: 2 }).catch(() => null);
+        await closeRecommendBlockingPanels(client, { attemptsLimit: 2, rootState }).catch(() => null);
+      }
     }
 
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recommend:screening");
-    let llmResult = null;
-    if (useLlmScreening) {
-      if (skipRecentColleagueContact || recoverableDetailError || detailResult?.image_evidence?.ok === false) {
-        llmResult = null;
-      } else if (!llmConfig) {
+    let llmResult = null;
+    if (useLlmScreening) {
+      if (skipRecentColleagueContact || recoverableDetailError || detailResult?.image_evidence?.ok === false) {
+        llmResult = null;
+      } else if (!llmConfig) {
         llmResult = createMissingLlmConfigResult();
       } else {
         try {
           const llmTimingKey = detailResult?.image_evidence?.file_paths?.length
             ? "vision_model_ms"
             : "text_model_ms";
-          llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
-            candidate: screeningCandidate,
-            criteria,
-            config: llmConfig,
-            timeoutMs: llmTimeoutMs,
+          llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+            candidate: screeningCandidate,
+            criteria,
+            config: llmConfig,
+            timeoutMs: llmTimeoutMs,
             imageEvidence: detailResult?.image_evidence || null,
             maxImages: llmImageLimit,
             imageDetail: llmImageDetail
           }));
-          } catch (error) {
-            if (isFatalLlmProviderError(error)) {
-              throw createFatalLlmRunError(error, {
-                domain: "recommend",
-                candidate: screeningCandidate
-              });
-            }
-            llmResult = createFailedLlmScreeningResult(error);
-          }
-      }
-      if (detailResult) detailResult.llm_result = llmResult;
-    }
-    const screening = skipRecentColleagueContact
-      ? createRecentColleagueContactSkipScreening(screeningCandidate, colleagueContact)
-      : recoverableDetailError
-      ? createRecoverableDetailFailureScreening(screeningCandidate, recoverableDetailError)
-      : detailResult?.image_evidence?.ok === false
+          } catch (error) {
+            if (isFatalLlmProviderError(error)) {
+              throw createFatalLlmRunError(error, {
+                domain: "recommend",
+                candidate: screeningCandidate
+              });
+            }
+            llmResult = createFailedLlmScreeningResult(error);
+          }
+      }
+      if (detailResult) detailResult.llm_result = llmResult;
+    }
+    const screening = skipRecentColleagueContact
+      ? createRecentColleagueContactSkipScreening(screeningCandidate, colleagueContact)
+      : recoverableDetailError
+      ? createRecoverableDetailFailureScreening(screeningCandidate, recoverableDetailError)
+      : detailResult?.image_evidence?.ok === false
       ? createImageCaptureFailureScreening(screeningCandidate, {
         code: detailResult.image_evidence.error_code,
         message: detailResult.image_evidence.error
@@ -1444,17 +1572,17 @@ export async function runRecommendWorkflow({
       : useLlmScreening
         ? llmResultToScreening(llmResult, screeningCandidate)
         : screenCandidate(screeningCandidate, { criteria });
-    let actionDiscovery = null;
-    let postActionResult = null;
-    let closeFailureError = null;
-    let closeRecoveryFailure = null;
-    if (postActionEnabled && detailResult && !skipRecentColleagueContact) {
-      const postActionStarted = Date.now();
-      await runControl.waitIfPaused();
-      runControl.throwIfCanceled();
-      runControl.setPhase("recommend:post-action");
-      await maybeHumanActionCooldown("before_post_action", timings);
-      actionDiscovery = await waitForRecommendDetailActionControls(client, {
+    let actionDiscovery = null;
+    let postActionResult = null;
+    let closeFailureError = null;
+    let closeRecoveryFailure = null;
+    if (postActionEnabled && detailResult && !skipRecentColleagueContact) {
+      const postActionStarted = Date.now();
+      await runControl.waitIfPaused();
+      runControl.throwIfCanceled();
+      runControl.setPhase("recommend:post-action");
+      await maybeHumanActionCooldown("before_post_action", timings);
+      actionDiscovery = await waitForRecommendDetailActionControls(client, {
         timeoutMs: actionTimeoutMs,
         intervalMs: actionIntervalMs,
         requireAny: true
@@ -1473,34 +1601,34 @@ export async function runRecommendWorkflow({
         greetCount += 1;
       }
       addTiming(timings, "post_action_ms", Date.now() - postActionStarted);
-    }
-    if (detailResult && closeDetail && !detailResult.close_result?.closed) {
-      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
-      await maybeHumanActionCooldown("after_detail_close", timings);
-      if (!detailResult.close_result?.closed) {
-        closeFailureError = createRecommendCloseFailureError(detailResult.close_result);
-        try {
-          const recovery = await recoverAndReapplyRecommendContext("detail_close_failed", closeFailureError, {
-            forceRecentNotView: true
-          });
-          detailResult.cv_acquisition = {
-            ...(detailResult.cv_acquisition || {}),
-            close_recovery: {
-              ok: Boolean(recovery.ok),
-              method: recovery.method || "",
-              forced_recent_not_view: Boolean(recovery.forced_recent_not_view),
-              card_count: recovery.card_count || 0
-            }
-          };
-        } catch (error) {
-          closeRecoveryFailure = error;
-          detailResult.cv_acquisition = {
+    }
+    if (detailResult && closeDetail && !detailResult.close_result?.closed) {
+      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
+      await maybeHumanActionCooldown("after_detail_close", timings);
+      if (!detailResult.close_result?.closed) {
+        closeFailureError = createRecommendCloseFailureError(detailResult.close_result);
+        try {
+          const recovery = await recoverAndReapplyRecommendContext("detail_close_failed", closeFailureError, {
+            forceRecentNotView: true
+          });
+          detailResult.cv_acquisition = {
+            ...(detailResult.cv_acquisition || {}),
+            close_recovery: {
+              ok: Boolean(recovery.ok),
+              method: recovery.method || "",
+              forced_recent_not_view: Boolean(recovery.forced_recent_not_view),
+              card_count: recovery.card_count || 0
+            }
+          };
+        } catch (error) {
+          closeRecoveryFailure = error;
+          detailResult.cv_acquisition = {
             ...(detailResult.cv_acquisition || {}),
             close_recovery: {
               ok: false,
               reason: "context_recovery_failed",
               error: error?.message || String(error),
-              forced_recent_not_view: true
+              forced_recent_not_view: Boolean(normalizedFilter.enabled)
             }
           };
         }
@@ -1516,14 +1644,14 @@ export async function runRecommendWorkflow({
       llm_screening: detailResult ? null : compactScreeningLlmResult(llmResult),
       screening: compactScreening(screening),
       action_discovery: compactActionDiscovery(actionDiscovery),
-      post_action: postActionResult,
-      error: recoverableDetailError
-        ? compactRecoverableDetailError(recoverableDetailError)
-        : closeRecoveryFailure
-        ? compactError(closeFailureError, "DETAIL_CLOSE_FAILED")
-        : detailResult?.image_evidence?.ok === false
-        ? compactError({
-          code: detailResult.image_evidence.error_code,
+      post_action: postActionResult,
+      error: recoverableDetailError
+        ? compactRecoverableDetailError(recoverableDetailError)
+        : closeRecoveryFailure
+        ? compactError(closeFailureError, "DETAIL_CLOSE_FAILED")
+        : detailResult?.image_evidence?.ok === false
+        ? compactError({
+          code: detailResult.image_evidence.error_code,
           message: detailResult.image_evidence.error
         }, "IMAGE_CAPTURE_FAILED")
         : null,
@@ -1558,66 +1686,67 @@ export async function runRecommendWorkflow({
         error: compactResult.error,
         post_action: postActionResult
       }
-    });
-    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
-
-    if (closeRecoveryFailure) {
-      throw closeRecoveryFailure;
-    }
-
-    if (postActionResult?.stop_run) {
-      listEndReason = postActionResult.reason || "post_action_stop";
-      break;
-    }
-
-    if (effectiveHumanRestEnabled) {
-      const restStarted = Date.now();
-      const restResult = await humanRestController.takeBreakIfNeeded({
-        sleepFn: (ms) => runControl.sleep(ms)
-      });
-      const restElapsed = Date.now() - restStarted;
-      if (restResult.rested) {
-        recordHumanEvent({
-          kind: "rest",
-          pause_ms: restResult.pause_ms || restElapsed,
-          events: restResult.events || []
-        });
-        compactResult.human_rest = restResult;
-        addTiming(compactResult.timings, "human_rest_ms", restElapsed);
-        compactResult.timings.total_ms = Date.now() - candidateStarted;
-        updateRecommendProgress({
-          human_rest_level: effectiveHumanBehavior.restLevel,
-          human_rest_last: restResult
-        });
-      }
-    }
-
-    if (delayMs > 0) {
-      const sleepStarted = Date.now();
-      await runControl.sleep(delayMs);
-      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
-      compactResult.timings.total_ms = Date.now() - candidateStarted;
+    });
+    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
+
+    if (closeRecoveryFailure) {
+      throw closeRecoveryFailure;
+    }
+
+    if (postActionResult?.stop_run) {
+      listEndReason = postActionResult.reason || "post_action_stop";
+      break;
+    }
+
+    if (effectiveHumanRestEnabled) {
+      const restStarted = Date.now();
+      const restResult = await humanRestController.takeBreakIfNeeded({
+        sleepFn: (ms) => runControl.sleep(ms)
+      });
+      const restElapsed = Date.now() - restStarted;
+      if (restResult.rested) {
+        recordHumanEvent({
+          kind: "rest",
+          pause_ms: restResult.pause_ms || restElapsed,
+          events: restResult.events || []
+        });
+        compactResult.human_rest = restResult;
+        addTiming(compactResult.timings, "human_rest_ms", restElapsed);
+        compactResult.timings.total_ms = Date.now() - candidateStarted;
+        updateRecommendProgress({
+          human_rest_level: effectiveHumanBehavior.restLevel,
+          human_rest_last: restResult
+        });
+      }
+    }
+
+    if (delayMs > 0) {
+      const sleepStarted = Date.now();
+      await runControl.sleep(delayMs);
+      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
+      compactResult.timings.total_ms = Date.now() - candidateStarted;
     }
   }
 
   runControl.setPhase("recommend:done");
-  return {
-    domain: "recommend",
-    target_url: targetUrl,
-    job_selection: compactJobSelection(jobSelection),
-    page_scope: compactPageScopeSelection(pageScopeSelection),
-    filter: compactFilterResult(filterResult),
-    card_count: cardNodeIds.length,
-    candidate_list: compactInfiniteListState(listState),
+  return {
+    domain: "recommend",
+    target_url: targetUrl,
+    job_selection: compactJobSelection(jobSelection),
+    page_scope: compactPageScopeSelection(pageScopeSelection),
+    current_city_only: compactCurrentCityOnlyResult(currentCityOnlyResult),
+    filter: compactFilterResult(filterResult),
+    card_count: cardNodeIds.length,
+    candidate_list: compactInfiniteListState(listState),
     viewport_health: {
       stats: viewportGuard.getStats(),
-      events: viewportGuard.getEvents()
-    },
-    human_behavior: effectiveHumanBehavior,
-    human_rest: humanRestController.getState(),
-    last_human_event: lastHumanEvent,
-    list_end_reason: listEndReason || null,
-    refresh_rounds: refreshRounds,
+      events: viewportGuard.getEvents()
+    },
+    human_behavior: effectiveHumanBehavior,
+    human_rest: humanRestController.getState(),
+    last_human_event: lastHumanEvent,
+    list_end_reason: listEndReason || null,
+    refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,
     context_recoveries: contextRecoveryAttempts,
     ...countRecommendResultStatuses(results, { greetCount }),
@@ -1667,30 +1796,30 @@ export function createRecommendRunService({
     actionIntervalMs = 500,
     actionAfterClickDelayMs = 900,
     screeningMode = "llm",
-    llmConfig = null,
-    llmTimeoutMs = 120000,
-    llmImageLimit = 8,
-    llmImageDetail = "high",
-    imageOutputDir = "",
-    humanRestEnabled = false,
-    humanBehavior = null,
-    skipRecentColleagueContacted = true,
-    colleagueContactWindowDays = 14,
-    name = "recommend-domain-run"
-  } = {}) {
-    if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
-    const normalizedFilter = normalizeFilter(filter);
-    const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
-    const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
-    const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
-    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
-    const shouldSkipRecentColleagueContacted = skipRecentColleagueContacted !== false;
-    const normalizedColleagueContactWindowDays = Math.max(1, Number(colleagueContactWindowDays) || 14);
-    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
-      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
-    });
-    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
-    const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
+    llmConfig = null,
+    llmTimeoutMs = 120000,
+    llmImageLimit = 8,
+    llmImageDetail = "high",
+    imageOutputDir = "",
+    humanRestEnabled = false,
+    humanBehavior = null,
+    skipRecentColleagueContacted = true,
+    colleagueContactWindowDays = 14,
+    name = "recommend-domain-run"
+  } = {}) {
+    if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
+    const normalizedFilter = normalizeFilter(filter);
+    const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
+    const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
+    const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
+    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+    const shouldSkipRecentColleagueContacted = skipRecentColleagueContacted !== false;
+    const normalizedColleagueContactWindowDays = Math.max(1, Number(colleagueContactWindowDays) || 14);
+    const effectiveHumanBehavior = normalizeHumanBehaviorOptions(humanBehavior, {
+      legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
+    });
+    const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
+    const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? null : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
       runId,
@@ -1699,16 +1828,17 @@ export function createRecommendRunService({
       context: {
         domain: "recommend",
         target_url: targetUrl,
-        criteria_present: Boolean(criteria),
-        job_label: jobLabel || "",
-        requested_page_scope: requestedPageScope,
-        fallback_page_scope: normalizedFallbackPageScope,
-        filter: normalizedFilter,
-        max_candidates: maxCandidates,
-        max_candidates_semantics: "passed_candidates",
-        detail_limit: normalizedDetailLimit,
-        close_detail: closeDetail,
-        cv_acquisition_mode: cvAcquisitionMode,
+        criteria_present: Boolean(criteria),
+        job_label: jobLabel || "",
+        requested_page_scope: requestedPageScope,
+        fallback_page_scope: normalizedFallbackPageScope,
+        filter: normalizedFilter,
+        current_city_only_requested: normalizedFilter.currentCityOnly,
+        max_candidates: maxCandidates,
+        max_candidates_semantics: "passed_candidates",
+        detail_limit: normalizedDetailLimit,
+        close_detail: closeDetail,
+        cv_acquisition_mode: cvAcquisitionMode,
         max_image_pages: maxImagePages,
         image_wheel_delta_y: imageWheelDeltaY,
         list_max_scrolls: listMaxScrolls,
@@ -1726,45 +1856,48 @@ export function createRecommendRunService({
         action_timeout_ms: actionTimeoutMs,
         screening_mode: normalizedScreeningMode,
         llm_configured: Boolean(llmConfig),
-        llm_timeout_ms: llmTimeoutMs,
-        llm_image_limit: llmImageLimit,
-        llm_image_detail: llmImageDetail,
-        image_output_dir: imageOutputDir || "",
-        skip_recent_colleague_contacted: shouldSkipRecentColleagueContacted,
-        colleague_contact_window_days: normalizedColleagueContactWindowDays,
-        human_behavior_enabled: effectiveHumanBehavior.enabled,
-        human_behavior_profile: effectiveHumanBehavior.profile,
-        human_behavior: effectiveHumanBehavior,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled
-      },
-      progress: {
+        llm_timeout_ms: llmTimeoutMs,
+        llm_image_limit: llmImageLimit,
+        llm_image_detail: llmImageDetail,
+        image_output_dir: imageOutputDir || "",
+        skip_recent_colleague_contacted: shouldSkipRecentColleagueContacted,
+        colleague_contact_window_days: normalizedColleagueContactWindowDays,
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_behavior: effectiveHumanBehavior,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled
+      },
+      progress: {
         card_count: 0,
         target_count: candidateLimit,
         target_count_semantics: "passed_candidates",
         processed: 0,
         screened: 0,
         detail_opened: 0,
-        llm_screened: 0,
-        passed: 0,
-        skipped: 0,
-        greet_count: 0,
+        llm_screened: 0,
+        passed: 0,
+        skipped: 0,
+        greet_count: 0,
         post_action_clicked: 0,
-        image_capture_failed: 0,
-        detail_open_failed: 0,
+        image_capture_failed: 0,
+        detail_open_failed: 0,
         transient_recovered: 0,
         colleague_contact_checked: 0,
         recent_colleague_contact_skipped: 0,
         colleague_contact_panel_missing: 0,
         context_recoveries: 0,
+        current_city_only_requested: normalizedFilter.currentCityOnly,
+        current_city_only_effective: null,
+        current_city_only_unavailable: false,
         human_behavior_enabled: effectiveHumanBehavior.enabled,
         human_behavior_profile: effectiveHumanBehavior.profile,
         human_rest_level: effectiveHumanBehavior.restLevel,
         human_rest_enabled: effectiveHumanRestEnabled,
         human_rest_count: 0,
-        human_rest_ms: 0,
-        last_human_event: null
-      },
+        human_rest_ms: 0,
+        last_human_event: null
+      },
       checkpoint: {},
       task: (runControl) => workflow({
         client,
@@ -1799,17 +1932,17 @@ export function createRecommendRunService({
         actionAfterClickDelayMs,
         screeningMode: normalizedScreeningMode,
         llmConfig,
-        llmTimeoutMs,
-        llmImageLimit,
-        llmImageDetail,
-        imageOutputDir,
-        humanRestEnabled: effectiveHumanRestEnabled,
-        humanBehavior: effectiveHumanBehavior,
-        skipRecentColleagueContacted: shouldSkipRecentColleagueContacted,
-        colleagueContactWindowDays: normalizedColleagueContactWindowDays
-      }, runControl)
-    });
-  }
+        llmTimeoutMs,
+        llmImageLimit,
+        llmImageDetail,
+        imageOutputDir,
+        humanRestEnabled: effectiveHumanRestEnabled,
+        humanBehavior: effectiveHumanBehavior,
+        skipRecentColleagueContacted: shouldSkipRecentColleagueContacted,
+        colleagueContactWindowDays: normalizedColleagueContactWindowDays
+      }, runControl)
+    });
+  }
 
   return {
     startRecommendRun,