import { cpus, hostname, totalmem } from 'node:os'

import { ApiClientError } from '@geo/http-client'
import type {
  DesktopAccountHealthReport,
  DesktopAccountInfo,
  DesktopArticleContent,
  DesktopClientInfo,
  DesktopRuntimeSessionSyncRequest,
  DesktopTaskEventMessage,
  DesktopTaskInfo,
  JsonValue,
  LeaseDesktopTaskResponse,
  MonitoringLeaseTask,
  MonitoringSourceItem,
  MonitoringTaskResultPayload,
} from '@geo/shared-types'
import { aiPlatformCatalog, getAIPlatformCatalogItem, isAIPlatformId } from '@geo/shared-types'

import {
  buildAccountIdentityKey,
  normalizeAccountPlatformUid,
  sameAccountPlatformUid,
} from '../shared/account-identity'
import { normalizeDesktopApiBaseURL } from '../shared/api-base-url'
import { type PublishAccountIdentity, type PublishAccountProfile } from './account-binder'
import {
  ensureAccountReady,
  forgetTrackedAccountHealth,
  getAccountHealthSnapshot,
  getProjectedAccountHealth,
  markTrackedAccountBound,
  markTrackedAccountMissingPartition,
  probeTrackedAccount,
  reportAccountFailure,
  syncTrackedAccounts,
} from './account-health'
import {
  baijiahaoAdapter,
  bilibiliAdapter,
  dongchediAdapter,
  getMonitorAdapter,
  jianshuAdapter,
  juejinAdapter,
  qiehaoAdapter,
  smzdmAdapter,
  sohuhaoAdapter,
  toutiaoAdapter,
  wangyihaoAdapter,
  weixinGzhAdapter,
  zhihuAdapter,
  zolAdapter,
  type AdapterExecutionResult,
  type MonitorAdapter,
  type PublishAdapter,
} from './adapters'
import { getDesktopAppVersion, getDesktopReleaseChannel } from './app-version'
import {
  getLeaseManagerSnapshot,
  noteLeaseExtended,
  noteLeaseReleased,
  setActiveLease,
} from './lease-manager'
import {
  enqueueMonitorLeaseTask,
  enqueueMonitorTaskFromEvent,
  getMonitorSchedulerSnapshot,
  initMonitorScheduler,
  noteMonitorTaskActivated,
  noteMonitorTaskCanceled,
  noteMonitorTaskCompleted,
  noteMonitorTaskLeaseMiss,
  noteMonitorTaskLeased,
  selectNextMonitorTask,
} from './monitor-scheduler'
import { retainHiddenPlaywrightPage, startHiddenPlaywrightReaper } from './playwright-cdp'
import { getProcessMetricsSnapshot } from './process-metrics'
import {
  enqueuePublishTask as enqueuePublishSchedulerTask,
  getPublishSchedulerSnapshot,
  initPublishScheduler,
  notePublishTaskActivated,
  notePublishTaskCanceled,
  notePublishTaskCompleted,
  notePublishTaskLeaseMiss,
  selectNextPublishTask,
} from './publish-scheduler'
import { emitRuntimeInvalidated, onRuntimeInvalidated } from './runtime-events'
import {
  initScheduler,
  noteSchedulerAccountsSync,
  noteSchedulerHeartbeat,
  noteSchedulerPull,
  noteSchedulerSseEvent,
  noteSchedulerTaskFinished,
  setSchedulerCurrentTask,
  setSchedulerError,
  setSchedulerNextHeartbeat,
  setSchedulerNextPull,
  setSchedulerPhase,
  setSchedulerQueueDepth,
} from './scheduler'
import {
  clearSessionHandle,
  createSessionHandle,
  getPersistedPartition,
  getSessionHandle,
} from './session-registry'
import {
  cancelDesktopTask,
  cancelMonitoringTask,
  completeDesktopTask,
  configureTransport,
  deleteDesktopAccount,
  extendDesktopTask,
  getDesktopArticleContent,
  heartbeatDesktopClient,
  leaseDesktopTask,
  leaseMonitoringTasks,
  listDesktopAccounts,
  markDesktopTaskPublishSubmitStarted,
  noteTransportHeartbeat,
  noteTransportPull,
  offlineDesktopClient,
  reportDesktopAccountHealth,
  resumeMonitoringTasks,
  revokeDesktopClient,
  setTransportAuthState,
  setTransportDispatchState,
  skipMonitoringTask,
  submitMonitoringTaskResult,
  upsertDesktopAccount,
} from './transport/api-client'
import { DispatchWsClient } from './transport/dispatch-ws-client'
import { releaseHotView, retainHotView } from './view-pool'

type RuntimeTone = 'info' | 'success' | 'warn' | 'danger'
type RuntimeTaskStatus = 'queued' | 'in_progress' | 'succeeded' | 'failed' | 'unknown' | 'aborted'
type RuntimeTaskRouting = 'rabbitmq-primary' | 'db-recovery'
type MonitorExecutionPhase =
  | 'PREPARING'
  | 'NAVIGATING'
  | 'AUTHENTICATING'
  | 'INPUTTING'
  | 'SUBMITTING'
  | 'WAITING'
  | 'PARSING'
  | 'POSTING'

const heartbeatIntervalMs = 15_000
const pullIntervalMs = 60_000
const pumpWatchdogIntervalMs = 15_000
const leaseExtendIntervalMs = 60_000
const defaultPublishTaskTimeoutMs = 5 * 60_000
const publishTaskStaleProgressMs = 2 * 60_000
const publishLongRunningNotificationMs = 15 * 60_000
const maxActivityItems = 60
const monitorBusinessTimeZone = 'Asia/Shanghai'
const authRequiredMonitorPlatforms = new Set(aiPlatformCatalog.map((platform) => platform.id))
const publishReservedSlots = 1
const minimumForegroundTotalConcurrency = 2
const maximumRuntimeTotalConcurrency = 4
const BAIJIAHAO_RISK_CONTROL_PROMPT = '您触发平台风控，请手动发稿一篇并完成验证，方可继续使用'
const accountHealthReportDebounceMs = 1_000
const accountHealthReportMaxBatchSize = 100

interface RuntimeTaskRecord {
  id: string
  jobId: string
  title: string
  kind: 'publish' | 'monitor'
  platform: string
  accountId: string
  accountName: string
  clientId: string
  status: RuntimeTaskStatus
  routing: RuntimeTaskRouting
  leaseExpiresAt: number | null
  startedAt: number | null
  updatedAt: number
  summary: string
  payload: Record<string, JsonValue>
  error: Record<string, JsonValue> | null
  result: Record<string, JsonValue> | null
  attemptId: string | null
  leaseToken: string | null
}

export interface RuntimeControllerActivity {
  id: string
  severity: RuntimeTone
  title: string
  detail: string
  at: number
}

export interface RuntimeControllerSnapshot {
  session: DesktopRuntimeSessionSyncRequest | null
  client: DesktopClientInfo | null
  running: boolean
  dispatchConnected: boolean
  queueDepth: number
  accounts: DesktopAccountInfo[]
  accountProfiles: Record<string, PublishAccountProfile>
  tasks: Array<Omit<RuntimeTaskRecord, 'leaseToken'>>
  activity: RuntimeControllerActivity[]
  lastHeartbeatAt: number
  lastHeartbeatStatus: 'idle' | 'success' | 'failed'
  lastPullAt: number
  lastPullStatus: 'idle' | 'success' | 'failed'
  lastAccountsSyncAt: number
  lastServerTime: string | null
  onlineClientCount: number | null
  lastError: string | null
}

interface PendingTaskRequest {
  taskId: string
  routing: RuntimeTaskRouting
  platform?: string
  source?: 'desktop_task' | 'monitoring_lease'
}

interface ActiveRuntimeExecution {
  taskId: string
  kind: 'publish' | 'monitor'
  platform: string
  accountId: string
  abortController: AbortController
  executionPhase: MonitorExecutionPhase | null
  interruptRequested: boolean
  interruptGeneration: number
  interruptReason: string | null
  lastSafePointAt: number | null
  startedAt: number
  lastProgressAt: number
  lastProgressSummary: string | null
  deadlineAt: number | null
  deadlineHandle: ReturnType<typeof setTimeout> | null
  longRunningNotifiedAt: number | null
  // Set the moment a publish adapter enters its irreversible submit/save_draft stage. Once set,
  // an interrupted publish is completed as 'unknown' (manual reconcile) instead of 'failed', so a
  // possibly-already-published article is never silently re-posted by a retry.
  submitStartedAt: number | null
}

interface RuntimeState {
  session: DesktopRuntimeSessionSyncRequest | null
  client: DesktopClientInfo | null
  running: boolean
  tasks: Map<string, RuntimeTaskRecord>
  accounts: DesktopAccountInfo[]
  accountProfiles: Map<string, PublishAccountProfile>
  activity: RuntimeControllerActivity[]
  activeExecutions: Map<string, ActiveRuntimeExecution>
  leaseInFlightKinds: Set<'publish' | 'monitor'>
  publishFallbackBackoffUntil: number
  heartbeatTimer: ReturnType<typeof setInterval> | null
  pullTimer: ReturnType<typeof setInterval> | null
  pumpWatchdogTimer: ReturnType<typeof setInterval> | null
  accountHealthReportTimer: ReturnType<typeof setTimeout> | null
  accountHealthReportQueue: Map<string, DesktopAccountHealthReport>
  accountHealthReportBadAccounts: Set<string>
  accountRemoteHealth: Map<string, DesktopAccountInfo['health']>
  dispatchWsClient: DispatchWsClient | null
  dispatchWsConnected: boolean
  lastHeartbeatAt: number
  lastHeartbeatStatus: 'idle' | 'success' | 'failed'
  lastPullAt: number
  lastPullStatus: 'idle' | 'success' | 'failed'
  lastAccountsSyncAt: number
  lastServerTime: string | null
  onlineClientCount: number | null
  lastError: string | null
  activitySeq: number
}

const state: RuntimeState = {
  session: null,
  client: null,
  running: false,
  tasks: new Map<string, RuntimeTaskRecord>(),
  accounts: [],
  accountProfiles: new Map<string, PublishAccountProfile>(),
  activity: [],
  activeExecutions: new Map<string, ActiveRuntimeExecution>(),
  leaseInFlightKinds: new Set<'publish' | 'monitor'>(),
  publishFallbackBackoffUntil: 0,
  heartbeatTimer: null,
  pullTimer: null,
  pumpWatchdogTimer: null,
  accountHealthReportTimer: null,
  accountHealthReportQueue: new Map<string, DesktopAccountHealthReport>(),
  accountHealthReportBadAccounts: new Set<string>(),
  accountRemoteHealth: new Map<string, DesktopAccountInfo['health']>(),
  dispatchWsClient: null,
  dispatchWsConnected: false,
  lastHeartbeatAt: 0,
  lastHeartbeatStatus: 'idle',
  lastPullAt: 0,
  lastPullStatus: 'idle',
  lastAccountsSyncAt: 0,
  lastServerTime: null,
  onlineClientCount: null,
  lastError: null,
  activitySeq: 0,
}
let accountHealthReportBridgeUnsubscribe: (() => void) | null = null

function accountIdentityFromDesktopAccount(account: DesktopAccountInfo): PublishAccountIdentity {
  return {
    id: account.id,
    platform: account.platform,
    platformUid: normalizeAccountPlatformUid(account.platform_uid) || account.platform_uid,
    displayName: account.display_name,
  }
}

function accountIdentityFromTask(task: RuntimeTaskRecord): PublishAccountIdentity | null {
  if (!task.accountId) {
    return null
  }

  const matched = state.accounts.find((account) => account.id === task.accountId) ?? null
  if (matched) {
    return accountIdentityFromDesktopAccount(matched)
  }

  return {
    id: task.accountId,
    platform: task.platform,
    platformUid: '',
    displayName: task.accountName || '待同步账号',
  }
}

function isDefinitiveAuthState(authState: string): boolean {
  return ['active', 'expired', 'challenge_required', 'revoked'].includes(authState)
}

function hasLocalAccountSession(accountId: string): boolean {
  return Boolean(getSessionHandle(accountId) || getPersistedPartition(accountId))
}

function isAccountOwnedByCurrentClient(account: DesktopAccountInfo): boolean {
  return Boolean(account.client_id && account.client_id === state.client?.id)
}

function hasLocalAccountAuthorization(account: DesktopAccountInfo): boolean {
  return isAccountOwnedByCurrentClient(account) && hasLocalAccountSession(account.id)
}

function accountRequiresLocalAuthorization(account: DesktopAccountInfo): boolean {
  return Boolean(account.client_id)
}

function shouldReportAccountPresence(account: DesktopAccountInfo): boolean {
  return hasLocalAccountSession(account.id) && isAccountOwnedByCurrentClient(account)
}

function buildRuntimeAccountDedupeKey(account: DesktopAccountInfo): string {
  if (isAIPlatformId(account.platform)) {
    return `ai-platform:${account.platform}`
  }

  return buildAccountIdentityKey({
    platform: account.platform,
    platformUid: account.platform_uid,
    displayName: account.display_name,
  })
}

function accountHealthRank(health: DesktopAccountInfo['health']): number {
  switch (health) {
    case 'live':
      return 4
    case 'risk':
      return 3
    case 'captcha':
      return 2
    case 'expired':
      return 1
    default:
      return 0
  }
}

function accountTimestamp(value: string | null | undefined): number {
  return parseTimestamp(value) ?? 0
}

function shouldPreferRuntimeAccount(
  candidate: DesktopAccountInfo,
  current: DesktopAccountInfo,
): boolean {
  const candidateHealthRank = accountHealthRank(candidate.health)
  const currentHealthRank = accountHealthRank(current.health)
  if (candidateHealthRank !== currentHealthRank) {
    return candidateHealthRank > currentHealthRank
  }

  const candidateVerifiedAt = accountTimestamp(candidate.verified_at)
  const currentVerifiedAt = accountTimestamp(current.verified_at)
  if (candidateVerifiedAt !== currentVerifiedAt) {
    return candidateVerifiedAt > currentVerifiedAt
  }

  return candidate.sync_version > current.sync_version
}

function runtimePlatformLabel(platform: string): string {
  return getAIPlatformCatalogItem(platform)?.label ?? platform
}

function accountActionRequiredSummary(
  platform: string,
  authReason: string | null | undefined,
): string {
  const label = runtimePlatformLabel(platform)
  if (platform === 'baijiahao') {
    return BAIJIAHAO_RISK_CONTROL_PROMPT
  }
  if (authReason === 'risk_control') {
    return `${label} 账号疑似触发风控，请打开平台处理验证或等待限制解除后再继续执行。`
  }
  return `${label} 账号需要完成人机验证后才能继续执行。`
}

function markAuthorizationFailureNonRetryable(
  error: Record<string, JsonValue>,
  category: 'ai_platform_authorization' | 'media_account_authorization',
): Record<string, JsonValue> {
  return {
    ...error,
    retryable: false,
    non_retryable: true,
    failure_category: category,
  }
}

function isAuthorizationFailureCode(code: string | null | undefined): boolean {
  if (!code) {
    return false
  }
  const normalized = code.trim().toLowerCase()
  return (
    normalized === 'desktop_account_auth_expired' ||
    normalized === 'desktop_account_challenge_required' ||
    normalized === 'desktop_account_risk_control' ||
    normalized.endsWith('_not_logged_in') ||
    normalized.endsWith('_login_required') ||
    normalized.endsWith('_login_expired') ||
    normalized.endsWith('_challenge_required')
  )
}

function isAuthorizationFailureMessage(message: string | null | undefined): boolean {
  if (!message) {
    return false
  }
  const normalized = message.trim().toLowerCase()
  return (
    normalized.includes('login required') ||
    normalized.includes('login expired') ||
    normalized.includes('not logged in') ||
    normalized.includes('unauthorized') ||
    normalized.includes('登录态失效') ||
    normalized.includes('登录态已失效') ||
    normalized.includes('登录已失效') ||
    normalized.includes('请重新登录') ||
    normalized.includes('请先登录') ||
    normalized.includes('未登录')
  )
}

function isAuthorizationFailureCategory(category: string | null | undefined): boolean {
  return category === 'ai_platform_authorization' || category === 'media_account_authorization'
}

function isNonRetryableAuthorizationFailure(
  task: RuntimeTaskRecord,
  result: AdapterExecutionResult,
): boolean {
  if (result.status !== 'failed') {
    return false
  }

  const code = typeof result.error?.code === 'string' ? result.error.code : null
  const message = typeof result.error?.message === 'string' ? result.error.message : null
  const category =
    typeof result.error?.failure_category === 'string' ? result.error.failure_category : null
  if (isAuthorizationFailureCategory(category)) {
    return true
  }
  if (!isAuthorizationFailureCode(code) && !isAuthorizationFailureMessage(message)) {
    return false
  }

  return task.kind === 'publish' || isAIPlatformId(task.platform)
}

function withAuthorizationRetryPolicy(
  task: RuntimeTaskRecord,
  result: AdapterExecutionResult,
): AdapterExecutionResult {
  if (!isNonRetryableAuthorizationFailure(task, result)) {
    return result
  }

  const category = isAIPlatformId(task.platform)
    ? 'ai_platform_authorization'
    : 'media_account_authorization'
  const baseError = result.error ?? {
    code: 'desktop_account_authorization_failed',
    message: result.summary,
  }
  return {
    ...result,
    error: markAuthorizationFailureNonRetryable(baseError, category),
  }
}

async function resolveAuthorizationPreflightBlock(
  task: RuntimeTaskRecord,
): Promise<AdapterExecutionResult | null> {
  const accountIdentity = accountIdentityFromTask(task)
  if (!accountIdentity || !shouldEnforceActiveAccount(task)) {
    return null
  }

  const previousSnapshot = getAccountHealthSnapshot(accountIdentity.id)
  const readiness = await ensureAccountReady(accountIdentity)
  if (readiness.authState === 'active') {
    return null
  }

  const result = withAuthorizationRetryPolicy(task, buildAccountBlockedResult(task, readiness))
  maybeRecordAccountAccessAlert(task, accountIdentity, previousSnapshot, readiness)
  enqueueAccountHealthReport(accountIdentity.id)
  recordAuthorizationPreflightBlock(task, result)
  return result
}

function recordAuthorizationPreflightBlock(
  task: RuntimeTaskRecord,
  result: AdapterExecutionResult,
): void {
  if (!isNonRetryableAuthorizationFailure(task, result)) {
    return
  }

  const scope = task.kind === 'monitor' && isAIPlatformId(task.platform) ? '同模型' : '同账号'
  recordActivity(
    'warn',
    '授权失效，任务未执行',
    `${runtimePlatformLabel(task.platform)} ${scope}授权不是 active，${task.title} 已直接回写 non-retryable 授权失败。`,
  )
}

function maybeRecordAccountAccessAlert(
  task: RuntimeTaskRecord,
  accountIdentity: PublishAccountIdentity | null,
  previous: ReturnType<typeof getAccountHealthSnapshot>,
  next: ReturnType<typeof getAccountHealthSnapshot>,
): void {
  if (!accountIdentity || !next) {
    return
  }

  if (previous?.authState === next.authState && previous?.authReason === next.authReason) {
    return
  }

  if (next.authState === 'challenge_required' && next.authReason === 'risk_control') {
    if (accountIdentity.platform === 'baijiahao') {
      recordActivity('warn', '百家号触发平台风控', BAIJIAHAO_RISK_CONTROL_PROMPT)
      return
    }
    recordActivity(
      'warn',
      `${runtimePlatformLabel(accountIdentity.platform)} 触发风控`,
      `${accountIdentity.displayName || task.accountName || '当前账号'} 已被平台限制，请打开平台处理验证或等待限制解除后再刷新状态。`,
    )
    return
  }

  if (next.authState === 'challenge_required') {
    if (accountIdentity.platform === 'baijiahao') {
      recordActivity('warn', '百家号触发平台风控', BAIJIAHAO_RISK_CONTROL_PROMPT)
      return
    }
    recordActivity(
      'warn',
      `${runtimePlatformLabel(accountIdentity.platform)} 需要人工验证`,
      `${accountIdentity.displayName || task.accountName || '当前账号'} 需要打开平台完成人工验证后再继续执行任务。`,
    )
  }
}

function isoFromTimestamp(value: number | null): string | null {
  return value ? new Date(value).toISOString() : null
}

export function syncRuntimeSession(next: DesktopRuntimeSessionSyncRequest | null): void {
  const normalized = normalizeSession(next)
  const changed = !sameSession(state.session, normalized)

  state.session = normalized
  state.client = normalized?.desktop_client ?? null

  if (!canRunLive(normalized)) {
    stopRuntime()
    clearRuntimeState()
    configureTransport(null)
    setTransportAuthState('pending')
    return
  }

  configureTransport(normalized)
  setTransportAuthState('registered')

  if (changed) {
    stopRuntime()
    clearRuntimeState()
    recordActivity(
      'info',
      '任务消费端已就绪',
      `客户端 ${normalized.desktop_client?.device_name ?? normalized.desktop_client?.id ?? '未知客户端'} 已准备消费桌面任务。`,
    )
  }

  if (!state.running) {
    startRuntime()
  }
}

export async function releaseRuntimeSession(options: { revoke?: boolean } = {}): Promise<void> {
  const currentSession = state.session
  const shouldReleaseRemote = canRunLive(currentSession)

  if (shouldReleaseRemote) {
    try {
      if (options.revoke) {
        await revokeDesktopClient()
      } else {
        await offlineDesktopClient()
      }
    } catch (error) {
      console.warn('[desktop-runtime] release runtime session failed', {
        revoke: Boolean(options.revoke),
        message: errorMessage(error),
      })
    }
  }

  stopRuntime()
  clearRuntimeState()
  configureTransport(null)
  setTransportAuthState('pending')
  state.session = null
  state.client = null
}

export function getRuntimeControllerSnapshot(): RuntimeControllerSnapshot {
  return {
    session: state.session ? { ...state.session } : null,
    client: state.client ? { ...state.client } : null,
    running: state.running,
    dispatchConnected: state.dispatchWsConnected,
    queueDepth: localQueueDepth(),
    accounts: state.accounts.map((item) => ({ ...item })),
    accountProfiles: Object.fromEntries(
      [...state.accountProfiles.entries()].map(([accountId, profile]) => [
        accountId,
        { ...profile },
      ]),
    ),
    tasks: [...state.tasks.values()]
      .sort((left, right) => right.updatedAt - left.updatedAt)
      .map(({ leaseToken: _leaseToken, ...task }) => ({
        ...task,
        startedAt: state.activeExecutions.get(task.id)?.startedAt ?? task.startedAt,
      })),
    activity: [...state.activity],
    lastHeartbeatAt: state.lastHeartbeatAt,
    lastHeartbeatStatus: state.lastHeartbeatStatus,
    lastPullAt: state.lastPullAt,
    lastPullStatus: state.lastPullStatus,
    lastAccountsSyncAt: state.lastAccountsSyncAt,
    lastServerTime: state.lastServerTime,
    onlineClientCount: state.onlineClientCount,
    lastError: state.lastError,
  }
}

function startRuntime(): void {
  if (!canRunLive(state.session) || state.running) {
    return
  }

  initScheduler()
  initMonitorScheduler()
  initPublishScheduler()
  startHiddenPlaywrightReaper()
  ensureAccountHealthReportBridge()
  state.running = true
  setSchedulerPhase('running')
  setSchedulerError(null)
  recordActivity('success', '调度节点已启动', '已启动 WebSocket 分发、心跳上报和兜底拉取。')

  connectDispatchWs()
  scheduleHeartbeatLoop()
  schedulePullLoop()
  schedulePumpWatchdogLoop()

  void sendHeartbeat('startup')
  void syncAccounts('startup')
  void resumeLeasedMonitoringTasks('startup')
  pumpExecutionLoop()
}

function ensureAccountHealthReportBridge(): void {
  if (accountHealthReportBridgeUnsubscribe) {
    return
  }

  accountHealthReportBridgeUnsubscribe = onRuntimeInvalidated((event) => {
    if (event.reason !== 'account-health' || !event.accountId) {
      return
    }
    enqueueAccountHealthReport(event.accountId)
  })
}

function stopRuntime(): void {
  state.running = false
  state.leaseInFlightKinds.clear()
  for (const execution of state.activeExecutions.values()) {
    if (execution.deadlineHandle) {
      clearTimeout(execution.deadlineHandle)
      execution.deadlineHandle = null
    }
    execution.abortController.abort()
  }
  state.activeExecutions.clear()

  if (state.heartbeatTimer) {
    clearInterval(state.heartbeatTimer)
    state.heartbeatTimer = null
  }
  if (state.pullTimer) {
    clearInterval(state.pullTimer)
    state.pullTimer = null
  }
  if (state.pumpWatchdogTimer) {
    clearInterval(state.pumpWatchdogTimer)
    state.pumpWatchdogTimer = null
  }
  if (state.accountHealthReportTimer) {
    clearTimeout(state.accountHealthReportTimer)
    state.accountHealthReportTimer = null
  }
  if (state.dispatchWsClient) {
    state.dispatchWsClient.stop()
    state.dispatchWsClient = null
  }
  state.dispatchWsConnected = false
  setTransportDispatchState('idle')

  setSchedulerPhase('idle')
  setSchedulerCurrentTask(null)
  setSchedulerQueueDepth(localQueueDepth())
  setSchedulerNextHeartbeat(null)
  setSchedulerNextPull(null)

  if (getLeaseManagerSnapshot().activeTaskId) {
    noteLeaseReleased('cleared')
  }
}

function clearRuntimeState(): void {
  initPublishScheduler()
  state.tasks.clear()
  state.accounts = []
  state.accountProfiles.clear()
  state.accountHealthReportQueue.clear()
  state.accountHealthReportBadAccounts.clear()
  state.accountRemoteHealth.clear()
  state.activeExecutions.clear()
  state.lastHeartbeatAt = 0
  state.lastHeartbeatStatus = 'idle'
  state.lastPullAt = 0
  state.lastPullStatus = 'idle'
  state.lastAccountsSyncAt = 0
  state.lastServerTime = null
  state.onlineClientCount = null
  state.lastError = null
  state.publishFallbackBackoffUntil = 0
  setSchedulerQueueDepth(localQueueDepth())
}

function scheduleHeartbeatLoop(): void {
  if (state.heartbeatTimer) {
    clearInterval(state.heartbeatTimer)
  }

  setSchedulerNextHeartbeat(Date.now() + heartbeatIntervalMs)
  state.heartbeatTimer = setInterval(() => {
    setSchedulerNextHeartbeat(Date.now() + heartbeatIntervalMs)
    void sendHeartbeat('timer')
  }, heartbeatIntervalMs)
}

function schedulePullLoop(): void {
  if (state.pullTimer) {
    clearInterval(state.pullTimer)
  }

  setSchedulerNextPull(Date.now() + pullIntervalMs)
  state.pullTimer = setInterval(() => {
    setSchedulerNextPull(Date.now() + pullIntervalMs)
    pumpExecutionLoop()
  }, pullIntervalMs)
}

function schedulePumpWatchdogLoop(): void {
  if (state.pumpWatchdogTimer) {
    clearInterval(state.pumpWatchdogTimer)
  }

  state.pumpWatchdogTimer = setInterval(() => {
    notifyLongRunningPublishTasks()
    pumpExecutionLoop()
  }, pumpWatchdogIntervalMs)
}

function connectDispatchWs(): void {
  if (!canRunLive(state.session)) {
    return
  }

  state.dispatchWsClient?.stop()
  setTransportDispatchState('connecting')

  const wsUrl = buildApiUrl(state.session.api_base_url, '/api/desktop/dispatch')
    .replace(/^http:\/\//, 'ws://')
    .replace(/^https:\/\//, 'wss://')

  const client = new DispatchWsClient({
    url: wsUrl,
    headers: {
      Authorization: `Bearer ${state.session.client_token}`,
    },
  })
  let hasConnectedOnce = false

  client.on('open', () => {
    state.dispatchWsConnected = true
    setTransportDispatchState('streaming')
    setSchedulerError(null)
    recordActivity('success', '任务分发通道已连接', '统一 WebSocket 分发通道已就绪。')
    void pullNextTask('monitor')
    if (hasConnectedOnce) {
      void resumeLeasedMonitoringTasks('reconnect')
    }
    hasConnectedOnce = true
  })

  client.on('connected', (payload) => {
    state.dispatchWsConnected = true
    setTransportDispatchState('streaming')
    if (isConnectedEvent(payload)) {
      state.lastServerTime = payload.server_time
    }
  })

  const dispatchTaskHandler = (payload: unknown) => {
    state.dispatchWsConnected = true
    noteSchedulerSseEvent()

    if (isMonitoringTaskControlEvent(payload)) {
      void handleMonitoringTaskControl(payload)
      return
    }
    if (isMonitoringDispatchSignal(payload)) {
      void handleMonitoringDispatchSignal(payload)
      return
    }
    if (!isDesktopTaskEvent(payload)) {
      return
    }
    handleTaskEvent(payload)
  }

  client.on('task_available', dispatchTaskHandler)
  client.on('task_leased', dispatchTaskHandler)
  client.on('task_extended', dispatchTaskHandler)
  client.on('task_completed', dispatchTaskHandler)
  client.on('task_canceled', dispatchTaskHandler)
  client.on('task_reconciled', dispatchTaskHandler)
  client.on('task_control', dispatchTaskHandler)

  client.on('error', (payload) => {
    state.dispatchWsConnected = false
    setTransportDispatchState('connecting')
    const message = errorMessage(payload)
    state.lastError = message
    setSchedulerError(message)
    recordActivity('warn', '任务分发通道异常', message)
  })

  client.on('close', () => {
    state.dispatchWsConnected = false
    setTransportDispatchState(state.running ? 'connecting' : 'idle')
  })

  client.on('reconnect', (payload) => {
    if (!isReconnectPayload(payload)) {
      return
    }
    setTransportDispatchState('connecting')
    recordActivity('info', '任务分发通道退避等待', `将在 ${payload.delayMs}ms 后重连 WebSocket。`)
  })

  state.dispatchWsClient = client
  client.start()
}

function handleTaskEvent(event: DesktopTaskEventMessage): void {
  if (event.type === 'task_control' || event.signal_only || !event.task_id.trim()) {
    return
  }

  const existing = state.tasks.get(event.task_id)
  const eventUpdatedAt = parseTimestamp(event.updated_at) ?? Date.now()
  if (existing && eventUpdatedAt < existing.updatedAt) {
    return
  }

  const next: RuntimeTaskRecord = {
    id: event.task_id,
    jobId: event.job_id,
    title: existing?.title ?? defaultTaskTitle(event.kind, event.platform || existing?.platform),
    kind: event.kind,
    platform:
      event.platform || existing?.platform || inferPlatformFromAccount(event.target_account_id),
    accountId: event.target_account_id || existing?.accountId || '',
    accountName: existing?.accountName ?? '待同步账号',
    clientId: event.target_client_id,
    status: event.status,
    routing: existing?.routing ?? 'rabbitmq-primary',
    leaseExpiresAt: event.status === 'in_progress' ? (existing?.leaseExpiresAt ?? null) : null,
    startedAt: event.status === 'in_progress' ? (existing?.startedAt ?? eventUpdatedAt) : null,
    updatedAt: eventUpdatedAt,
    summary: summaryFromEventType(event.type, event.status),
    payload: existing?.payload ?? {},
    error: existing?.error ?? null,
    result: existing?.result ?? null,
    attemptId: event.status === 'in_progress' ? (existing?.attemptId ?? null) : null,
    leaseToken: event.status === 'in_progress' ? (existing?.leaseToken ?? null) : null,
  }

  state.tasks.set(event.task_id, next)

  if (event.kind === 'monitor') {
    if (event.type === 'task_available') {
      enqueueMonitorTaskFromEvent(event, 'rabbitmq-primary')
    }
    if (
      event.type === 'task_completed' ||
      event.type === 'task_reconciled' ||
      event.type === 'task_canceled'
    ) {
      noteMonitorTaskCanceled(event.task_id)
    }
  }

  if (
    event.kind === 'publish' &&
    (event.type === 'task_completed' ||
      event.type === 'task_reconciled' ||
      event.type === 'task_canceled')
  ) {
    notePublishTaskCanceled(event.task_id)
  }

  if (event.type === 'task_available') {
    if (event.kind === 'publish') {
      enqueuePublishTask(next.id, next.platform, 'rabbitmq-primary')
    }
    pumpExecutionLoop()
  }
}

async function handleMonitoringDispatchSignal(event: DesktopTaskEventMessage): Promise<void> {
  if (event.target_client_id !== currentClientID()) {
    return
  }

  if ((event.lane ?? '').trim() === 'high') {
    recordActivity(
      'info',
      '收到监控高优先级信号',
      '客户端将按平台隔离和并发上限，优先领取 collect-now 桌面监控任务。',
    )
  }

  if (event.task_id.trim()) {
    enqueueMonitorTaskFromEvent(event, 'rabbitmq-primary')
    pumpExecutionLoop()
    return
  }

  await pullNextTask('monitor')
}

async function handleMonitoringTaskControl(event: DesktopTaskEventMessage): Promise<void> {
  if (
    event.target_client_id !== currentClientID() ||
    event.control !== 'interrupt_requested' ||
    !event.task_id.trim()
  ) {
    return
  }

  const taskId = event.task_id.trim()
  const generation = toInterruptGeneration(event.interrupt_generation)
  const existing = state.tasks.get(taskId) ?? null
  if (existing && generation < toInterruptGeneration(existing.payload.interrupt_generation)) {
    return
  }

  const active = state.activeExecutions.get(taskId)
  if (active?.kind === 'monitor') {
    if (isDesktopTaskID(taskId)) {
      if (existing) {
        existing.summary =
          '已收到立即收集请求；当前执行继续保留，high lane 任务会按平台隔离和并发上限调度。'
        existing.updatedAt = Date.now()
        state.tasks.set(taskId, existing)
      }
      recordActivity(
        'info',
        '监控任务保留当前执行',
        `${existing?.title ?? taskId} 当前执行继续保留；若 high lane 属于其他平台可使用第二个窗口并行，否则等待当前平台释放。`,
      )
      return
    }

    if (existing) {
      existing.summary = '已收到抢占请求；当前监控执行将自然完成，随后优先处理 high lane 任务。'
      existing.updatedAt = Date.now()
      state.tasks.set(taskId, existing)
    }
    recordActivity(
      'warn',
      '监控任务收到抢占请求',
      `${existing?.title ?? taskId} 当前已在执行，Phase 1 将等待自然完成。`,
    )
    return
  }

  if (existing) {
    existing.payload = {
      ...existing.payload,
      interrupt_requested: true,
      interrupt_generation: generation,
      interrupt_reason: event.reason?.trim() || 'collect_now_preempt',
      replacement_task_id: event.replacement_task_id?.trim() || null,
    }
    existing.updatedAt = Date.now()
    state.tasks.set(taskId, existing)
  }

  if (!existing?.leaseToken) {
    noteMonitorTaskCanceled(taskId)
    if (existing) {
      existing.status = 'aborted'
      existing.summary = '已收到抢占请求，本地排队中的旧监控任务已让路。'
      existing.updatedAt = Date.now()
      state.tasks.set(taskId, existing)
    }
    await pullMonitoringTasks('rabbitmq-primary')
    return
  }

  const monitoringTaskID = Number.parseInt(taskId, 10)
  if (!Number.isFinite(monitoringTaskID)) {
    noteMonitorTaskCanceled(taskId)
    if (existing) {
      existing.status = 'aborted'
      existing.leaseToken = null
      existing.summary =
        '已收到抢占请求，但任务不是 legacy monitoring lease，已从本地调度队列移除。'
      existing.updatedAt = Date.now()
      state.tasks.set(taskId, existing)
    }
    await pullMonitoringTasks('rabbitmq-primary')
    return
  }

  try {
    await cancelMonitoringTask(monitoringTaskID, {
      lease_token: existing.leaseToken,
      reason: event.reason?.trim() || 'collect_now_preempt',
    })
    noteMonitorTaskCanceled(taskId)
    existing.status = 'aborted'
    existing.leaseToken = null
    existing.summary = '已响应抢占请求，释放旧监控租约并为高优任务让路。'
    existing.updatedAt = Date.now()
    state.tasks.set(taskId, existing)
    recordActivity('info', '已取消旧监控租约', `${existing.title} 已从本地排队队列中移除。`)
    await pullMonitoringTasks('rabbitmq-primary')
  } catch (error) {
    const message = errorMessage(error)
    if (existing) {
      existing.summary = `收到抢占请求，但取消租约失败：${message}`
      existing.updatedAt = Date.now()
      state.tasks.set(taskId, existing)
    }
    recordActivity(
      'warn',
      '监控租约抢占失败',
      `${existing?.title ?? taskId} 取消租约失败：${message}`,
    )
  }
}

async function sendHeartbeat(source: 'startup' | 'timer'): Promise<void> {
  if (!canRunLive(state.session)) {
    return
  }

  const previousStatus = state.lastHeartbeatStatus

  try {
    const response = await heartbeatDesktopClient({
      device_name: hostname() || state.client?.device_name || `Desktop ${process.platform}`,
      os: process.platform,
      cpu_arch: process.arch,
      client_version: getDesktopAppVersion(),
      channel: state.client?.channel ?? getDesktopReleaseChannel(),
      startup: source === 'startup',
      account_ids: state.accounts
        .filter((account) => shouldReportAccountPresence(account))
        .map((account) => account.id),
    })

    state.client = response.client
    state.lastHeartbeatAt = Date.now()
    state.lastHeartbeatStatus = 'success'
    state.lastServerTime = response.server_time
    state.onlineClientCount =
      response.current_user_online_client_count ?? response.online_client_count ?? null
    state.lastError = null

    noteTransportHeartbeat(true)
    noteSchedulerHeartbeat()
    setSchedulerError(null)

    if (source === 'startup' || previousStatus === 'failed') {
      recordActivity('success', '心跳连接正常', '客户端心跳已回写到服务端。')
    }
  } catch (error) {
    state.lastHeartbeatAt = Date.now()
    state.lastHeartbeatStatus = 'failed'
    state.lastError = errorMessage(error)

    noteTransportHeartbeat(false)
    setSchedulerError(state.lastError)

    if (source === 'startup' || previousStatus !== 'failed') {
      recordActivity('danger', '心跳连接失败', state.lastError)
    }
  }
}

async function syncAccounts(source: 'startup' | 'manual'): Promise<void> {
  if (!canRunLive(state.session)) {
    return
  }

  try {
    const accounts = await listDesktopAccounts()
    state.lastAccountsSyncAt = Date.now()
    state.lastError = null

    noteSchedulerAccountsSync()
    setSchedulerError(null)

    const identities = accounts
      .filter((account) => hasLocalAccountAuthorization(account))
      .map((account) => accountIdentityFromDesktopAccount(account))
    syncTrackedAccounts(identities)
    state.accountRemoteHealth = new Map(accounts.map((account) => [account.id, account.health]))

    state.accountProfiles.clear()
    const syncedAccounts: Array<DesktopAccountInfo | null> = accounts.map((account) => {
      const normalizedPlatformUid =
        normalizeAccountPlatformUid(account.platform_uid) || account.platform_uid
      const isAIPlatform = isAIPlatformId(account.platform)
      const accountIdentity = accountIdentityFromDesktopAccount({
        ...account,
        platform_uid: normalizedPlatformUid,
      })
      if (accountRequiresLocalAuthorization(account) && !hasLocalAccountAuthorization(account)) {
        markTrackedAccountMissingPartition(accountIdentity)
      }
      const projected = getProjectedAccountHealth({
        accountId: account.id,
        platform: account.platform,
        health: account.health,
        verifiedAt: account.verified_at,
      })

      if (projected.profile?.subjectUid && projected.profile.displayName) {
        state.accountProfiles.set(account.id, {
          platformUid: projected.profile.subjectUid,
          displayName: projected.profile.displayName,
          avatarUrl: projected.profile.avatarUrl,
        })
      }

      const normalizedLocalPlatformUid = projected.profile?.subjectUid
        ? normalizeAccountPlatformUid(projected.profile.subjectUid) || projected.profile.subjectUid
        : null
      const hasPlatformUidMismatch = Boolean(
        normalizedLocalPlatformUid &&
        !sameAccountPlatformUid(normalizedLocalPlatformUid, normalizedPlatformUid),
      )

      if (hasPlatformUidMismatch && !isAIPlatform) {
        return {
          ...account,
          platform_uid: normalizedPlatformUid,
          health: 'expired' as const,
        }
      }

      const resolvedAccount: DesktopAccountInfo = {
        ...account,
        platform_uid: normalizedPlatformUid,
        display_name: projected.profile?.displayName ?? account.display_name,
        avatar_url: projected.profile?.avatarUrl ?? account.avatar_url,
        health: projected.health,
        verified_at: isoFromTimestamp(projected.lastVerifiedAt) ?? account.verified_at,
      }

      return resolvedAccount
    })
    const duplicateAccounts: DesktopAccountInfo[] = []
    const dedupedAccounts: DesktopAccountInfo[] = []
    const seenAccountIndexes = new Map<string, number>()

    for (const account of syncedAccounts) {
      if (!account) {
        continue
      }

      const identityKey = buildRuntimeAccountDedupeKey(account)
      const existingIndex = seenAccountIndexes.get(identityKey)
      if (existingIndex !== undefined) {
        const existingAccount = dedupedAccounts[existingIndex]
        if (shouldPreferRuntimeAccount(account, existingAccount)) {
          duplicateAccounts.push(existingAccount)
          dedupedAccounts[existingIndex] = account
        } else {
          duplicateAccounts.push(account)
        }
        continue
      }

      seenAccountIndexes.set(identityKey, dedupedAccounts.length)
      dedupedAccounts.push(account)
    }

    state.accounts = dedupedAccounts

    if (duplicateAccounts.length > 0) {
      void cleanupDuplicateDesktopAccounts(duplicateAccounts)
    }

    if (source === 'startup') {
      recordActivity('info', '本地账号同步', `已同步 ${state.accounts.length} 个桌面账号。`)
    }

    refreshAccountNames()
    pumpExecutionLoop()
    void sendHeartbeat('timer')
  } catch (error) {
    const message = errorMessage(error)
    state.lastError = message
    setSchedulerError(message)

    recordActivity('warn', '账号同步失败', message)
  }
}

async function cleanupDuplicateDesktopAccounts(accounts: DesktopAccountInfo[]): Promise<void> {
  for (const account of accounts) {
    try {
      await deleteDesktopAccount(account.id, account.sync_version)
      await clearSessionHandle(account.id)
      forgetTrackedAccountHealth(account.id)
    } catch (error) {
      console.warn('[desktop-runtime] duplicate desktop account cleanup failed', {
        accountId: account.id,
        platform: account.platform,
        platformUid: account.platform_uid,
        message: errorMessage(error),
      })
    }
  }
}

function buildAccountHealthReport(account: DesktopAccountInfo): DesktopAccountHealthReport {
  const projected = getProjectedAccountHealth({
    accountId: account.id,
    platform: account.platform,
    health: account.health,
    verifiedAt: account.verified_at,
  })
  const health =
    projected.authState === 'expiring_soon' && projected.probeState !== 'network_error'
      ? 'live'
      : projected.health
  return {
    account_id: account.id,
    platform: account.platform,
    platform_uid: normalizeAccountPlatformUid(account.platform_uid) || account.platform_uid,
    health,
    auth_state: projected.authState,
    probe_state: projected.probeState,
    auth_reason: projected.authReason,
    display_name: projected.profile?.displayName ?? account.display_name,
    avatar_url: projected.profile?.avatarUrl ?? account.avatar_url,
    verified_at: isoFromTimestamp(projected.lastVerifiedAt) ?? account.verified_at,
    checked_at: new Date().toISOString(),
  }
}

function isAccountHealthFailureReport(report: DesktopAccountHealthReport): boolean {
  return (
    report.health !== 'live' ||
    report.auth_state === 'expired' ||
    report.auth_state === 'challenge_required' ||
    report.auth_state === 'revoked' ||
    report.probe_state === 'network_error'
  )
}

function shouldQueueAccountHealthReport(
  account: DesktopAccountInfo,
  report: DesktopAccountHealthReport,
): boolean {
  if (isAccountHealthFailureReport(report)) {
    return true
  }

  if (state.accountHealthReportBadAccounts.has(account.id)) {
    return true
  }

  return (state.accountRemoteHealth.get(account.id) ?? account.health) !== 'live'
}

function enqueueAccountHealthReport(accountId: string): void {
  const account = state.accounts.find((item) => item.id === accountId) ?? null
  if (!account) {
    return
  }
  if (!hasLocalAccountAuthorization(account)) {
    return
  }

  const report = buildAccountHealthReport(account)
  if (!shouldQueueAccountHealthReport(account, report)) {
    return
  }

  if (isAccountHealthFailureReport(report)) {
    state.accountHealthReportBadAccounts.add(account.id)
  }

  state.accountHealthReportQueue.set(account.id, report)
  if (state.accountHealthReportTimer) {
    return
  }

  state.accountHealthReportTimer = setTimeout(() => {
    state.accountHealthReportTimer = null
    void flushAccountHealthReports()
  }, accountHealthReportDebounceMs)
}

async function flushAccountHealthReports(): Promise<void> {
  if (state.accountHealthReportQueue.size === 0 || !canRunLive(state.session)) {
    return
  }

  const reports = [...state.accountHealthReportQueue.values()].slice(
    0,
    accountHealthReportMaxBatchSize,
  )
  for (const report of reports) {
    state.accountHealthReportQueue.delete(report.account_id)
  }

  try {
    await reportDesktopAccountHealth({ reports })
    for (const report of reports) {
      state.accountRemoteHealth.set(report.account_id, report.health)
      if (isAccountHealthFailureReport(report)) {
        state.accountHealthReportBadAccounts.add(report.account_id)
      } else {
        state.accountHealthReportBadAccounts.delete(report.account_id)
      }
    }
  } catch (error) {
    console.warn('[desktop-runtime] account health report failed', {
      count: reports.length,
      message: errorMessage(error),
    })
    for (const report of reports) {
      state.accountHealthReportQueue.set(report.account_id, report)
    }
  } finally {
    if (state.accountHealthReportQueue.size > 0 && !state.accountHealthReportTimer) {
      state.accountHealthReportTimer = setTimeout(() => {
        state.accountHealthReportTimer = null
        void flushAccountHealthReports()
      }, accountHealthReportDebounceMs)
    }
  }
}

async function mirrorProjectedAccountProfile(accountId: string): Promise<void> {
  const account = state.accounts.find((item) => item.id === accountId) ?? null
  if (!account) {
    return
  }

  const projected = getProjectedAccountHealth({
    accountId: account.id,
    platform: account.platform,
    health: account.health,
    verifiedAt: account.verified_at,
  })
  if (!isDefinitiveAuthState(projected.authState)) {
    return
  }

  const nextDisplayName = projected.profile?.displayName ?? account.display_name
  const nextAvatarUrl = projected.profile?.avatarUrl ?? account.avatar_url
  const shouldMirrorProfile =
    account.display_name !== nextDisplayName || account.avatar_url !== nextAvatarUrl
  if (!shouldMirrorProfile) {
    return
  }

  const normalizedPlatformUid =
    normalizeAccountPlatformUid(account.platform_uid) || account.platform_uid
  const updated = await upsertDesktopAccount({
    platform: account.platform,
    platform_uid: normalizedPlatformUid,
    display_name: nextDisplayName,
    avatar_url: nextAvatarUrl,
    account_fingerprint: account.account_fingerprint ?? normalizedPlatformUid,
    health: account.health,
    verified_at: account.verified_at,
    tags: account.tags,
  })

  state.accounts = state.accounts.map((item) =>
    item.id === account.id
      ? {
          ...updated,
          platform_uid: normalizeAccountPlatformUid(updated.platform_uid) || updated.platform_uid,
          health: account.health,
        }
      : item,
  )
  state.accountProfiles.set(account.id, {
    platformUid: normalizedPlatformUid,
    displayName: nextDisplayName,
    avatarUrl: nextAvatarUrl,
  })
  refreshAccountNames()
}

export async function refreshRuntimeAccounts(): Promise<void> {
  await syncAccounts('manual')
}

export async function requestRuntimeAccountProbe(
  accountId: string,
  options: { account?: PublishAccountIdentity; force?: boolean } = {},
): Promise<void> {
  const existingAccount = state.accounts.find((item) => item.id === accountId) ?? null
  const account =
    options.account ?? (existingAccount ? accountIdentityFromDesktopAccount(existingAccount) : null)
  if (!account) {
    throw new Error('runtime_account_not_found')
  }
  if (existingAccount && !hasLocalAccountAuthorization(existingAccount)) {
    markTrackedAccountMissingPartition(account)
    return
  }

  try {
    await probeTrackedAccount(account, {
      trigger: 'manual',
      allowSilentRefresh: true,
      force: options.force ?? true,
    })
    enqueueAccountHealthReport(account.id)
    await mirrorProjectedAccountProfile(account.id)
  } catch (error) {
    console.warn('[desktop-runtime] account probe failed', {
      accountId: account.id,
      platform: account.platform,
      message: errorMessage(error),
    })
    throw error
  }
}

export function noteRuntimeAccountBound(account: DesktopAccountInfo): void {
  const verifiedAt = new Date().toISOString()
  const normalizedAccount: DesktopAccountInfo = {
    ...account,
    platform_uid: normalizeAccountPlatformUid(account.platform_uid) || account.platform_uid,
    health: 'live',
    verified_at: account.verified_at ?? verifiedAt,
  }
  const existingIndex = state.accounts.findIndex(
    (item) =>
      item.id === normalizedAccount.id ||
      (isAIPlatformId(normalizedAccount.platform) &&
        item.platform === normalizedAccount.platform) ||
      (item.platform === normalizedAccount.platform &&
        sameAccountPlatformUid(item.platform_uid, normalizedAccount.platform_uid)),
  )
  const replacedAccount =
    existingIndex >= 0 && state.accounts[existingIndex].id !== normalizedAccount.id
      ? state.accounts[existingIndex]
      : null

  if (existingIndex >= 0) {
    state.accounts = state.accounts.map((item, index) =>
      index === existingIndex ? normalizedAccount : item,
    )
  } else {
    state.accounts = [normalizedAccount, ...state.accounts]
  }

  state.accountProfiles.set(normalizedAccount.id, {
    platformUid: normalizedAccount.platform_uid,
    displayName: normalizedAccount.display_name,
    avatarUrl: normalizedAccount.avatar_url,
  })
  if (replacedAccount) {
    state.accountProfiles.delete(replacedAccount.id)
    forgetTrackedAccountHealth(replacedAccount.id)
    void clearSessionHandle(replacedAccount.id)
    void deleteDesktopAccount(replacedAccount.id, replacedAccount.sync_version).catch((error) => {
      console.warn('[desktop-runtime] replaced desktop account cleanup failed', {
        accountId: replacedAccount.id,
        platform: replacedAccount.platform,
        platformUid: replacedAccount.platform_uid,
        message: errorMessage(error),
      })
    })
  }
  state.lastAccountsSyncAt = Date.now()
  syncTrackedAccounts(
    state.accounts
      .filter((item) => hasLocalAccountAuthorization(item))
      .map((item) => accountIdentityFromDesktopAccount(item)),
  )
  markTrackedAccountBound(accountIdentityFromDesktopAccount(normalizedAccount), {
    subjectUid: normalizedAccount.platform_uid,
    displayName: normalizedAccount.display_name,
    avatarUrl: normalizedAccount.avatar_url,
  })
  enqueueAccountHealthReport(normalizedAccount.id)
  refreshAccountNames()
}

export async function unbindRuntimeAccount(accountId: string, syncVersion: number): Promise<void> {
  const matchedAccount = state.accounts.find((item) => item.id === accountId) ?? null

  await deleteDesktopAccount(accountId, syncVersion)
  await clearSessionHandle(accountId)
  forgetTrackedAccountHealth(accountId)

  state.accounts = state.accounts.filter((item) => item.id !== accountId)
  state.accountProfiles.delete(accountId)
  refreshAccountNames()

  if (matchedAccount) {
    recordActivity(
      'info',
      '账号已解绑',
      `${matchedAccount.display_name} 已解绑，并清理了当前机器上的本地会话缓存。`,
    )
  }

  await syncAccounts('manual')
}

function enqueuePublishTask(taskId: string, platform: string, routing: RuntimeTaskRouting): void {
  if (!taskId || state.activeExecutions.has(taskId)) {
    return
  }

  enqueuePublishSchedulerTask({ taskId, platform, routing })
  syncSchedulerSurface()
}

function createActiveExecution(
  taskRecord: RuntimeTaskRecord,
  abortController: AbortController,
): ActiveRuntimeExecution {
  const now = Date.now()
  return {
    taskId: taskRecord.id,
    kind: taskRecord.kind,
    platform: taskRecord.platform,
    accountId: taskRecord.accountId,
    abortController,
    executionPhase: taskRecord.kind === 'monitor' ? 'PREPARING' : null,
    interruptRequested:
      taskRecord.kind === 'monitor' && Boolean(taskRecord.payload.interrupt_requested),
    interruptGeneration:
      taskRecord.kind === 'monitor'
        ? toInterruptGeneration(taskRecord.payload.interrupt_generation)
        : 0,
    interruptReason: taskRecord.kind === 'monitor' ? interruptReasonFromTask(taskRecord) : null,
    lastSafePointAt: taskRecord.kind === 'monitor' ? now : null,
    startedAt: now,
    lastProgressAt: now,
    lastProgressSummary: taskRecord.summary,
    deadlineAt: null,
    deadlineHandle: null,
    longRunningNotifiedAt: null,
    submitStartedAt: null,
  }
}

function armPublishTaskDeadline(
  taskRecord: RuntimeTaskRecord,
  active: ActiveRuntimeExecution,
): void {
  if (taskRecord.kind !== 'publish') {
    return
  }

  const taskDeadlineMs = resolvePublishTaskTimeoutMs(taskRecord.platform)
  active.deadlineAt = active.startedAt + taskDeadlineMs
  active.deadlineHandle = setTimeout(() => {
    if (active.abortController.signal.aborted) {
      return
    }

    const timeoutError = new Error('publish_task_timeout')
    recordActivity(
      'warn',
      '任务超时',
      `${taskRecord.title} 执行超过 ${Math.round(taskDeadlineMs / 1000)}s，已中止并释放。`,
    )
    updateTaskProgress(taskRecord.id, `${taskRecord.title} 执行超时，正在释放任务。`)
    active.abortController.abort(timeoutError)
  }, taskDeadlineMs)
}

function resolvePublishTaskTimeoutMs(platform: string): number {
  const envKey = `GEO_DESKTOP_PUBLISH_TIMEOUT_${platform.toUpperCase().replace(/[^A-Z0-9]/g, '_')}_MS`
  return (
    resolvePositiveEnvInteger(envKey) ??
    resolvePositiveEnvInteger('GEO_DESKTOP_PUBLISH_TIMEOUT_MS') ??
    defaultPublishTaskTimeoutMs
  )
}

function resolvePositiveEnvInteger(key: string): number | null {
  const raw = process.env[key]?.trim()
  if (!raw) {
    return null
  }
  const parsed = Number.parseInt(raw, 10)
  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
}

// Stages emitted by an adapter right before it performs an irreversible platform write (creating
// the article/draft). After this point the article may exist on the platform regardless of whether
// the local task records it, so an interrupted publish must not be auto-retried.
function isIrreversiblePublishStage(stage: string): boolean {
  const normalized = stage.trim().toLowerCase()
  return (
    normalized.endsWith('.create_note') ||
    normalized.endsWith('.create_article_id') ||
    normalized.endsWith('.create_draft') ||
    normalized.endsWith('.publish') ||
    normalized.endsWith('.publish_draft') ||
    normalized.endsWith('.save_content') ||
    normalized.endsWith('.submit') ||
    normalized.endsWith('.submit_editor') ||
    normalized.endsWith('.save_draft') ||
    normalized === 'create_note' ||
    normalized === 'create_article_id' ||
    normalized === 'create_draft' ||
    normalized === 'publish' ||
    normalized === 'publish_draft' ||
    normalized === 'save_content' ||
    normalized === 'submit' ||
    normalized === 'submit_editor' ||
    normalized === 'save_draft'
  )
}

// Persist a durable "submit started" marker before the irreversible platform write. The local flag
// is set only after the server confirms the marker, so recovery can trust publish_submit_started_at.
async function markPublishSubmitStartedIfNeeded(taskId: string, stage: string): Promise<void> {
  if (!isIrreversiblePublishStage(stage)) {
    return
  }
  const active = state.activeExecutions.get(taskId)
  if (!active || active.kind !== 'publish' || active.submitStartedAt !== null) {
    return
  }
  const leaseToken = state.tasks.get(taskId)?.leaseToken
  if (!leaseToken) {
    throw new Error('publish_submit_marker_lease_missing')
  }
  await markDesktopTaskPublishSubmitStarted(taskId, leaseToken)

  active.submitStartedAt = Date.now()
  state.activeExecutions.set(taskId, active)
}

function asSubmitUncertainExecution(result: AdapterExecutionResult): AdapterExecutionResult {
  if (result.status !== 'failed') {
    return result
  }
  return {
    ...result,
    status: 'unknown',
    summary: '发布可能已提交到平台，结果待人工确认，已避免自动重复发布。',
    error: {
      ...(result.error ?? {}),
      publish_submit_uncertain: true,
      original_status: 'failed',
      original_summary: result.summary,
    },
  }
}

function pumpExecutionLoop(): void {
  if (!state.running) {
    return
  }

  syncSchedulerSurface()

  if (canStartAnotherPublishExecution()) {
    const selected = selectNextPublishTask({
      maxConcurrency: resolveAdaptiveTotalConcurrency(),
      activePlatforms: activePublishPlatforms(),
      activeCount: activePublishCount(),
    })
    if (selected) {
      void leaseSpecificTask(selected, 'publish')
      return
    }
  }

  if (shouldPullPublishFallback()) {
    void pullNextTask('publish')
    return
  }

  if (hasPublishBacklog()) {
    return
  }

  if (canStartAnotherMonitorExecution()) {
    const selected = selectNextMonitorTask({
      maxConcurrency: resolveAdaptiveMonitorConcurrency(),
      activePlatforms: activeMonitorPlatforms(),
      activeQuestionKeys: activeMonitorQuestionKeys(),
      activeCount: activeMonitorCount(),
    })
    if (selected) {
      void leaseSpecificTask(selected, 'monitor')
      return
    }
  }

  return
}

async function leaseSpecificTask(
  request: PendingTaskRequest,
  expectedKind: 'publish' | 'monitor',
): Promise<void> {
  if (!canRunLive(state.session) || isLeaseInFlight(expectedKind)) {
    return
  }

  state.leaseInFlightKinds.add(expectedKind)

  try {
    if (expectedKind === 'monitor' && request.source === 'monitoring_lease') {
      state.leaseInFlightKinds.delete(expectedKind)
      await executeLeasedMonitoringTask(request.taskId, request.routing)
      return
    }

    const leased = await leaseDesktopTask({ task_id: request.taskId })
    if (!leased.task) {
      if (expectedKind === 'monitor') {
        noteMonitorTaskLeaseMiss(request.taskId)
      } else {
        notePublishTaskLeaseMiss(request.taskId)
      }
      return
    }
    state.leaseInFlightKinds.delete(expectedKind)
    await executeLeasedTask(leased, request.routing)
  } catch (error) {
    if (expectedKind === 'monitor') {
      if (error instanceof ApiClientError && error.code === 40991) {
        noteMonitorTaskCanceled(request.taskId)
        const existing = state.tasks.get(request.taskId)
        if (existing) {
          existing.status = 'aborted'
          existing.leaseToken = null
          existing.summary = '本地缓存的监控任务已不在服务端 queued，已从调度队列移除。'
          existing.updatedAt = Date.now()
          state.tasks.set(request.taskId, existing)
        }
      } else {
        noteMonitorTaskLeaseMiss(request.taskId)
      }
    } else {
      notePublishTaskLeaseMiss(request.taskId)
    }

    state.lastError = errorMessage(error)
    setSchedulerError(state.lastError)
    recordActivity('warn', '指定任务领取失败', `${request.taskId} 未能成功领取：${state.lastError}`)
  } finally {
    if (state.leaseInFlightKinds.has(expectedKind)) {
      state.leaseInFlightKinds.delete(expectedKind)
      syncSchedulerSurface()
      if (localQueueDepth() > 0) {
        pumpExecutionLoop()
      }
    }
  }
}

async function pullNextTask(kind: 'publish' | 'monitor'): Promise<void> {
  if (kind === 'monitor') {
    if (!canRunLive(state.session) || isLeaseInFlight('monitor')) {
      return
    }

    state.leaseInFlightKinds.add('monitor')
    try {
      const leased = await leaseDesktopTask({ kind: 'monitor' })
      state.lastPullAt = Date.now()
      state.lastPullStatus = 'success'
      noteTransportPull(true)
      noteSchedulerPull()

      if (leased.task) {
        state.leaseInFlightKinds.delete('monitor')
        await executeLeasedTask(leased, 'rabbitmq-primary')
        return
      }
    } catch (error) {
      state.lastPullAt = Date.now()
      state.lastPullStatus = 'failed'
      state.lastError = errorMessage(error)
      noteTransportPull(false)
      setSchedulerError(state.lastError)
    } finally {
      state.leaseInFlightKinds.delete('monitor')
      syncSchedulerSurface()
    }

    await pullMonitoringTasks('db-recovery')
    return
  }

  if (!canRunLive(state.session) || isLeaseInFlight('publish')) {
    return
  }

  let leasedPublishTask = false
  state.leaseInFlightKinds.add('publish')

  try {
    const leased = await leaseDesktopTask({ kind })
    state.lastPullAt = Date.now()
    state.lastPullStatus = 'success'
    noteTransportPull(true)
    noteSchedulerPull()

    if (!leased.task) {
      state.publishFallbackBackoffUntil = Date.now() + pullIntervalMs
      return
    }

    state.publishFallbackBackoffUntil = 0
    leasedPublishTask = true
    state.leaseInFlightKinds.delete('publish')
    await executeLeasedTask(leased, 'db-recovery')
  } catch (error) {
    state.lastPullAt = Date.now()
    state.lastPullStatus = 'failed'
    state.lastError = errorMessage(error)
    state.publishFallbackBackoffUntil = Date.now() + pullIntervalMs

    noteTransportPull(false)
    setSchedulerError(state.lastError)

    recordActivity('warn', '兜底拉取失败', state.lastError)
  } finally {
    state.leaseInFlightKinds.delete('publish')
    syncSchedulerSurface()
    if (!leasedPublishTask && state.running) {
      queueMicrotask(() => pumpExecutionLoop())
    }
  }
}

async function pullMonitoringTasks(routing: RuntimeTaskRouting): Promise<void> {
  const leaseLimit = resolveLegacyMonitoringLeaseLimit()
  if (!canRunLive(state.session) || isLeaseInFlight('monitor') || leaseLimit <= 0) {
    return
  }

  state.leaseInFlightKinds.add('monitor')

  try {
    const leased = await leaseMonitoringTasks({
      limit: leaseLimit,
    })
    state.lastPullAt = Date.now()
    state.lastPullStatus = 'success'
    noteTransportPull(true)
    noteSchedulerPull()

    enqueueLeasedMonitoringTasks(leased.tasks, routing)
  } catch (error) {
    state.lastPullAt = Date.now()
    state.lastPullStatus = 'failed'
    state.lastError = errorMessage(error)
    noteTransportPull(false)
    setSchedulerError(state.lastError)

    recordActivity('warn', '监控任务拉取失败', state.lastError)
  } finally {
    state.leaseInFlightKinds.delete('monitor')
    syncSchedulerSurface()
  }
}

async function resumeLeasedMonitoringTasks(source: 'startup' | 'reconnect'): Promise<void> {
  if (!canRunLive(state.session)) {
    return
  }

  try {
    const resumed = await resumeMonitoringTasks({})
    enqueueLeasedMonitoringTasks(resumed.tasks, 'db-recovery')
    if (resumed.tasks.length > 0) {
      recordActivity(
        'info',
        '已恢复监控租约',
        `从服务端恢复了 ${resumed.tasks.length} 条未完成监控任务（${source}）。`,
      )
    }
    void pullNextTask('monitor')
  } catch (error) {
    recordActivity('warn', '恢复监控租约失败', errorMessage(error))
  }
}

function enqueueLeasedMonitoringTasks(
  tasks: MonitoringLeaseTask[],
  routing: RuntimeTaskRouting,
): void {
  if (tasks.length === 0) {
    return
  }

  for (const task of tasks) {
    const taskId = String(task.task_id)
    const accountId = resolveMonitoringAccountID(task.ai_platform_id)
    const now = Date.now()
    state.tasks.set(taskId, {
      id: taskId,
      jobId: taskId,
      title: buildMonitoringTaskTitle(task),
      kind: 'monitor',
      platform: task.ai_platform_id,
      accountId,
      accountName: accountId
        ? resolveAccountName(accountId, task.platform_name)
        : task.platform_name,
      clientId: state.client?.id ?? taskId,
      status: 'queued',
      routing,
      leaseExpiresAt: parseTimestamp(task.lease_expires_at),
      startedAt: null,
      updatedAt: now,
      summary: `已领取监控租约，等待本地调度执行（${describeRouting(routing)}）。`,
      payload: {
        title: buildMonitoringTaskTitle(task),
        question_id: task.question_id,
        question_hash: task.question_hash,
        question_text: task.question_text,
        ai_platform_id: task.ai_platform_id,
        platform_name: task.platform_name,
        collector_type: task.collector_type,
        run_mode: task.run_mode,
        trigger_source: task.trigger_source,
        business_date: task.business_date,
        priority: typeof task.priority === 'number' ? task.priority : null,
        lane: typeof task.lane === 'string' ? task.lane : null,
        monitoring_task_id: task.task_id,
        lease_token: task.lease_token,
        lease_expires_at: task.lease_expires_at,
        scheduler_group_key: task.question_hash || `qid:${task.question_id}`,
        legacy_monitoring_task: true,
      },
      error: null,
      result: null,
      attemptId: null,
      leaseToken: task.lease_token,
    })
    enqueueMonitorLeaseTask({
      taskId,
      jobId: taskId,
      accountId,
      clientId: state.client?.id ?? taskId,
      platform: task.ai_platform_id,
      routing,
      priority:
        typeof task.priority === 'number'
          ? task.priority
          : task.trigger_source === 'manual'
            ? 5000
            : 100,
      lane:
        typeof task.lane === 'string'
          ? task.lane
          : task.trigger_source === 'manual'
            ? 'high'
            : 'normal',
      title: buildMonitoringTaskTitle(task),
      businessDate: task.business_date,
      questionKey: task.question_hash || `qid:${task.question_id}`,
      questionText: task.question_text,
    })
  }

  syncSchedulerSurface()
  pumpExecutionLoop()
}

async function executeLeasedMonitoringTask(
  taskId: string,
  _routing: RuntimeTaskRouting,
): Promise<void> {
  const taskRecord = state.tasks.get(taskId)
  if (!taskRecord || taskRecord.kind !== 'monitor' || !taskRecord.leaseToken) {
    noteMonitorTaskLeaseMiss(taskId)
    return
  }

  const monitoringTaskID = Number.parseInt(taskId, 10)
  if (!Number.isFinite(monitoringTaskID)) {
    noteMonitorTaskCanceled(taskId)
    state.tasks.delete(taskId)
    return
  }

  setSchedulerPhase('running')
  setActiveLease({
    taskId,
    attemptId: null,
    leaseExpiresAt: isoFromTimestamp(taskRecord.leaseExpiresAt),
  })

  recordActivity('info', '监控任务开始执行', `${taskRecord.title} 已进入本地执行队列。`)

  const abortController = new AbortController()
  state.activeExecutions.set(taskRecord.id, createActiveExecution(taskRecord, abortController))
  noteMonitorTaskActivated(taskId)
  syncSchedulerSurface()
  queueMicrotask(() => pumpExecutionLoop())

  try {
    const execution =
      (await resolveAuthorizationPreflightBlock(taskRecord)) ??
      withAuthorizationRetryPolicy(
        taskRecord,
        await executeTaskAdapter(taskRecord, abortController.signal),
      )
    if (execution.status === 'unknown') {
      const skipReason = monitoringSkipReasonFromExecution(execution)
      await skipMonitoringTask(monitoringTaskID, {
        lease_token: taskRecord.leaseToken,
        skip_reason: skipReason,
        error_message: execution.summary,
        completed_at: new Date().toISOString(),
      })
      const existing = state.tasks.get(taskId)
      if (existing) {
        existing.status = 'aborted'
        existing.summary = execution.summary
        existing.error = execution.error ?? null
        existing.updatedAt = Date.now()
        existing.leaseToken = null
        state.tasks.set(taskId, existing)
      }
      noteLeaseReleased('completed', taskId)
      noteMonitorTaskCompleted(taskId)
      recordActivity(
        skipReason === 'stale_business_date' ? 'info' : 'warn',
        skipReason === 'stale_business_date' ? '监控任务已按跨日策略丢弃' : '监控任务结果待确认',
        `${taskRecord.title} ${execution.summary}`,
      )
      return
    }

    await submitMonitoringTaskResult(
      monitoringTaskID,
      buildMonitoringResultPayload(taskRecord.leaseToken, execution),
    )
    const existing = state.tasks.get(taskId)
    if (existing) {
      existing.status = execution.status
      existing.summary = execution.summary
      existing.result = execution.payload ?? null
      existing.error = execution.error ?? null
      existing.updatedAt = Date.now()
      existing.leaseToken = null
      state.tasks.set(taskId, existing)
    }
    noteLeaseReleased(execution.status === 'failed' ? 'failed' : 'completed', taskId)
    noteMonitorTaskCompleted(taskId)
    recordActivity(
      execution.status === 'failed' ? 'danger' : 'success',
      execution.status === 'failed' ? '监控任务执行失败' : '监控任务执行成功',
      `${taskRecord.title} ${execution.summary}`,
    )
  } catch (error) {
    if (isMonitorAbortReason(taskRecord, error, 'stale_business_date')) {
      let dropSummary = staleMonitoringDropSummary(taskRecord)
      try {
        await skipMonitoringTask(monitoringTaskID, {
          lease_token: taskRecord.leaseToken,
          skip_reason: 'stale_business_date',
          error_message: dropSummary,
          completed_at: new Date().toISOString(),
        })
      } catch (skipError) {
        dropSummary = `${dropSummary}（skip 回写失败：${errorMessage(skipError)}）`
      }

      const existing = state.tasks.get(taskId)
      if (existing) {
        existing.status = 'aborted'
        existing.summary = dropSummary
        existing.error = {
          ...toStructuredError(error),
          dropped_reason: 'stale_business_date',
        }
        existing.updatedAt = Date.now()
        existing.leaseToken = null
        state.tasks.set(taskId, existing)
      }
      noteLeaseReleased('completed', taskId)
      noteMonitorTaskCompleted(taskId)
      recordActivity('info', '监控任务已按跨日策略丢弃', dropSummary)
      return
    }

    const message = errorMessage(error)
    const existing = state.tasks.get(taskId)
    if (existing) {
      existing.status = 'failed'
      existing.summary = message
      existing.error = toStructuredError(error)
      existing.updatedAt = Date.now()
      existing.leaseToken = null
      state.tasks.set(taskId, existing)
    }
    noteLeaseReleased('failed', taskId)
    noteMonitorTaskCompleted(taskId)
    recordActivity('danger', '监控任务执行失败', `${taskRecord.title} 执行失败：${message}`)
  } finally {
    state.activeExecutions.delete(taskId)
    syncSchedulerSurface()
    noteSchedulerTaskFinished()
    pumpExecutionLoop()
  }
}

function buildMonitoringTaskTitle(task: MonitoringLeaseTask): string {
  const base = task.question_text.trim()
  if (!base) {
    return `监控任务 · ${task.platform_name}`
  }
  return `${task.platform_name} · ${base}`
}

function resolveMonitoringAccountID(platform: string): string {
  const live = state.accounts.find(
    (account) =>
      account.platform === platform &&
      getProjectedAccountHealth({
        accountId: account.id,
        platform: account.platform,
        health: account.health,
        verifiedAt: account.verified_at,
      }).health === 'live',
  )
  if (live) {
    return live.id
  }
  return state.accounts.find((account) => account.platform === platform)?.id ?? ''
}

function buildMonitoringResultPayload(
  leaseToken: string,
  execution: AdapterExecutionResult,
): MonitoringTaskResultPayload {
  const payload = execution.payload ?? {}
  const status = execution.status === 'succeeded' ? 'succeeded' : 'failed'
  const rawResponseJSON = asRecord(payload.raw_response_json)
  const failedRawResponseJSON =
    status === 'failed' && execution.error
      ? {
          ...rawResponseJSON,
          runtime_error: execution.error,
        }
      : rawResponseJSON
  return {
    lease_token: leaseToken,
    status,
    provider_model: asOptionalString(payload.provider_model),
    provider_request_id: asOptionalString(payload.provider_request_id),
    request_id: asOptionalString(payload.request_id),
    answer: asOptionalString(payload.answer),
    raw_response_json: failedRawResponseJSON,
    citations: asSourceItems(payload.citations),
    search_results: asSourceItems(payload.search_results),
    brand_mentioned: asOptionalBoolean(payload.brand_mentioned),
    brand_mention_position: asOptionalString(payload.brand_mention_position),
    first_recommended: asOptionalBoolean(payload.first_recommended),
    sentiment_label: asOptionalString(payload.sentiment_label),
    matched_brand_terms: asStringArray(payload.matched_brand_terms),
    error_message: status === 'failed' ? execution.summary : undefined,
    completed_at: new Date().toISOString(),
  }
}

function buildMonitoringFailurePayload(
  leaseToken: string,
  failureMessage: string,
  structuredError: Record<string, JsonValue>,
  task?: RuntimeTaskRecord,
): MonitoringTaskResultPayload {
  const runtimeError = task
    ? (withAuthorizationRetryPolicy(task, {
        status: 'failed',
        summary: failureMessage,
        error: structuredError,
      }).error ?? structuredError)
    : structuredError
  return {
    lease_token: leaseToken,
    status: 'failed',
    raw_response_json: {
      runtime_error: runtimeError,
    },
    error_message: failureMessage,
    completed_at: new Date().toISOString(),
  }
}

async function executeLeasedDesktopMonitorTask(
  taskRecord: RuntimeTaskRecord,
  leased: LeaseDesktopTaskResponse,
  routing: RuntimeTaskRouting,
  signal: AbortSignal,
): Promise<void> {
  const monitoringTaskID = extractMonitoringTaskID(taskRecord.payload)
  if (!monitoringTaskID) {
    const missingMessage = 'monitor desktop task is missing monitoring_task_id'
    const completed = await completeDesktopTask(taskRecord.id, {
      lease_token: leased.lease_token as string,
      status: 'failed',
      error: {
        code: 'monitoring_task_id_missing',
        message: missingMessage,
      },
    })
    upsertTaskFromInfo(completed, {
      routing,
      summary: missingMessage,
      attemptId: null,
      leaseToken: null,
    })
    noteLeaseReleased('failed', taskRecord.id)
    noteMonitorTaskCompleted(taskRecord.id)
    recordActivity(
      'danger',
      '监控任务执行失败',
      `${taskRecord.title} 缺少 monitoring_task_id，无法回写结果。`,
    )
    return
  }

  try {
    const execution =
      (await resolveAuthorizationPreflightBlock(taskRecord)) ??
      withAuthorizationRetryPolicy(taskRecord, await executeTaskAdapter(taskRecord, signal))
    if (execution.status === 'unknown') {
      const skipReason = monitoringSkipReasonFromExecution(execution)
      await skipMonitoringTask(monitoringTaskID, {
        lease_token: leased.lease_token as string,
        skip_reason: skipReason,
        error_message: execution.summary,
        completed_at: new Date().toISOString(),
      })
      if (skipReason === 'stale_business_date') {
        const canceled = await cancelDesktopTask(taskRecord.id, {
          lease_token: leased.lease_token as string,
          reason: skipReason,
        }).catch((cancelError) => {
          const existing = state.tasks.get(taskRecord.id)
          if (existing) {
            existing.status = 'aborted'
            existing.error = {
              ...(execution.error ?? {}),
              cancel_error: errorMessage(cancelError),
              dropped_reason: 'stale_business_date',
            }
            existing.summary = `${execution.summary}（desktop task 取消失败：${errorMessage(cancelError)}）`
            existing.updatedAt = Date.now()
            existing.leaseToken = null
            state.tasks.set(taskRecord.id, existing)
          }
          return null
        })
        if (canceled) {
          upsertTaskFromInfo(canceled, {
            routing,
            summary: execution.summary,
            attemptId: null,
            leaseToken: null,
          })
        }
        noteLeaseReleased('completed', taskRecord.id)
        noteMonitorTaskCompleted(taskRecord.id)
        recordActivity(
          'info',
          '监控任务已按跨日策略丢弃',
          `${taskRecord.title} ${execution.summary}`,
        )
        return
      }
      const completed = await completeDesktopTask(taskRecord.id, {
        lease_token: leased.lease_token as string,
        status: 'unknown',
        error: execution.error ?? {
          code: 'runtime_unknown',
          message: execution.summary,
        },
      })
      upsertTaskFromInfo(completed, {
        routing,
        summary: execution.summary,
        attemptId: null,
        leaseToken: null,
      })
      noteLeaseReleased('completed', taskRecord.id)
      noteMonitorTaskCompleted(taskRecord.id)
      recordActivity('warn', '监控任务结果待确认', `${taskRecord.title} ${execution.summary}`)
      return
    }

    await submitMonitoringTaskResult(
      monitoringTaskID,
      buildMonitoringResultPayload(leased.lease_token as string, execution),
    )

    const existing = state.tasks.get(taskRecord.id)
    if (existing) {
      existing.status = execution.status
      existing.summary = execution.summary
      existing.result = execution.payload ?? null
      existing.error = execution.error ?? null
      existing.updatedAt = Date.now()
      existing.attemptId = null
      existing.leaseToken = null
      state.tasks.set(taskRecord.id, existing)
    }
    noteLeaseReleased(execution.status === 'failed' ? 'failed' : 'completed', taskRecord.id)
    noteMonitorTaskCompleted(taskRecord.id)
    recordActivity(
      execution.status === 'failed' ? 'danger' : 'success',
      execution.status === 'failed' ? '监控任务执行失败' : '监控任务执行成功',
      `${taskRecord.title} ${execution.summary}`,
    )
  } catch (error) {
    if (isMonitorAbortReason(taskRecord, error, 'stale_business_date')) {
      let dropSummary = staleMonitoringDropSummary(taskRecord)
      try {
        await skipMonitoringTask(monitoringTaskID, {
          lease_token: leased.lease_token as string,
          skip_reason: 'stale_business_date',
          error_message: dropSummary,
          completed_at: new Date().toISOString(),
        })
      } catch (skipError) {
        dropSummary = `${dropSummary}（monitoring skip 回写失败：${errorMessage(skipError)}）`
      }

      const canceled = await cancelDesktopTask(taskRecord.id, {
        lease_token: leased.lease_token as string,
        reason: 'stale_business_date',
      }).catch((cancelError) => {
        const existing = state.tasks.get(taskRecord.id)
        if (existing) {
          existing.status = 'aborted'
          existing.error = {
            ...toStructuredError(error),
            cancel_error: errorMessage(cancelError),
            dropped_reason: 'stale_business_date',
          }
          existing.summary = `${dropSummary}（desktop task 取消失败：${errorMessage(cancelError)}）`
          existing.updatedAt = Date.now()
          existing.leaseToken = null
          state.tasks.set(taskRecord.id, existing)
        }
        return null
      })

      if (canceled) {
        upsertTaskFromInfo(canceled, {
          routing,
          summary: dropSummary,
          attemptId: null,
          leaseToken: null,
        })
      }
      noteLeaseReleased('completed', taskRecord.id)
      noteMonitorTaskCompleted(taskRecord.id)
      recordActivity('info', '监控任务已按跨日策略丢弃', dropSummary)
      return
    }

    if (isDesktopTaskMonitorInterrupt(taskRecord, error)) {
      const canceled = await cancelDesktopTask(taskRecord.id, {
        lease_token: leased.lease_token as string,
        reason: interruptReasonFromTask(taskRecord),
      })
      upsertTaskFromInfo(canceled, {
        routing,
        summary: '已响应 Phase 2 抢占请求，当前监控任务已回队等待 retry。',
        attemptId: null,
        leaseToken: null,
      })
      noteLeaseReleased('completed', taskRecord.id)
      noteMonitorTaskCompleted(taskRecord.id)
      recordActivity('warn', '监控任务已让路', `${taskRecord.title} 已安全中止，并回队为 retry。`)
      return
    }

    const failureMessage = errorMessage(error)
    const structuredError = toStructuredError(error)
    let monitoringResultWriteError: unknown = null

    try {
      await submitMonitoringTaskResult(
        monitoringTaskID,
        buildMonitoringFailurePayload(
          leased.lease_token as string,
          failureMessage || '监控任务执行失败。',
          structuredError,
          taskRecord,
        ),
      )
    } catch (submitError) {
      monitoringResultWriteError = submitError
    }

    const failureSummary = monitoringResultWriteError
      ? `${failureMessage || '监控任务执行失败。'}（monitoring 失败回传失败：${errorMessage(monitoringResultWriteError)}）`
      : failureMessage || '监控任务执行失败。'
    const existing = state.tasks.get(taskRecord.id)
    if (existing) {
      existing.status = 'failed'
      existing.error = structuredError
      existing.summary = failureSummary
      existing.updatedAt = Date.now()
      existing.attemptId = null
      existing.leaseToken = null
      state.tasks.set(taskRecord.id, existing)
    }
    noteLeaseReleased('failed', taskRecord.id)
    noteMonitorTaskCompleted(taskRecord.id)
    recordActivity(
      'danger',
      '监控任务执行失败',
      `${taskRecord.title} 执行失败：${failureSummary || '未知错误'}`,
    )
  }
}

function extractMonitoringTaskID(payload: Record<string, JsonValue>): number | null {
  const raw = payload.monitoring_task_id
  if (typeof raw === 'number' && Number.isFinite(raw)) {
    return raw
  }
  if (typeof raw === 'string' && raw.trim()) {
    const parsed = Number.parseInt(raw.trim(), 10)
    if (Number.isFinite(parsed)) {
      return parsed
    }
  }
  return null
}

function noteMonitorExecutionSafePoint(taskId: string, phase: MonitorExecutionPhase | null): void {
  const active = state.activeExecutions.get(taskId)
  if (!active || active.kind !== 'monitor') {
    return
  }

  if (phase) {
    active.executionPhase = phase
  }
  active.lastSafePointAt = Date.now()
  active.lastProgressAt = Date.now()
  state.activeExecutions.set(taskId, active)

  const taskRecord = state.tasks.get(taskId)
  if (taskRecord?.kind === 'monitor') {
    const staleBusinessDate = resolveStaleMonitoringBusinessDate(taskRecord.payload)
    if (staleBusinessDate) {
      requestMonitorStaleBusinessDateDrop(taskId, staleBusinessDate)
      return
    }
  }

  if (active.interruptRequested && !active.abortController.signal.aborted) {
    active.abortController.abort()
  }
}

function requestMonitorStaleBusinessDateDrop(taskId: string, staleBusinessDate: string): void {
  const active = state.activeExecutions.get(taskId)
  if (!active || active.kind !== 'monitor') {
    return
  }

  active.interruptReason = 'stale_business_date'
  active.lastSafePointAt = Date.now()
  active.lastProgressAt = Date.now()
  state.activeExecutions.set(taskId, active)

  const existing = state.tasks.get(taskId)
  if (existing) {
    existing.payload = {
      ...existing.payload,
      interrupt_reason: 'stale_business_date',
      dropped_reason: 'stale_business_date',
    }
    existing.summary = staleMonitoringDropSummary(existing, staleBusinessDate)
    existing.updatedAt = Date.now()
    state.tasks.set(taskId, existing)
  }

  if (!active.abortController.signal.aborted) {
    active.abortController.abort()
  }
}

function monitorExecutionPhaseFromStage(stage: string): MonitorExecutionPhase {
  const normalized = stage.trim().toLowerCase()
  if (!normalized) {
    return 'WAITING'
  }
  if (normalized.includes('bootstrap') || normalized.includes('page_ready')) {
    return 'NAVIGATING'
  }
  if (normalized.includes('login') || normalized.includes('runtime_state')) {
    return 'AUTHENTICATING'
  }
  if (normalized.includes('input')) {
    return 'INPUTTING'
  }
  if (normalized.includes('query') || normalized.includes('submit')) {
    return 'SUBMITTING'
  }
  if (normalized.includes('parse')) {
    return 'PARSING'
  }
  return 'WAITING'
}

function isDesktopTaskMonitorInterrupt(taskRecord: RuntimeTaskRecord, error: unknown): boolean {
  return (
    isDesktopTaskID(taskRecord.id) && isMonitorAbortReason(taskRecord, error, 'collect_now_preempt')
  )
}

function isMonitorAbortReason(
  taskRecord: RuntimeTaskRecord,
  error: unknown,
  reason: string,
): boolean {
  return (
    errorMessage(error).includes('adapter_aborted') && monitorAbortReason(taskRecord) === reason
  )
}

function monitorAbortReason(taskRecord: RuntimeTaskRecord): string | null {
  const active = state.activeExecutions.get(taskRecord.id)
  if (active?.interruptReason?.trim()) {
    return active.interruptReason.trim()
  }

  const raw = taskRecord.payload.interrupt_reason
  if (typeof raw === 'string' && raw.trim()) {
    return raw.trim()
  }

  if (Boolean(taskRecord.payload.interrupt_requested) || Boolean(active?.interruptRequested)) {
    return 'collect_now_preempt'
  }
  return null
}

function interruptReasonFromTask(taskRecord: RuntimeTaskRecord): string {
  return monitorAbortReason(taskRecord) ?? 'collect_now_preempt'
}

function isDesktopTaskID(taskId: string): boolean {
  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
    taskId.trim(),
  )
}

async function executeLeasedTask(
  leased: LeaseDesktopTaskResponse,
  routing: RuntimeTaskRouting,
): Promise<void> {
  if (!leased.task || !leased.lease_token) {
    return
  }

  const task = leased.task

  setSchedulerPhase('running')

  setActiveLease({
    taskId: task.id,
    attemptId: leased.attempt_id ?? null,
    leaseExpiresAt: leased.lease_expires_at ?? task.lease_expires_at ?? null,
  })

  const taskRecord = upsertTaskFromInfo(task, {
    routing,
    attemptId: leased.attempt_id ?? null,
    leaseToken: leased.lease_token,
    summary: `已领取租约，开始执行 ${routing === 'rabbitmq-primary' ? 'MQ 唤醒' : '兜底拉取'} 消费。`,
  })

  recordActivity(
    'info',
    '任务已领取',
    `${taskRecord.title} 已由当前客户端领取，路由：${describeRouting(routing)}。`,
  )

  const abortController = new AbortController()
  const activeExecution = createActiveExecution(taskRecord, abortController)
  armPublishTaskDeadline(taskRecord, activeExecution)
  state.activeExecutions.set(taskRecord.id, activeExecution)

  if (task.kind === 'monitor') {
    noteMonitorTaskLeased(task, routing)
  } else {
    notePublishTaskActivated(taskRecord.id, taskRecord.platform)
    emitRuntimeInvalidated('publish-task-lease', { taskId: taskRecord.id })
  }
  syncSchedulerSurface()
  queueMicrotask(() => pumpExecutionLoop())

  const extendHandle = setInterval(() => {
    void extendActiveLease(taskRecord.id, leased.lease_token as string)
  }, leaseExtendIntervalMs)

  try {
    if (task.kind === 'monitor') {
      await executeLeasedDesktopMonitorTask(taskRecord, leased, routing, abortController.signal)
      return
    }

    const execution =
      (await resolveAuthorizationPreflightBlock(taskRecord)) ??
      withAuthorizationRetryPolicy(
        taskRecord,
        await executeTaskAdapter(taskRecord, abortController.signal),
      )
    const completed = await completeDesktopTask(taskRecord.id, {
      lease_token: leased.lease_token,
      status: execution.status,
      payload: execution.payload,
      error: execution.error,
    })

    noteLeaseReleased(execution.status === 'failed' ? 'failed' : 'completed', taskRecord.id)
    upsertTaskFromInfo(completed, {
      routing,
      summary: execution.summary,
      attemptId: null,
      leaseToken: null,
    })

    recordActivity(
      execution.status === 'failed'
        ? 'danger'
        : execution.status === 'unknown'
          ? 'warn'
          : 'success',
      execution.status === 'failed'
        ? '任务执行失败'
        : execution.status === 'unknown'
          ? '任务执行结果待确认'
          : '任务执行成功',
      `${taskRecord.title} ${execution.summary}`,
    )
  } catch (error) {
    const failureMessage = errorMessage(error)
    const structuredError = toStructuredError(error)
    const accountIdentity = accountIdentityFromTask(taskRecord)

    // If a publish task was interrupted AFTER it may have entered the irreversible submit phase,
    // the article might already be live on the platform. Completing as a clean 'failed' would drop
    // it from the server dedup set and let a retry double-post. Complete as 'unknown' instead so it
    // stays for manual reconcile. (A pre-submit interruption is a true failure and stays 'failed'.)
    const submitMaybeStarted =
      taskRecord.kind === 'publish' && activeExecution.submitStartedAt !== null
    const terminalStatus: 'failed' | 'unknown' = submitMaybeStarted ? 'unknown' : 'failed'
    const interruptedSummary = '发布可能已提交到平台，结果待人工确认，已避免自动重复发布。'
    // Tag the persisted error so the desktop UI can require explicit confirmation before a manual
    // retry of a possibly-already-published task (mirrors the server recovery payload marker).
    const terminalError = submitMaybeStarted
      ? { ...structuredError, publish_submit_uncertain: true }
      : structuredError

    // A submit-phase interruption is typically a network/timeout stall, not an auth problem — don't
    // wrongly degrade account health for it.
    if (accountIdentity && !submitMaybeStarted) {
      await reportAccountFailure(accountIdentity, {
        summary: failureMessage,
        error: structuredError,
      }).catch((reportError) => {
        console.warn('[desktop-runtime] thrown failure report failed', {
          taskId: taskRecord.id,
          accountId: accountIdentity.id,
          platform: accountIdentity.platform,
          message: reportError instanceof Error ? reportError.message : String(reportError),
        })
      })
    }

    try {
      const completed = await completeDesktopTask(taskRecord.id, {
        lease_token: leased.lease_token,
        status: terminalStatus,
        error: terminalError,
      })

      upsertTaskFromInfo(completed, {
        routing,
        summary: submitMaybeStarted ? interruptedSummary : failureMessage || '桌面任务执行失败。',
        attemptId: null,
        leaseToken: null,
      })
    } catch (completeError) {
      const existing = state.tasks.get(taskRecord.id)
      if (existing) {
        existing.status = terminalStatus
        existing.error = terminalError
        existing.summary = submitMaybeStarted
          ? `${interruptedSummary}（result 回写失败：${errorMessage(completeError)}）`
          : `${failureMessage || '桌面任务执行失败。'}（result 回写失败：${errorMessage(completeError)}）`
        existing.updatedAt = Date.now()
        state.tasks.set(taskRecord.id, existing)
      }
    }

    noteLeaseReleased('failed', taskRecord.id)
    recordActivity(
      submitMaybeStarted ? 'warn' : 'danger',
      submitMaybeStarted ? '发布结果待确认' : '任务执行失败',
      submitMaybeStarted
        ? `${taskRecord.title} 进入提交阶段后中断，可能已发布，已转人工确认以避免重复发文。`
        : `${taskRecord.title} 执行失败：${failureMessage || '未知错误'}`,
    )
  } finally {
    clearInterval(extendHandle)
    if (activeExecution.deadlineHandle) {
      clearTimeout(activeExecution.deadlineHandle)
      activeExecution.deadlineHandle = null
    }
    if (taskRecord.kind === 'publish') {
      notePublishTaskCompleted(taskRecord.id, taskRecord.platform)
    }
    state.activeExecutions.delete(taskRecord.id)
    syncSchedulerSurface()
    noteSchedulerTaskFinished()
    pumpExecutionLoop()
  }
}

async function extendActiveLease(taskId: string, leaseToken: string): Promise<void> {
  const existing = state.tasks.get(taskId)
  const active = state.activeExecutions.get(taskId)
  if (existing?.kind === 'monitor') {
    const staleBusinessDate = resolveStaleMonitoringBusinessDate(existing.payload)
    if (staleBusinessDate) {
      requestMonitorStaleBusinessDateDrop(taskId, staleBusinessDate)
      return
    }
  }
  if (existing?.kind === 'publish' && active) {
    const idleMs = Date.now() - active.lastProgressAt
    if (idleMs >= publishTaskStaleProgressMs) {
      const detail = active.lastProgressSummary ? `，最后进度：${active.lastProgressSummary}` : ''
      existing.summary = `发布任务超过 ${Math.round(idleMs / 1000)} 秒没有新进度，已中止并释放，准备由服务端重排${detail}。`
      existing.updatedAt = Date.now()
      state.tasks.set(taskId, existing)
      recordActivity('warn', '发布任务疑似卡住', `${existing.title} ${existing.summary}`)
      // Abort the local execution instead of merely letting the lease lapse: this
      // releases the slot immediately and, crucially, closes the window where the
      // server could re-queue the task while a stalled adapter is still mid-publish
      // (which would double-post a non-idempotent article).
      if (!active.abortController.signal.aborted) {
        active.abortController.abort(new Error('publish_stale_progress'))
      }
      return
    }
  }

  try {
    const task = await extendDesktopTask(taskId, { lease_token: leaseToken })

    noteLeaseExtended(task.lease_expires_at ?? null, taskId)

    const existing = state.tasks.get(taskId)
    if (existing) {
      existing.leaseExpiresAt = parseTimestamp(task.lease_expires_at) ?? existing.leaseExpiresAt
      existing.updatedAt = Date.now()
      existing.summary =
        existing.kind === 'publish'
          ? (active?.lastProgressSummary ?? '租约已自动续期，发布任务仍在执行。')
          : '租约已自动续期，任务仍在执行。'
      state.tasks.set(taskId, existing)
    }
  } catch (error) {
    const message = errorMessage(error)
    state.lastError = message
    setSchedulerError(message)
    recordActivity('warn', '租约续期失败', `${taskId} 续租失败：${message}`)
  }
}

async function executeTaskAdapter(
  task: RuntimeTaskRecord,
  signal: AbortSignal,
): Promise<AdapterExecutionResult> {
  const accountIdentity = accountIdentityFromTask(task)
  if (accountIdentity && shouldEnforceActiveAccount(task)) {
    const readiness = await ensureAccountReady(accountIdentity)
    if (readiness.authState !== 'active') {
      return buildAccountBlockedResult(task, readiness)
    }
  }

  const sessionHandle = createSessionHandle(task.accountId || task.id)
  const payload = task.payload

  if (task.kind === 'publish') {
    const adapter = selectPublishAdapter(task.platform)
    if (!adapter) {
      return buildScaffoldResult(task, payload, 'publish adapter is not implemented yet')
    }

    const viewHandle =
      adapter.executionMode === 'session' || adapter.executionMode === 'playwright'
        ? null
        : retainHotView(task.accountId || task.id)
    const playwrightLease =
      adapter.executionMode === 'playwright'
        ? await retainHiddenPlaywrightPage({
            accountId: task.accountId || task.id,
            session: sessionHandle.session,
            targetURL: resolvePlaywrightTargetURL(task.platform, payload),
            title: `${task.title} · Hidden Playwright`,
          })
        : null

    try {
      const result = await adapter.publish(
        {
          taskId: task.id,
          accountId: task.accountId || task.id,
          session: sessionHandle.session,
          view: viewHandle?.view ?? null,
          playwright: playwrightLease
            ? {
                browser: playwrightLease.browser,
                page: playwrightLease.page,
              }
            : null,
          signal,
          phase: 'initial',
          article: await loadPublishArticle(task),
          async reportProgress(stage: string) {
            noteMonitorExecutionSafePoint(task.id, null)
            updateTaskProgress(task.id, `publish adapter progress: ${stage}`)
            await markPublishSubmitStartedIfNeeded(task.id, stage)
          },
        },
        payload,
      )
      const active = state.activeExecutions.get(task.id)
      const normalizedResult =
        active?.submitStartedAt != null ? asSubmitUncertainExecution(result) : result
      await maybeReportTaskAuthFailure(task, normalizedResult, accountIdentity)
      return normalizedResult
    } finally {
      await playwrightLease?.release()
      if (viewHandle) {
        releaseHotView(viewHandle.accountId)
      }
    }
  }

  const staleBusinessDate = resolveStaleMonitoringBusinessDate(payload)
  if (staleBusinessDate) {
    return {
      status: 'unknown',
      payload: {
        ...payload,
        dropped_by_client: true,
        dropped_reason: 'stale_business_date',
      },
      error: {
        code: 'desktop_monitor_task_stale',
        message: 'monitor task is stale and has been dropped by desktop client',
        business_date: staleBusinessDate,
      },
      summary: `${task.title} 已过业务日 ${staleBusinessDate}，按漏采策略直接丢弃。`,
    }
  }

  const adapter = selectMonitorAdapter(task.platform)
  if (!adapter) {
    return buildScaffoldResult(task, payload, 'monitor adapter is not implemented yet')
  }

  const viewHandle =
    adapter.executionMode === 'session' || adapter.executionMode === 'playwright'
      ? null
      : retainHotView(task.accountId || task.id)
  const playwrightLease =
    adapter.executionMode === 'playwright'
      ? await retainHiddenPlaywrightPage({
          accountId: task.accountId || task.id,
          session: sessionHandle.session,
          targetURL: resolvePlaywrightTargetURL(task.platform, payload),
          title: `${task.title} · Hidden Playwright`,
        })
      : null

  try {
    const result = await adapter.query(
      {
        taskId: task.id,
        accountId: task.accountId || task.id,
        session: sessionHandle.session,
        view: viewHandle?.view ?? null,
        playwright: playwrightLease
          ? {
              browser: playwrightLease.browser,
              page: playwrightLease.page,
            }
          : null,
        signal,
        phase: 'initial',
        reportProgress(stage: string) {
          noteMonitorExecutionSafePoint(task.id, monitorExecutionPhaseFromStage(stage))
          updateTaskProgress(task.id, `monitor adapter progress: ${stage}`)
        },
      },
      payload,
    )
    await maybeReportTaskAuthFailure(task, result, accountIdentity)
    return result
  } finally {
    await playwrightLease?.release()
    if (viewHandle) {
      releaseHotView(viewHandle.accountId)
    }
  }
}

function shouldEnforceActiveAccount(task: RuntimeTaskRecord): boolean {
  if (task.kind === 'publish') {
    return true
  }

  if (!isAIPlatformId(task.platform)) {
    return true
  }

  return authRequiredMonitorPlatforms.has(task.platform)
}

function buildAccountBlockedResult(
  task: RuntimeTaskRecord,
  readiness: Awaited<ReturnType<typeof ensureAccountReady>>,
): AdapterExecutionResult {
  if (readiness.authState === 'challenge_required') {
    return {
      status: 'failed',
      summary: accountActionRequiredSummary(task.platform, readiness.authReason),
      error: markAuthorizationFailureNonRetryable(
        {
          code:
            readiness.authReason === 'risk_control'
              ? 'desktop_account_risk_control'
              : 'desktop_account_challenge_required',
          message:
            readiness.authReason === 'risk_control'
              ? 'desktop account risk control triggered'
              : 'desktop account challenge required',
        },
        isAIPlatformId(task.platform) ? 'ai_platform_authorization' : 'media_account_authorization',
      ),
    }
  }

  if (readiness.authState === 'expired' || readiness.authState === 'revoked') {
    return {
      status: 'failed',
      summary: `${task.accountName} 登录态已失效，请重新授权后再试。`,
      error: markAuthorizationFailureNonRetryable(
        {
          code: 'desktop_account_auth_expired',
          message: 'desktop account auth expired',
        },
        isAIPlatformId(task.platform) ? 'ai_platform_authorization' : 'media_account_authorization',
      ),
    }
  }

  return {
    status: 'unknown',
    summary: `${task.accountName} 最近校验失败，已暂缓执行任务。`,
    error: {
      code: 'desktop_account_probe_pending',
      message: 'desktop account readiness pending',
    },
  }
}

async function maybeReportTaskAuthFailure(
  task: RuntimeTaskRecord,
  result: AdapterExecutionResult,
  accountIdentity: PublishAccountIdentity | null,
): Promise<void> {
  if (!accountIdentity) {
    return
  }

  const previousSnapshot = getAccountHealthSnapshot(accountIdentity.id)
  const nextSnapshot = await reportAccountFailure(accountIdentity, {
    summary: result.summary,
    error: result.error ?? null,
  }).catch((error) => {
    console.warn('[desktop-runtime] account failure report failed', {
      taskId: task.id,
      accountId: accountIdentity.id,
      platform: accountIdentity.platform,
      message: error instanceof Error ? error.message : String(error),
    })
    return null
  })

  maybeRecordAccountAccessAlert(task, accountIdentity, previousSnapshot, nextSnapshot)
  if (nextSnapshot && nextSnapshot.authState !== 'active') {
    enqueueAccountHealthReport(accountIdentity.id)
  }
}

function resolvePlaywrightTargetURL(platform: string, payload: Record<string, JsonValue>): string {
  const payloadURL = resolveStringField(payload, [
    'target_url',
    'targetUrl',
    'console_url',
    'consoleUrl',
    'url',
  ])
  if (payloadURL) {
    return payloadURL
  }

  const aiPlatform = getAIPlatformCatalogItem(platform)
  if (aiPlatform?.consoleUrl) {
    return aiPlatform.consoleUrl
  }

  return 'about:blank'
}

function buildScaffoldResult(
  task: RuntimeTaskRecord,
  adapterPayload: Record<string, JsonValue>,
  detail: string,
): AdapterExecutionResult {
  return {
    status: 'failed',
    payload: {
      ...adapterPayload,
      runtime_mode: 'desktop-scaffold',
      task_kind: task.kind,
      task_platform: task.platform,
    },
    error: {
      code: 'desktop_task_adapter_missing',
      message: 'desktop runtime adapter is not implemented for this platform',
      detail,
    },
    summary: `${task.title} 执行失败：当前平台的 desktop ${task.kind === 'publish' ? '发布' : '监测'}适配器尚未实现。`,
  }
}

async function loadPublishArticle(task: RuntimeTaskRecord): Promise<DesktopArticleContent> {
  const articleId = resolveArticleId(task.payload)
  if (articleId === null) {
    throw new Error('desktop_publish_article_id_missing')
  }

  const article = await getDesktopArticleContent(articleId)
  return {
    ...article,
    title: article.title?.trim() || task.title,
  }
}

function resolveArticleId(payload: Record<string, JsonValue>): number | null {
  const direct = toPositiveInt(payload.article_id)
  if (direct !== null) {
    return direct
  }

  const contentRef = payload.content_ref
  if (!contentRef || typeof contentRef !== 'object' || Array.isArray(contentRef)) {
    return null
  }

  const typed = contentRef as Record<string, JsonValue>
  return toPositiveInt(typed.id ?? typed.article_id ?? null)
}

function toPositiveInt(value: JsonValue | null): number | null {
  if (typeof value === 'number' && Number.isInteger(value) && value > 0) {
    return value
  }
  if (typeof value === 'string' && /^\d+$/.test(value.trim())) {
    const parsed = Number.parseInt(value.trim(), 10)
    return parsed > 0 ? parsed : null
  }
  return null
}

function resolveStringField(payload: Record<string, JsonValue>, keys: string[]): string | null {
  for (const key of keys) {
    const value = payload[key]
    if (typeof value !== 'string') {
      continue
    }
    const normalized = value.trim()
    if (normalized) {
      return normalized
    }
  }
  return null
}

function resolveStaleMonitoringBusinessDate(payload: Record<string, JsonValue>): string | null {
  const businessDate = resolveMonitoringBusinessDate(payload)
  if (!businessDate) {
    return null
  }

  return businessDate < currentMonitoringBusinessDate() ? businessDate : null
}

function monitoringSkipReasonFromExecution(execution: AdapterExecutionResult): string {
  return isStaleMonitoringExecutionResult(execution) ? 'stale_business_date' : 'runtime_unknown'
}

function isStaleMonitoringExecutionResult(execution: AdapterExecutionResult): boolean {
  return execution.payload?.dropped_reason === 'stale_business_date'
}

function staleMonitoringDropSummary(
  task: RuntimeTaskRecord,
  staleBusinessDate?: string | null,
): string {
  const businessDate = staleBusinessDate ?? resolveMonitoringBusinessDate(task.payload)
  if (businessDate) {
    return `${task.title} 已过业务日 ${businessDate}，按漏采策略直接丢弃。`
  }
  return `${task.title} 已跨业务日，按漏采策略直接丢弃。`
}

function resolveMonitoringBusinessDate(payload: Record<string, JsonValue>): string | null {
  const candidates = [
    payload.business_date,
    payload.businessDate,
    payload.metric_date,
    payload.date,
  ]

  for (const candidate of candidates) {
    if (typeof candidate !== 'string') {
      continue
    }
    const normalized = candidate.trim()
    if (/^\d{4}-\d{2}-\d{2}$/.test(normalized)) {
      return normalized
    }
  }

  return null
}

function currentMonitoringBusinessDate(now = new Date()): string {
  const parts = new Intl.DateTimeFormat('en-US', {
    timeZone: monitorBusinessTimeZone,
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
  }).formatToParts(now)

  const year = parts.find((part) => part.type === 'year')?.value ?? ''
  const month = parts.find((part) => part.type === 'month')?.value ?? ''
  const day = parts.find((part) => part.type === 'day')?.value ?? ''
  return `${year}-${month}-${day}`
}

function updateTaskProgress(taskId: string, summary: string): void {
  const existing = state.tasks.get(taskId)
  if (!existing) {
    return
  }

  existing.summary = summary
  existing.updatedAt = Date.now()
  state.tasks.set(taskId, existing)

  const active = state.activeExecutions.get(taskId)
  if (active) {
    active.lastProgressAt = Date.now()
    active.lastProgressSummary = summary
    state.activeExecutions.set(taskId, active)
  }

  if (existing.kind === 'publish') {
    emitRuntimeInvalidated('publish-task-progress', { taskId })
  }
}

function upsertTaskFromInfo(
  task: DesktopTaskInfo,
  options: {
    routing?: RuntimeTaskRouting
    summary?: string
    attemptId?: string | null
    leaseToken?: string | null
  } = {},
): RuntimeTaskRecord {
  const existing = state.tasks.get(task.id)
  const payload = normalizeJsonObject(task.payload)
  const record: RuntimeTaskRecord = {
    id: task.id,
    jobId: task.job_id,
    title: resolveTaskTitle(task, payload, existing),
    kind: task.kind,
    platform: task.platform,
    accountId: task.target_account_id,
    accountName: resolveAccountName(task.target_account_id, existing?.accountName),
    clientId: task.target_client_id,
    status: task.status,
    routing: options.routing ?? existing?.routing ?? 'db-recovery',
    leaseExpiresAt: parseTimestamp(task.lease_expires_at) ?? null,
    startedAt: task.status === 'in_progress' ? (existing?.startedAt ?? Date.now()) : null,
    updatedAt: parseTimestamp(task.updated_at) ?? Date.now(),
    summary: options.summary ?? existing?.summary ?? summaryFromTaskStatus(task.status),
    payload,
    error: normalizeJsonObjectOrNull(task.error),
    result: normalizeJsonObjectOrNull(task.result),
    attemptId:
      task.status === 'in_progress'
        ? (options.attemptId ?? existing?.attemptId ?? task.active_attempt_id ?? null)
        : null,
    leaseToken:
      task.status === 'in_progress' ? (options.leaseToken ?? existing?.leaseToken ?? null) : null,
  }

  state.tasks.set(task.id, record)
  return record
}

function refreshAccountNames(): void {
  for (const [taskId, task] of state.tasks.entries()) {
    const nextName = resolveAccountName(task.accountId, task.accountName)
    if (nextName === task.accountName) {
      continue
    }
    state.tasks.set(taskId, { ...task, accountName: nextName })
  }
}

function recordActivity(severity: RuntimeTone, title: string, detail: string): void {
  const next: RuntimeControllerActivity = {
    id: `rt-${Date.now()}-${(state.activitySeq += 1)}`,
    severity,
    title,
    detail,
    at: Date.now(),
  }

  state.activity.unshift(next)
  if (state.activity.length > maxActivityItems) {
    state.activity.length = maxActivityItems
  }
}

function syncSchedulerSurface(): void {
  setSchedulerQueueDepth(localQueueDepth())
  setSchedulerCurrentTask(primaryActiveTaskId())
}

function notifyLongRunningPublishTasks(): void {
  const now = Date.now()
  for (const active of state.activeExecutions.values()) {
    if (active.kind !== 'publish' || active.longRunningNotifiedAt) {
      continue
    }
    if (now - active.startedAt < publishLongRunningNotificationMs) {
      continue
    }
    active.longRunningNotifiedAt = now
    state.activeExecutions.set(active.taskId, active)

    const task = state.tasks.get(active.taskId)
    if (task) {
      task.summary = `${task.summary || '发布任务仍在执行。'}（已执行 ${formatDurationText(now - active.startedAt)}，如网络异常可取消后重试。）`
      task.updatedAt = now
      state.tasks.set(task.id, task)
      recordActivity(
        'warn',
        '发布等待较久',
        `${task.title} 已执行 ${formatDurationText(now - active.startedAt)}，可能存在网络异常。`,
      )
      emitRuntimeInvalidated('publish-task-progress', { taskId: task.id })
    }
  }
}

function formatDurationText(ms: number): string {
  const seconds = Math.max(0, Math.floor(ms / 1000))
  const minutes = Math.floor(seconds / 60)
  const restSeconds = seconds % 60
  if (minutes <= 0) {
    return `${restSeconds} 秒`
  }
  if (restSeconds === 0) {
    return `${minutes} 分钟`
  }
  return `${minutes} 分 ${restSeconds} 秒`
}

function localQueueDepth(): number {
  const publish = getPublishSchedulerSnapshot()
  const monitor = getMonitorSchedulerSnapshot()
  return publish.queueDepth + monitor.queuedCount + monitor.leasingCount
}

function primaryActiveTaskId(): string | null {
  const active = [...state.activeExecutions.values()]
  const publish = active.find((item) => item.kind === 'publish') ?? null
  return publish?.taskId ?? active[0]?.taskId ?? null
}

function isLeaseInFlight(kind: 'publish' | 'monitor'): boolean {
  return state.leaseInFlightKinds.has(kind)
}

function activePublishCount(): number {
  return [...state.activeExecutions.values()].filter((item) => item.kind === 'publish').length
}

function activePublishPlatforms(): Set<string> {
  const platforms = new Set(
    [...state.activeExecutions.values()]
      .filter((item) => item.kind === 'publish')
      .map((item) => item.platform),
  )
  for (const task of getPublishSchedulerSnapshot().tasks) {
    if (task.state === 'active' || task.state === 'leasing') {
      platforms.add(task.platform)
    }
  }
  return platforms
}

function activeMonitorCount(): number {
  return [...state.activeExecutions.values()].filter((item) => item.kind === 'monitor').length
}

function activeMonitorPlatforms(): Set<string> {
  const platforms = new Set(
    [...state.activeExecutions.values()]
      .filter((item) => item.kind === 'monitor')
      .map((item) => item.platform),
  )
  for (const task of getMonitorSchedulerSnapshot().tasks) {
    if (task.state === 'active' || task.state === 'leasing') {
      platforms.add(task.platform)
    }
  }
  return platforms
}

function activeMonitorQuestionKeys(): Set<string> {
  return new Set(
    getMonitorSchedulerSnapshot()
      .tasks.filter(
        (task) =>
          (task.state === 'active' || task.state === 'leasing') && Boolean(task.questionKey),
      )
      .map((task) => task.questionKey as string),
  )
}

function hasPublishBacklog(): boolean {
  const snapshot = getPublishSchedulerSnapshot()
  return snapshot.queuedCount + snapshot.leasingCount > 0
}

function activeAdmissionCount(): number {
  const publish = getPublishSchedulerSnapshot()
  const monitor = getMonitorSchedulerSnapshot()
  return (
    state.activeExecutions.size +
    publish.leasingCount +
    monitor.leasingCount +
    state.leaseInFlightKinds.size
  )
}

function hasTotalCapacityForNewExecution(): boolean {
  return (
    activeAdmissionCount() < resolveAdaptiveTotalConcurrency() &&
    shouldAdmitNewExecutionUnderRuntimePressure()
  )
}

function canStartAnotherPublishExecution(): boolean {
  const snapshot = getPublishSchedulerSnapshot()
  return (
    snapshot.queuedCount > 0 && !isLeaseInFlight('publish') && hasTotalCapacityForNewExecution()
  )
}

function shouldPullPublishFallback(): boolean {
  return (
    !state.dispatchWsConnected &&
    Date.now() >= state.publishFallbackBackoffUntil &&
    !isLeaseInFlight('publish') &&
    !hasPublishBacklog() &&
    activePublishCount() === 0 &&
    hasTotalCapacityForNewExecution()
  )
}

function canStartAnotherMonitorExecution(): boolean {
  if (hasPublishBacklog() || isLeaseInFlight('publish') || isLeaseInFlight('monitor')) {
    return false
  }
  const limit = resolveAdaptiveMonitorConcurrency()
  if (limit <= 0) {
    return false
  }
  const scheduler = getMonitorSchedulerSnapshot()
  return activeMonitorCount() + scheduler.leasingCount < limit && hasTotalCapacityForNewExecution()
}

function resolveLegacyMonitoringLeaseLimit(): number {
  if (!canStartAnotherMonitorExecution()) {
    return 0
  }

  const snapshot = getMonitorSchedulerSnapshot()
  if (snapshot.queuedCount > 0 || snapshot.leasingCount > 0) {
    return 0
  }

  // Legacy monitoring leases cannot be extended while they sit in the local
  // scheduler, so only pull one when it can start immediately.
  if (activeMonitorCount() > 0) {
    return 0
  }

  return 1
}

function resolveAdaptiveMonitorConcurrency(): number {
  const backgroundBudget = resolveMonitorBackgroundBudget()
  if (backgroundBudget <= 0) {
    return 0
  }

  const monitorAccountCount = state.accounts.filter(
    (account) =>
      isAIPlatformId(account.platform) &&
      getProjectedAccountHealth({
        accountId: account.id,
        platform: account.platform,
        health: account.health,
        verifiedAt: account.verified_at,
      }).health === 'live',
  ).length
  if (monitorAccountCount <= 1) {
    return Math.min(monitorAccountCount, backgroundBudget)
  }

  const metrics = getProcessMetricsSnapshot().latestSample
  if (!metrics) {
    return Math.min(1, backgroundBudget)
  }

  const totalCPUUsage = metrics.processes.reduce((sum, item) => sum + item.percentCPUUsage, 0)
  const totalPrivateBytesKB = metrics.totals.privateBytes
  const processCount = metrics.totals.processCount
  const mainPrivateBytesKB = metrics.mainProcess.memory?.private ?? 0

  if (
    totalCPUUsage >= 180 ||
    totalPrivateBytesKB >= 2_500_000 ||
    mainPrivateBytesKB >= 1_000_000 ||
    processCount >= 40
  ) {
    return Math.min(1, backgroundBudget)
  }

  return Math.min(2, backgroundBudget)
}

function resolveMonitorBackgroundBudget(): number {
  if (hasPublishBacklog() || isLeaseInFlight('publish')) {
    return 0
  }
  return Math.max(0, resolveAdaptiveTotalConcurrency() - publishReservedSlots)
}

function resolveAdaptiveTotalConcurrency(): number {
  const hardwareCap = resolveHardwareTotalConcurrency()
  const runtimeCap = resolveRuntimeHealthTotalConcurrency(hardwareCap)
  const featureFlagCap = resolveFeatureFlagTotalConcurrency() ?? maximumRuntimeTotalConcurrency
  return clampInteger(
    Math.min(hardwareCap, runtimeCap, featureFlagCap),
    featureFlagCap <= 1 ? 1 : minimumForegroundTotalConcurrency,
    maximumRuntimeTotalConcurrency,
  )
}

function resolveHardwareTotalConcurrency(): number {
  const cpuCount = Math.max(1, cpus().length)
  const memoryGB = totalmem() / 1024 / 1024 / 1024

  if (cpuCount >= 10 && memoryGB >= 32) {
    return 4
  }
  if (cpuCount >= 6 && memoryGB >= 16) {
    return 3
  }
  return 2
}

function resolveRuntimeHealthTotalConcurrency(hardwareCap: number): number {
  return hardwareCap
}

function shouldAdmitNewExecutionUnderRuntimePressure(): boolean {
  const metrics = getProcessMetricsSnapshot().latestSample
  if (!metrics) {
    return true
  }

  const totalCPUUsage = metrics.processes.reduce((sum, item) => sum + item.percentCPUUsage, 0)
  const totalPrivateBytesKB = metrics.totals.privateBytes
  const processCount = metrics.totals.processCount
  const mainPrivateBytesKB = metrics.mainProcess.memory?.private ?? 0

  if (
    totalCPUUsage >= 180 ||
    totalPrivateBytesKB >= 2_500_000 ||
    mainPrivateBytesKB >= 1_000_000 ||
    processCount >= 40
  ) {
    return activeAdmissionCount() < minimumForegroundTotalConcurrency
  }

  return true
}

function resolveFeatureFlagTotalConcurrency(): number | null {
  const raw = process.env.GEO_DESKTOP_MAX_TOTAL_CONCURRENCY?.trim()
  if (!raw) {
    return null
  }

  const parsed = Number.parseInt(raw, 10)
  if (!Number.isFinite(parsed)) {
    return null
  }
  return clampInteger(parsed, 1, maximumRuntimeTotalConcurrency)
}

function clampInteger(value: number, min: number, max: number): number {
  return Math.min(max, Math.max(min, Math.floor(value)))
}

function selectPublishAdapter(platform: string): PublishAdapter | null {
  if (platform === toutiaoAdapter.platform) {
    return toutiaoAdapter
  }
  if (platform === baijiahaoAdapter.platform) {
    return baijiahaoAdapter
  }
  if (platform === sohuhaoAdapter.platform) {
    return sohuhaoAdapter
  }
  if (platform === zhihuAdapter.platform) {
    return zhihuAdapter
  }
  if (platform === wangyihaoAdapter.platform) {
    return wangyihaoAdapter
  }
  if (platform === jianshuAdapter.platform) {
    return jianshuAdapter
  }
  if (platform === juejinAdapter.platform) {
    return juejinAdapter
  }
  if (platform === qiehaoAdapter.platform) {
    return qiehaoAdapter
  }
  if (platform === bilibiliAdapter.platform) {
    return bilibiliAdapter
  }
  if (platform === smzdmAdapter.platform) {
    return smzdmAdapter
  }
  if (platform === weixinGzhAdapter.platform) {
    return weixinGzhAdapter
  }
  if (platform === zolAdapter.platform) {
    return zolAdapter
  }
  if (platform === dongchediAdapter.platform) {
    return dongchediAdapter
  }
  return null
}

function selectMonitorAdapter(platform: string): MonitorAdapter | null {
  return getMonitorAdapter(platform)
}

function normalizeSession(
  session: DesktopRuntimeSessionSyncRequest | null,
): DesktopRuntimeSessionSyncRequest | null {
  if (!session) {
    return null
  }

  return {
    api_base_url: normalizeDesktopApiBaseURL(session.api_base_url),
    mode: session.mode,
    client_token: session.client_token?.trim() || null,
    desktop_client: session.desktop_client ? { ...session.desktop_client } : null,
  }
}

function sameSession(
  left: DesktopRuntimeSessionSyncRequest | null,
  right: DesktopRuntimeSessionSyncRequest | null,
): boolean {
  if (!left && !right) {
    return true
  }
  if (!left || !right) {
    return false
  }

  return (
    left.api_base_url === right.api_base_url &&
    left.mode === right.mode &&
    left.client_token === right.client_token &&
    left.desktop_client?.id === right.desktop_client?.id
  )
}

function canRunLive(
  session: DesktopRuntimeSessionSyncRequest | null,
): session is DesktopRuntimeSessionSyncRequest {
  return Boolean(
    session && session.mode === 'authenticated' && session.client_token && session.desktop_client,
  )
}

function resolveAccountName(accountId: string, fallback = '待同步账号'): string {
  const account = state.accounts.find((item) => item.id === accountId)
  return account?.display_name ?? fallback
}

function currentClientID(): string {
  return state.client?.id ?? state.session?.desktop_client?.id ?? ''
}

function resolveTaskTitle(
  task: DesktopTaskInfo,
  payload: Record<string, JsonValue>,
  existing?: RuntimeTaskRecord,
): string {
  const title = typeof payload.title === 'string' ? payload.title.trim() : ''
  if (title) {
    return title
  }
  return existing?.title ?? defaultTaskTitle(task.kind, task.platform)
}

function describeRouting(routing: RuntimeTaskRouting): string {
  return routing === 'rabbitmq-primary' ? '主消息队列通道' : '数据库兜底拉取'
}

function defaultTaskTitle(kind: 'publish' | 'monitor', platform?: string): string {
  return `${kind === 'publish' ? '发布任务' : '监控任务'}${platform ? ` · ${platform}` : ''}`
}

function summaryFromTaskStatus(status: RuntimeTaskStatus): string {
  switch (status) {
    case 'queued':
      return '任务已排队，等待客户端领取租约。'
    case 'in_progress':
      return '任务正在执行，结果回写需要携带有效租约凭证。'
    case 'succeeded':
      return '任务执行成功。'
    case 'failed':
      return '任务执行失败。'
    case 'aborted':
      return '任务已被取消。'
    default:
      return '任务执行异常，已按失败处理。'
  }
}

function summaryFromEventType(
  type: DesktopTaskEventMessage['type'],
  status: RuntimeTaskStatus,
): string {
  switch (type) {
    case 'task_available':
      return '主消息队列事件已送达当前客户端，等待领取租约。'
    case 'task_leased':
      return '服务端已确认租约归属。'
    case 'task_extended':
      return '任务租约已续期。'
    case 'task_canceled':
      return '任务已被取消。'
    case 'task_reconciled':
      return '任务已完成人工对账并回写。'
    default:
      return summaryFromTaskStatus(status)
  }
}

function inferPlatformFromAccount(accountId: string | null): string {
  if (!accountId) {
    return 'desktop'
  }
  return state.accounts.find((item) => item.id === accountId)?.platform ?? 'desktop'
}

function buildApiUrl(baseURL: string, pathname: string): string {
  const normalized = baseURL.endsWith('/') ? baseURL : `${baseURL}/`
  return new URL(pathname.replace(/^\//, ''), normalized).toString()
}

function normalizeJsonObject(
  value: Record<string, JsonValue> | null | undefined,
): Record<string, JsonValue> {
  if (!value) {
    return {}
  }
  return { ...value }
}

function normalizeJsonObjectOrNull(
  value: Record<string, JsonValue> | null | undefined,
): Record<string, JsonValue> | null {
  if (!value) {
    return null
  }
  return { ...value }
}

function asOptionalString(value: unknown): string | undefined {
  if (typeof value !== 'string') {
    return undefined
  }
  const normalized = value.trim()
  return normalized || undefined
}

function asOptionalBoolean(value: unknown): boolean | undefined {
  return typeof value === 'boolean' ? value : undefined
}

function asOptionalNumber(value: unknown): number | undefined {
  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
}

function asStringArray(value: unknown): string[] | undefined {
  if (!Array.isArray(value)) {
    return undefined
  }
  const normalized = value
    .filter((item): item is string => typeof item === 'string')
    .map((item) => item.trim())
    .filter((item) => item.length > 0)
  return normalized.length > 0 ? normalized : undefined
}

function asRecord(value: unknown): Record<string, JsonValue> | undefined {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    return undefined
  }
  return value as Record<string, JsonValue>
}

function asSourceItems(value: unknown): MonitoringSourceItem[] | undefined {
  if (!Array.isArray(value)) {
    return undefined
  }

  const items: MonitoringSourceItem[] = []
  for (const entry of value) {
    const record = asRecord(entry)
    const url = asOptionalString(record?.url)
    if (!record || !url) {
      continue
    }

    const item: MonitoringSourceItem = { url }
    const title = asOptionalString(record.title)
    const siteName = asOptionalString(record.site_name)
    const siteKey = asOptionalString(record.site_key)
    const normalizedURL = asOptionalString(record.normalized_url)
    const host = asOptionalString(record.host)
    const registrableDomain = asOptionalString(record.registrable_domain)
    const subdomain = asOptionalString(record.subdomain)
    const suffix = asOptionalString(record.suffix)
    const articleID = asOptionalNumber(record.article_id)
    const publishRecordID = asOptionalNumber(record.publish_record_id)
    const resolutionStatus = asOptionalString(record.resolution_status)
    const resolutionConfidence = asOptionalString(record.resolution_confidence)

    if (title !== undefined) {
      item.title = title
    }
    if (siteName !== undefined) {
      item.site_name = siteName
    }
    if (siteKey !== undefined) {
      item.site_key = siteKey
    }
    if (normalizedURL !== undefined) {
      item.normalized_url = normalizedURL
    }
    if (host !== undefined) {
      item.host = host
    }
    if (registrableDomain !== undefined) {
      item.registrable_domain = registrableDomain
    }
    if (subdomain !== undefined) {
      item.subdomain = subdomain
    }
    if (suffix !== undefined) {
      item.suffix = suffix
    }
    if (articleID !== undefined) {
      item.article_id = articleID
    }
    if (publishRecordID !== undefined) {
      item.publish_record_id = publishRecordID
    }
    if (resolutionStatus !== undefined) {
      item.resolution_status = resolutionStatus
    }
    if (resolutionConfidence !== undefined) {
      item.resolution_confidence = resolutionConfidence
    }

    items.push(item)
  }

  return items.length > 0 ? items : undefined
}

function toInterruptGeneration(value: unknown): number {
  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0
}

function toStructuredError(error: unknown): Record<string, JsonValue> {
  if (error instanceof ApiClientError) {
    return {
      code: error.code,
      message: error.message,
      detail: error.detail ?? null,
      request_id: error.requestId ?? null,
      status: error.status ?? null,
    }
  }

  if (error instanceof Error) {
    return {
      code: 'desktop_runtime_error',
      message: error.message,
      name: error.name,
    }
  }

  return {
    code: 'desktop_runtime_error',
    message: String(error),
  }
}

function errorMessage(error: unknown): string {
  if (error instanceof ApiClientError) {
    return error.detail ? `${error.message}: ${error.detail}` : error.message
  }
  if (error instanceof Error) {
    return error.message
  }
  return String(error)
}

function parseTimestamp(value: string | null | undefined): number | null {
  if (!value) {
    return null
  }

  const timestamp = Date.parse(value)
  return Number.isNaN(timestamp) ? null : timestamp
}

function isDesktopTaskEvent(value: unknown): value is DesktopTaskEventMessage {
  if (typeof value !== 'object' || value === null) {
    return false
  }

  const event = value as Partial<DesktopTaskEventMessage>
  return Boolean(
    typeof event.type === 'string' &&
    event.type !== 'task_control' &&
    typeof event.task_id === 'string' &&
    event.task_id.trim() !== '' &&
    typeof event.target_client_id === 'string' &&
    event.target_client_id.trim() !== '' &&
    (event.kind === 'publish' || event.kind === 'monitor') &&
    typeof event.status === 'string' &&
    typeof event.updated_at === 'string',
  )
}

function isMonitoringDispatchSignal(value: unknown): value is DesktopTaskEventMessage {
  if (typeof value !== 'object' || value === null) {
    return false
  }

  const event = value as Partial<DesktopTaskEventMessage>
  return (
    event.kind === 'monitor' &&
    event.type === 'task_available' &&
    event.signal_only === true &&
    typeof event.target_client_id === 'string' &&
    event.target_client_id.trim() !== ''
  )
}

function isMonitoringTaskControlEvent(value: unknown): value is DesktopTaskEventMessage {
  if (typeof value !== 'object' || value === null) {
    return false
  }

  const event = value as Partial<DesktopTaskEventMessage>
  return (
    event.kind === 'monitor' &&
    event.type === 'task_control' &&
    event.control === 'interrupt_requested' &&
    typeof event.task_id === 'string' &&
    event.task_id.trim() !== '' &&
    typeof event.target_client_id === 'string' &&
    event.target_client_id.trim() !== ''
  )
}

function isConnectedEvent(value: unknown): value is { server_time: string } {
  if (typeof value !== 'object' || value === null) {
    return false
  }
  return typeof (value as { server_time?: string }).server_time === 'string'
}

function isReconnectPayload(value: unknown): value is { delayMs: number } {
  if (typeof value !== 'object' || value === null) {
    return false
  }
  return typeof (value as { delayMs?: number }).delayMs === 'number'
}