From 6066f43a7d74a97ed26b3ea11af4746f902b0417 Mon Sep 17 00:00:00 2001
From: liangxu <liangxu0920@qq.com>
Date: Sun, 12 Apr 2026 09:56:18 +0800
Subject: [PATCH] Add monitoring service and database schema

- Implement monitoring service with heartbeat, lease tasks, resume tasks, and task result handling.
- Create monitoring time utilities for business date calculations.
- Add unit tests for date window resolution and business day handling.
- Define database schema for monitoring-related tables including quotas, daily reports, and task management.
- Establish migration scripts for creating and dropping monitoring tables.
---
 README.md                                     |    0
 .../src/components/MarkdownPreview.vue        |    6 +-
 apps/admin-web/src/components/PageHero.vue    |   15 +-
 apps/admin-web/src/i18n/messages/en-US.ts     |  133 +-
 apps/admin-web/src/i18n/messages/zh-CN.ts     |  133 +-
 apps/admin-web/src/lib/api.ts                 |   37 +
 apps/admin-web/src/lib/errors.ts              |    6 +
 apps/admin-web/src/lib/monitoring-plugin.ts   |  155 ++
 apps/admin-web/src/router/index.ts            |   12 +-
 apps/admin-web/src/views/BrandsView.vue       |    2 +-
 .../src/views/TrackingQuestionDetailView.vue  |  943 +++++++
 apps/admin-web/src/views/TrackingView.vue     | 1412 ++++++++++
 .../entrypoints/background.ts                 |  236 +-
 apps/browser-extension/entrypoints/content.ts |   90 +-
 .../entrypoints/popup/App.vue                 |  524 +++-
 .../src/monitoring-adapters/common.ts         |   79 +
 .../src/monitoring-adapters/doubao-state.ts   |  194 ++
 .../src/monitoring-adapters/doubao.ts         |  998 +++++++
 .../src/monitoring-adapters/index.ts          |   74 +
 .../src/monitoring-adapters/qwen.ts           |  598 ++++
 .../src/monitoring-adapters/types.ts          |   52 +
 .../src/monitoring-platforms.ts               |   72 +
 .../src/monitoring-runtime.ts                 |  729 +++++
 apps/browser-extension/src/storage.ts         |  167 +-
 apps/browser-extension/wxt.config.ts          |    2 +-
 packages/shared-types/src/index.ts            |  326 +++
 server/Makefile                               |   10 +-
 server/cmd/dev-seed/main.go                   |  998 ++++++-
 server/cmd/tenant-api/main.go                 |   13 +
 server/configs/config.local.yaml.example      |   22 +
 server/configs/config.yaml                    |   26 +
 server/docker-compose.yaml                    |   27 +
 server/go.mod                                 |    7 +-
 server/go.sum                                 |    3 +-
 server/internal/bootstrap/bootstrap.go        |   35 +
 server/internal/shared/config/config.go       |   89 +-
 .../shared/messaging/rabbitmq/client.go       |  325 +++
 server/internal/shared/middleware/logger.go   |    3 +
 .../tenant/app/brand_monitoring_cleanup.go    |  192 ++
 server/internal/tenant/app/brand_service.go   |   86 +-
 server/internal/tenant/app/media_service.go   |   19 +
 .../tenant/app/monitoring_answer_llm_parse.go |  173 ++
 .../tenant/app/monitoring_answer_parse.go     |  246 ++
 .../tenant/app/monitoring_callback_service.go | 2306 ++++++++++++++++
 .../internal/tenant/app/monitoring_errors.go  |    9 +
 .../tenant/app/monitoring_lease_recovery.go   |   79 +
 .../app/monitoring_lease_recovery_worker.go   |  116 +
 .../tenant/app/monitoring_projection.go       |  540 ++++
 .../monitoring_projection_rebuild_queue.go    |  194 ++
 .../monitoring_projection_rebuild_worker.go   |  133 +
 .../app/monitoring_received_inspection.go     |  113 +
 .../monitoring_received_inspection_worker.go  |  105 +
 .../app/monitoring_result_ingest_worker.go    |  134 +
 .../monitoring_result_ingest_worker_test.go   |   93 +
 .../app/monitoring_result_recovery_worker.go  |  204 ++
 .../internal/tenant/app/monitoring_service.go | 2456 +++++++++++++++++
 .../app/monitoring_service_date_test.go       |   67 +
 server/internal/tenant/app/monitoring_time.go |   39 +
 .../tenant/transport/brand_handler.go         |    2 +-
 .../transport/monitoring_callback_handler.go  |  162 ++
 .../tenant/transport/monitoring_handler.go    |  133 +
 server/internal/tenant/transport/router.go    |   14 +
 .../internal/tenant/transport/router_test.go  |    6 +
 ...10103000_create_monitoring_tables.down.sql |    1 +
 ...0410103000_create_monitoring_tables.up.sql |   13 +
 ...10103000_create_monitoring_tables.down.sql |   10 +
 ...0410103000_create_monitoring_tables.up.sql |  239 ++
 67 files changed, 16312 insertions(+), 125 deletions(-)
 create mode 100644 README.md
 create mode 100644 apps/admin-web/src/lib/monitoring-plugin.ts
 create mode 100644 apps/admin-web/src/views/TrackingQuestionDetailView.vue
 create mode 100644 apps/admin-web/src/views/TrackingView.vue
 create mode 100644 apps/browser-extension/src/monitoring-adapters/common.ts
 create mode 100644 apps/browser-extension/src/monitoring-adapters/doubao-state.ts
 create mode 100644 apps/browser-extension/src/monitoring-adapters/doubao.ts
 create mode 100644 apps/browser-extension/src/monitoring-adapters/index.ts
 create mode 100644 apps/browser-extension/src/monitoring-adapters/qwen.ts
 create mode 100644 apps/browser-extension/src/monitoring-adapters/types.ts
 create mode 100644 apps/browser-extension/src/monitoring-platforms.ts
 create mode 100644 apps/browser-extension/src/monitoring-runtime.ts
 create mode 100644 server/internal/shared/messaging/rabbitmq/client.go
 create mode 100644 server/internal/tenant/app/brand_monitoring_cleanup.go
 create mode 100644 server/internal/tenant/app/monitoring_answer_llm_parse.go
 create mode 100644 server/internal/tenant/app/monitoring_answer_parse.go
 create mode 100644 server/internal/tenant/app/monitoring_callback_service.go
 create mode 100644 server/internal/tenant/app/monitoring_errors.go
 create mode 100644 server/internal/tenant/app/monitoring_lease_recovery.go
 create mode 100644 server/internal/tenant/app/monitoring_lease_recovery_worker.go
 create mode 100644 server/internal/tenant/app/monitoring_projection.go
 create mode 100644 server/internal/tenant/app/monitoring_projection_rebuild_queue.go
 create mode 100644 server/internal/tenant/app/monitoring_projection_rebuild_worker.go
 create mode 100644 server/internal/tenant/app/monitoring_received_inspection.go
 create mode 100644 server/internal/tenant/app/monitoring_received_inspection_worker.go
 create mode 100644 server/internal/tenant/app/monitoring_result_ingest_worker.go
 create mode 100644 server/internal/tenant/app/monitoring_result_ingest_worker_test.go
 create mode 100644 server/internal/tenant/app/monitoring_result_recovery_worker.go
 create mode 100644 server/internal/tenant/app/monitoring_service.go
 create mode 100644 server/internal/tenant/app/monitoring_service_date_test.go
 create mode 100644 server/internal/tenant/app/monitoring_time.go
 create mode 100644 server/internal/tenant/transport/monitoring_callback_handler.go
 create mode 100644 server/internal/tenant/transport/monitoring_handler.go
 create mode 100644 server/migrations/20260410103000_create_monitoring_tables.down.sql
 create mode 100644 server/migrations/20260410103000_create_monitoring_tables.up.sql
 create mode 100644 server/migrations_monitoring/20260410103000_create_monitoring_tables.down.sql
 create mode 100644 server/migrations_monitoring/20260410103000_create_monitoring_tables.up.sql

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/apps/admin-web/src/components/MarkdownPreview.vue b/apps/admin-web/src/components/MarkdownPreview.vue
index a67108f..afa7e67 100644
--- a/apps/admin-web/src/components/MarkdownPreview.vue
+++ b/apps/admin-web/src/components/MarkdownPreview.vue
@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import DOMPurify from "dompurify";
 import MarkdownIt from "markdown-it";
 import { computed } from "vue";
 
@@ -12,7 +13,10 @@ const renderer = new MarkdownIt({
   breaks: true,
 });
 
-const html = computed(() => renderer.render(props.content || ""));
+const html = computed(() => {
+  const rawHtml = renderer.render(props.content || "");
+  return DOMPurify.sanitize(rawHtml);
+});
 </script>
 
 <template>
diff --git a/apps/admin-web/src/components/PageHero.vue b/apps/admin-web/src/components/PageHero.vue
index 998ff9a..5674fba 100644
--- a/apps/admin-web/src/components/PageHero.vue
+++ b/apps/admin-web/src/components/PageHero.vue
@@ -28,13 +28,13 @@ withDefaults(
 <style scoped>
 .page-hero {
   display: flex;
-  align-items: flex-start;
+  align-items: center;
   justify-content: space-between;
   gap: 24px;
-  padding: 28px 30px;
-  background: linear-gradient(135deg, #ffffff 0%, #f7fbff 100%);
-  border: 1px solid #e6edf5;
-  border-radius: 24px;
+  padding: 24px;
+  background: #ffffff;
+  border: 1px solid #f0f3fa;
+  border-radius: 12px;
 }
 
 .page-hero__copy {
@@ -52,8 +52,9 @@ withDefaults(
 
 .page-hero h1 {
   margin: 0;
-  font-size: 30px;
-  line-height: 1.08;
+  font-size: 24px;
+  font-weight: 700;
+  line-height: 1.2;
 }
 
 .page-hero p:last-child {
diff --git a/apps/admin-web/src/i18n/messages/en-US.ts b/apps/admin-web/src/i18n/messages/en-US.ts
index fa34eb0..5b3bbfd 100644
--- a/apps/admin-web/src/i18n/messages/en-US.ts
+++ b/apps/admin-web/src/i18n/messages/en-US.ts
@@ -50,6 +50,8 @@ const enUS = {
     upgrade: "Upgrade",
     copy: "Copy",
     copySuccess: "Content copied",
+    yes: "Yes",
+    no: "No",
   },
   nav: {
     workspace: "Workspace",
@@ -123,7 +125,11 @@ const enUS = {
     },
     tracking: {
       title: "Data Details",
-      description: "No matching backend APIs exist in this repository yet.",
+      description: "Inspect plugin-sampled brand performance, platform coverage, hot questions, and citation attribution.",
+    },
+    trackingQuestion: {
+      title: "Question Detail",
+      description: "Inspect answer content, citation sources, citation analysis, and content citations for a single question.",
     },
     knowledge: {
       title: "Knowledge Base",
@@ -155,6 +161,131 @@ const enUS = {
     emptyTemplates: "No template cards available yet",
     noRecentArticles: "No recent generations yet",
   },
+  tracking: {
+    eyebrow: "AI Brand Monitoring",
+    brandPlaceholder: "Select brand",
+    keywordPlaceholder: "Select keyword",
+    collectNow: "Collect Now",
+    collectKeywordRequired: "Select a keyword before collecting the current question set.",
+    pluginMode: "Plugin sampling",
+    pluginHint: "Plugin-mode data depends on device uptime. Low coverage should be treated as directional only.",
+    awaitingSnapshot: "Waiting for the next valid snapshot",
+    infoStrip:
+      "{mode} · target {desired} · planned {planned} · sampled {actual} · coverage {coverage} · updated {updatedAt} · {trigger}",
+    latestSnapshot: "Latest Snapshot",
+    coverage: "Coverage",
+    coverageTitle: "Sampling Coverage",
+    coverageSummary: "Target {desired} · Sampled {actual} · Coverage {coverage}",
+    platformMatrix: "Platform Matrix",
+    platformMatrixTitle: "Platform Comparison Matrix",
+    hotQuestions: "Hot Questions",
+    hotQuestionsTitle: "Hot Questions",
+    hotQuestionsHint: "Questions come from the brand library under the selected keyword.",
+    questionSearchPlaceholder: "Search questions under the selected keyword",
+    questionDetailEyebrow: "Question Detail",
+    questionDetailCollectedAt: "Collected at {time}",
+    questionDetailFallback: "Question Detail",
+    backToQuestions: "Back to questions",
+    citationRanking: "Citation Ranking",
+    citationRankingTitle: "Citation Ranking",
+    citationRankingHint: "Track how often content published from this system appears across model answers.",
+    citedArticles: "Cited Articles",
+    citedArticlesTitle: "Cited Articles",
+    answerContent: "Answer Content",
+    citationSources: "Citation Sources",
+    citationSourcesTitle: "Citation Sources",
+    citationAnalysis: "Citation Analysis",
+    citationAnalysisTitle: "Citation Analysis",
+    contentCitations: "Content Citations",
+    contentCitationsTitle: "Content Citations",
+    taskDebugTitle: "Async Task Debug",
+    taskDebugHint: "For troubleshooting the callback -> queue -> worker flow only. The four main content sections above stay unchanged.",
+    contentCitationBadge: "Content Citation",
+    noQuestions: "No hot questions for the current filters",
+    noCitationRanking: "No attributable citations in the current window",
+    noCitedArticles: "No content citations in the current window",
+    noAnswer: "No sampled answer for this platform",
+    noCitations: "No citations for this platform",
+    noCitationAnalysis: "No citation analysis for this platform",
+    noContentCitations: "No content citations for the active platform",
+    noTaskDebug: "No async task debug data for the current filters",
+    samples: "samples",
+    citations: "citations",
+    citedArticleMeta: "{count} cited articles",
+    contentCitationMeta: "{count} content references",
+    manual: "Manual",
+    automatic: "Automatic",
+    noChange: "Flat",
+    metrics: {
+      mentionRate: "Mention Rate",
+      top1MentionRate: "Top-1 Mention Rate",
+      firstRecommendRate: "First Recommendation Rate",
+      positiveMentionRate: "Positive Mention Rate",
+    },
+    columns: {
+      platform: "Platform",
+      appearances: "Appearances",
+      citedAnswers: "Cited Answers",
+      citedArticles: "Cited Articles",
+      citationRate: "Citation Rate",
+      citations: "Citations",
+      sourcePlatform: "Source",
+      domain: "Domain",
+      share: "Share",
+      contentName: "Content",
+      publishPlatform: "Publish Platform",
+      distinctSites: "Distinct Sites",
+      brandContent: "Has Brand Content",
+    },
+    status: {
+      sampled: "Sampled",
+      partial: "Partially Sampled",
+      unsampled: "Unsampled",
+      pending: "Pending",
+      not_logged_in: "Not Logged In",
+      unavailable: "Unavailable",
+    },
+    confidence: {
+      high: "High confidence",
+      medium: "Medium confidence",
+      low: "Low confidence",
+    },
+    taskDebug: {
+      labels: {
+        plannedAt: "Planned At",
+        leasedAt: "Leased At",
+        callbackReceivedAt: "Callback Received At",
+        queueEnqueuedAt: "Queued At",
+        completedAt: "Completed At",
+        leaseExpiresAt: "Lease Expires At",
+        runId: "Run ID",
+        runStatus: "Run Status",
+        providerModel: "Model",
+        requestId: "Request ID",
+        providerRequestId: "Provider Request ID",
+        receivedAlertCount: "Received Alert Count",
+        receivedAlertedAt: "Last Alerted At",
+        skipReason: "Skip Reason",
+        errorMessage: "Task Error",
+        lastQueuePublishError: "Queue Publish Error",
+      },
+      taskStatus: {
+        pending: "Pending",
+        leased: "Leased",
+        received: "Received",
+        completed: "Completed",
+        failed: "Failed",
+        skipped: "Skipped",
+        expired: "Expired",
+      },
+      queueStatus: {
+        pending: "Pending Queue",
+        queued: "Queued",
+        publish_failed: "Publish Failed",
+        invalid_payload: "Invalid Payload",
+      },
+    },
+  },
   templateMeta: {
     top_x_article: {
       eyebrow: "Ranked Content",
diff --git a/apps/admin-web/src/i18n/messages/zh-CN.ts b/apps/admin-web/src/i18n/messages/zh-CN.ts
index 41fc624..5588dd8 100644
--- a/apps/admin-web/src/i18n/messages/zh-CN.ts
+++ b/apps/admin-web/src/i18n/messages/zh-CN.ts
@@ -50,6 +50,8 @@ const zhCN = {
     upgrade: "去升级",
     copy: "复制",
     copySuccess: "内容已复制",
+    yes: "是",
+    no: "否",
   },
   nav: {
     workspace: "工作台",
@@ -123,7 +125,11 @@ const zhCN = {
     },
     tracking: {
       title: "数据详情",
-      description: "当前仓库还没有匹配的后端接口，页面暂保持为设计占位。",
+      description: "围绕插件采样快照查看品牌表现、平台矩阵、高频问题和引用归因。",
+    },
+    trackingQuestion: {
+      title: "问题详情",
+      description: "按问题查看大模型回答、引用来源、引用分析和内容引用。",
     },
     knowledge: {
       title: "知识库",
@@ -155,6 +161,131 @@ const zhCN = {
     emptyTemplates: "暂无模版卡片数据",
     noRecentArticles: "暂无最近生成内容",
   },
+  tracking: {
+    eyebrow: "AI Brand Monitoring",
+    brandPlaceholder: "选择品牌",
+    keywordPlaceholder: "选择关键词",
+    collectNow: "立即采集",
+    collectKeywordRequired: "请先选择关键词，再立即采集当前问题",
+    pluginMode: "插件采样",
+    pluginHint: "插件模式下结果受设备在线率影响，低覆盖样本仅供趋势参考。",
+    awaitingSnapshot: "等待下一次有效快照",
+    infoStrip:
+      "{mode} · 目标 {desired} · 计划 {planned} · 已采样 {actual} · 覆盖率 {coverage} · 更新于 {updatedAt} · {trigger}",
+    latestSnapshot: "Latest Snapshot",
+    coverage: "Coverage",
+    coverageTitle: "采样覆盖条",
+    coverageSummary: "目标 {desired} · 已采样 {actual} · 覆盖率 {coverage}",
+    platformMatrix: "Platform Matrix",
+    platformMatrixTitle: "平台对比矩阵",
+    hotQuestions: "Hot Questions",
+    hotQuestionsTitle: "高频问题",
+    hotQuestionsHint: "高频问题来自品牌库当前关键词下的全部问题。",
+    questionSearchPlaceholder: "搜索当前关键词下的问题",
+    questionDetailEyebrow: "Question Detail",
+    questionDetailCollectedAt: "采集时间 {time}",
+    questionDetailFallback: "问题详情",
+    backToQuestions: "返回问题列表",
+    citationRanking: "Citation Ranking",
+    citationRankingTitle: "引用排行",
+    citationRankingHint: "统计系统发布内容在各模型回答中出现的次数与覆盖率。",
+    citedArticles: "Cited Articles",
+    citedArticlesTitle: "被引用文章",
+    answerContent: "答案内容",
+    citationSources: "Citation Sources",
+    citationSourcesTitle: "引用来源",
+    citationAnalysis: "Citation Analysis",
+    citationAnalysisTitle: "引用分析",
+    contentCitations: "Content Citations",
+    contentCitationsTitle: "内容引用",
+    taskDebugTitle: "异步任务调试",
+    taskDebugHint: "仅用于排查 callback -> queue -> worker 的异步流转，不影响上方四块主内容。",
+    contentCitationBadge: "内容引用",
+    noQuestions: "当前筛选条件下暂无高频问题",
+    noCitationRanking: "当前时间窗口内暂无可归因引用",
+    noCitedArticles: "当前时间窗口内暂无内容引用",
+    noAnswer: "该平台暂无采样回答",
+    noCitations: "该平台无引用来源",
+    noCitationAnalysis: "该平台暂无引用分析",
+    noContentCitations: "当前平台暂无内容引用",
+    noTaskDebug: "当前条件下暂无异步任务调试数据",
+    samples: "次采样",
+    citations: "次引用",
+    citedArticleMeta: "{count} 篇内容被引用",
+    contentCitationMeta: "含 {count} 条内容引用",
+    manual: "手动",
+    automatic: "自动",
+    noChange: "持平",
+    metrics: {
+      mentionRate: "提及率",
+      top1MentionRate: "首位提及率",
+      firstRecommendRate: "首选推荐率",
+      positiveMentionRate: "正面提及率",
+    },
+    columns: {
+      platform: "平台",
+      appearances: "出现次数",
+      citedAnswers: "引用回答数",
+      citedArticles: "引用文章数",
+      citationRate: "引用率",
+      citations: "引用次数",
+      sourcePlatform: "来源平台",
+      domain: "来源域名",
+      share: "占比",
+      contentName: "内容名称",
+      publishPlatform: "发布平台",
+      distinctSites: "引用站点数",
+      brandContent: "含品牌内容",
+    },
+    status: {
+      sampled: "已采样",
+      partial: "部分采样",
+      unsampled: "未采样",
+      pending: "等待采样",
+      not_logged_in: "未登录",
+      unavailable: "不可用",
+    },
+    confidence: {
+      high: "高置信度",
+      medium: "中等置信度",
+      low: "低置信度",
+    },
+    taskDebug: {
+      labels: {
+        plannedAt: "计划时间",
+        leasedAt: "领取时间",
+        callbackReceivedAt: "回调收到时间",
+        queueEnqueuedAt: "入队时间",
+        completedAt: "完成时间",
+        leaseExpiresAt: "租约过期时间",
+        runId: "Run ID",
+        runStatus: "Run 状态",
+        providerModel: "模型",
+        requestId: "请求 ID",
+        providerRequestId: "Provider Request ID",
+        receivedAlertCount: "Received 告警次数",
+        receivedAlertedAt: "最近告警时间",
+        skipReason: "跳过原因",
+        errorMessage: "任务错误",
+        lastQueuePublishError: "队列投递错误",
+      },
+      taskStatus: {
+        pending: "待采集",
+        leased: "已领取",
+        received: "已收到回调",
+        completed: "已完成",
+        failed: "已失败",
+        skipped: "已跳过",
+        expired: "已过期",
+      },
+      queueStatus: {
+        pending: "待入队",
+        queued: "已入队",
+        publish_failed: "入队失败",
+        invalid_payload: "消息无效",
+      },
+    },
+  },
   templateMeta: {
     top_x_article: {
       eyebrow: "榜单内容",
diff --git a/apps/admin-web/src/lib/api.ts b/apps/admin-web/src/lib/api.ts
index 4e13a4c..2e94b6e 100644
--- a/apps/admin-web/src/lib/api.ts
+++ b/apps/admin-web/src/lib/api.ts
@@ -32,6 +32,9 @@ import type {
   LoginRequest,
   LoginResponse,
   MediaPlatform,
+  MonitoringCollectNowResponse,
+  MonitoringDashboardCompositeResponse,
+  MonitoringQuestionDetailResponse,
   PlatformAccount,
   PublishRecord,
   RegisterPluginInstallationRequest,
@@ -549,6 +552,40 @@ export const mediaApi = {
   },
 };
 
+export const monitoringApi = {
+  dashboardComposite(params: {
+    brand_id?: number;
+    keyword_id?: number | null;
+    days?: number;
+    business_date?: string;
+  }) {
+    return apiClient.get<MonitoringDashboardCompositeResponse>("/api/tenant/monitoring/dashboard/composite", {
+      params,
+    });
+  },
+  questionDetail(
+    brandId: number,
+    questionId: number,
+    params: {
+      date_from?: string;
+      date_to?: string;
+      question_hash?: string;
+      ai_platform_id?: string;
+    },
+  ) {
+    return apiClient.get<MonitoringQuestionDetailResponse>(
+      `/api/tenant/monitoring/brands/${brandId}/questions/${questionId}/detail`,
+      { params },
+    );
+  },
+  collectNow(brandId: number, payload?: { keyword_id?: number | null }) {
+    return apiClient.post<MonitoringCollectNowResponse, { keyword_id?: number | null }>(
+      `/api/tenant/monitoring/brands/${brandId}/collect-now`,
+      payload ?? {},
+    );
+  },
+};
+
 export const promptRulesApi = {
   list(params?: PromptRuleListParams) {
     return apiClient.get<PromptRuleListResponse>("/api/tenant/prompt-rules", { params });
diff --git a/apps/admin-web/src/lib/errors.ts b/apps/admin-web/src/lib/errors.ts
index 123b746..bbf2e80 100644
--- a/apps/admin-web/src/lib/errors.ts
+++ b/apps/admin-web/src/lib/errors.ts
@@ -40,6 +40,12 @@ const errorMessageMap: Record<string, string> = {
   publisher_plugin_empty_response: "浏览器插件未返回数据，请刷新当前页面后重试",
   publisher_plugin_invalid_response: "浏览器插件返回了无效数据，请刷新当前页面后重试",
   publisher_plugin_unknown_error: "浏览器插件调用失败，请稍后重试",
+  monitoring_plugin_timeout: "监测插件响应超时，请稍后重试",
+  monitoring_plugin_invalid_response: "监测插件返回了无效数据，请稍后重试",
+  monitoring_plugin_unknown_error: "监测插件调用失败，请稍后重试",
+  monitoring_plugin_required: "请先安装并打开浏览器插件",
+  monitoring_plugin_register_required: "浏览器插件正在初始化，请稍后重试",
+  installation_offline: "监测插件离线，请打开浏览器插件后重试",
   network_error: "网络连接失败，请稍后重试",
   unknown_error: "发生未知错误",
 };
diff --git a/apps/admin-web/src/lib/monitoring-plugin.ts b/apps/admin-web/src/lib/monitoring-plugin.ts
new file mode 100644
index 0000000..479fb94
--- /dev/null
+++ b/apps/admin-web/src/lib/monitoring-plugin.ts
@@ -0,0 +1,155 @@
+import type {
+  MonitoringCycleKickoffResponse,
+  MonitoringCycleResult,
+  MonitoringHeartbeatSyncResult,
+  MonitoringLocalPlatformState,
+  MonitoringPluginPingResponse,
+  MonitoringRuntimeStateSnapshot,
+} from "@geo/shared-types";
+
+type MonitoringAction = "ping" | "detectPlatforms" | "syncHeartbeat" | "runCycle" | "kickoffCycle" | "getState";
+
+type MonitoringPluginSuccessPayload<T> = {
+  source: "geo-extension";
+  type: "geo.monitoring.response";
+  requestId: string;
+  success: true;
+  data: T;
+};
+
+type MonitoringPluginErrorPayload = {
+  source: "geo-extension";
+  type: "geo.monitoring.response";
+  requestId: string;
+  success: false;
+  error: string;
+};
+
+type MonitoringPluginPayloadMap = {
+  ping: MonitoringPluginPingResponse;
+  detectPlatforms: MonitoringLocalPlatformState[];
+  syncHeartbeat: MonitoringHeartbeatSyncResult;
+  runCycle: MonitoringCycleResult;
+  kickoffCycle: MonitoringCycleKickoffResponse;
+  getState: MonitoringRuntimeStateSnapshot;
+};
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isMonitoringPingPayload(value: unknown): value is MonitoringPluginPingResponse {
+  return isPlainObject(value) && typeof value.installed === "boolean";
+}
+
+function isMonitoringDetectPayload(value: unknown): value is MonitoringLocalPlatformState[] {
+  return Array.isArray(value);
+}
+
+function isMonitoringHeartbeatPayload(value: unknown): value is MonitoringHeartbeatSyncResult {
+  return isPlainObject(value) && typeof value.success === "boolean" && Array.isArray(value.platform_states);
+}
+
+function isMonitoringCyclePayload(value: unknown): value is MonitoringCycleResult {
+  return (
+    isPlainObject(value) &&
+    typeof value.success === "boolean" &&
+    typeof value.leased_task_count === "number" &&
+    typeof value.processed_task_count === "number" &&
+    typeof value.failed_task_count === "number" &&
+    typeof value.skipped_task_count === "number"
+  );
+}
+
+function isMonitoringKickoffPayload(value: unknown): value is MonitoringCycleKickoffResponse {
+  return isPlainObject(value) && value.accepted === true && typeof value.status === "string";
+}
+
+function isMonitoringStatePayload(value: unknown): value is MonitoringRuntimeStateSnapshot {
+  return isPlainObject(value) && typeof value.installation_key === "string" && Array.isArray(value.monitoring_platforms);
+}
+
+function isMonitoringPayloadValid<T extends MonitoringAction>(action: T, value: unknown): value is MonitoringPluginPayloadMap[T] {
+  switch (action) {
+    case "ping":
+      return isMonitoringPingPayload(value);
+    case "detectPlatforms":
+      return isMonitoringDetectPayload(value);
+    case "syncHeartbeat":
+      return isMonitoringHeartbeatPayload(value);
+    case "runCycle":
+      return isMonitoringCyclePayload(value);
+    case "kickoffCycle":
+      return isMonitoringKickoffPayload(value);
+    case "getState":
+      return isMonitoringStatePayload(value);
+    default:
+      return false;
+  }
+}
+
+function nextRequestId(): string {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `geo-monitoring-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+async function requestMonitoringPlugin<T extends MonitoringAction>(action: T, timeoutMs = 5000): Promise<MonitoringPluginPayloadMap[T]> {
+  if (typeof window === "undefined") {
+    throw new Error("plugin bridge is only available in browser contexts");
+  }
+
+  const requestId = nextRequestId();
+
+  return new Promise((resolve, reject) => {
+    const timer = window.setTimeout(() => {
+      cleanup();
+      reject(new Error("monitoring_plugin_timeout"));
+    }, timeoutMs);
+
+    const handleMessage = (event: MessageEvent<MonitoringPluginSuccessPayload<MonitoringPluginPayloadMap[T]> | MonitoringPluginErrorPayload>) => {
+      if (event.source !== window || !event.data || event.data.type !== "geo.monitoring.response") {
+        return;
+      }
+      if (event.data.requestId !== requestId || event.data.source !== "geo-extension") {
+        return;
+      }
+
+      cleanup();
+      if (event.data.success) {
+        if (!isMonitoringPayloadValid(action, event.data.data)) {
+          reject(new Error("monitoring_plugin_invalid_response"));
+          return;
+        }
+        resolve(event.data.data);
+        return;
+      }
+      reject(new Error(event.data.error || "monitoring_plugin_unknown_error"));
+    };
+
+    const cleanup = () => {
+      window.clearTimeout(timer);
+      window.removeEventListener("message", handleMessage);
+    };
+
+    window.addEventListener("message", handleMessage);
+    window.postMessage(
+      {
+        source: "geo-admin",
+        type: "geo.monitoring.request",
+        requestId,
+        action,
+      },
+      window.location.origin,
+    );
+  });
+}
+
+export async function runMonitoringCycle(): Promise<MonitoringCycleResult> {
+  return requestMonitoringPlugin("runCycle", 30000);
+}
+
+export async function kickoffMonitoringCycle(): Promise<MonitoringCycleKickoffResponse> {
+  return requestMonitoringPlugin("kickoffCycle", 5000);
+}
diff --git a/apps/admin-web/src/router/index.ts b/apps/admin-web/src/router/index.ts
index b857163..de75d97 100644
--- a/apps/admin-web/src/router/index.ts
+++ b/apps/admin-web/src/router/index.ts
@@ -109,13 +109,23 @@ const router = createRouter({
         {
           path: "tracking",
           name: "tracking",
-          component: () => import("@/views/FeatureStubView.vue"),
+          component: () => import("@/views/TrackingView.vue"),
           meta: {
             titleKey: "route.tracking.title",
             descriptionKey: "route.tracking.description",
             navKey: "/tracking",
           },
         },
+        {
+          path: "tracking/questions/:brandId/:questionId",
+          name: "tracking-question-detail",
+          component: () => import("@/views/TrackingQuestionDetailView.vue"),
+          meta: {
+            titleKey: "route.trackingQuestion.title",
+            descriptionKey: "route.trackingQuestion.description",
+            navKey: "/tracking",
+          },
+        },
         {
           path: "knowledge",
           name: "knowledge",
diff --git a/apps/admin-web/src/views/BrandsView.vue b/apps/admin-web/src/views/BrandsView.vue
index 5052409..7913fe9 100644
--- a/apps/admin-web/src/views/BrandsView.vue
+++ b/apps/admin-web/src/views/BrandsView.vue
@@ -818,7 +818,7 @@ async function submitCompetitor(): Promise<void> {
   width: 4px;
   height: 18px;
   border-radius: 2px;
-  background: #111827;
+  background: #1f5cff;
   margin-right: 12px;
 }
 
diff --git a/apps/admin-web/src/views/TrackingQuestionDetailView.vue b/apps/admin-web/src/views/TrackingQuestionDetailView.vue
new file mode 100644
index 0000000..49ad39b
--- /dev/null
+++ b/apps/admin-web/src/views/TrackingQuestionDetailView.vue
@@ -0,0 +1,943 @@
+<script setup lang="ts">
+import { ArrowLeftOutlined } from "@ant-design/icons-vue";
+import { useQuery } from "@tanstack/vue-query";
+import dayjs from "dayjs";
+import type {
+  MonitoringQuestionCitationAnalysisItem,
+  MonitoringQuestionContentCitation,
+  MonitoringQuestionDetailCitation,
+  MonitoringQuestionDetailPlatform,
+} from "@geo/shared-types";
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useRoute, useRouter } from "vue-router";
+
+import MarkdownPreview from "@/components/MarkdownPreview.vue";
+import { monitoringApi } from "@/lib/api";
+import { formatDateTime } from "@/lib/display";
+import { formatError } from "@/lib/errors";
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+
+const trackingMaxHistoryDays = 30;
+const trackingToday = dayjs().format("YYYY-MM-DD");
+
+const brandId = computed(() => parsePositiveNumber(route.params.brandId));
+const questionId = computed(() => parsePositiveNumber(route.params.questionId));
+const questionHash = computed(() => normalizeQueryValue(route.query.question_hash));
+const questionTitleFallback = computed(() => normalizeQueryValue(route.query.question_text));
+const keywordId = computed(() => normalizeQueryValue(route.query.keyword_id));
+const businessDate = computed(() => normalizeTrackingBusinessDate(route.query.business_date) || trackingToday);
+const dateFrom = computed(() => {
+  return normalizeQueryValue(route.query.date_from) || businessDate.value;
+});
+const dateTo = computed(() => {
+  return normalizeQueryValue(route.query.date_to) || businessDate.value;
+});
+
+const detailQuery = useQuery({
+  queryKey: computed(() => [
+    "tracking",
+    "question-detail-page",
+    brandId.value,
+    questionId.value,
+    questionHash.value,
+    dateFrom.value,
+    dateTo.value,
+  ]),
+  enabled: computed(() => Boolean(brandId.value && questionId.value)),
+  queryFn: () =>
+    monitoringApi.questionDetail(brandId.value as number, questionId.value as number, {
+      date_from: dateFrom.value,
+      date_to: dateTo.value,
+      question_hash: questionHash.value || undefined,
+    }),
+});
+
+const activePlatformId = ref("");
+
+watch(
+  () => detailQuery.data.value?.platforms,
+  (platforms) => {
+    if (!platforms?.length) {
+      activePlatformId.value = "";
+      return;
+    }
+
+    const requestedPlatformId = normalizeQueryValue(route.query.ai_platform_id);
+    const requestedPlatform = requestedPlatformId
+      ? platforms.find((item) => item.ai_platform_id === requestedPlatformId)
+      : null;
+    const sampledPlatform = platforms.find((item) => item.sample_status === "sampled");
+    const nextPlatform = requestedPlatform ?? sampledPlatform ?? platforms[0];
+
+    if (!platforms.some((item) => item.ai_platform_id === activePlatformId.value)) {
+      activePlatformId.value = nextPlatform.ai_platform_id;
+    }
+  },
+  { immediate: true },
+);
+
+const pageTitle = computed(() => {
+  return detailQuery.data.value?.question_text ?? questionTitleFallback.value ?? t("tracking.questionDetailFallback");
+});
+
+const activePlatform = computed<MonitoringQuestionDetailPlatform | null>(() => {
+  return detailQuery.data.value?.platforms.find((item) => item.ai_platform_id === activePlatformId.value) ?? null;
+});
+
+const activeCitationAnalysis = computed<MonitoringQuestionCitationAnalysisItem[]>(() => {
+  const items = detailQuery.data.value?.citation_analysis ?? [];
+  if (!activePlatformId.value) {
+    return items;
+  }
+  return items.filter((item) => item.ai_platform_id === activePlatformId.value);
+});
+
+const activeContentCitations = computed<MonitoringQuestionContentCitation[]>(() => {
+  const items = detailQuery.data.value?.content_citations ?? [];
+  return items.filter((item) => item.ai_platform_id === activePlatformId.value);
+});
+
+const latestSampledAt = computed<string | null>(() => {
+  const platforms = detailQuery.data.value?.platforms ?? [];
+  const sampledAtValues = platforms
+    .map((item) => item.sampled_at)
+    .filter((value): value is string => Boolean(value));
+
+  if (!sampledAtValues.length) {
+    return null;
+  }
+
+  return sampledAtValues.reduce((latest, current) => {
+    if (!latest) {
+      return current;
+    }
+    return dayjs(current).isAfter(dayjs(latest)) ? current : latest;
+  }, sampledAtValues[0] ?? null);
+});
+
+const collectedAtDisplay = computed(() => {
+  const sampledAt = activePlatform.value?.sampled_at || latestSampledAt.value;
+  return sampledAt ? formatDateTime(sampledAt) : "--";
+});
+
+function goBack(): void {
+  void router.push({
+    name: "tracking",
+    query: {
+      brand_id: brandId.value ? String(brandId.value) : undefined,
+      keyword_id: keywordId.value || undefined,
+      business_date: businessDate.value,
+    },
+  });
+}
+
+function formatPercent(value: number | null | undefined): string {
+  if (value === null || value === undefined) {
+    return "--";
+  }
+  return `${(value * 100).toFixed(2)}%`;
+}
+
+function statusTagColor(status: string): string {
+  switch (status) {
+    case "sampled":
+      return "green";
+    case "pending":
+      return "gold";
+    case "not_logged_in":
+      return "default";
+    case "unavailable":
+      return "red";
+    default:
+      return "default";
+  }
+}
+
+function statusLabel(status: string): string {
+  return t(`tracking.status.${status}`);
+}
+
+function resolveCitationTitle(citation: MonitoringQuestionDetailCitation): string {
+  return citation.cited_title || citation.article_title || citation.cited_url;
+}
+
+function normalizeQueryValue(value: unknown): string {
+  const raw = Array.isArray(value) ? value[0] : value;
+  return String(raw ?? "").trim();
+}
+
+function normalizeTrackingBusinessDate(value: unknown): string | null {
+  const normalized = normalizeQueryValue(value);
+  if (!normalized) {
+    return null;
+  }
+  const parsed = dayjs(normalized);
+  if (!parsed.isValid() || parsed.format("YYYY-MM-DD") !== normalized) {
+    return null;
+  }
+
+  const today = dayjs().startOf("day");
+  const earliestAllowed = today.subtract(trackingMaxHistoryDays - 1, "day");
+  if (parsed.isAfter(today, "day") || parsed.isBefore(earliestAllowed, "day")) {
+    return null;
+  }
+  return normalized;
+}
+
+function parsePositiveNumber(value: unknown): number | null {
+  const raw = Array.isArray(value) ? value[0] : value;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+}
+</script>
+
+<template>
+  <section class="tracking-question-page">
+    <div class="tracking-question-page__hero">
+      <div class="tracking-question-page__header-top">
+        <button type="button" class="tracking-question-page__back" @click="goBack">
+          <ArrowLeftOutlined />
+          <span>{{ t("tracking.backToQuestions") }}</span>
+        </button>
+      </div>
+
+      <div class="tracking-question-page__copy">
+        <p class="tracking-question-page__eyebrow">{{ t("tracking.questionDetailEyebrow") }}</p>
+        <h1>{{ pageTitle }}</h1>
+        <p class="tracking-question-page__meta">
+          {{ t("tracking.questionDetailCollectedAt", { time: collectedAtDisplay }) }}
+        </p>
+      </div>
+    </div>
+
+    <a-alert
+      v-if="detailQuery.error.value"
+      type="error"
+      show-icon
+      :message="formatError(detailQuery.error.value)"
+      class="tracking-question-page__alert"
+    />
+
+    <a-spin :spinning="detailQuery.isLoading.value">
+      <div class="tracking-question-page__content">
+        <div class="tracking-question-page__tabs-wrapper">
+        <a-tabs
+          v-model:activeKey="activePlatformId"
+          size="large"
+          class="tracking-question-tabs"
+        >
+          <a-tab-pane
+            v-for="platform in detailQuery.data.value?.platforms ?? []"
+            :key="platform.ai_platform_id"
+          >
+            <template #tab>
+              <span :class="platform.sample_status !== 'sampled' ? 'is-muted' : ''">
+                {{ platform.platform_name }}
+              </span>
+            </template>
+          </a-tab-pane>
+        </a-tabs>
+      </div>
+
+      <div class="tracking-question-grid">
+        <section class="tracking-question-card tracking-question-card--answer">
+          <div class="tracking-question-card__header">
+            <div class="tracking-question-card__section-title">
+              <span class="tracking-question-card__accent" />
+              <span>{{ t("tracking.answerContent") }}</span>
+            </div>
+          </div>
+
+          <div class="tracking-question-card__body">
+            <div class="tracking-question-answer__headline">
+              <h2>{{ activePlatform?.platform_name ?? t("common.noData") }}</h2>
+              <a-tag :color="statusTagColor(activePlatform?.sample_status ?? 'pending')">
+                {{ statusLabel(activePlatform?.sample_status ?? 'pending') }}
+              </a-tag>
+            </div>
+
+            <div class="tracking-question-answer__content custom-scrollbar">
+              <MarkdownPreview
+                v-if="activePlatform?.answer_text"
+                :content="activePlatform.answer_text"
+              />
+              <a-empty v-else :description="t('tracking.noAnswer')" />
+            </div>
+
+            <div class="tracking-question-answer__meta">
+              <span>{{ activePlatform?.sampled_at ? formatDateTime(activePlatform.sampled_at) : "--" }}</span>
+              <span>{{ activePlatform?.provider_model ?? "--" }}</span>
+            </div>
+          </div>
+        </section>
+
+        <section class="tracking-question-card">
+          <div class="tracking-question-card__header">
+            <div class="tracking-question-card__section-title">
+              <span class="tracking-question-card__accent" />
+              <span>{{ t("tracking.citationSourcesTitle") }}</span>
+            </div>
+          </div>
+
+          <div class="tracking-question-card__scroll-area custom-scrollbar">
+            <div v-if="activePlatform?.citations?.length" class="tracking-question-source-list">
+              <a
+                v-for="citation in activePlatform.citations"
+                :key="citation.cited_url"
+                :href="citation.cited_url"
+                target="_blank"
+                rel="noreferrer"
+                class="tracking-question-source-card"
+              >
+                <div class="tracking-question-source-card__headline">
+                  <strong>{{ citation.site_name }}</strong>
+                  <span class="tracking-question-source-card__divider" v-if="resolveCitationTitle(citation)">·</span>
+                  <span class="tracking-question-source-card__title" :title="resolveCitationTitle(citation)">{{ resolveCitationTitle(citation) }}</span>
+                  <a-tag v-if="citation.article_id" color="blue" class="tracking-question-source-card__badge">{{ t("tracking.contentCitationBadge") }}</a-tag>
+                </div>
+                <div class="tracking-question-source-card__link">
+                  {{ citation.cited_url }}
+                </div>
+              </a>
+            </div>
+            <a-empty v-else :description="t('tracking.noCitations')" />
+          </div>
+        </section>
+
+        <section class="tracking-question-card">
+          <div class="tracking-question-card__header">
+            <div class="tracking-question-card__section-title">
+              <span class="tracking-question-card__accent" />
+              <span>{{ t("tracking.citationAnalysisTitle") }}</span>
+            </div>
+          </div>
+
+          <div class="tracking-question-card__scroll-area custom-scrollbar">
+            <div v-if="activeCitationAnalysis.length" class="tracking-question-table">
+              <div class="tracking-question-table__head">
+                <span>{{ t("tracking.columns.sourcePlatform") }}</span>
+                <span>{{ t("tracking.columns.domain") }}</span>
+                <span>{{ t("tracking.columns.citations") }}</span>
+                <span>{{ t("tracking.columns.share") }}</span>
+              </div>
+
+              <div
+                v-for="item in activeCitationAnalysis"
+                :key="`${item.ai_platform_id}-${item.site_key}`"
+                class="tracking-question-table__row"
+              >
+                <span class="tracking-question-table__primary">
+                  <strong>{{ item.site_name }}</strong>
+                  <small v-if="item.content_citation_count > 0">
+                    {{ t("tracking.contentCitationMeta", { count: item.content_citation_count }) }}
+                  </small>
+                </span>
+                <span class="tracking-question-table__secondary">{{ item.site_domain || item.site_key }}</span>
+                <span>{{ item.citation_count }}</span>
+                <strong>{{ formatPercent(item.citation_rate) }}</strong>
+              </div>
+            </div>
+            <a-empty v-else :description="t('tracking.noCitationAnalysis')" />
+          </div>
+        </section>
+
+        <section class="tracking-question-card">
+          <div class="tracking-question-card__header">
+            <div class="tracking-question-card__section-title">
+              <span class="tracking-question-card__accent" />
+              <span>{{ t("tracking.contentCitationsTitle") }}</span>
+            </div>
+          </div>
+
+          <div class="tracking-question-card__scroll-area custom-scrollbar">
+            <div v-if="activeContentCitations.length" class="tracking-question-table">
+              <div
+                class="tracking-question-table__head"
+              >
+                <span>{{ t("tracking.columns.contentName") }}</span>
+                <span>{{ t("tracking.columns.publishPlatform") }}</span>
+                <span>{{ t("tracking.columns.citations") }}</span>
+                <span>{{ t("tracking.columns.share") }}</span>
+              </div>
+
+              <div
+                v-for="item in activeContentCitations"
+                :key="`${item.ai_platform_id}-${item.article_id}`"
+                class="tracking-question-table__row"
+              >
+                <div class="tracking-question-table__primary">
+                  <router-link :to="`/articles/${item.article_id}/edit`">{{ item.article_title }}</router-link>
+                </div>
+                <span class="tracking-question-table__secondary">{{ item.publish_platform }}</span>
+                <div class="tracking-question-table__metric">
+                  <span>{{ item.citation_count }}</span>
+                </div>
+                <div class="tracking-question-table__metric">
+                  <strong>{{ formatPercent(item.citation_rate) }}</strong>
+                </div>
+              </div>
+            </div>
+            <a-empty v-else :description="t('tracking.noContentCitations')" />
+          </div>
+        </section>
+      </div>
+      </div>
+    </a-spin>
+  </section>
+</template>
+
+<style scoped>
+.tracking-question-page {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.tracking-question-page__content {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.tracking-question-page__hero {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  padding: 24px 32px;
+  background: #ffffff;
+  border: 1px solid #e8edf5;
+  border-radius: 20px;
+  box-shadow: 0 4px 12px rgba(15, 23, 42, 0.02);
+}
+
+.tracking-question-page__header-top {
+  display: flex;
+}
+
+.tracking-question-page__back {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  height: 32px;
+  padding: 0 12px 0 8px;
+  border: none;
+  border-radius: 6px;
+  background: transparent;
+  color: #64748b;
+  font-size: 14px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  margin-left: -8px;
+}
+
+.tracking-question-page__back:hover {
+  background: #e2e8f0;
+  color: #0f172a;
+}
+
+.tracking-question-page__copy {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+}
+
+.tracking-question-page__eyebrow {
+  margin: 0;
+  color: #2563eb;
+  font-size: 13px;
+  font-weight: 700;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+
+.tracking-question-page__copy h1 {
+  margin: 0;
+  color: #0f172a;
+  font-size: 32px;
+  font-weight: 800;
+  line-height: 1.25;
+  letter-spacing: -0.02em;
+}
+
+.tracking-question-page__meta {
+  margin: 8px 0 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 12px;
+  background: #f1f5f9;
+  border-radius: 6px;
+  color: #475569;
+  font-size: 14px;
+  font-weight: 500;
+  width: fit-content;
+}
+
+.tracking-question-page__alert {
+  border-radius: 16px;
+}
+
+.tracking-question-page__tabs-wrapper {
+  background: #ffffff;
+  padding: 4px 24px 0;
+  border-radius: 16px;
+  border: 1px solid #e8edf5;
+  box-shadow: 0 4px 12px rgba(15, 23, 42, 0.02);
+}
+
+.tracking-question-tabs :deep(.ant-tabs-nav) {
+  margin-bottom: 0;
+}
+
+.tracking-question-tabs .is-muted {
+  opacity: 0.65;
+}
+
+.tracking-question-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1.45fr) minmax(0, 1fr);
+  grid-auto-rows: 800px;
+  gap: 20px;
+}
+
+.tracking-question-card {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  padding: 24px 28px;
+  border: 1px solid #e8edf5;
+  border-radius: 20px;
+  background: #ffffff;
+  box-shadow: 0 10px 30px rgba(15, 23, 42, 0.03);
+}
+
+.tracking-question-card--answer {
+  /* removed min-height, grid-auto-rows handles this universally */
+}
+
+.tracking-question-card__header {
+  margin-bottom: 20px;
+  flex-shrink: 0;
+}
+
+.tracking-question-card__header--split {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+.tracking-question-card__section-title {
+  display: inline-flex;
+  align-items: center;
+  gap: 14px;
+  color: #111827;
+  font-size: 20px;
+  font-weight: 700;
+}
+
+.tracking-question-card__accent {
+  display: inline-block;
+  width: 6px;
+  height: 28px;
+  border-radius: 999px;
+  background: #2563eb;
+}
+
+.tracking-question-card__hint {
+  margin: 0;
+  max-width: 420px;
+  color: #94a3b8;
+  font-size: 13px;
+  line-height: 1.6;
+  text-align: right;
+}
+
+.tracking-question-card__body {
+  display: flex;
+  flex: 1;
+  min-height: 0;
+  flex-direction: column;
+}
+
+.tracking-question-card__scroll-area {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  margin-right: -12px;
+  padding-right: 12px;
+}
+
+.tracking-question-answer__headline {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 18px;
+  flex-shrink: 0;
+}
+
+.tracking-question-answer__content {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  margin-right: -12px;
+  padding-right: 12px;
+  margin-bottom: 18px;
+}
+
+.custom-scrollbar::-webkit-scrollbar {
+  width: 6px;
+}
+
+.custom-scrollbar::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.custom-scrollbar::-webkit-scrollbar-thumb {
+  background: #e2e8f0;
+  border-radius: 4px;
+}
+
+.custom-scrollbar::-webkit-scrollbar-thumb:hover {
+  background: #cbd5e1;
+}
+
+.tracking-question-answer__headline h2 {
+  margin: 0;
+  font-size: 22px;
+}
+
+.tracking-question-answer__meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 18px;
+  margin-top: auto;
+  padding-top: 18px;
+  color: #9ca3af;
+  font-size: 13px;
+}
+
+.tracking-question-source-list,
+.tracking-question-content-list {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.tracking-question-source-card,
+.tracking-question-content-card {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 12px 16px;
+  border: 1px solid #edf2f7;
+  border-radius: 10px;
+  background: #f8fbff;
+  transition: all 0.2s ease;
+  text-decoration: none;
+}
+
+.tracking-question-source-card:hover,
+.tracking-question-content-card:hover {
+  border-color: #dbeafe;
+  box-shadow: 0 4px 12px rgba(37, 99, 235, 0.05);
+}
+
+.tracking-question-source-card__headline {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+}
+
+.tracking-question-source-card__headline strong {
+  display: block;
+  color: #2563eb;
+  font-size: 14px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.tracking-question-source-card__divider {
+  color: #cbd5e1;
+  font-weight: bold;
+}
+
+.tracking-question-source-card__title {
+  color: #475569;
+  font-size: 14px;
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tracking-question-source-card__badge {
+  margin: 0;
+  margin-left: auto;
+  white-space: nowrap;
+}
+
+.tracking-question-source-card__link {
+  color: #94a3b8;
+  font-size: 12px;
+  width: 100%;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tracking-question-content-card__copy a {
+  color: #2563eb;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.tracking-question-table {
+  display: flex;
+  flex-direction: column;
+}
+
+.tracking-question-table__head,
+.tracking-question-table__row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.45fr) minmax(0, 1fr) 92px 92px;
+  gap: 16px;
+  align-items: center;
+  padding: 18px 0;
+}
+
+.tracking-question-table__head {
+  color: #9ca3af;
+  font-size: 13px;
+  font-weight: 700;
+  border-bottom: 1px solid #edf2f7;
+}
+
+.tracking-question-table__row {
+  color: #4b5563;
+  border-bottom: 1px solid #f3f4f6;
+}
+
+.tracking-question-table__row:last-child {
+  border-bottom: 0;
+  padding-bottom: 0;
+}
+
+.tracking-question-table__primary {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.tracking-question-table__primary strong,
+.tracking-question-table__primary a {
+  color: #111827;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.tracking-question-table__primary small {
+  color: #94a3b8;
+}
+
+.tracking-question-table__secondary {
+  color: #94a3b8;
+  word-break: break-all;
+}
+
+.tracking-question-table__metric {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.tracking-question-table__metric strong,
+.tracking-question-table__row > strong {
+  color: #4b5563;
+  font-size: 16px;
+  justify-self: end;
+}
+
+.tracking-question-card--debug {
+  margin-top: 4px;
+}
+
+.tracking-task-debug-list {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.tracking-task-debug-card {
+  padding: 20px 22px;
+  border: 1px solid #edf2f7;
+  border-radius: 20px;
+  background: linear-gradient(180deg, #fbfdff 0%, #f5f9ff 100%);
+}
+
+.tracking-task-debug-card__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 18px;
+}
+
+.tracking-task-debug-card__headline {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.tracking-task-debug-card__headline strong {
+  color: #111827;
+  font-size: 16px;
+}
+
+.tracking-task-debug-card__headline small {
+  color: #94a3b8;
+  word-break: break-all;
+}
+
+.tracking-task-debug-card__tags {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.tracking-task-debug-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 14px;
+}
+
+.tracking-task-debug-grid__item {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  gap: 8px;
+  padding: 14px 16px;
+  border-radius: 16px;
+  background: #ffffff;
+}
+
+.tracking-task-debug-grid__item span {
+  color: #94a3b8;
+  font-size: 12px;
+}
+
+.tracking-task-debug-grid__item strong {
+  color: #1f2937;
+  font-size: 13px;
+  line-height: 1.6;
+  word-break: break-all;
+}
+
+.tracking-task-debug-notes {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+  margin-top: 14px;
+}
+
+.tracking-task-debug-notes__item {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 14px 16px;
+  border-radius: 16px;
+  background: #ffffff;
+}
+
+.tracking-task-debug-notes__item span {
+  color: #94a3b8;
+  font-size: 12px;
+}
+
+.tracking-task-debug-notes__item strong {
+  color: #1f2937;
+  line-height: 1.6;
+  word-break: break-word;
+}
+
+.tracking-task-debug-notes__item.is-error {
+  background: #fff7f7;
+}
+
+.tracking-task-debug-notes__item.is-error strong {
+  color: #b91c1c;
+}
+
+@media (max-width: 1080px) {
+  .tracking-question-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .tracking-task-debug-grid,
+  .tracking-task-debug-notes {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 720px) {
+  .tracking-question-page__hero {
+    flex-direction: column;
+  }
+
+  .tracking-question-page__copy h1 {
+    font-size: 26px;
+  }
+
+  .tracking-question-card {
+    padding: 22px 18px;
+  }
+
+  .tracking-question-card__header--split,
+  .tracking-task-debug-card__header {
+    flex-direction: column;
+  }
+
+  .tracking-question-card__hint,
+  .tracking-task-debug-card__tags {
+    max-width: none;
+    text-align: left;
+    justify-content: flex-start;
+  }
+
+  .tracking-question-table__head,
+  .tracking-question-table__row {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .tracking-question-source-card,
+  .tracking-question-content-card {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+
+  .tracking-question-source-card__meta,
+  .tracking-question-table__metric {
+    align-items: flex-start;
+    justify-content: flex-start;
+  }
+
+  .tracking-task-debug-grid,
+  .tracking-task-debug-notes {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/apps/admin-web/src/views/TrackingView.vue b/apps/admin-web/src/views/TrackingView.vue
new file mode 100644
index 0000000..bb5115c
--- /dev/null
+++ b/apps/admin-web/src/views/TrackingView.vue
@@ -0,0 +1,1412 @@
+<script setup lang="ts">
+import {
+  ReloadOutlined,
+} from "@ant-design/icons-vue";
+import { useMutation, useQuery } from "@tanstack/vue-query";
+import { useStorage } from "@vueuse/core";
+import { message } from "ant-design-vue";
+import dayjs from "dayjs";
+import type {
+  Brand,
+  MonitoringHotQuestion,
+  MonitoringTimeBucket,
+} from "@geo/shared-types";
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useRoute, useRouter } from "vue-router";
+
+import PageHero from "@/components/PageHero.vue";
+import { brandsApi, monitoringApi } from "@/lib/api";
+import { formatDateTime } from "@/lib/display";
+import { formatError } from "@/lib/errors";
+import { kickoffMonitoringCycle } from "@/lib/monitoring-plugin";
+import { loadPublisherRuntimeState } from "@/lib/publisher-runtime";
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+
+const trackingMaxHistoryDays = 30;
+const trackingBusinessTimeZone = "Asia/Shanghai";
+const trackingToday = formatTrackingBusinessDate(new Date());
+
+type CitationRankingRow = {
+  ai_platform_id: string;
+  platform_name: string;
+  cited_answer_count: number | null;
+  cited_article_count: number | null;
+  citation_rate: number | null;
+  share: number;
+  color: string;
+  surface: string;
+  glyph: string;
+};
+
+function formatTrackingBusinessDate(value: Date): string {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: trackingBusinessTimeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(value);
+
+  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;
+  if (!year || !month || !day) {
+    throw new Error("tracking_business_date_format_failed");
+  }
+
+  return `${year}-${month}-${day}`;
+}
+
+const platformAppearanceMap: Record<string, { color: string; surface: string; glyph: string }> = {
+  doubao: { color: "#ff9348", surface: "#fff2e8", glyph: "豆" },
+  deepseek: { color: "#5d72ff", surface: "#eef1ff", glyph: "D" },
+  qwen: { color: "#276ef1", surface: "#edf4ff", glyph: "通" },
+  tongyi: { color: "#6d5efc", surface: "#f1efff", glyph: "通" },
+  tongyiqianwen: { color: "#6d5efc", surface: "#f1efff", glyph: "通" },
+  wenxin: { color: "#20c6d7", surface: "#ebfcff", glyph: "文" },
+  wenxinyiyan: { color: "#20c6d7", surface: "#ebfcff", glyph: "文" },
+  yuanbao: { color: "#19bf6b", surface: "#eafbf1", glyph: "元" },
+  kimi: { color: "#111827", surface: "#f3f4f6", glyph: "K" },
+};
+
+const selectedBrandId = useStorage<number | null>("tracking_selected_brand", null);
+const selectedKeywordId = useStorage<number | null>("tracking_selected_keyword", null);
+const selectedBusinessDate = useStorage<string>("tracking_selected_business_date", trackingToday);
+const pluginPreparing = ref(false);
+
+selectedBusinessDate.value = normalizeTrackingBusinessDate(selectedBusinessDate.value) ?? trackingToday;
+
+const brandsQuery = useQuery({
+  queryKey: ["tracking", "brands"],
+  queryFn: () => brandsApi.list(),
+});
+
+watch(
+  () => brandsQuery.data.value,
+  (brands) => {
+    if (!brands?.length) {
+      return;
+    }
+
+    const requestedBrandId = parseNumericQuery(route.query.brand_id);
+    if (requestedBrandId && brands.some((item) => item.id === requestedBrandId)) {
+      selectedBrandId.value = requestedBrandId;
+      return;
+    }
+
+    if (selectedBrandId.value && brands.some((item) => item.id === selectedBrandId.value)) {
+      return;
+    }
+
+    selectedBrandId.value = brands[0].id;
+  },
+  { immediate: true },
+);
+
+const keywordsQuery = useQuery({
+  queryKey: computed(() => ["tracking", "keywords", selectedBrandId.value]),
+  enabled: computed(() => Boolean(selectedBrandId.value)),
+  queryFn: () => brandsApi.listKeywords(selectedBrandId.value as number),
+});
+
+watch(
+  () => keywordsQuery.data.value,
+  (keywords) => {
+    if (!keywords?.length) {
+      return;
+    }
+
+    const requestedKeywordId = parseNumericQuery(route.query.keyword_id);
+    if (requestedKeywordId && keywords.some((item) => item.id === requestedKeywordId)) {
+      selectedKeywordId.value = requestedKeywordId;
+      return;
+    }
+
+    if (selectedKeywordId.value && keywords.some((item) => item.id === selectedKeywordId.value)) {
+      return;
+    }
+
+    selectedKeywordId.value = keywords[0].id;
+  },
+  { immediate: true },
+);
+
+watch(selectedBrandId, (newId, oldId) => {
+  if (oldId && newId !== oldId) {
+    selectedKeywordId.value = null;
+  }
+});
+
+watch(
+  () => route.query.business_date,
+  (value) => {
+    const requestedBusinessDate = normalizeTrackingBusinessDate(value);
+    if (requestedBusinessDate) {
+      selectedBusinessDate.value = requestedBusinessDate;
+    }
+  },
+  { immediate: true },
+);
+
+watch([selectedBrandId, selectedKeywordId, selectedBusinessDate], ([brandId, keywordId, businessDate]) => {
+  const nextBrandId = brandId ? String(brandId) : undefined;
+  const nextKeywordId = keywordId ? String(keywordId) : undefined;
+  const nextBusinessDate = normalizeTrackingBusinessDate(businessDate) ?? trackingToday;
+  const currentBrandId = normalizeQueryValue(route.query.brand_id) || undefined;
+  const currentKeywordId = normalizeQueryValue(route.query.keyword_id) || undefined;
+  const currentBusinessDate = normalizeTrackingBusinessDate(route.query.business_date) ?? trackingToday;
+
+  if (
+    currentBrandId === nextBrandId &&
+    currentKeywordId === nextKeywordId &&
+    currentBusinessDate === nextBusinessDate
+  ) {
+    return;
+  }
+
+  void router.replace({
+    name: "tracking",
+    query: {
+      ...(nextBrandId ? { brand_id: nextBrandId } : {}),
+      ...(nextKeywordId ? { keyword_id: nextKeywordId } : {}),
+      business_date: nextBusinessDate,
+    },
+  });
+});
+
+const trackingWindow = computed(() => {
+  const end = dayjs(selectedBusinessDate.value);
+  const earliestAllowed = dayjs(trackingToday).subtract(trackingMaxHistoryDays - 1, "day").startOf("day");
+  const candidateFrom = end.subtract(trackingMaxHistoryDays - 1, "day");
+  const from = candidateFrom.isBefore(earliestAllowed, "day") ? earliestAllowed : candidateFrom;
+  return {
+    from: from.format("YYYY-MM-DD"),
+    to: end.format("YYYY-MM-DD"),
+  };
+});
+
+async function ensureMonitoringPluginReady(options?: { silent?: boolean }): Promise<void> {
+  pluginPreparing.value = true;
+  try {
+    const runtime = await loadPublisherRuntimeState();
+    if (!runtime.ping.installed) {
+      throw new Error("monitoring_plugin_required");
+    }
+    if (!runtime.pluginInstallationId) {
+      throw new Error("monitoring_plugin_register_required");
+    }
+  } catch (error) {
+    if (!options?.silent) {
+      throw error;
+    }
+  } finally {
+    pluginPreparing.value = false;
+  }
+}
+
+const dashboardQuery = useQuery({
+  queryKey: computed(() => ["tracking", "dashboard", selectedBrandId.value, selectedKeywordId.value, selectedBusinessDate.value]),
+  enabled: computed(() => Boolean(selectedBrandId.value)),
+  queryFn: () =>
+    monitoringApi.dashboardComposite({
+      brand_id: selectedBrandId.value ?? undefined,
+      keyword_id: selectedKeywordId.value,
+      days: trackingMaxHistoryDays,
+      business_date: selectedBusinessDate.value,
+    }),
+});
+
+const collectNowMutation = useMutation({
+  mutationFn: async () => {
+    if (!selectedKeywordId.value) {
+      throw new Error("tracking_keyword_required");
+    }
+    await ensureMonitoringPluginReady();
+    const collectNowResult = await monitoringApi.collectNow(selectedBrandId.value as number, {
+      keyword_id: selectedKeywordId.value,
+    });
+
+    try {
+      const kickoffResult = await kickoffMonitoringCycle();
+      return {
+        collectNowResult,
+        kickoffResult,
+        kickoffError: null,
+      };
+    } catch (error) {
+      return {
+        collectNowResult,
+        kickoffResult: null,
+        kickoffError: formatError(error),
+      };
+    }
+  },
+  onSuccess: ({ collectNowResult, kickoffResult, kickoffError }) => {
+    if (kickoffError) {
+      message.warning(`${collectNowResult.message}，但后台采集启动失败：${kickoffError}`);
+      void dashboardQuery.refetch();
+      return;
+    }
+
+    if (kickoffResult?.status === "already_running") {
+      message.success(`${collectNowResult.message}，插件后台已继续执行`);
+      void dashboardQuery.refetch();
+      return;
+    }
+
+    message.success(collectNowResult.message);
+    void dashboardQuery.refetch();
+  },
+  onError: (error) => {
+    if (error instanceof Error && error.message === "tracking_keyword_required") {
+      message.warning(t("tracking.collectKeywordRequired"));
+      return;
+    }
+    if (error instanceof Error && (error.message === "monitoring_plugin_required" || error.message === "monitoring_plugin_register_required")) {
+      message.warning(formatError(error));
+      return;
+    }
+    message.error(formatError(error));
+  },
+});
+
+const selectedBrand = computed<Brand | null>(() => {
+  return brandsQuery.data.value?.find((item) => item.id === selectedBrandId.value) ?? null;
+});
+
+const selectedDateHasData = computed(() => {
+  return (dashboardQuery.data.value?.overview.actual_sample_count ?? 0) > 0;
+});
+
+const hotQuestions = computed(() => {
+  return dashboardQuery.data.value?.hot_questions ?? [];
+});
+
+const selectedMetricCards = computed(() => {
+  const overview = dashboardQuery.data.value?.overview;
+  const buckets = dashboardQuery.data.value?.brand_time_buckets ?? [];
+  const points = selectedDateHasData.value ? buckets : [];
+  return [
+    {
+      key: "mention",
+      title: t("tracking.metrics.mentionRate"),
+      value: overview?.mention_rate ?? null,
+      previous: overview?.prev_snapshot_mention_rate ?? null,
+      points: points.map((item) => item.mention_rate),
+    },
+    {
+      key: "top1",
+      title: t("tracking.metrics.top1MentionRate"),
+      value: overview?.top1_mention_rate ?? null,
+      previous: overview?.prev_snapshot_top1_mention_rate ?? null,
+      points: points.map((item) => item.top1_mention_rate),
+    },
+    {
+      key: "first",
+      title: t("tracking.metrics.firstRecommendRate"),
+      value: overview?.first_recommend_rate ?? null,
+      previous: overview?.prev_snapshot_first_recommend_rate ?? null,
+      points: points.map((item) => item.first_recommend_rate),
+    },
+    {
+      key: "positive",
+      title: t("tracking.metrics.positiveMentionRate"),
+      value: overview?.positive_mention_rate ?? null,
+      previous: overview?.prev_snapshot_positive_mention_rate ?? null,
+      points: points.map((item) => item.positive_mention_rate),
+    },
+  ];
+});
+
+const coverageSummary = computed(() => {
+  const overview = dashboardQuery.data.value?.overview;
+  if (!overview) {
+    return "";
+  }
+  if (!selectedDateHasData.value) {
+    return `${selectedBusinessDate.value} 暂无抓取数据`;
+  }
+  return t("tracking.coverageSummary", {
+    desired: overview.desired_sample_count,
+    actual: overview.actual_sample_count,
+    coverage: formatPercent(overview.coverage_rate),
+  });
+});
+
+const citationRankingRows = computed<CitationRankingRow[]>(() => {
+  if (!selectedDateHasData.value) {
+    return [];
+  }
+
+  const breakdown = dashboardQuery.data.value?.platform_breakdown ?? [];
+  const ranking = dashboardQuery.data.value?.citation_ranking ?? [];
+  const order = new Map<string, number>();
+  const rows = new Map<string, CitationRankingRow>();
+
+  breakdown.forEach((item, index) => {
+    order.set(item.ai_platform_id, index);
+    rows.set(item.ai_platform_id, {
+      ai_platform_id: item.ai_platform_id,
+      platform_name: item.platform_name,
+      cited_answer_count: null,
+      cited_article_count: null,
+      citation_rate: null,
+      share: 0,
+      ...platformAppearance(item.ai_platform_id, item.platform_name),
+    });
+  });
+
+  ranking.forEach((item, index) => {
+    if (!order.has(item.ai_platform_id)) {
+      order.set(item.ai_platform_id, breakdown.length + index);
+    }
+
+    const existing = rows.get(item.ai_platform_id);
+    rows.set(item.ai_platform_id, {
+      ai_platform_id: item.ai_platform_id,
+      platform_name: item.platform_name || existing?.platform_name || item.ai_platform_id,
+      cited_answer_count: item.cited_answer_count,
+      cited_article_count: item.cited_article_count,
+      citation_rate: item.citation_rate,
+      share: 0,
+      ...platformAppearance(item.ai_platform_id, item.platform_name || existing?.platform_name || item.ai_platform_id),
+    });
+  });
+
+  const list = Array.from(rows.values());
+  const totalAppearances = list.reduce((sum, item) => sum + Math.max(item.cited_answer_count ?? 0, 0), 0);
+  const enriched = list.map((item) => ({
+    ...item,
+    share: totalAppearances > 0 ? Math.max(item.cited_answer_count ?? 0, 0) / totalAppearances : 0,
+  }));
+  const hasCitationData = enriched.some((item) => (item.cited_answer_count ?? 0) > 0);
+
+  return enriched.sort((left, right) => {
+    if (hasCitationData) {
+      const countDiff = (right.cited_answer_count ?? 0) - (left.cited_answer_count ?? 0);
+      if (countDiff !== 0) {
+        return countDiff;
+      }
+    }
+    return (order.get(left.ai_platform_id) ?? 0) - (order.get(right.ai_platform_id) ?? 0);
+  });
+});
+
+const visibleCitedArticles = computed(() => {
+  if (!selectedDateHasData.value) {
+    return [];
+  }
+  return dashboardQuery.data.value?.cited_articles ?? [];
+});
+
+const citationChartStyle = computed(() => {
+  const segments = citationRankingRows.value.filter((item) => (item.cited_answer_count ?? 0) > 0);
+
+  if (!segments.length) {
+    return {
+      background: "linear-gradient(180deg, #eef4ff 0%, #e5ecff 100%)",
+    };
+  }
+
+  let offset = 0;
+  const gradientStops = segments.map((item) => {
+    const next = offset + item.share * 360;
+    const stop = `${item.color} ${offset.toFixed(2)}deg ${next.toFixed(2)}deg`;
+    offset = next;
+    return stop;
+  });
+
+  return {
+    background: `conic-gradient(${gradientStops.join(", ")})`,
+  };
+});
+
+void ensureMonitoringPluginReady({ silent: true });
+
+const heroDescription = computed(() => {
+  const overview = dashboardQuery.data.value?.overview;
+  if (!overview?.last_sampled_at) {
+    return `${selectedBusinessDate.value} 暂无抓取数据`;
+  }
+  return `最近一次采集数据：${formatDateTime(overview.last_sampled_at)}`;
+});
+
+function openQuestion(question: MonitoringHotQuestion): void {
+  if (!selectedBrandId.value) {
+    return;
+  }
+
+  void router.push({
+    name: "tracking-question-detail",
+    params: {
+      brandId: String(selectedBrandId.value),
+      questionId: String(question.question_id),
+    },
+    query: {
+      question_hash: question.question_hash,
+      question_text: question.question_text,
+      business_date: selectedBusinessDate.value,
+      date_from: selectedBusinessDate.value,
+      date_to: selectedBusinessDate.value,
+      ...(selectedKeywordId.value ? { keyword_id: String(selectedKeywordId.value) } : {}),
+    },
+  });
+}
+
+function formatPercent(value: number | null | undefined): string {
+  if (value === null || value === undefined) {
+    return "--";
+  }
+  return `${(value * 100).toFixed(value < 0.1 ? 1 : 0)}%`;
+}
+
+function formatCount(value: number | null | undefined): string {
+  if (value === null || value === undefined) {
+    return "--";
+  }
+  return String(value);
+}
+
+function formatDelta(current: number | null | undefined, previous: number | null | undefined): string | null {
+  if (current === null || current === undefined || previous === null || previous === undefined) {
+    return null;
+  }
+  const diff = current - previous;
+  if (Math.abs(diff) < 0.001) {
+    return t("tracking.noChange");
+  }
+  const prefix = diff > 0 ? "+" : "";
+  return `${prefix}${(diff * 100).toFixed(1)}%`;
+}
+
+function bucketPointClass(bucket: MonitoringTimeBucket, point: number | null): string {
+  if (point === null || point === undefined) {
+    return "metric-card__point metric-card__point--empty";
+  }
+  if (bucket.sample_status === "partial") {
+    return "metric-card__point metric-card__point--partial";
+  }
+  return "metric-card__point metric-card__point--solid";
+}
+
+function dayDotClass(bucket: MonitoringTimeBucket): string {
+  if (bucket.sample_status === "sampled") {
+    return "tracking-day-dot tracking-day-dot--sampled";
+  }
+  if (bucket.sample_status === "partial") {
+    return "tracking-day-dot tracking-day-dot--partial";
+  }
+  return "tracking-day-dot";
+}
+
+function formatTriggerSource(value: string): string {
+  return value === "manual" ? t("tracking.manual") : t("tracking.automatic");
+}
+
+function statusTagColor(status: string): string {
+  switch (status) {
+    case "sampled":
+      return "green";
+    case "pending":
+      return "gold";
+    case "not_logged_in":
+      return "default";
+    case "unavailable":
+      return "red";
+    default:
+      return "default";
+  }
+}
+
+function statusLabel(status: string): string {
+  return t(`tracking.status.${status}`);
+}
+
+function platformAppearance(aiPlatformId: string, platformName: string) {
+  const normalizedId = aiPlatformId.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const matched = platformAppearanceMap[normalizedId];
+
+  if (matched) {
+    return matched;
+  }
+
+  const glyph = platformName.trim().slice(0, 1).toUpperCase() || "?";
+  return {
+    color: "#f5b13d",
+    surface: "#fff7e8",
+    glyph,
+  };
+}
+
+function parseNumericQuery(value: unknown): number | null {
+  const raw = Array.isArray(value) ? value[0] : value;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+}
+
+function normalizeQueryValue(value: unknown): string {
+  return String(Array.isArray(value) ? value[0] ?? "" : value ?? "").trim();
+}
+
+function normalizeTrackingBusinessDate(value: unknown): string | null {
+  const normalized = normalizeQueryValue(value);
+  if (!normalized) {
+    return null;
+  }
+  const parsed = dayjs(normalized);
+  if (!parsed.isValid() || parsed.format("YYYY-MM-DD") !== normalized) {
+    return null;
+  }
+
+  const today = dayjs().startOf("day");
+  const earliestAllowed = today.subtract(trackingMaxHistoryDays - 1, "day");
+  if (parsed.isAfter(today, "day") || parsed.isBefore(earliestAllowed, "day")) {
+    return null;
+  }
+  return normalized;
+}
+
+function disableTrackingDate(current: dayjs.Dayjs): boolean {
+  const today = dayjs().endOf("day");
+  const earliestAllowed = dayjs().subtract(trackingMaxHistoryDays - 1, "day").startOf("day");
+  return current.isAfter(today) || current.isBefore(earliestAllowed);
+}
+</script>
+
+<template>
+  <section class="tracking-view">
+    <PageHero
+      :eyebrow="t('tracking.eyebrow')"
+      :title="t('route.tracking.title')"
+      :description="heroDescription"
+    >
+      <template #actions>
+        <a-space wrap align="center" class="tracking-actions-wrap">
+          <div class="tracking-action-item">
+            <span class="tracking-action-label">品牌</span>
+            <a-select
+              v-model:value="selectedBrandId"
+              class="tracking-select"
+              :placeholder="t('tracking.brandPlaceholder')"
+              :options="(brandsQuery.data.value ?? []).map((item) => ({ label: item.name, value: item.id }))"
+            />
+          </div>
+          <div class="tracking-action-item">
+            <span class="tracking-action-label">关键词</span>
+            <a-select
+              v-model:value="selectedKeywordId"
+              allow-clear
+              class="tracking-select"
+              :placeholder="t('tracking.keywordPlaceholder')"
+              :options="(keywordsQuery.data.value ?? []).map((item) => ({ label: item.name, value: item.id }))"
+            />
+          </div>
+          <div class="tracking-action-item">
+            <span class="tracking-action-label">日期</span>
+            <a-date-picker
+              v-model:value="selectedBusinessDate"
+              class="tracking-date-picker"
+              format="YYYY-MM-DD"
+              value-format="YYYY-MM-DD"
+              :allow-clear="false"
+              :disabled-date="disableTrackingDate"
+            />
+          </div>
+          <a-button
+            type="primary"
+            :disabled="!selectedBrandId || !selectedKeywordId"
+            :loading="collectNowMutation.isPending.value || pluginPreparing"
+            @click="collectNowMutation.mutate()"
+          >
+            <template #icon><ReloadOutlined /></template>
+            {{ t("tracking.collectNow") }}
+          </a-button>
+        </a-space>
+      </template>
+    </PageHero>
+
+    <a-alert
+      v-if="dashboardQuery.error.value"
+      type="error"
+      show-icon
+      :message="formatError(dashboardQuery.error.value)"
+      class="tracking-view__alert"
+    />
+
+    <div class="tracking-grid tracking-grid--top">
+      <a-card class="tracking-panel tracking-panel--overview" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-panel__header">
+          <h3 class="panel-title">{{ selectedBrand?.name ?? t("common.noData") }}</h3>
+          <a-tag :color="selectedDateHasData ? (dashboardQuery.data.value?.overview.confidence_level === 'high' ? 'green' : dashboardQuery.data.value?.overview.confidence_level === 'medium' ? 'gold' : 'default') : 'default'">
+            {{ selectedDateHasData ? t(`tracking.confidence.${dashboardQuery.data.value?.overview.confidence_level ?? 'low'}`) : '暂无抓取' }}
+          </a-tag>
+        </div>
+
+        <div class="metric-grid tracking-metric-grid">
+          <article v-for="card in selectedMetricCards" :key="card.key" class="metric-card">
+            <p class="metric-card__label">{{ card.title }}</p>
+            <div class="metric-card__value-row">
+              <strong>{{ formatPercent(card.value) }}</strong>
+              <span v-if="formatDelta(card.value, card.previous)" :class="['metric-card__delta', (card.value ?? 0) >= (card.previous ?? 0) ? 'metric-card__delta--up' : 'metric-card__delta--down']">
+                {{ formatDelta(card.value, card.previous) }}
+              </span>
+            </div>
+            <div class="metric-card__sparkline">
+              <span
+                v-for="(bucket, index) in dashboardQuery.data.value?.brand_time_buckets ?? []"
+                :key="`${card.key}-${bucket.date}`"
+                :class="bucketPointClass(bucket, card.points[index])"
+              />
+            </div>
+          </article>
+        </div>
+      </a-card>
+
+      <a-card class="tracking-panel" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-panel__header">
+          <h3 class="panel-title">{{ t("tracking.platformMatrixTitle") }}</h3>
+        </div>
+
+        <div class="platform-table">
+          <div class="platform-table__head">
+            <span>{{ t("tracking.columns.platform") }}</span>
+            <span>{{ t("tracking.metrics.mentionRate") }}</span>
+            <span>{{ t("tracking.metrics.top1MentionRate") }}</span>
+            <span>{{ t("common.status") }}</span>
+          </div>
+
+          <div
+            v-for="item in dashboardQuery.data.value?.platform_breakdown ?? []"
+            :key="item.ai_platform_id"
+            class="platform-table__row"
+          >
+            <div class="platform-table__platform">
+              <strong>{{ item.platform_name }}</strong>
+              <span>{{ item.actual_sample_count }} {{ t("tracking.samples") }}</span>
+            </div>
+            <span>{{ item.platform_sample_status === 'sampled' ? formatPercent(item.mention_rate) : '--' }}</span>
+            <span>{{ item.platform_sample_status === 'sampled' ? formatPercent(item.top1_mention_rate) : '--' }}</span>
+            <a-tag :color="statusTagColor(item.platform_sample_status)">
+              {{ statusLabel(item.platform_sample_status) }}
+            </a-tag>
+          </div>
+        </div>
+      </a-card>
+    </div>
+
+    <div class="tracking-grid tracking-grid--middle">
+      <a-card class="tracking-panel" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-panel__header">
+          <h3 class="panel-title">{{ t("tracking.coverageTitle") }}</h3>
+          <span class="tracking-panel__helper">{{ coverageSummary }}</span>
+        </div>
+
+        <a-progress
+          :percent="Math.round((dashboardQuery.data.value?.overview.coverage_rate ?? 0) * 100)"
+          :show-info="false"
+          stroke-color="#f97316"
+          trail-color="#fff1e6"
+        />
+
+        <div class="tracking-day-row">
+          <a-tooltip
+            v-for="bucket in dashboardQuery.data.value?.brand_time_buckets ?? []"
+            :key="bucket.date"
+            :title="`${bucket.date} · ${statusLabel(bucket.sample_status)} · ${bucket.actual_sample_count}/${bucket.planned_sample_count}`"
+          >
+            <span :class="dayDotClass(bucket)" />
+          </a-tooltip>
+        </div>
+      </a-card>
+
+      <a-card class="tracking-panel" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-panel__header">
+          <h3 class="panel-title">{{ t("tracking.hotQuestionsTitle") }}</h3>
+          <span class="tracking-panel__helper">{{ t("tracking.hotQuestionsHint") }}</span>
+        </div>
+
+        <div v-if="hotQuestions.length" class="question-list">
+          <button
+            v-for="question in hotQuestions"
+            :key="`${question.question_id}-${question.question_hash}`"
+            type="button"
+            class="question-list__item"
+            @click="openQuestion(question)"
+          >
+            <div>
+              <strong>{{ question.question_text }}</strong>
+              <p>{{ t("tracking.metrics.mentionRate") }} {{ formatPercent(question.mention_rate) }}</p>
+            </div>
+            <span class="question-list__time">{{ question.last_sampled_at ? formatDateTime(question.last_sampled_at) : '--' }}</span>
+          </button>
+        </div>
+
+        <a-empty v-else :description="t('tracking.noQuestions')" />
+      </a-card>
+    </div>
+
+    <div class="tracking-grid tracking-grid--bottom">
+      <a-card class="tracking-panel tracking-panel--citation" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-citation-section">
+          <div class="tracking-citation-header">
+            <h3 class="tracking-citation-title">{{ t("tracking.citationRankingTitle") }}</h3>
+            <p class="tracking-citation-desc">{{ t("tracking.citationRankingHint") }}</p>
+          </div>
+
+          <div class="citation-ranking-layout">
+            <div class="citation-ranking-visual">
+              <div class="citation-ranking-visual__canvas">
+                <div class="citation-ranking-visual__circle" :style="citationChartStyle" />
+              </div>
+
+              <div v-if="citationRankingRows.length" class="citation-ranking-legend">
+                <div
+                  v-for="item in citationRankingRows"
+                  :key="`legend-${item.ai_platform_id}`"
+                  class="citation-ranking-legend__item"
+                >
+                  <span class="citation-ranking-legend__swatch" :style="{ background: item.color }" />
+                  <span class="citation-platform__mini">
+                    <span
+                      class="citation-platform__mini-badge"
+                      :style="{ background: item.surface, color: item.color }"
+                    >
+                      {{ item.glyph }}
+                    </span>
+                    <span>{{ item.platform_name }}</span>
+                  </span>
+                </div>
+              </div>
+
+              <a-empty
+                v-else
+                :description="t('tracking.noCitationRanking')"
+              />
+            </div>
+
+            <div class="citation-ranking-sheet">
+              <div class="citation-ranking-sheet__head">
+                <span>{{ t("tracking.columns.platform") }}</span>
+                <span>{{ t("tracking.columns.appearances") }}</span>
+                <span>{{ t("tracking.columns.citationRate") }}</span>
+              </div>
+
+              <div
+                v-for="item in citationRankingRows"
+                :key="item.ai_platform_id"
+                class="citation-ranking-sheet__row"
+              >
+                <div class="citation-platform__mini">
+                  <span
+                    class="citation-platform__mini-badge"
+                    :style="{ background: item.surface, color: item.color }"
+                  >
+                    {{ item.glyph }}
+                  </span>
+                  <strong>{{ item.platform_name }}</strong>
+                </div>
+                <span class="citation-ranking-sheet__count">{{ formatCount(item.cited_answer_count) }} {{ item.cited_answer_count != null ? '条' : '' }}</span>
+                <strong class="citation-ranking-sheet__rate">{{ formatPercent(item.citation_rate) }}</strong>
+              </div>
+
+              <a-empty
+                v-if="!citationRankingRows.length"
+                :description="t('tracking.noCitationRanking')"
+              />
+            </div>
+          </div>
+        </div>
+      </a-card>
+
+      <a-card class="tracking-panel" :loading="dashboardQuery.isLoading.value">
+        <div class="tracking-panel__header">
+          <h3 class="panel-title">{{ t("tracking.citedArticlesTitle") }}</h3>
+        </div>
+
+        <div class="article-list">
+          <div
+            v-for="item in visibleCitedArticles"
+            :key="item.article_id"
+            class="article-list__item"
+          >
+            <div>
+              <strong>{{ item.article_title }}</strong>
+              <p>{{ item.publish_platform }}</p>
+            </div>
+            <div class="article-list__meta">
+              <span>{{ item.citation_count }} {{ t("tracking.citations") }}</span>
+              <strong>{{ formatPercent(item.citation_rate) }}</strong>
+            </div>
+          </div>
+          <a-empty
+            v-if="!visibleCitedArticles.length"
+            :description="t('tracking.noCitedArticles')"
+          />
+        </div>
+      </a-card>
+    </div>
+
+  </section>
+</template>
+
+<style scoped>
+.tracking-view {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.tracking-actions-wrap {
+  align-items: center;
+}
+
+.tracking-view__alert {
+  margin-bottom: 4px;
+}
+
+.tracking-action-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.tracking-action-label {
+  font-size: 14px;
+  color: #1f2937;
+  font-weight: 500;
+}
+
+.tracking-select {
+  min-width: 180px;
+}
+
+.tracking-date-picker {
+  min-width: 168px;
+}
+
+
+.tracking-grid {
+  display: grid;
+  gap: 20px;
+}
+
+.tracking-grid--top {
+  grid-template-columns: minmax(0, 1.6fr) minmax(0, 1fr);
+}
+
+.tracking-grid--middle {
+  grid-template-columns: minmax(0, 1.6fr) minmax(0, 1fr);
+}
+
+.tracking-grid--bottom {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.tracking-citation-section {
+  display: flex;
+  flex-direction: column;
+  padding: 0;
+  margin-top: 10px;
+}
+
+.tracking-citation-section.is-loading {
+  opacity: 0.6;
+  pointer-events: none;
+}
+
+.tracking-citation-header {
+  margin-bottom: 24px;
+}
+
+.tracking-citation-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 700;
+  color: #1a1a1a;
+}
+
+.tracking-citation-desc {
+  margin: 4px 0 0;
+  color: #8c8c8c;
+  font-size: 13px;
+}
+
+.tracking-panel {
+  border-radius: 12px;
+  background: #ffffff;
+}
+
+.tracking-panel--citation {
+  overflow: hidden;
+}
+
+.tracking-panel__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 20px;
+}
+
+.tracking-panel__header-left {
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 700;
+  color: #1a1a1a;
+  display: flex;
+  align-items: center;
+}
+
+.panel-title::before {
+  content: "";
+  display: inline-block;
+  width: 4px;
+  height: 14px;
+  background: #1f5cff;
+  border-radius: 2px;
+  margin-right: 8px;
+}
+
+.tracking-panel__description {
+  margin: 10px 0 0 12px;
+  color: #a3a3a3;
+  font-size: 13px;
+}
+
+.tracking-panel__helper {
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.tracking-metric-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16px;
+}
+
+.metric-card {
+  background: #f7f9fc;
+  border: 1px solid #f0f3fa;
+  border-radius: 12px;
+  padding: 16px;
+}
+
+.metric-card__label {
+  margin: 0;
+  color: #8c8c8c;
+  font-size: 13px;
+}
+
+.metric-card__value-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 10px;
+}
+
+.metric-card__value-row strong {
+  font-size: 24px;
+  font-weight: 800;
+  color: #141414;
+}
+
+.metric-card__delta {
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.metric-card__delta--up {
+  color: #15803d;
+}
+
+.metric-card__delta--down {
+  color: #dc2626;
+}
+
+.metric-card__sparkline {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 22px;
+  margin-top: 14px;
+}
+
+.metric-card__point {
+  width: 8px;
+  height: 8px;
+  border-radius: 999px;
+  background: #1677ff;
+}
+
+.metric-card__point--partial {
+  opacity: 0.4;
+}
+
+.metric-card__point--empty {
+  background: transparent;
+  border: 1px solid #1677ff;
+}
+
+.platform-table,
+.citation-table {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+}
+
+.platform-table__head,
+.platform-table__row,
+.citation-table__head,
+.citation-table__row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.5fr) repeat(3, minmax(0, 1fr));
+  align-items: center;
+  gap: 12px;
+}
+
+.platform-table__head,
+.citation-table__head {
+  background: #fafafa;
+  color: #8c8c8c;
+  font-weight: 500;
+  font-size: 13px;
+  padding: 12px 16px;
+  border-bottom: 1px solid #f0f0f0;
+}
+
+.platform-table__row,
+.citation-table__row {
+  padding: 16px;
+  border-bottom: 1px solid #f9f9f9;
+  background: #ffffff;
+}
+
+.platform-table__row:last-child,
+.citation-table__row:last-child {
+  border-bottom: none;
+}
+
+.platform-table__platform span {
+  display: block;
+  margin-top: 4px;
+  color: var(--muted);
+  font-size: 12px;
+}
+
+.citation-ranking-layout {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(400px, 1fr);
+  gap: 40px;
+  align-items: flex-start;
+}
+
+.citation-ranking-visual {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 32px;
+  padding: 0;
+}
+
+.citation-ranking-visual__canvas {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+}
+
+.citation-ranking-visual__circle {
+  width: min(32vw, 420px);
+  height: min(32vw, 420px);
+  min-width: 280px;
+  min-height: 280px;
+  border-radius: 999px;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.85);
+}
+
+.citation-ranking-legend {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 16px 24px;
+}
+
+.citation-ranking-legend__item {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: #4b5563;
+  font-size: 14px;
+}
+
+.citation-ranking-legend__swatch {
+  width: 12px;
+  height: 12px;
+  border-radius: 4px;
+  flex: 0 0 auto;
+}
+
+.citation-platform__mini {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+
+.citation-platform__mini-badge {
+  display: inline-flex;
+  width: 20px;
+  height: 20px;
+  border-radius: 999px;
+  align-items: center;
+  justify-content: center;
+  font-size: 11px;
+  font-weight: 700;
+  flex: 0 0 auto;
+}
+
+.citation-ranking-sheet {
+  border-radius: 12px;
+  border: 1px solid #f0f3fa;
+  background: #ffffff;
+  overflow: hidden;
+}
+
+.citation-ranking-sheet__head,
+.citation-ranking-sheet__row {
+  display: grid;
+  grid-template-columns: minmax(0, 1.4fr) minmax(0, 0.8fr) minmax(0, 0.8fr);
+  align-items: center;
+  gap: 16px;
+  padding: 20px 32px;
+}
+
+.citation-ranking-sheet__head {
+  background: #fafafa;
+  color: #4b5563;
+  font-size: 13px;
+  font-weight: 500;
+  border-bottom: 1px solid #f0f0f0;
+}
+
+.citation-ranking-sheet__row {
+  border-bottom: 1px solid #f9f9f9;
+  color: #4b5563;
+  font-size: 14px;
+}
+
+.citation-ranking-sheet__row:last-child {
+  border-bottom: none;
+}
+
+.citation-ranking-sheet__row strong {
+  color: #111827;
+  font-size: 14px;
+}
+
+.citation-ranking-sheet__row > span,
+.citation-ranking-sheet__row > strong {
+  justify-self: start;
+}
+
+.citation-ranking-sheet__count {
+  color: #374151;
+}
+
+.citation-ranking-sheet__rate {
+  color: #111827;
+}
+
+.tracking-day-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-top: 18px;
+}
+
+.tracking-day-dot {
+  width: 12px;
+  height: 12px;
+  border-radius: 999px;
+  border: 1px solid #fdba74;
+  background: transparent;
+}
+
+.tracking-day-dot--sampled {
+  background: #f97316;
+  border-color: #f97316;
+}
+
+.tracking-day-dot--partial {
+  background: linear-gradient(90deg, #f97316 50%, transparent 50%);
+}
+.question-list,
+.article-list,
+.detail-citation-list {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.question-list__item,
+.article-list__item,
+.detail-citation-list__item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  width: 100%;
+  padding: 16px;
+  border: 1px solid #f0f3fa;
+  border-radius: 12px;
+  background: #f7f9fc;
+  text-align: left;
+  transition: all 0.2s;
+}
+
+.question-list__item:hover,
+.article-list__item:hover,
+.detail-citation-list__item:hover {
+  background: #ffffff;
+  border-color: #e5eaf2;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
+}
+
+.question-list__item {
+  cursor: pointer;
+}
+
+.question-list__item strong,
+.article-list__item strong,
+.detail-citation-list__item strong {
+  display: block;
+}
+
+.question-list__item p,
+.article-list__item p,
+.detail-citation-list__item p {
+  margin: 4px 0 0;
+  color: var(--muted);
+}
+
+.question-list__time,
+.article-list__meta {
+  color: var(--muted);
+  font-size: 12px;
+}
+
+.article-list__meta {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 6px;
+}
+
+.detail-tabs {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-bottom: 16px;
+}
+
+.detail-tabs__item {
+  padding: 8px 14px;
+  border: 1px solid #fed7aa;
+  border-radius: 999px;
+  background: #fff7ed;
+  cursor: pointer;
+}
+
+.detail-tabs__item--active {
+  border-color: #f97316;
+  background: #f97316;
+  color: #fff;
+}
+
+.detail-tabs__item--muted {
+  opacity: 0.55;
+}
+
+.detail-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1.4fr) minmax(0, 1fr);
+  gap: 16px;
+}
+
+.detail-grid--bottom {
+  margin-top: 16px;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+}
+
+.detail-meta {
+  display: flex;
+  gap: 12px;
+  margin-top: 16px;
+  color: var(--muted);
+  font-size: 12px;
+}
+
+@media (max-width: 1080px) {
+  .tracking-grid--top,
+  .tracking-grid--middle,
+  .tracking-grid--bottom,
+  .detail-grid,
+  .detail-grid--bottom {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .citation-ranking-layout {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .citation-ranking-visual {
+    min-height: auto;
+    padding: 0;
+  }
+
+  .citation-ranking-visual__canvas {
+    min-height: 280px;
+  }
+
+  .citation-ranking-visual__circle {
+    width: min(72vw, 360px);
+    height: min(72vw, 360px);
+  }
+
+  .citation-ranking-sheet__head,
+  .citation-ranking-sheet__row {
+    padding: 22px 20px;
+  }
+}
+
+@media (max-width: 640px) {
+  .citation-ranking-sheet__head,
+  .citation-ranking-sheet__row {
+    grid-template-columns: minmax(0, 1.3fr) minmax(0, 0.7fr) minmax(0, 0.7fr);
+    gap: 10px;
+    font-size: 13px;
+  }
+
+  .citation-ranking-sheet__row strong,
+  .citation-ranking-sheet__row {
+    font-size: 14px;
+  }
+
+  .citation-ranking-legend {
+    gap: 12px 18px;
+    padding-left: 0;
+  }
+}
+</style>
diff --git a/apps/browser-extension/entrypoints/background.ts b/apps/browser-extension/entrypoints/background.ts
index 0b1cc03..3a6797c 100644
--- a/apps/browser-extension/entrypoints/background.ts
+++ b/apps/browser-extension/entrypoints/background.ts
@@ -1,12 +1,18 @@
+import type { MonitoringCycleKickoffResponse } from "@geo/shared-types";
 import { browser } from "wxt/browser";
 import { defineBackground } from "wxt/utils/define-background";
 
+import {
+  patchDoubaoMonitoringRuntimeState,
+  readDoubaoMonitoringRuntimePatchFromRequestUrl,
+} from "../src/monitoring-adapters/doubao-state";
+import { handleMonitoringAction, runMonitoringCycle, type MonitoringCycleMode } from "../src/monitoring-runtime";
 import { handlePublisherAction } from "../src/runtime";
-import { getExtensionState } from "../src/storage";
+import { getExtensionState, type ExtensionStorageState } from "../src/storage";
 
 type BackgroundSuccessResponse = {
   ok: true;
-  data: Awaited<ReturnType<typeof handlePublisherAction>>;
+  data: unknown;
 };
 
 type BackgroundErrorResponse = {
@@ -14,42 +20,236 @@ type BackgroundErrorResponse = {
   error: string;
 };
 
+const PUBLISHER_HEARTBEAT_ALARM = "geo.publisher.background-heartbeat";
+const MONITORING_HEARTBEAT_ALARM = "geo.monitoring.background-heartbeat";
+const MONITORING_QUEUE_ALARM = "geo.monitoring.queue-heartbeat";
+const MONITORING_WARMUP_INTERVAL_MS = 10 * 60 * 1000;
+const MONITORING_HEARTBEAT_INTERVAL_MINUTES = 15;
+const MONITORING_HEARTBEAT_START_JITTER_MS = 3 * 60 * 1000;
+const DOUBAO_COMPLETION_REQUEST_FILTER = {
+  urls: ["https://www.doubao.com/chat/completion*", "https://doubao.com/chat/completion*"],
+};
+
+let monitoringCycleInFlight: Promise<unknown> | null = null;
+
+function randomMonitoringHeartbeatStartDelayMs(): number {
+  return Math.floor(Math.random() * (MONITORING_HEARTBEAT_START_JITTER_MS + 1));
+}
+
+async function ensureBackgroundAlarms(): Promise<void> {
+  browser.alarms.create(PUBLISHER_HEARTBEAT_ALARM, {
+    periodInMinutes: 60,
+  });
+  browser.alarms.create(MONITORING_HEARTBEAT_ALARM, {
+    when: Date.now() + randomMonitoringHeartbeatStartDelayMs(),
+    periodInMinutes: MONITORING_HEARTBEAT_INTERVAL_MINUTES,
+  });
+}
+
+function shouldWarmupMonitoring(state: ExtensionStorageState): boolean {
+  if (!state.plugin_installation_id || !state.installation_token || !state.api_base_url) {
+    return false;
+  }
+
+  if (!state.monitoring_last_heartbeat_at) {
+    return true;
+  }
+
+  const lastHeartbeatAt = new Date(state.monitoring_last_heartbeat_at).getTime();
+  if (Number.isNaN(lastHeartbeatAt)) {
+    return true;
+  }
+
+  return Date.now() - lastHeartbeatAt >= MONITORING_WARMUP_INTERVAL_MS;
+}
+
+function registerMonitoringRuntimeCapture(): void {
+  if (!browser.webRequest?.onBeforeRequest) {
+    return;
+  }
+
+  browser.webRequest.onBeforeRequest.addListener(
+    (details) => {
+      const patch = readDoubaoMonitoringRuntimePatchFromRequestUrl(details.url);
+      if (!patch) {
+        return undefined;
+      }
+      void patchDoubaoMonitoringRuntimeState(patch).catch((error) => {
+        console.warn("[geo-monitoring] failed to persist doubao runtime patch", error);
+      });
+      return undefined;
+    },
+    DOUBAO_COMPLETION_REQUEST_FILTER,
+  );
+}
+
+async function warmupMonitoringRuntime(): Promise<void> {
+  const state = await getExtensionState();
+  if (!shouldWarmupMonitoring(state)) {
+    return;
+  }
+
+  await runMonitoringCycleSingleFlight("automatic");
+}
+
+async function syncMonitoringQueueAlarm(): Promise<void> {
+  const state = await getExtensionState();
+  const nextExecuteAt = state.monitoring_task_queue.reduce<number | null>((earliest, task) => {
+    const timestamp = new Date(task.next_execute_at).getTime();
+    if (Number.isNaN(timestamp)) {
+      return earliest;
+    }
+    if (earliest == null) {
+      return timestamp;
+    }
+    return Math.min(earliest, timestamp);
+  }, null);
+
+  await browser.alarms.clear(MONITORING_QUEUE_ALARM);
+  if (nextExecuteAt == null) {
+    return;
+  }
+
+  browser.alarms.create(MONITORING_QUEUE_ALARM, {
+    when: Math.max(Date.now() + 1000, nextExecuteAt),
+  });
+}
+
+function runMonitoringCycleSingleFlight(mode: MonitoringCycleMode): Promise<unknown> {
+  if (monitoringCycleInFlight) {
+    return monitoringCycleInFlight;
+  }
+
+  monitoringCycleInFlight = runMonitoringCycle(mode).finally(() => {
+    monitoringCycleInFlight = null;
+    void syncMonitoringQueueAlarm().catch((error) => {
+      console.warn("[geo-monitoring] failed to sync queue alarm", error);
+    });
+  });
+  return monitoringCycleInFlight;
+}
+
+function kickoffMonitoringCycle(): MonitoringCycleKickoffResponse {
+  if (monitoringCycleInFlight) {
+    return {
+      accepted: true,
+      status: "already_running",
+      message: "monitoring cycle is already running in background",
+    };
+  }
+
+  void runMonitoringCycleSingleFlight("manual").catch((error) => {
+    console.warn("[geo-monitoring] background cycle failed", error);
+  });
+
+  return {
+    accepted: true,
+    status: "started",
+    message: "monitoring cycle started in background",
+  };
+}
+
 export default defineBackground(() => {
   void getExtensionState();
+  void ensureBackgroundAlarms();
+  registerMonitoringRuntimeCapture();
+  void warmupMonitoringRuntime().catch((error) => {
+    console.warn("[geo-monitoring] warmup cycle failed", error);
+  });
+  void syncMonitoringQueueAlarm();
 
   browser.runtime.onInstalled.addListener(() => {
     void getExtensionState();
-    browser.alarms.create("geo.publisher.background-heartbeat", {
-      periodInMinutes: 60,
+    void ensureBackgroundAlarms();
+    void warmupMonitoringRuntime().catch((error) => {
+      console.warn("[geo-monitoring] install warmup cycle failed", error);
     });
+    void syncMonitoringQueueAlarm();
+  });
+
+  browser.runtime.onStartup.addListener(() => {
+    void getExtensionState();
+    void ensureBackgroundAlarms();
+    void warmupMonitoringRuntime().catch((error) => {
+      console.warn("[geo-monitoring] startup warmup cycle failed", error);
+    });
+    void syncMonitoringQueueAlarm();
   });
 
   browser.alarms.onAlarm.addListener(async (alarm) => {
-    if (alarm.name !== "geo.publisher.background-heartbeat") {
+    if (alarm.name === PUBLISHER_HEARTBEAT_ALARM) {
+      await getExtensionState();
       return;
     }
-    await getExtensionState();
+
+    if (alarm.name === MONITORING_HEARTBEAT_ALARM) {
+      try {
+        await runMonitoringCycleSingleFlight("automatic");
+      } catch (error) {
+        console.warn("[geo-monitoring] cycle failed", error);
+      }
+      return;
+    }
+
+    if (alarm.name === MONITORING_QUEUE_ALARM) {
+      try {
+        await runMonitoringCycleSingleFlight("automatic");
+      } catch (error) {
+        console.warn("[geo-monitoring] queue cycle failed", error);
+      }
+    }
   });
 
   chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
-    if (!message || message.type !== "geo.publisher.request") {
+    if (!message) {
       return undefined;
     }
 
-    void handlePublisherAction(message.action, message.payload)
-      .then((data) => {
+    if (message.type === "geo.publisher.request") {
+      void handlePublisherAction(message.action, message.payload)
+        .then((data) => {
+          sendResponse({
+            ok: true,
+            data,
+          } satisfies BackgroundSuccessResponse);
+        })
+        .catch((error: unknown) => {
+          sendResponse({
+            ok: false,
+            error: error instanceof Error ? error.message : "publisher_plugin_unknown_error",
+          } satisfies BackgroundErrorResponse);
+        });
+
+      return true;
+    }
+
+    if (message.type === "geo.monitoring.request") {
+      if (message.action === "kickoffCycle") {
         sendResponse({
           ok: true,
-          data,
+          data: kickoffMonitoringCycle(),
         } satisfies BackgroundSuccessResponse);
-      })
-      .catch((error: unknown) => {
-        sendResponse({
-          ok: false,
-          error: error instanceof Error ? error.message : "publisher_plugin_unknown_error",
-        } satisfies BackgroundErrorResponse);
-      });
+        return true;
+      }
 
-    return true;
+      const action = message.action === "runCycle" ? runMonitoringCycleSingleFlight("manual") : handleMonitoringAction(message.action);
+      void action
+        .then((data) => {
+          sendResponse({
+            ok: true,
+            data,
+          } satisfies BackgroundSuccessResponse);
+        })
+        .catch((error: unknown) => {
+          sendResponse({
+            ok: false,
+            error: error instanceof Error ? error.message : "monitoring_plugin_unknown_error",
+          } satisfies BackgroundErrorResponse);
+        });
+
+      return true;
+    }
+
+    return undefined;
   });
 });
diff --git a/apps/browser-extension/entrypoints/content.ts b/apps/browser-extension/entrypoints/content.ts
index 5b153ac..4dc0b9b 100644
--- a/apps/browser-extension/entrypoints/content.ts
+++ b/apps/browser-extension/entrypoints/content.ts
@@ -1,6 +1,8 @@
 import { browser } from "wxt/browser";
 import { defineContentScript } from "wxt/utils/define-content-script";
 
+import { syncDoubaoMonitoringRuntimeStateFromPage } from "../src/monitoring-adapters/doubao-state";
+
 type PublisherRequestMessage = {
   source: "geo-admin";
   type: "geo.publisher.request";
@@ -9,6 +11,13 @@ type PublisherRequestMessage = {
   payload?: unknown;
 };
 
+type MonitoringRequestMessage = {
+  source: "geo-admin";
+  type: "geo.monitoring.request";
+  requestId: string;
+  action: "ping" | "detectPlatforms" | "syncHeartbeat" | "runCycle" | "kickoffCycle" | "getState";
+};
+
 type BackgroundSuccessResponse = {
   ok: true;
   data: unknown;
@@ -19,26 +28,95 @@ type BackgroundErrorResponse = {
   error?: string;
 };
 
+type RuntimeSyncMessage = {
+  type: "geo.monitoring.runtime.sync";
+  platform: "doubao";
+};
+
+function isExtensionContextInvalidatedError(error: unknown): boolean {
+  const message =
+    typeof error === "string"
+      ? error
+      : typeof error === "object" && error !== null && "message" in error && typeof error.message === "string"
+        ? error.message
+        : String(error ?? "");
+
+  const normalized = message.toLowerCase();
+  return normalized.includes("extension context invalidated") || normalized.includes("context invalidated");
+}
+
 function isBackgroundResponse(value: unknown): value is BackgroundSuccessResponse | BackgroundErrorResponse {
   return typeof value === "object" && value !== null && "ok" in value;
 }
 
+function registerDoubaoRuntimeSync(): void {
+  const hostname = window.location.hostname;
+  if (hostname !== "doubao.com" && hostname !== "www.doubao.com" && !hostname.endsWith(".doubao.com")) {
+    return;
+  }
+
+  const sync = () => {
+    void syncDoubaoMonitoringRuntimeStateFromPage().catch((error) => {
+      if (isExtensionContextInvalidatedError(error)) {
+        return;
+      }
+      console.warn("[geo-monitoring] failed to sync doubao runtime state", error);
+    });
+  };
+
+  sync();
+
+  window.addEventListener("pageshow", sync);
+  document.addEventListener("visibilitychange", () => {
+    if (!document.hidden) {
+      sync();
+    }
+  });
+  window.setInterval(sync, 15000);
+}
+
 export default defineContentScript({
   matches: ["http://*/*", "https://*/*"],
   main() {
-    window.addEventListener("message", async (event: MessageEvent<PublisherRequestMessage>) => {
-      if (event.source !== window || !event.data || event.data.type !== "geo.publisher.request") {
+    registerDoubaoRuntimeSync();
+
+    browser.runtime.onMessage.addListener((message: RuntimeSyncMessage, _sender, sendResponse) => {
+      if (!message || message.type !== "geo.monitoring.runtime.sync" || message.platform !== "doubao") {
+        return undefined;
+      }
+
+      void syncDoubaoMonitoringRuntimeStateFromPage()
+        .then(() => {
+          sendResponse({ ok: true });
+        })
+        .catch((error) => {
+          sendResponse({
+            ok: false,
+            error: error instanceof Error ? error.message : "monitoring_runtime_sync_failed",
+          });
+        });
+
+      return true;
+    });
+
+    window.addEventListener("message", async (event: MessageEvent<PublisherRequestMessage | MonitoringRequestMessage>) => {
+      if (
+        event.source !== window ||
+        !event.data ||
+        (event.data.type !== "geo.publisher.request" && event.data.type !== "geo.monitoring.request")
+      ) {
         return;
       }
       if (event.data.source !== "geo-admin") {
         return;
       }
 
-      const { requestId, action, payload } = event.data;
+      const { requestId, action } = event.data;
+      const payload = "payload" in event.data ? event.data.payload : undefined;
 
       try {
         const response = await browser.runtime.sendMessage({
-          type: "geo.publisher.request",
+          type: event.data.type,
           action,
           payload,
         });
@@ -59,7 +137,7 @@ export default defineContentScript({
         window.postMessage(
           {
             source: "geo-extension",
-            type: "geo.publisher.response",
+            type: event.data.type === "geo.publisher.request" ? "geo.publisher.response" : "geo.monitoring.response",
             requestId,
             success: true,
             data,
@@ -70,7 +148,7 @@ export default defineContentScript({
         window.postMessage(
           {
             source: "geo-extension",
-            type: "geo.publisher.response",
+            type: event.data.type === "geo.publisher.request" ? "geo.publisher.response" : "geo.monitoring.response",
             requestId,
             success: false,
             error: error instanceof Error ? error.message : "publisher_plugin_unknown_error",
diff --git a/apps/browser-extension/entrypoints/popup/App.vue b/apps/browser-extension/entrypoints/popup/App.vue
index ce4763b..4561a87 100644
--- a/apps/browser-extension/entrypoints/popup/App.vue
+++ b/apps/browser-extension/entrypoints/popup/App.vue
@@ -4,6 +4,7 @@ import { browser } from "wxt/browser";
 
 import { normalizeRemoteUrl } from "../../src/adapters/common";
 import { getExtensionState } from "../../src/storage";
+import type { StoredMonitoringPlatformState } from "../../src/monitoring-platforms";
 import type { StoredPlatformState } from "../../src/platforms";
 
 type BackgroundSuccessResponse = {
@@ -18,13 +19,27 @@ type BackgroundErrorResponse = {
 
 const loading = ref(true);
 const refreshing = ref(false);
+const monitoringRefreshing = ref(false);
+const monitoringHeartbeating = ref(false);
+const monitoringCycling = ref(false);
 
 const installationKey = ref("");
 const installationId = ref<number | null>(null);
 const apiBaseUrl = ref<string | null>(null);
 const platforms = ref<StoredPlatformState[]>([]);
+const monitoringPlatforms = ref<StoredMonitoringPlatformState[]>([]);
+const monitoringLastHeartbeatAt = ref<string | null>(null);
+const monitoringLastHeartbeatStatus = ref<string | null>(null);
+const monitoringLastCycleAt = ref<string | null>(null);
+const monitoringLastCycleStatus = ref<string | null>(null);
+const popupError = ref<string | null>(null);
+const monitoringMessage = ref<string | null>(null);
 
 const connectedCount = computed(() => platforms.value.filter((item) => item.connected).length);
+const monitoringAccessibleCount = computed(() => monitoringPlatforms.value.filter((item) => item.accessible).length);
+const monitoringBusy = computed(
+  () => loading.value || monitoringRefreshing.value || monitoringHeartbeating.value || monitoringCycling.value,
+);
 
 const statusText = computed(() => {
   if (loading.value || refreshing.value) {
@@ -41,6 +56,10 @@ function clonePlatforms(items: StoredPlatformState[]): StoredPlatformState[] {
   return items.map((platform) => ({ ...platform }));
 }
 
+function cloneMonitoringPlatforms(items: StoredMonitoringPlatformState[]): StoredMonitoringPlatformState[] {
+  return items.map((platform) => ({ ...platform }));
+}
+
 function isBackgroundResponse(value: unknown): value is BackgroundSuccessResponse | BackgroundErrorResponse {
   return typeof value === "object" && value !== null && "ok" in value;
 }
@@ -48,11 +67,7 @@ function isBackgroundResponse(value: unknown): value is BackgroundSuccessRespons
 async function loadState(): Promise<void> {
   loading.value = true;
   try {
-    const state = await getExtensionState();
-    installationKey.value = state.installation_key;
-    installationId.value = state.plugin_installation_id;
-    apiBaseUrl.value = state.api_base_url;
-    platforms.value = clonePlatforms(state.platforms);
+    await syncStateFromStorage();
   } finally {
     loading.value = false;
   }
@@ -61,12 +76,25 @@ async function loadState(): Promise<void> {
 async function initializePopup(): Promise<void> {
   try {
     await loadState();
-    await refreshDetectedPlatforms();
+    await Promise.allSettled([refreshDetectedPlatforms(), refreshMonitoringPlatforms()]);
   } finally {
     loading.value = false;
   }
 }
 
+async function syncStateFromStorage(): Promise<void> {
+  const state = await getExtensionState();
+  installationKey.value = state.installation_key;
+  installationId.value = state.plugin_installation_id;
+  apiBaseUrl.value = state.api_base_url;
+  platforms.value = clonePlatforms(state.platforms);
+  monitoringPlatforms.value = cloneMonitoringPlatforms(state.monitoring_platforms);
+  monitoringLastHeartbeatAt.value = state.monitoring_last_heartbeat_at;
+  monitoringLastHeartbeatStatus.value = state.monitoring_last_heartbeat_status;
+  monitoringLastCycleAt.value = state.monitoring_last_cycle_at;
+  monitoringLastCycleStatus.value = state.monitoring_last_cycle_status;
+}
+
 function titleFor(platform: StoredPlatformState): string {
   return platform.nickname?.trim() || platform.platform_name;
 }
@@ -113,6 +141,7 @@ async function simulateDetect(): Promise<void> {
 
 async function refreshDetectedPlatforms(): Promise<void> {
   refreshing.value = true;
+  popupError.value = null;
   try {
     const response = await browser.runtime.sendMessage({
       type: "geo.publisher.request",
@@ -121,14 +150,170 @@ async function refreshDetectedPlatforms(): Promise<void> {
     if (isBackgroundResponse(response) && !response.ok) {
       throw new Error(response.error || "publisher_plugin_unknown_error");
     }
-    const state = await getExtensionState();
-    installationId.value = state.plugin_installation_id;
-    apiBaseUrl.value = state.api_base_url;
-    platforms.value = clonePlatforms(state.platforms);
+    await syncStateFromStorage();
+  } catch (error) {
+    popupError.value = error instanceof Error ? error.message : "publisher_plugin_unknown_error";
   } finally {
     refreshing.value = false;
   }
 }
+
+function monitoringStatusLabel(platform: StoredMonitoringPlatformState): string {
+  if (platform.reason_code === "runtime_sync_pending") {
+    return "待同步";
+  }
+  if (platform.accessible) {
+    return "可采集";
+  }
+  if (platform.reason_code === "not_logged_in") {
+    return "需登录";
+  }
+  return "不可用";
+}
+
+function monitoringTone(platform: StoredMonitoringPlatformState): "success" | "danger" | "pending" {
+  if (monitoringBusy.value) {
+    return "pending";
+  }
+  if (platform.reason_code === "runtime_sync_pending") {
+    return "pending";
+  }
+  return platform.accessible ? "success" : "danger";
+}
+
+function monitoringHeartbeatSummary(): string {
+  if (!monitoringLastHeartbeatAt.value) {
+    return `可采集 ${monitoringAccessibleCount.value}/${monitoringPlatforms.value.length} 个平台`;
+  }
+  return `可采集 ${monitoringAccessibleCount.value}/${monitoringPlatforms.value.length} 个平台 · 最近心跳 ${formatDateTime(monitoringLastHeartbeatAt.value)}`;
+}
+
+function formatDateTime(value?: string | null): string {
+  if (!value) {
+    return "--";
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date.toLocaleString("zh-CN", {
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+function monitoringHeartbeatStatusText(): string {
+  switch (monitoringLastHeartbeatStatus.value) {
+    case "success":
+      return `心跳在线 ${formatDateTime(monitoringLastHeartbeatAt.value)}`;
+    case "failed":
+      return `心跳失败 ${formatDateTime(monitoringLastHeartbeatAt.value)}`;
+    case "local_only":
+      return "插件尚未绑定到 SaaS";
+    default:
+      return "尚未同步心跳";
+  }
+}
+
+function monitoringCycleStatusText(): string {
+  switch (monitoringLastCycleStatus.value) {
+    case "success":
+      return `巡检完成 ${formatDateTime(monitoringLastCycleAt.value)}`;
+    case "partial_failed":
+      return `巡检部分失败 ${formatDateTime(monitoringLastCycleAt.value)}`;
+    case "skipped":
+      return `巡检已跳过 ${formatDateTime(monitoringLastCycleAt.value)}`;
+    case "idle":
+      return `巡检空闲 ${formatDateTime(monitoringLastCycleAt.value)}`;
+    case "no_query_capable_platforms":
+      return "已在线，采集适配器待接入";
+    case "not_configured":
+      return "插件尚未绑定到 SaaS";
+    case "heartbeat_failed":
+      return `巡检前心跳失败 ${formatDateTime(monitoringLastCycleAt.value)}`;
+    default:
+      return "尚未执行巡检";
+  }
+}
+
+function monitoringStatusPillTone(): "success" | "danger" | "pending" {
+  if (monitoringBusy.value) {
+    return "pending";
+  }
+  if (monitoringAccessibleCount.value > 0 && monitoringLastHeartbeatStatus.value === "success") {
+    return "success";
+  }
+  return "danger";
+}
+
+async function openMonitoringLoginPage(platform: StoredMonitoringPlatformState): Promise<void> {
+  if (!platform.login_url || monitoringBusy.value) {
+    return;
+  }
+  await browser.tabs.create({ url: platform.login_url });
+}
+
+async function refreshMonitoringPlatforms(): Promise<void> {
+  monitoringRefreshing.value = true;
+  monitoringMessage.value = null;
+  try {
+    const response = await browser.runtime.sendMessage({
+      type: "geo.monitoring.request",
+      action: "detectPlatforms",
+    });
+    if (isBackgroundResponse(response) && !response.ok) {
+      throw new Error(response.error || "monitoring_plugin_unknown_error");
+    }
+    await syncStateFromStorage();
+    monitoringMessage.value = "已刷新本地监测平台状态";
+  } catch (error) {
+    monitoringMessage.value = error instanceof Error ? error.message : "monitoring_plugin_unknown_error";
+  } finally {
+    monitoringRefreshing.value = false;
+  }
+}
+
+async function syncMonitoringHeartbeat(): Promise<void> {
+  monitoringHeartbeating.value = true;
+  monitoringMessage.value = null;
+  try {
+    const response = await browser.runtime.sendMessage({
+      type: "geo.monitoring.request",
+      action: "syncHeartbeat",
+    });
+    if (isBackgroundResponse(response) && !response.ok) {
+      throw new Error(response.error || "monitoring_plugin_unknown_error");
+    }
+    await syncStateFromStorage();
+    monitoringMessage.value = "已同步 monitoring heartbeat";
+  } catch (error) {
+    monitoringMessage.value = error instanceof Error ? error.message : "monitoring_plugin_unknown_error";
+  } finally {
+    monitoringHeartbeating.value = false;
+  }
+}
+
+async function runMonitoringCycle(): Promise<void> {
+  monitoringCycling.value = true;
+  monitoringMessage.value = null;
+  try {
+    const response = await browser.runtime.sendMessage({
+      type: "geo.monitoring.request",
+      action: "runCycle",
+    });
+    if (isBackgroundResponse(response) && !response.ok) {
+      throw new Error(response.error || "monitoring_plugin_unknown_error");
+    }
+    await syncStateFromStorage();
+    monitoringMessage.value = "已执行一轮 monitoring 巡检";
+  } catch (error) {
+    monitoringMessage.value = error instanceof Error ? error.message : "monitoring_plugin_unknown_error";
+  } finally {
+    monitoringCycling.value = false;
+  }
+}
 </script>
 
 <template>
@@ -196,6 +381,81 @@ async function refreshDetectedPlatforms(): Promise<void> {
         </article>
 
         <p class="popup-status">{{ statusText }}</p>
+        <p v-if="popupError" class="popup-status popup-status--error">{{ popupError }}</p>
+
+        <section class="popup-monitoring">
+          <div class="popup-monitoring__header">
+            <div>
+              <h3>AI 监测平台</h3>
+              <p>{{ monitoringHeartbeatSummary() }}</p>
+            </div>
+            <span class="popup-monitoring__pill" :class="`is-${monitoringStatusPillTone()}`">
+              {{ monitoringAccessibleCount }}/{{ monitoringPlatforms.length }} 可采集
+            </span>
+          </div>
+
+          <div class="popup-monitoring__stats">
+            <div class="popup-monitoring__stat">
+              <span>Heartbeat</span>
+              <strong>{{ monitoringHeartbeatStatusText() }}</strong>
+            </div>
+            <div class="popup-monitoring__stat">
+              <span>Cycle</span>
+              <strong>{{ monitoringCycleStatusText() }}</strong>
+            </div>
+          </div>
+
+          <div class="popup-monitoring__actions">
+            <button type="button" :disabled="monitoringBusy" @click="refreshMonitoringPlatforms">
+              {{ monitoringRefreshing ? "检测中" : "检测" }}
+            </button>
+            <button type="button" :disabled="monitoringBusy" @click="syncMonitoringHeartbeat">
+              {{ monitoringHeartbeating ? "同步中" : "心跳" }}
+            </button>
+            <button type="button" :disabled="monitoringBusy" @click="runMonitoringCycle">
+              {{ monitoringCycling ? "巡检中" : "巡检" }}
+            </button>
+          </div>
+
+          <p v-if="monitoringMessage" class="popup-monitoring__message">
+            {{ monitoringMessage }}
+          </p>
+
+          <div class="popup-monitoring__list">
+            <article
+              v-for="platform in monitoringPlatforms"
+              :key="platform.ai_platform_id"
+              class="popup-monitoring__item"
+              :class="`is-${monitoringTone(platform)}`"
+              :style="{ '--monitoring-accent': platform.accent_color }"
+            >
+              <div class="popup-monitoring__identity">
+                <div class="popup-monitoring__logo">
+                  <span>{{ platform.short_name }}</span>
+                </div>
+                <div class="popup-monitoring__copy">
+                  <strong>{{ platform.platform_name }}</strong>
+                  <span>{{ platform.access_requirement === "login_required" ? "登录后可采集" : "可匿名采集" }}</span>
+                </div>
+              </div>
+
+              <div class="popup-monitoring__meta">
+                <em>{{ monitoringStatusLabel(platform) }}</em>
+                <small>{{ platform.reason_message || formatDateTime(platform.detected_at) }}</small>
+              </div>
+
+              <button
+                v-if="platform.access_requirement === 'login_required' && !platform.connected && platform.login_url"
+                type="button"
+                class="popup-monitoring__login"
+                :disabled="monitoringBusy"
+                @click.stop="openMonitoringLoginPage(platform)"
+              >
+                去登录
+              </button>
+            </article>
+          </div>
+        </section>
 
         <details class="popup-debug">
           <summary>调试信息</summary>
@@ -212,6 +472,14 @@ async function refreshDetectedPlatforms(): Promise<void> {
               <dt>Installation Key</dt>
               <dd>{{ installationKey }}</dd>
             </div>
+            <div>
+              <dt>Monitoring Heartbeat</dt>
+              <dd>{{ monitoringLastHeartbeatStatus || "--" }}</dd>
+            </div>
+            <div>
+              <dt>Monitoring Cycle</dt>
+              <dd>{{ monitoringLastCycleStatus || "--" }}</dd>
+            </div>
           </dl>
         </details>
       </section>
@@ -573,6 +841,242 @@ async function refreshDetectedPlatforms(): Promise<void> {
   text-align: center;
 }
 
+.popup-status--error {
+  color: #c84545;
+}
+
+.popup-monitoring {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  margin-top: 14px;
+  padding: 14px;
+  border: 1px solid rgba(216, 225, 238, 0.95);
+  border-radius: 18px;
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.94), rgba(246, 249, 255, 0.94));
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.86);
+}
+
+.popup-monitoring__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.popup-monitoring__header h3 {
+  margin: 0;
+  color: #213247;
+  font-size: 15px;
+  font-weight: 800;
+}
+
+.popup-monitoring__header p {
+  margin: 4px 0 0;
+  color: #7d8ca0;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.popup-monitoring__pill {
+  flex-shrink: 0;
+  padding: 6px 10px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 800;
+}
+
+.popup-monitoring__pill.is-success {
+  color: #167a61;
+  background: rgba(37, 182, 135, 0.12);
+  border-color: rgba(37, 182, 135, 0.18);
+}
+
+.popup-monitoring__pill.is-danger {
+  color: #b64d4d;
+  background: rgba(224, 95, 95, 0.12);
+  border-color: rgba(224, 95, 95, 0.18);
+}
+
+.popup-monitoring__pill.is-pending {
+  color: #8d6b17;
+  background: rgba(243, 190, 68, 0.15);
+  border-color: rgba(243, 190, 68, 0.22);
+}
+
+.popup-monitoring__stats {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.popup-monitoring__stat {
+  padding: 10px 12px;
+  border: 1px solid rgba(223, 230, 240, 0.92);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.82);
+}
+
+.popup-monitoring__stat span {
+  display: block;
+  margin-bottom: 6px;
+  color: #8a96a7;
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+}
+
+.popup-monitoring__stat strong {
+  display: block;
+  color: #324459;
+  font-size: 12px;
+  font-weight: 700;
+  line-height: 1.4;
+}
+
+.popup-monitoring__actions {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.popup-monitoring__actions button,
+.popup-monitoring__login {
+  appearance: none;
+  min-height: 36px;
+  padding: 0 10px;
+  border: 1px solid rgba(76, 114, 255, 0.18);
+  border-radius: 12px;
+  background: #ffffff;
+  color: #3351b8;
+  font-size: 12px;
+  font-weight: 800;
+  cursor: pointer;
+  transition:
+    transform 150ms ease,
+    opacity 150ms ease,
+    box-shadow 150ms ease;
+}
+
+.popup-monitoring__actions button:hover:not(:disabled),
+.popup-monitoring__login:hover:not(:disabled) {
+  transform: translateY(-1px);
+  box-shadow: 0 6px 14px rgba(56, 91, 205, 0.12);
+}
+
+.popup-monitoring__actions button:disabled,
+.popup-monitoring__login:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+  transform: none;
+  box-shadow: none;
+}
+
+.popup-monitoring__message {
+  margin: 0;
+  padding: 10px 12px;
+  border-radius: 12px;
+  background: rgba(67, 102, 215, 0.08);
+  color: #4d6180;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.popup-monitoring__list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.popup-monitoring__item {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  padding: 12px;
+  border: 1px solid rgba(223, 230, 240, 0.92);
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.88);
+}
+
+.popup-monitoring__item.is-success {
+  border-color: rgba(56, 176, 142, 0.22);
+}
+
+.popup-monitoring__item.is-danger {
+  border-color: rgba(226, 104, 104, 0.2);
+}
+
+.popup-monitoring__item.is-pending {
+  border-color: rgba(232, 188, 73, 0.2);
+}
+
+.popup-monitoring__identity {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-width: 0;
+}
+
+.popup-monitoring__logo {
+  display: grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--monitoring-accent) 12%, white);
+  color: var(--monitoring-accent);
+  font-size: 18px;
+  font-weight: 900;
+}
+
+.popup-monitoring__copy {
+  min-width: 0;
+}
+
+.popup-monitoring__copy strong,
+.popup-monitoring__copy span,
+.popup-monitoring__meta em,
+.popup-monitoring__meta small {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.popup-monitoring__copy strong {
+  color: #223244;
+  font-size: 13px;
+  font-weight: 800;
+}
+
+.popup-monitoring__copy span {
+  margin-top: 3px;
+  color: #7c8a9c;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.popup-monitoring__meta {
+  min-width: 0;
+  text-align: right;
+}
+
+.popup-monitoring__meta em {
+  color: #2a405e;
+  font-size: 12px;
+  font-style: normal;
+  font-weight: 800;
+}
+
+.popup-monitoring__meta small {
+  margin-top: 4px;
+  color: #8895a6;
+  font-size: 11px;
+  font-weight: 600;
+}
+
 .popup-debug {
   margin-top: 12px;
   border: 1px solid rgba(216, 225, 238, 0.95);
diff --git a/apps/browser-extension/src/monitoring-adapters/common.ts b/apps/browser-extension/src/monitoring-adapters/common.ts
new file mode 100644
index 0000000..42ed70a
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/common.ts
@@ -0,0 +1,79 @@
+import { browser } from "wxt/browser";
+
+import type { StoredMonitoringPlatformState } from "../monitoring-platforms";
+
+import type { MonitoringAdapterDetectResult } from "./types";
+
+export type SilentAutomationPageHandle = {
+  tabId: number;
+  groupId: number | null;
+};
+
+export async function openSilentAutomationPage(url: string): Promise<SilentAutomationPageHandle> {
+  const createdTab = await browser.tabs.create({
+    url,
+    active: false,
+  });
+
+  if (typeof createdTab.id !== "number") {
+    throw new Error("silent_automation_tab_unavailable");
+  }
+
+  let groupId: number | null = null;
+  try {
+    groupId = await chrome.tabs.group({ tabIds: createdTab.id });
+    await chrome.tabGroups.update(groupId, { collapsed: true, title: "" });
+  } catch {
+    // tabGroups API 不可用时降级为普通 tab
+  }
+
+  return { tabId: createdTab.id, groupId };
+}
+
+export async function closeSilentAutomationPage(handle: SilentAutomationPageHandle): Promise<void> {
+  await browser.tabs.remove(handle.tabId).catch(() => undefined);
+}
+
+export function normalizeDetectResult(
+  connected: boolean,
+  accessible: boolean,
+  reasonCode: string | null,
+  reasonMessage: string | null,
+): MonitoringAdapterDetectResult {
+  return {
+    connected,
+    accessible,
+    detected_at: new Date().toISOString(),
+    reason_code: reasonCode,
+    reason_message: reasonMessage,
+    message: reasonMessage,
+  };
+}
+
+export async function hasAnyPlatformCookie(platform: StoredMonitoringPlatformState): Promise<boolean> {
+  for (const domain of platform.cookie_domains) {
+    try {
+      const cookies = await browser.cookies.getAll({ domain });
+      if (cookies.length > 0) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return false;
+}
+
+export async function isPlatformReachable(platform: StoredMonitoringPlatformState): Promise<boolean> {
+  try {
+    const response = await fetch(platform.home_url, {
+      method: "GET",
+      redirect: "follow",
+      credentials: "include",
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
diff --git a/apps/browser-extension/src/monitoring-adapters/doubao-state.ts b/apps/browser-extension/src/monitoring-adapters/doubao-state.ts
new file mode 100644
index 0000000..d1439d5
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/doubao-state.ts
@@ -0,0 +1,194 @@
+import { getExtensionState, patchExtensionState, type DoubaoMonitoringRuntimeState } from "../storage";
+
+const DOUBAO_HOST_SUFFIX = ".doubao.com";
+const DOUBAO_SAMANTHA_KEY = "samantha_web_web_id";
+const DOUBAO_TEA_CACHE_KEY = "__tea_cache_tokens_497858";
+const DOUBAO_MS_TOKEN_KEY = "xmst";
+const DOUBAO_FP_COOKIE_NAME = "s_v_web_id";
+
+function normalizeText(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeOptionalField(value: unknown): string | null | undefined {
+  if (typeof value === "undefined") {
+    return undefined;
+  }
+  return normalizeText(value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isDoubaoHost(hostname: string): boolean {
+  return hostname === "doubao.com" || hostname === "www.doubao.com" || hostname.endsWith(DOUBAO_HOST_SUFFIX);
+}
+
+function safeParseJSON(raw: string | null): unknown {
+  const normalized = normalizeText(raw);
+  if (!normalized) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(normalized);
+  } catch {
+    return normalized;
+  }
+}
+
+function getNestedString(source: unknown, path: string[]): string | null {
+  let current: unknown = source;
+  for (const segment of path) {
+    if (!isRecord(current) || !(segment in current)) {
+      return null;
+    }
+    current = current[segment];
+  }
+  return normalizeText(current);
+}
+
+function pickFirstString(source: unknown, paths: string[][]): string | null {
+  for (const path of paths) {
+    const value = getNestedString(source, path);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function readCookieValue(cookieHeader: string, name: string): string | null {
+  const segments = cookieHeader.split(";");
+  for (const segment of segments) {
+    const [rawName, ...rest] = segment.trim().split("=");
+    if (rawName !== name) {
+      continue;
+    }
+    return normalizeText(rest.join("="));
+  }
+  return null;
+}
+
+function hasRuntimeStateValue(state: DoubaoMonitoringRuntimeState): boolean {
+  return Boolean(state.fp || state.ms_token || state.device_id || state.web_id || state.tea_uuid);
+}
+
+function isSameDoubaoRuntimeState(
+  left: DoubaoMonitoringRuntimeState | null,
+  right: DoubaoMonitoringRuntimeState | null,
+): boolean {
+  if (left === right) {
+    return true;
+  }
+  if (!left || !right) {
+    return false;
+  }
+
+  return (
+    left.fp === right.fp &&
+    left.ms_token === right.ms_token &&
+    left.device_id === right.device_id &&
+    left.web_id === right.web_id &&
+    left.tea_uuid === right.tea_uuid &&
+    left.source_url === right.source_url
+  );
+}
+
+export function readDoubaoMonitoringRuntimeStateFromPage(): DoubaoMonitoringRuntimeState | null {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return null;
+  }
+  if (!isDoubaoHost(window.location.hostname)) {
+    return null;
+  }
+
+  const localStorageRef = window.localStorage;
+  const samanthaState = safeParseJSON(localStorageRef.getItem(DOUBAO_SAMANTHA_KEY));
+  const teaState = safeParseJSON(localStorageRef.getItem(DOUBAO_TEA_CACHE_KEY));
+
+  const runtimeState: DoubaoMonitoringRuntimeState = {
+    fp: readCookieValue(document.cookie, DOUBAO_FP_COOKIE_NAME),
+    ms_token: normalizeText(localStorageRef.getItem(DOUBAO_MS_TOKEN_KEY)),
+    device_id: pickFirstString(samanthaState, [["web_id"], ["device_id"], ["deviceId"], ["id"]]),
+    web_id: pickFirstString(teaState, [["web_id"], ["webId"], ["id"]]),
+    tea_uuid: pickFirstString(teaState, [["web_id"], ["tea_uuid"], ["teaUuid"], ["user_unique_id"], ["uuid"]]),
+    synced_at: new Date().toISOString(),
+    source_url: window.location.href,
+  };
+
+  if (!hasRuntimeStateValue(runtimeState)) {
+    return null;
+  }
+
+  return runtimeState;
+}
+
+export function readDoubaoMonitoringRuntimePatchFromRequestUrl(urlValue: string): Partial<DoubaoMonitoringRuntimeState> | null {
+  try {
+    const url = new URL(urlValue);
+    if (!isDoubaoHost(url.hostname)) {
+      return null;
+    }
+
+    const patch: Partial<DoubaoMonitoringRuntimeState> = {
+      fp: normalizeOptionalField(url.searchParams.get("fp")),
+      ms_token: normalizeOptionalField(url.searchParams.get("msToken")),
+      device_id: normalizeOptionalField(url.searchParams.get("device_id")),
+      web_id: normalizeOptionalField(url.searchParams.get("web_id")),
+      tea_uuid: normalizeOptionalField(url.searchParams.get("tea_uuid")),
+      synced_at: new Date().toISOString(),
+      source_url: url.toString(),
+    };
+
+    if (!hasRuntimeStateValue({
+      fp: patch.fp ?? null,
+      ms_token: patch.ms_token ?? null,
+      device_id: patch.device_id ?? null,
+      web_id: patch.web_id ?? null,
+      tea_uuid: patch.tea_uuid ?? null,
+      synced_at: patch.synced_at ?? null,
+      source_url: patch.source_url ?? null,
+    })) {
+      return null;
+    }
+
+    return patch;
+  } catch {
+    return null;
+  }
+}
+
+export async function patchDoubaoMonitoringRuntimeState(
+  patch: Partial<DoubaoMonitoringRuntimeState> | null,
+): Promise<void> {
+  if (!patch) {
+    return;
+  }
+
+  await patchExtensionState({
+    monitoring_runtime: {
+      doubao: {
+        ...patch,
+        synced_at: patch.synced_at ?? new Date().toISOString(),
+      } satisfies Partial<DoubaoMonitoringRuntimeState>,
+    },
+  });
+}
+
+export async function syncDoubaoMonitoringRuntimeStateFromPage(): Promise<void> {
+  const nextRuntimeState = readDoubaoMonitoringRuntimeStateFromPage();
+  const currentState = await getExtensionState();
+  const currentRuntimeState = currentState.monitoring_runtime.doubao;
+
+  if (isSameDoubaoRuntimeState(currentRuntimeState, nextRuntimeState)) {
+    return;
+  }
+
+  await patchDoubaoMonitoringRuntimeState(nextRuntimeState);
+}
diff --git a/apps/browser-extension/src/monitoring-adapters/doubao.ts b/apps/browser-extension/src/monitoring-adapters/doubao.ts
new file mode 100644
index 0000000..1cd1e3e
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/doubao.ts
@@ -0,0 +1,998 @@
+import type { MonitoringSourceItem } from "@geo/shared-types";
+import { browser } from "wxt/browser";
+
+import type { StoredMonitoringPlatformState } from "../monitoring-platforms";
+import { getExtensionState } from "../storage";
+
+import {
+  closeSilentAutomationPage,
+  hasAnyPlatformCookie,
+  isPlatformReachable,
+  normalizeDetectResult,
+  openSilentAutomationPage,
+} from "./common";
+import type { MonitoringAdapter, MonitoringAdapterQueryResult } from "./types";
+
+const DOUBAO_APP_ID = "497858";
+const DOUBAO_BOT_ID = "7338286299411103781";
+const DOUBAO_CHAT_URL = "https://www.doubao.com/chat/completion";
+const DOUBAO_REFERER = "https://www.doubao.com/chat/";
+const DOUBAO_BOOTSTRAP_URL = DOUBAO_REFERER;
+const DOUBAO_FP_COOKIE_NAME = "s_v_web_id";
+const DOUBAO_COOKIE_URLS = ["https://www.doubao.com/", "https://doubao.com/"];
+const DOUBAO_TAB_URL_PATTERNS = ["https://www.doubao.com/*", "https://doubao.com/*"];
+const DOUBAO_RUNTIME_SYNC_MESSAGE = "doubao runtime passive sync pending";
+const DOUBAO_RUNTIME_SYNC_HINT = "插件正在后台静默拉起豆包并自动同步";
+const DOUBAO_RUNTIME_BOOTSTRAP_TIMEOUT_MS = 15_000;
+const DOUBAO_EXISTING_TAB_BOOTSTRAP_TIMEOUT_MS = 5_000;
+const DOUBAO_RUNTIME_BOOTSTRAP_POLL_INTERVAL_MS = 500;
+const DOUBAO_RUNTIME_BOOTSTRAP_COOLDOWN_MS = 30_000;
+const DOUBAO_EXISTING_TAB_PROBE_LIMIT = 2;
+const DOUBAO_REQUIRED_RUNTIME_KEYS: Array<keyof DoubaoRequestRuntimeState> = [
+  "fp",
+  "ms_token",
+  "device_id",
+  "web_id",
+  "tea_uuid",
+];
+const SEARCH_RESULT_KEYS = new Set([
+  "references",
+  "reference_list",
+  "referenceList",
+  "reference_cards",
+  "referenceCards",
+  "reference_docs",
+  "referenceDocs",
+  "sources",
+  "source_list",
+  "sourceList",
+  "source_cards",
+  "sourceCards",
+  "search_results",
+  "searchResults",
+  "search_result_list",
+  "searchResultList",
+  "search_refs",
+  "searchRefs",
+  "web_results",
+  "webResults",
+  "grounding",
+  "grounding_results",
+  "groundingResults",
+  "browse_results",
+  "browseResults",
+  "browse_references",
+  "browseReferences",
+]);
+const CONTENT_CITATION_KEYS = new Set([
+  "citations",
+  "citation_list",
+  "citationList",
+  "content_citations",
+  "contentCitations",
+  "answer_citations",
+  "answerCitations",
+]);
+const SEARCH_RESULT_KEYWORDS = [
+  "reference",
+  "source",
+  "searchresult",
+  "searchref",
+  "webresult",
+  "grounding",
+  "browse",
+];
+const CONTENT_CITATION_KEYWORDS = ["citation", "contentcitation", "answercitation"];
+
+type SourceCollectionBucket = "search" | "citation" | null;
+
+type DoubaoRequestRuntimeState = {
+  fp: string;
+  ms_token: string;
+  device_id: string;
+  web_id: string;
+  tea_uuid: string;
+};
+
+type DoubaoStreamEvent = {
+  event: string;
+  payload: unknown;
+};
+
+type DoubaoStreamSummary = {
+  answer: string | null;
+  provider_request_id: string | null;
+  request_id: string | null;
+  conversation_id: string | null;
+  citations: MonitoringSourceItem[];
+  search_results: MonitoringSourceItem[];
+  events: DoubaoStreamEvent[];
+  error_message: string | null;
+};
+
+type DoubaoRuntimeSyncResponse = {
+  ok?: boolean;
+  error?: string;
+};
+
+let doubaoRuntimeBootstrapInFlight: Promise<boolean> | null = null;
+let lastDoubaoRuntimeBootstrapAt = 0;
+
+function normalizeText(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeAnswerFragment(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.replace(/\r/g, "");
+  return normalized.trim() ? normalized : null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getDirectString(record: Record<string, unknown>, keys: string[]): string | null {
+  for (const key of keys) {
+    const value = normalizeText(record[key]);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function readNestedString(source: unknown, path: string[]): string | null {
+  let current: unknown = source;
+  for (const key of path) {
+    if (!isRecord(current) || !(key in current)) {
+      return null;
+    }
+    current = current[key];
+  }
+  return normalizeText(current);
+}
+
+function findFirstStringByKey(source: unknown, keys: string[], depth = 0): string | null {
+  if (depth > 8 || source == null) {
+    return null;
+  }
+  if (Array.isArray(source)) {
+    for (const item of source) {
+      const found = findFirstStringByKey(item, keys, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (!isRecord(source)) {
+    return null;
+  }
+
+  for (const key of keys) {
+    const direct = normalizeText(source[key]);
+    if (direct) {
+      return direct;
+    }
+  }
+
+  for (const value of Object.values(source)) {
+    const found = findFirstStringByKey(value, keys, depth + 1);
+    if (found) {
+      return found;
+    }
+  }
+
+  return null;
+}
+
+function mergeAnswerText(current: string | null, nextFragment: string | null): string | null {
+  if (!nextFragment) {
+    return current;
+  }
+  if (!current) {
+    return nextFragment;
+  }
+  if (current === nextFragment || current.includes(nextFragment)) {
+    return current;
+  }
+  if (nextFragment.startsWith(current)) {
+    return nextFragment;
+  }
+  return `${current}${nextFragment}`;
+}
+
+function safeParseJSON(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function normalizeSourceUrl(value: string | null): string | null {
+  const input = normalizeText(value);
+  if (!input) {
+    return null;
+  }
+
+  try {
+    const url = new URL(input);
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return input;
+  }
+}
+
+function normalizeSourceKey(key: string): string {
+  return key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+
+function resolveSourceBucket(key: string): SourceCollectionBucket {
+  const normalized = normalizeSourceKey(key);
+  if (!normalized) {
+    return null;
+  }
+  if (CONTENT_CITATION_KEYS.has(key) || CONTENT_CITATION_KEYWORDS.some((keyword) => normalized.includes(keyword))) {
+    return "citation";
+  }
+  if (SEARCH_RESULT_KEYS.has(key) || SEARCH_RESULT_KEYWORDS.some((keyword) => normalized.includes(keyword))) {
+    return "search";
+  }
+  return null;
+}
+
+function buildSourceItem(input: unknown): MonitoringSourceItem | null {
+  if (typeof input === "string") {
+    const url = normalizeSourceUrl(input);
+    return url ? { url, normalized_url: url } : null;
+  }
+  if (!isRecord(input)) {
+    return null;
+  }
+
+  const url = normalizeSourceUrl(
+    getDirectString(input, [
+      "url",
+      "link",
+      "uri",
+      "href",
+      "cited_url",
+      "target_url",
+      "targetUrl",
+      "source_url",
+      "sourceUrl",
+      "page_url",
+      "pageUrl",
+      "jump_url",
+      "jumpUrl",
+    ]),
+  );
+  if (!url) {
+    return null;
+  }
+
+  let host: string | null = null;
+  try {
+    host = new URL(url).hostname || null;
+  } catch {
+    host = null;
+  }
+
+  return {
+    url,
+    title: getDirectString(input, ["title", "name", "cited_title", "page_title", "display_title", "page_name"]),
+    site_name: getDirectString(input, ["site_name", "siteName", "source", "platform_name", "domain", "site", "host_name"]),
+    site_key: getDirectString(input, ["site_key", "siteKey", "domain_key"]),
+    normalized_url: url,
+    host,
+    resolution_status: getDirectString(input, ["resolution_status", "resolutionStatus"]),
+    resolution_confidence: getDirectString(input, ["resolution_confidence", "resolutionConfidence"]),
+  };
+}
+
+function looksExplicitlyLikeSourceRecord(input: Record<string, unknown>): boolean {
+  return (
+    getDirectString(input, [
+      "title",
+      "name",
+      "cited_title",
+      "page_title",
+      "display_title",
+      "page_name",
+      "site_name",
+      "siteName",
+      "source",
+      "platform_name",
+      "domain",
+      "host_name",
+    ]) !== null
+  );
+}
+
+function isSourceLikeArray(value: unknown): value is unknown[] {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  return value.some((item) => buildSourceItem(item) !== null);
+}
+
+function dedupeSourceItems(items: MonitoringSourceItem[]): MonitoringSourceItem[] {
+  const keyed = new Map<string, MonitoringSourceItem>();
+  for (const item of items) {
+    const key = normalizeSourceUrl(item.normalized_url ?? item.url);
+    if (!key) {
+      continue;
+    }
+
+    const existing = keyed.get(key);
+    if (!existing) {
+      keyed.set(key, {
+        ...item,
+        normalized_url: key,
+      });
+      continue;
+    }
+
+    keyed.set(key, {
+      ...existing,
+      title: existing.title ?? item.title ?? null,
+      site_name: existing.site_name ?? item.site_name ?? null,
+      site_key: existing.site_key ?? item.site_key ?? null,
+      host: existing.host ?? item.host ?? null,
+      resolution_status: existing.resolution_status ?? item.resolution_status ?? null,
+      resolution_confidence: existing.resolution_confidence ?? item.resolution_confidence ?? null,
+    });
+  }
+
+  return Array.from(keyed.values());
+}
+
+function collectSources(
+  payload: unknown,
+  searchResults: MonitoringSourceItem[],
+  citations: MonitoringSourceItem[],
+  bucket: SourceCollectionBucket = null,
+  depth = 0,
+): void {
+  if (depth > 12 || payload == null) {
+    return;
+  }
+
+  const pushToBucket = (item: MonitoringSourceItem, targetBucket: SourceCollectionBucket) => {
+    if (targetBucket === "citation") {
+      citations.push(item);
+      return;
+    }
+    searchResults.push(item);
+  };
+
+  if (typeof payload === "string") {
+    if (!bucket) {
+      return;
+    }
+    const item = buildSourceItem(payload);
+    if (item) {
+      pushToBucket(item, bucket);
+    }
+    return;
+  }
+
+  if (Array.isArray(payload)) {
+    if (bucket && isSourceLikeArray(payload)) {
+      for (const item of payload) {
+        const sourceItem = buildSourceItem(item);
+        if (sourceItem) {
+          pushToBucket(sourceItem, bucket);
+        }
+      }
+    }
+    for (const item of payload) {
+      collectSources(item, searchResults, citations, bucket, depth + 1);
+    }
+    return;
+  }
+  if (!isRecord(payload)) {
+    return;
+  }
+
+  const directSourceItem = buildSourceItem(payload);
+  if (directSourceItem && (bucket || looksExplicitlyLikeSourceRecord(payload))) {
+    pushToBucket(directSourceItem, bucket ?? "search");
+  }
+
+  for (const [key, value] of Object.entries(payload)) {
+    const nextBucket = resolveSourceBucket(key) ?? bucket;
+
+    if (nextBucket && isSourceLikeArray(value)) {
+      const sourceItems = value.map((item) => buildSourceItem(item)).filter((item): item is MonitoringSourceItem => item !== null);
+      for (const item of sourceItems) {
+        pushToBucket(item, nextBucket);
+      }
+    }
+
+    if (nextBucket && typeof value === "string") {
+      const item = buildSourceItem(value);
+      if (item) {
+        pushToBucket(item, nextBucket);
+      }
+    }
+
+    if (Array.isArray(value) || isRecord(value) || typeof value === "string") {
+      collectSources(value, searchResults, citations, nextBucket, depth + 1);
+    }
+  }
+}
+
+function collectAnswerFragments(payload: unknown, result: string[] = []): string[] {
+  if (payload == null) {
+    return result;
+  }
+  if (Array.isArray(payload)) {
+    for (const item of payload) {
+      collectAnswerFragments(item, result);
+    }
+    return result;
+  }
+  if (!isRecord(payload)) {
+    return result;
+  }
+
+  const textBlockText = readNestedString(payload, ["text_block", "text"]);
+  if (textBlockText) {
+    result.push(textBlockText);
+  }
+
+  const deltaText = normalizeAnswerFragment(payload.delta);
+  if (deltaText) {
+    result.push(deltaText);
+  }
+
+  const nestedDeltaText = readNestedString(payload, ["delta", "text"]);
+  if (nestedDeltaText) {
+    result.push(nestedDeltaText);
+  }
+
+  const assistantText =
+    (normalizeText(payload.role) === "assistant" || normalizeText(payload.message_type) === "assistant") &&
+    normalizeAnswerFragment(payload.text);
+  if (assistantText) {
+    result.push(assistantText);
+  }
+
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "text_block" || key === "delta") {
+      continue;
+    }
+    if (Array.isArray(value) || isRecord(value)) {
+      collectAnswerFragments(value, result);
+    }
+  }
+
+  return result;
+}
+
+function formatDoubaoStreamError(payload: unknown): string {
+  const errorCode = findFirstStringByKey(payload, ["error_code", "code"]);
+  const errorMessage = findFirstStringByKey(payload, ["error_msg", "message", "detail"]);
+  const verifyScene = findFirstStringByKey(payload, ["verify_scene"]);
+
+  if (verifyScene) {
+    return `doubao verification required (${verifyScene})`;
+  }
+  if (errorCode && errorMessage) {
+    return `doubao stream error ${errorCode}: ${errorMessage}`;
+  }
+  if (errorCode) {
+    return `doubao stream error ${errorCode}`;
+  }
+  if (errorMessage) {
+    return `doubao stream error: ${errorMessage}`;
+  }
+  return "doubao stream error";
+}
+
+function parseSSERecord(record: string): DoubaoStreamEvent | null {
+  const lines = record.split(/\r?\n/);
+  let eventName = "message";
+  const dataLines: string[] = [];
+
+  for (const line of lines) {
+    if (!line || line.startsWith(":")) {
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim() || eventName;
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    }
+  }
+
+  if (dataLines.length === 0) {
+    return null;
+  }
+
+  return {
+    event: eventName,
+    payload: safeParseJSON(dataLines.join("\n")),
+  };
+}
+
+async function parseDoubaoStream(response: Response): Promise<DoubaoStreamSummary> {
+  const summary: DoubaoStreamSummary = {
+    answer: null,
+    provider_request_id: null,
+    request_id: null,
+    conversation_id: null,
+    citations: [],
+    search_results: [],
+    events: [],
+    error_message: null,
+  };
+
+  const body = response.body;
+  if (!body) {
+    throw new Error("doubao response stream missing");
+  }
+
+  const decoder = new TextDecoder();
+  const reader = body.getReader();
+  let buffer = "";
+
+  const consumeRecord = (rawRecord: string) => {
+    const parsed = parseSSERecord(rawRecord);
+    if (!parsed) {
+      return;
+    }
+
+    summary.events.push(parsed);
+    const upperEvent = parsed.event.toUpperCase();
+    if (upperEvent.includes("ERROR")) {
+      summary.error_message = formatDoubaoStreamError(parsed.payload);
+      return;
+    }
+
+    if (!summary.conversation_id) {
+      summary.conversation_id =
+        readNestedString(parsed.payload, ["ack_client_meta", "conversation_id"]) ??
+        readNestedString(parsed.payload, ["client_meta", "conversation_id"]) ??
+        findFirstStringByKey(parsed.payload, ["conversation_id"]);
+    }
+    if (!summary.provider_request_id) {
+      summary.provider_request_id = findFirstStringByKey(parsed.payload, ["log_id", "request_id", "req_id"]);
+    }
+    if (!summary.request_id) {
+      summary.request_id = findFirstStringByKey(parsed.payload, ["message_id", "local_message_id", "reply_id"]);
+    }
+
+    const fragments = collectAnswerFragments(parsed.payload);
+    for (const fragment of fragments) {
+      summary.answer = mergeAnswerText(summary.answer, fragment);
+    }
+
+    collectSources(parsed.payload, summary.search_results, summary.citations);
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      buffer += decoder.decode();
+      buffer = buffer.replace(/\r\n/g, "\n");
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    buffer = buffer.replace(/\r\n/g, "\n");
+
+    let separatorIndex = buffer.indexOf("\n\n");
+    while (separatorIndex !== -1) {
+      const rawRecord = buffer.slice(0, separatorIndex).trim();
+      buffer = buffer.slice(separatorIndex + 2);
+      if (rawRecord) {
+        consumeRecord(rawRecord);
+      }
+      separatorIndex = buffer.indexOf("\n\n");
+    }
+  }
+
+  const tail = buffer.trim();
+  if (tail) {
+    consumeRecord(tail);
+  }
+
+  summary.citations = dedupeSourceItems(summary.citations);
+  summary.search_results = dedupeSourceItems(summary.search_results);
+  return summary;
+}
+
+async function getDoubaoCookieValue(name: string): Promise<string | null> {
+  for (const url of DOUBAO_COOKIE_URLS) {
+    try {
+      const cookie = await browser.cookies.get({ url, name });
+      const value = normalizeText(cookie?.value);
+      if (value) {
+        return value;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+async function readCurrentDoubaoRequestRuntimeState(): Promise<Partial<DoubaoRequestRuntimeState>> {
+  const state = await getExtensionState();
+  const runtimeState = state.monitoring_runtime.doubao;
+
+  return {
+    fp: runtimeState?.fp ?? (await getDoubaoCookieValue(DOUBAO_FP_COOKIE_NAME)) ?? undefined,
+    ms_token: runtimeState?.ms_token ?? undefined,
+    device_id: runtimeState?.device_id ?? undefined,
+    web_id: runtimeState?.web_id ?? undefined,
+    tea_uuid: runtimeState?.tea_uuid ?? undefined,
+  };
+}
+
+function getDoubaoMissingRuntimeKeys(
+  runtimeState: Partial<DoubaoRequestRuntimeState>,
+): Array<keyof DoubaoRequestRuntimeState> {
+  return DOUBAO_REQUIRED_RUNTIME_KEYS.filter((key) => !normalizeText(runtimeState[key]));
+}
+
+function finalizeDoubaoRequestRuntimeState(
+  runtimeState: Partial<DoubaoRequestRuntimeState>,
+): DoubaoRequestRuntimeState {
+  const missingKeys = getDoubaoMissingRuntimeKeys(runtimeState);
+  if (missingKeys.length > 0) {
+    throw new Error(`${DOUBAO_RUNTIME_SYNC_MESSAGE}: ${missingKeys.join(", ")}`);
+  }
+
+  return {
+    fp: runtimeState.fp as string,
+    ms_token: runtimeState.ms_token as string,
+    device_id: runtimeState.device_id as string,
+    web_id: runtimeState.web_id as string,
+    tea_uuid: runtimeState.tea_uuid as string,
+  };
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    globalThis.setTimeout(resolve, ms);
+  });
+}
+
+function isDoubaoTabUrl(urlValue: string | undefined): boolean {
+  if (!urlValue) {
+    return false;
+  }
+
+  try {
+    const url = new URL(urlValue);
+    return url.hostname === "doubao.com" || url.hostname === "www.doubao.com" || url.hostname.endsWith(".doubao.com");
+  } catch {
+    return false;
+  }
+}
+
+function isDoubaoRuntimeSyncResponse(value: unknown): value is DoubaoRuntimeSyncResponse {
+  return typeof value === "object" && value !== null;
+}
+
+async function hasReadyDoubaoRequestRuntimeState(): Promise<boolean> {
+  const runtimeState = await readCurrentDoubaoRequestRuntimeState();
+  return getDoubaoMissingRuntimeKeys(runtimeState).length === 0;
+}
+
+async function waitForDoubaoRequestRuntimeState(timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() <= deadline) {
+    if (await hasReadyDoubaoRequestRuntimeState()) {
+      return true;
+    }
+    await delay(DOUBAO_RUNTIME_BOOTSTRAP_POLL_INTERVAL_MS);
+  }
+
+  return await hasReadyDoubaoRequestRuntimeState();
+}
+
+async function waitForTabComplete(tabId: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() <= deadline) {
+    const tab = await browser.tabs.get(tabId).catch(() => null);
+    if (!tab) {
+      return false;
+    }
+    if (tab.status === "complete") {
+      return true;
+    }
+    await delay(DOUBAO_RUNTIME_BOOTSTRAP_POLL_INTERVAL_MS);
+  }
+
+  const tab = await browser.tabs.get(tabId).catch(() => null);
+  return tab?.status === "complete";
+}
+
+async function requestDoubaoRuntimeSync(tabId: number): Promise<void> {
+  try {
+    const response = await browser.tabs.sendMessage(tabId, {
+      type: "geo.monitoring.runtime.sync",
+      platform: "doubao",
+    });
+
+    if (isDoubaoRuntimeSyncResponse(response) && response.ok === false) {
+      throw new Error(response.error || "monitoring_runtime_sync_failed");
+    }
+  } catch {
+    // The content script also syncs on page load, so a missed message is safe to ignore here.
+  }
+}
+
+function sortDoubaoTabs(tabs: chrome.tabs.Tab[]): chrome.tabs.Tab[] {
+  return [...tabs].sort((left, right) => {
+    if (Boolean(left.active) !== Boolean(right.active)) {
+      return left.active ? -1 : 1;
+    }
+    if ((left.status === "complete") !== (right.status === "complete")) {
+      return left.status === "complete" ? -1 : 1;
+    }
+    return (left.id ?? Number.MAX_SAFE_INTEGER) - (right.id ?? Number.MAX_SAFE_INTEGER);
+  });
+}
+
+async function bootstrapDoubaoRuntimeFromTab(tabId: number, timeoutMs: number): Promise<boolean> {
+  const tabReady = await waitForTabComplete(tabId, timeoutMs);
+  if (!tabReady) {
+    return await waitForDoubaoRequestRuntimeState(timeoutMs);
+  }
+
+  await delay(DOUBAO_RUNTIME_BOOTSTRAP_POLL_INTERVAL_MS);
+  await requestDoubaoRuntimeSync(tabId);
+  return await waitForDoubaoRequestRuntimeState(timeoutMs);
+}
+
+async function bootstrapDoubaoRuntimeWithExistingTabs(): Promise<boolean> {
+  const tabs = await browser.tabs.query({ url: DOUBAO_TAB_URL_PATTERNS }).catch(() => []);
+
+  for (const tab of sortDoubaoTabs(tabs).filter((candidate) => typeof candidate.id === "number").slice(0, DOUBAO_EXISTING_TAB_PROBE_LIMIT)) {
+    if (await bootstrapDoubaoRuntimeFromTab(tab.id as number, DOUBAO_EXISTING_TAB_BOOTSTRAP_TIMEOUT_MS)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+async function bootstrapDoubaoRuntimeWithSilentTab(): Promise<boolean> {
+  const page = await openSilentAutomationPage(DOUBAO_BOOTSTRAP_URL).catch(() => null);
+  if (!page) {
+    return false;
+  }
+
+  try {
+    return await bootstrapDoubaoRuntimeFromTab(page.tabId, DOUBAO_RUNTIME_BOOTSTRAP_TIMEOUT_MS);
+  } finally {
+    await closeSilentAutomationPage(page);
+  }
+}
+
+async function ensureDoubaoRequestRuntimeStateReady(): Promise<boolean> {
+  if (await hasReadyDoubaoRequestRuntimeState()) {
+    return true;
+  }
+
+  if (doubaoRuntimeBootstrapInFlight) {
+    return await doubaoRuntimeBootstrapInFlight;
+  }
+
+  if (Date.now() - lastDoubaoRuntimeBootstrapAt < DOUBAO_RUNTIME_BOOTSTRAP_COOLDOWN_MS) {
+    return false;
+  }
+
+  lastDoubaoRuntimeBootstrapAt = Date.now();
+  doubaoRuntimeBootstrapInFlight = (async () => {
+    if (await bootstrapDoubaoRuntimeWithExistingTabs()) {
+      return true;
+    }
+
+    if (await hasReadyDoubaoRequestRuntimeState()) {
+      return true;
+    }
+
+    return await bootstrapDoubaoRuntimeWithSilentTab();
+  })().finally(() => {
+    doubaoRuntimeBootstrapInFlight = null;
+  });
+
+  return await doubaoRuntimeBootstrapInFlight;
+}
+
+async function loadDoubaoRequestRuntimeState(): Promise<DoubaoRequestRuntimeState> {
+  const currentState = await readCurrentDoubaoRequestRuntimeState();
+  try {
+    return finalizeDoubaoRequestRuntimeState(currentState);
+  } catch {
+    const ready = await ensureDoubaoRequestRuntimeStateReady();
+    if (!ready) {
+      throw new Error(
+        `${DOUBAO_RUNTIME_SYNC_MESSAGE}: ${getDoubaoMissingRuntimeKeys(await readCurrentDoubaoRequestRuntimeState()).join(", ")}`,
+      );
+    }
+
+    return finalizeDoubaoRequestRuntimeState(await readCurrentDoubaoRequestRuntimeState());
+  }
+}
+
+function buildDoubaoRequestUrl(runtimeState: DoubaoRequestRuntimeState): string {
+  const url = new URL(DOUBAO_CHAT_URL);
+  url.searchParams.set("aid", DOUBAO_APP_ID);
+  url.searchParams.set("device_platform", "web");
+  url.searchParams.set("device_id", runtimeState.device_id);
+  url.searchParams.set("web_id", runtimeState.web_id);
+  url.searchParams.set("tea_uuid", runtimeState.tea_uuid);
+  url.searchParams.set("msToken", runtimeState.ms_token);
+  url.searchParams.set("fp", runtimeState.fp);
+  return url.toString();
+}
+
+function buildDoubaoRequestBody(questionText: string, runtimeState: DoubaoRequestRuntimeState): Record<string, unknown> {
+  return {
+    client_meta: {
+      local_conversation_id: `local_${Date.now()}${Math.floor(Math.random() * 1_000_000)}`,
+      conversation_id: "",
+      bot_id: DOUBAO_BOT_ID,
+      last_section_id: "",
+      last_message_index: null,
+    },
+    messages: [
+      {
+        local_message_id: crypto.randomUUID(),
+        content_block: [
+          {
+            block_type: 10000,
+            content: {
+              text_block: {
+                text: questionText,
+                icon_url: "",
+                icon_url_dark: "",
+                summary: "",
+              },
+              pc_event_block: "",
+            },
+            block_id: crypto.randomUUID(),
+            parent_id: "",
+            meta_info: [],
+            append_fields: [],
+          },
+        ],
+        message_status: 0,
+      },
+    ],
+    option: {
+      need_deep_think: 1,
+      need_create_conversation: true,
+      conversation_init_option: {
+        need_ack_conversation: true,
+      },
+      sse_recv_event_options: {
+        support_chunk_delta: true,
+      },
+    },
+    ext: {
+      use_deep_think: "1",
+      fp: runtimeState.fp,
+      conversation_init_option: JSON.stringify({
+        need_ack_conversation: true,
+      }),
+      commerce_credit_config_enable: "0",
+      sub_conv_firstmet_type: "1",
+    },
+  };
+}
+
+async function queryDoubao(platform: StoredMonitoringPlatformState, questionText: string): Promise<MonitoringAdapterQueryResult> {
+  const runtimeState = await loadDoubaoRequestRuntimeState();
+  const requestBody = buildDoubaoRequestBody(questionText, runtimeState);
+  const response = await fetch(buildDoubaoRequestUrl(runtimeState), {
+    method: "POST",
+    credentials: "include",
+    headers: {
+      Accept: "text/event-stream",
+      "Content-Type": "application/json",
+    },
+    referrer: DOUBAO_REFERER,
+    body: JSON.stringify(requestBody),
+  });
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    const detail = normalizeText(bodyText)?.slice(0, 200);
+    throw new Error(detail ? `doubao request failed ${response.status}: ${detail}` : `doubao request failed ${response.status}`);
+  }
+
+  const streamSummary = await parseDoubaoStream(response);
+  if (streamSummary.error_message) {
+    throw new Error(streamSummary.error_message);
+  }
+  if (!streamSummary.answer && streamSummary.citations.length === 0 && streamSummary.search_results.length === 0) {
+    throw new Error("doubao empty response");
+  }
+
+  return {
+    provider_model: `${platform.ai_platform_id}-web-thinking`,
+    provider_request_id: streamSummary.provider_request_id,
+    request_id: streamSummary.request_id ?? streamSummary.conversation_id,
+    answer: streamSummary.answer,
+    raw_response_json: {
+      platform: platform.ai_platform_id,
+      mode: "deep_think",
+      conversation_id: streamSummary.conversation_id,
+      provider_request_id: streamSummary.provider_request_id,
+      request_id: streamSummary.request_id,
+      answer: streamSummary.answer,
+      citation_count: streamSummary.citations.length,
+      thought_reference_count: streamSummary.search_results.length,
+      reference_count: streamSummary.search_results.length,
+      search_result_count: streamSummary.search_results.length,
+      event_count: streamSummary.events.length,
+      citations: streamSummary.citations,
+      thought_references: streamSummary.search_results,
+      thinking_references: streamSummary.search_results,
+      references: streamSummary.search_results,
+      search_results: streamSummary.search_results,
+      sources: streamSummary.search_results,
+      events: streamSummary.events,
+      status: "succeeded",
+    },
+    citations: streamSummary.citations,
+    search_results: streamSummary.search_results,
+  };
+}
+
+export const doubaoMonitoringAdapter: MonitoringAdapter = {
+  async detect(platform) {
+    const connected = await hasAnyPlatformCookie(platform);
+    const reachable = await isPlatformReachable(platform);
+
+    if (!reachable) {
+      return normalizeDetectResult(connected, false, "unavailable", "平台当前不可访问");
+    }
+
+    let runtimeState = await readCurrentDoubaoRequestRuntimeState();
+    if (getDoubaoMissingRuntimeKeys(runtimeState).length > 0) {
+      await ensureDoubaoRequestRuntimeStateReady();
+      runtimeState = await readCurrentDoubaoRequestRuntimeState();
+    }
+
+    if (getDoubaoMissingRuntimeKeys(runtimeState).length > 0) {
+      return {
+        ...normalizeDetectResult(connected, true, "runtime_sync_pending", DOUBAO_RUNTIME_SYNC_HINT),
+        message: DOUBAO_RUNTIME_SYNC_HINT,
+      };
+    }
+
+    return normalizeDetectResult(connected, true, null, null);
+  },
+  async canQuery() {
+    try {
+      await loadDoubaoRequestRuntimeState();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async query(platform, task) {
+    return await queryDoubao(platform, task.question_text);
+  },
+};
diff --git a/apps/browser-extension/src/monitoring-adapters/index.ts b/apps/browser-extension/src/monitoring-adapters/index.ts
new file mode 100644
index 0000000..f9edb46
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/index.ts
@@ -0,0 +1,74 @@
+import type { StoredMonitoringPlatformState } from "../monitoring-platforms";
+
+import { hasAnyPlatformCookie, isPlatformReachable, normalizeDetectResult } from "./common";
+import { doubaoMonitoringAdapter } from "./doubao";
+import { qwenMonitoringAdapter } from "./qwen";
+import type { MonitoringAdapter, MonitoringAdapterTaskContext } from "./types";
+
+function createDefaultMonitoringAdapter(): MonitoringAdapter {
+  return {
+    async detect(platform) {
+      const connected = await hasAnyPlatformCookie(platform);
+      const reachable = await isPlatformReachable(platform);
+
+      if (platform.access_requirement === "login_required") {
+        if (!connected) {
+          return normalizeDetectResult(false, false, "not_logged_in", "当前平台需要登录后才可采集");
+        }
+        if (!reachable) {
+          return normalizeDetectResult(true, false, "unavailable", "平台当前不可访问");
+        }
+        return normalizeDetectResult(true, true, null, null);
+      }
+
+      if (reachable || connected) {
+        return normalizeDetectResult(connected, true, null, null);
+      }
+
+      return normalizeDetectResult(false, false, "unavailable", "平台当前不可访问");
+    },
+    canQuery() {
+      return false;
+    },
+  };
+}
+
+const defaultAdapter = createDefaultMonitoringAdapter();
+
+const monitoringAdapters: Record<string, MonitoringAdapter> = {
+  deepseek: defaultAdapter,
+  qwen: qwenMonitoringAdapter,
+  doubao: doubaoMonitoringAdapter,
+};
+
+export async function detectMonitoringPlatformState(
+  platform: StoredMonitoringPlatformState,
+): Promise<StoredMonitoringPlatformState> {
+  const adapter = monitoringAdapters[platform.ai_platform_id] ?? defaultAdapter;
+  const detected = await adapter.detect(platform);
+  return {
+    ...platform,
+    ...detected,
+  };
+}
+
+export async function canQueryMonitoringPlatform(platform: StoredMonitoringPlatformState): Promise<boolean> {
+  const adapter = monitoringAdapters[platform.ai_platform_id];
+  if (!adapter?.canQuery) {
+    return false;
+  }
+
+  return await adapter.canQuery(platform);
+}
+
+export async function queryMonitoringTask(
+  platform: StoredMonitoringPlatformState,
+  task: MonitoringAdapterTaskContext,
+) {
+  const adapter = monitoringAdapters[platform.ai_platform_id];
+  if (!adapter?.query) {
+    throw new Error(`monitoring_adapter_query_not_implemented:${platform.ai_platform_id}`);
+  }
+
+  return await adapter.query(platform, task);
+}
diff --git a/apps/browser-extension/src/monitoring-adapters/qwen.ts b/apps/browser-extension/src/monitoring-adapters/qwen.ts
new file mode 100644
index 0000000..d7f0dfd
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/qwen.ts
@@ -0,0 +1,598 @@
+import type { MonitoringSourceItem } from "@geo/shared-types";
+import { browser } from "wxt/browser";
+
+import type { StoredMonitoringPlatformState } from "../monitoring-platforms";
+
+import {
+  closeSilentAutomationPage,
+  hasAnyPlatformCookie,
+  isPlatformReachable,
+  normalizeDetectResult,
+  openSilentAutomationPage,
+} from "./common";
+import type { MonitoringAdapter, MonitoringAdapterQueryResult } from "./types";
+
+const QWEN_BOOTSTRAP_URL = "https://www.qianwen.com/";
+const QWEN_PAGE_READY_TIMEOUT_MS = 20_000;
+const QWEN_QUERY_TIMEOUT_MS = 90_000;
+const QWEN_TAB_POLL_INTERVAL_MS = 500;
+
+type QwenPageQuestionSnapshot = {
+  model?: string | null;
+  deepSearch?: string | null;
+  enableSearch?: boolean | null;
+  cardText?: string | null;
+};
+
+type QwenPageAnswerSnapshot = {
+  reqId?: string | null;
+  status?: string | null;
+  content?: Record<string, unknown> | null;
+  extraInfo?: Record<string, unknown> | null;
+  communication?: Record<string, unknown> | null;
+};
+
+type QwenPageQuerySuccessResult = {
+  ok: true;
+  url: string;
+  question: QwenPageQuestionSnapshot | null;
+  answer: QwenPageAnswerSnapshot | null;
+};
+
+type QwenPageQueryFailureResult = {
+  ok: false;
+  error: string;
+  detail?: string | null;
+  url?: string | null;
+  question?: QwenPageQuestionSnapshot | null;
+  answer?: QwenPageAnswerSnapshot | null;
+};
+
+type QwenPageQueryResult = QwenPageQuerySuccessResult | QwenPageQueryFailureResult;
+
+function normalizeText(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readNestedString(source: unknown, path: string[]): string | null {
+  let current: unknown = source;
+  for (const segment of path) {
+    if (!isRecord(current) || !(segment in current)) {
+      return null;
+    }
+    current = current[segment];
+  }
+
+  return normalizeText(current);
+}
+
+function normalizeUrl(value: unknown): string | null {
+  const input = normalizeText(value);
+  if (!input) {
+    return null;
+  }
+
+  try {
+    const url = new URL(input);
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return input;
+  }
+}
+
+function buildQwenSourceItem(source: unknown): MonitoringSourceItem | null {
+  if (!isRecord(source)) {
+    return null;
+  }
+
+  const url = normalizeUrl(source.url ?? source.href ?? source.link);
+  if (!url) {
+    return null;
+  }
+
+  let host: string | null = null;
+  try {
+    host = new URL(url).hostname || null;
+  } catch {
+    host = null;
+  }
+
+  return {
+    url,
+    title: normalizeText(source.title),
+    site_name: normalizeText(source.name ?? source.site_name ?? source.authority),
+    normalized_url: url,
+    host,
+  };
+}
+
+function collectQwenSources(payload: unknown, result: MonitoringSourceItem[], depth = 0): void {
+  if (depth > 12 || payload == null) {
+    return;
+  }
+
+  if (Array.isArray(payload)) {
+    for (const item of payload) {
+      collectQwenSources(item, result, depth + 1);
+    }
+    return;
+  }
+
+  if (!isRecord(payload)) {
+    return;
+  }
+
+  const sourceItem = buildQwenSourceItem(payload);
+  if (sourceItem) {
+    result.push(sourceItem);
+  }
+
+  for (const value of Object.values(payload)) {
+    if (Array.isArray(value) || isRecord(value)) {
+      collectQwenSources(value, result, depth + 1);
+    }
+  }
+}
+
+function dedupeSourceItems(items: MonitoringSourceItem[]): MonitoringSourceItem[] {
+  const keyed = new Map<string, MonitoringSourceItem>();
+  for (const item of items) {
+    const key = normalizeUrl(item.normalized_url ?? item.url);
+    if (!key) {
+      continue;
+    }
+
+    const existing = keyed.get(key);
+    if (!existing) {
+      keyed.set(key, {
+        ...item,
+        normalized_url: key,
+      });
+      continue;
+    }
+
+    keyed.set(key, {
+      ...existing,
+      title: existing.title ?? item.title ?? null,
+      site_name: existing.site_name ?? item.site_name ?? null,
+      host: existing.host ?? item.host ?? null,
+    });
+  }
+
+  return Array.from(keyed.values());
+}
+
+function resolveQwenProviderModel(pageResult: QwenPageQuerySuccessResult): string | null {
+  return (
+    readNestedString(pageResult.answer?.extraInfo, ["chat_odps", "model_info", "model"]) ??
+    normalizeText(pageResult.question?.model) ??
+    (pageResult.question?.deepSearch === "1" ? "Qwen-deepThink" : "Qwen")
+  );
+}
+
+function formatQwenQueryError(result: QwenPageQueryFailureResult | QwenPageQuerySuccessResult): string {
+  if (!result.ok) {
+    const detail = normalizeText(result.detail);
+    return detail ? `${result.error}: ${detail}` : result.error;
+  }
+
+  const status = normalizeText(result.answer?.status);
+  return status ? `qwen query ended with status ${status}` : "qwen query failed";
+}
+
+function hasQwenScriptingApi(): boolean {
+  return typeof chrome !== "undefined" && Boolean(chrome.scripting?.executeScript);
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    globalThis.setTimeout(resolve, ms);
+  });
+}
+
+async function waitForTabComplete(tabId: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() <= deadline) {
+    const tab = await browser.tabs.get(tabId).catch(() => null);
+    if (!tab) {
+      return false;
+    }
+    if (tab.status === "complete") {
+      return true;
+    }
+    await delay(QWEN_TAB_POLL_INTERVAL_MS);
+  }
+
+  const tab = await browser.tabs.get(tabId).catch(() => null);
+  return tab?.status === "complete";
+}
+
+async function runQwenMainWorldScript<TArgs extends unknown[], TResult>(
+  tabId: number,
+  func: (...args: TArgs) => TResult | Promise<TResult>,
+  args: TArgs,
+): Promise<TResult> {
+  if (!hasQwenScriptingApi()) {
+    throw new Error("qwen scripting api unavailable");
+  }
+
+  const results = await chrome.scripting.executeScript({
+    target: { tabId },
+    world: "MAIN",
+    func,
+    args,
+  });
+
+  return (results[0]?.result ?? null) as TResult;
+}
+
+function qwenQueryInPage(questionText: string, options?: { timeoutMs?: number; deepThink?: boolean }): Promise<QwenPageQueryResult> {
+  const queryTimeoutMs = typeof options?.timeoutMs === "number" ? options.timeoutMs : 90_000;
+  const deepThinkEnabled = options?.deepThink !== false;
+
+  const wait = (ms: number) =>
+    new Promise<void>((resolve) => {
+      window.setTimeout(resolve, ms);
+    });
+
+  const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+  const normalizeInlineText = (value: unknown): string | null => {
+    if (typeof value !== "string") {
+      return null;
+    }
+
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  };
+
+  const toSerializable = (value: unknown): Record<string, unknown> | null => {
+    if (value == null) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
+    } catch {
+      return null;
+    }
+  };
+
+  const locateManagers = () => {
+    const bindingMap = (window as typeof window & { __TONGYI_PORTSL_GLOBAL_CONTAINER__?: { container?: { _bindingDictionary?: { _map?: Map<unknown, unknown[]> } } } })
+      .__TONGYI_PORTSL_GLOBAL_CONTAINER__?.container?._bindingDictionary?._map;
+
+    if (!(bindingMap instanceof Map)) {
+      return null;
+    }
+
+    let textAreaManager: Record<string, unknown> | null = null;
+    let chatManager: Record<string, unknown> | null = null;
+
+    for (const bindings of bindingMap.values()) {
+      if (!Array.isArray(bindings)) {
+        continue;
+      }
+
+      for (const binding of bindings) {
+        const candidate = isObjectRecord(binding) && "cache" in binding ? binding.cache : null;
+        if (!isObjectRecord(candidate)) {
+          continue;
+        }
+
+        const protoKeys = Object.getOwnPropertyNames(Object.getPrototypeOf(candidate) ?? {});
+        if (!textAreaManager && protoKeys.includes("setText") && protoKeys.includes("getWidget") && protoKeys.includes("enterMode")) {
+          textAreaManager = candidate;
+        }
+        if (!chatManager && protoKeys.includes("textAreaSubmit") && protoKeys.includes("sendWithParams") && protoKeys.includes("submit")) {
+          chatManager = candidate;
+        }
+      }
+    }
+
+    const state = (
+      window as typeof window & {
+        __qianwenChatAPI?: {
+          sharedValues?: {
+            chatAPI?: {
+              state?: Record<string, unknown>;
+            };
+          };
+        };
+      }
+    ).__qianwenChatAPI?.sharedValues?.chatAPI?.state;
+
+    if (!textAreaManager || !chatManager || !isObjectRecord(state)) {
+      return null;
+    }
+
+    return {
+      textAreaManager,
+      chatManager,
+      state,
+    };
+  };
+
+  const waitForReadyManagers = async (timeoutMs: number) => {
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() <= deadline) {
+      const managers = locateManagers();
+      if (managers) {
+        return managers;
+      }
+      await wait(250);
+    }
+
+    return locateManagers();
+  };
+
+  const getLatestSnapshot = (minimumRoundCount: number) => {
+    const state = (
+      window as typeof window & {
+        __qianwenChatAPI?: {
+          sharedValues?: {
+            chatAPI?: {
+              state?: {
+                chatRounds?: Array<Record<string, unknown>>;
+              };
+            };
+          };
+        };
+      }
+    ).__qianwenChatAPI?.sharedValues?.chatAPI?.state;
+
+    const chatRounds = Array.isArray(state?.chatRounds) ? state.chatRounds : [];
+    const candidateRounds = chatRounds.length > minimumRoundCount ? chatRounds.slice(minimumRoundCount) : chatRounds;
+
+    for (let index = candidateRounds.length - 1; index >= 0; index -= 1) {
+      const round = candidateRounds[index];
+      if (!isObjectRecord(round)) {
+        continue;
+      }
+
+      const questions = Array.isArray(round.questions) ? round.questions : [];
+      const currentQuestionIndex = typeof round.currentQuestionIndex === "number" ? round.currentQuestionIndex : 0;
+      const question = questions[currentQuestionIndex];
+      if (!isObjectRecord(question)) {
+        continue;
+      }
+
+      const cards = Array.isArray(question.cards) ? question.cards : [];
+      const firstCard = cards[0];
+      const cardText =
+        isObjectRecord(firstCard) && "content" in firstCard ? normalizeInlineText(firstCard.content) : null;
+      if (cardText !== questionText) {
+        continue;
+      }
+
+      const answers = Array.isArray(question.answers) ? question.answers : [];
+      const currentAnswerIndex = typeof question.currentAnswerIndex === "number" ? question.currentAnswerIndex : 0;
+      const answer = answers[currentAnswerIndex];
+
+      return {
+        question: {
+          model: normalizeInlineText(question.model),
+          deepSearch: normalizeInlineText(question.deepSearch),
+          enableSearch: typeof question.enableSearch === "boolean" ? question.enableSearch : null,
+          cardText,
+        },
+        answer: isObjectRecord(answer)
+          ? {
+              reqId: normalizeInlineText(answer.reqId),
+              status: normalizeInlineText(answer.status),
+              content: toSerializable(answer.content),
+              extraInfo: toSerializable(answer.extraInfo),
+              communication: toSerializable(answer.communication),
+            }
+          : null,
+      };
+    }
+
+    return {
+      question: null,
+      answer: null,
+    };
+  };
+
+  return (async (): Promise<QwenPageQueryResult> => {
+    const managers = await waitForReadyManagers(20_000);
+    if (!managers) {
+      return {
+        ok: false,
+        error: "qwen_page_not_ready",
+        url: window.location.href,
+      };
+    }
+
+    const { textAreaManager, chatManager, state } = managers;
+    const initialRoundCount = Array.isArray(state.chatRounds) ? state.chatRounds.length : 0;
+
+    try {
+      if (typeof textAreaManager.reset === "function") {
+        textAreaManager.reset();
+      }
+
+      const widgetContainer = isObjectRecord(textAreaManager.inputWidgetContainer) ? textAreaManager.inputWidgetContainer : null;
+      if (deepThinkEnabled && typeof widgetContainer?.activeWidget === "function") {
+        await widgetContainer.activeWidget("deepThink");
+      } else if (typeof widgetContainer?.inactiveAllWidget === "function") {
+        await widgetContainer.inactiveAllWidget();
+      }
+
+      if (typeof textAreaManager.setText === "function") {
+        textAreaManager.setText(questionText);
+      }
+      if (normalizeInlineText(textAreaManager.text) !== questionText && typeof textAreaManager.setTextImmediately === "function") {
+        textAreaManager.setTextImmediately(questionText);
+      }
+
+      await wait(50);
+
+      if (textAreaManager.isSubmitDisabled) {
+        return {
+          ok: false,
+          error: "qwen_submit_disabled",
+          detail: normalizeInlineText(textAreaManager.text) ?? "input_state_invalid",
+          url: window.location.href,
+        };
+      }
+
+      if (typeof chatManager.textAreaSubmit !== "function") {
+        return {
+          ok: false,
+          error: "qwen_submit_method_missing",
+          url: window.location.href,
+        };
+      }
+
+      await chatManager.textAreaSubmit();
+    } catch (error) {
+      return {
+        ok: false,
+        error: "qwen_submit_failed",
+        detail: error instanceof Error ? error.message : String(error ?? ""),
+        url: window.location.href,
+      };
+    }
+
+    const deadline = Date.now() + queryTimeoutMs;
+    while (Date.now() <= deadline) {
+      const snapshot = getLatestSnapshot(initialRoundCount);
+      const answerStatus = normalizeInlineText(snapshot.answer?.status);
+      if (answerStatus && ["finish", "failed", "interrupted"].includes(answerStatus)) {
+        if (answerStatus === "finish") {
+          return {
+            ok: true,
+            url: window.location.href,
+            question: snapshot.question,
+            answer: snapshot.answer,
+          };
+        }
+
+        return {
+          ok: false,
+          error: "qwen_query_finished_without_success",
+          detail: answerStatus,
+          url: window.location.href,
+          question: snapshot.question,
+          answer: snapshot.answer,
+        };
+      }
+      await wait(500);
+    }
+
+    const timeoutSnapshot = getLatestSnapshot(initialRoundCount);
+    return {
+      ok: false,
+      error: "qwen_query_timeout",
+      url: window.location.href,
+      question: timeoutSnapshot.question,
+      answer: timeoutSnapshot.answer,
+    };
+  })();
+}
+
+async function queryQwen(platform: StoredMonitoringPlatformState, questionText: string): Promise<MonitoringAdapterQueryResult> {
+  const page = await openSilentAutomationPage(QWEN_BOOTSTRAP_URL);
+
+  try {
+    await waitForTabComplete(page.tabId, QWEN_PAGE_READY_TIMEOUT_MS);
+    const pageResult = await runQwenMainWorldScript(page.tabId, qwenQueryInPage, [
+      questionText,
+      {
+        deepThink: true,
+        timeoutMs: QWEN_QUERY_TIMEOUT_MS,
+      },
+    ]);
+
+    if (!pageResult?.ok || !pageResult.answer) {
+      throw new Error(formatQwenQueryError(pageResult));
+    }
+
+    const answerText =
+      readNestedString(pageResult.answer.content, ["multiLoadIframe", "content"]) ??
+      readNestedString(pageResult.answer.content, ["barIframe", "content"]) ??
+      null;
+    const requestId =
+      normalizeText(pageResult.answer.reqId) ??
+      readNestedString(pageResult.answer.communication, ["reqid"]) ??
+      null;
+    const sessionId = readNestedString(pageResult.answer.communication, ["sessionid"]);
+    const providerModel = resolveQwenProviderModel(pageResult);
+
+    const searchResults: MonitoringSourceItem[] = [];
+    collectQwenSources(pageResult.answer.content, searchResults);
+    const dedupedSearchResults = dedupeSourceItems(searchResults);
+
+    if (!answerText && dedupedSearchResults.length === 0) {
+      throw new Error("qwen empty response");
+    }
+
+    return {
+      provider_model: providerModel,
+      provider_request_id: requestId,
+      request_id: requestId ?? sessionId,
+      answer: answerText,
+      raw_response_json: {
+        platform: platform.ai_platform_id,
+        mode: pageResult.question?.deepSearch === "1" ? "deep_think" : "standard",
+        page_url: pageResult.url,
+        session_id: sessionId,
+        provider_request_id: requestId,
+        provider_model: providerModel,
+        answer: answerText,
+        question: pageResult.question ?? null,
+        source_count: dedupedSearchResults.length,
+        search_results: dedupedSearchResults,
+        content: pageResult.answer.content ?? null,
+        extra_info: pageResult.answer.extraInfo ?? null,
+        communication: pageResult.answer.communication ?? null,
+        status: "succeeded",
+      },
+      citations: [],
+      search_results: dedupedSearchResults,
+    };
+  } finally {
+    await closeSilentAutomationPage(page);
+  }
+}
+
+export const qwenMonitoringAdapter: MonitoringAdapter = {
+  async detect(platform) {
+    const connected = await hasAnyPlatformCookie(platform);
+
+    if (!hasQwenScriptingApi()) {
+      return normalizeDetectResult(connected, false, "unsupported", "当前浏览器不支持千问静默采集");
+    }
+
+    const reachable = await isPlatformReachable(platform);
+    if (!reachable) {
+      return normalizeDetectResult(connected, false, "unavailable", "平台当前不可访问");
+    }
+
+    return normalizeDetectResult(connected, true, null, null);
+  },
+  async canQuery(platform) {
+    if (!hasQwenScriptingApi()) {
+      return false;
+    }
+
+    return await isPlatformReachable(platform);
+  },
+  async query(platform, task) {
+    return await queryQwen(platform, task.question_text);
+  },
+};
diff --git a/apps/browser-extension/src/monitoring-adapters/types.ts b/apps/browser-extension/src/monitoring-adapters/types.ts
new file mode 100644
index 0000000..a0702ee
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-adapters/types.ts
@@ -0,0 +1,52 @@
+import type { MonitoringSourceItem } from "@geo/shared-types";
+
+import type { StoredMonitoringPlatformState } from "../monitoring-platforms";
+
+export interface MonitoringAdapterTaskContext {
+  task_id: number;
+  brand_id: number;
+  question_id: number;
+  question_hash: string;
+  question_text: string;
+  ai_platform_id: string;
+  platform_name: string;
+  collector_type: string;
+  run_mode: string;
+  trigger_source: string;
+  business_date: string;
+  lease_token: string;
+  lease_expires_at: string;
+}
+
+export interface MonitoringAdapterDetectResult {
+  connected: boolean;
+  accessible: boolean;
+  detected_at: string;
+  reason_code?: string | null;
+  reason_message?: string | null;
+  message?: string | null;
+}
+
+export interface MonitoringAdapterQueryResult {
+  provider_model?: string | null;
+  provider_request_id?: string | null;
+  request_id?: string | null;
+  answer?: string | null;
+  raw_response_json?: Record<string, unknown>;
+  citations?: MonitoringSourceItem[];
+  search_results?: MonitoringSourceItem[];
+  brand_mentioned?: boolean | null;
+  brand_mention_position?: string | null;
+  first_recommended?: boolean | null;
+  sentiment_label?: string | null;
+  matched_brand_terms?: string[];
+}
+
+export interface MonitoringAdapter {
+  detect: (platform: StoredMonitoringPlatformState) => Promise<MonitoringAdapterDetectResult>;
+  canQuery?: (platform: StoredMonitoringPlatformState) => Promise<boolean> | boolean;
+  query?: (
+    platform: StoredMonitoringPlatformState,
+    task: MonitoringAdapterTaskContext,
+  ) => Promise<MonitoringAdapterQueryResult>;
+}
diff --git a/apps/browser-extension/src/monitoring-platforms.ts b/apps/browser-extension/src/monitoring-platforms.ts
new file mode 100644
index 0000000..9409f2d
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-platforms.ts
@@ -0,0 +1,72 @@
+import type { MonitoringLocalPlatformState } from "@geo/shared-types";
+
+export type MonitoringAccessRequirement = "login_required" | "anonymous_allowed";
+
+export interface StoredMonitoringPlatformState extends MonitoringLocalPlatformState {
+  platform_name: string;
+  short_name: string;
+  accent_color: string;
+  home_url: string;
+  login_url: string | null;
+  access_requirement: MonitoringAccessRequirement;
+  cookie_domains: string[];
+}
+
+const monitoringPlatformDefinitions = [
+  {
+    ai_platform_id: "deepseek",
+    platform_name: "DeepSeek",
+    short_name: "D",
+    accent_color: "#4468ff",
+    home_url: "https://chat.deepseek.com/",
+    login_url: "https://chat.deepseek.com/",
+    access_requirement: "login_required",
+    cookie_domains: ["chat.deepseek.com", "deepseek.com"],
+  },
+  {
+    ai_platform_id: "qwen",
+    platform_name: "通义千问",
+    short_name: "Q",
+    accent_color: "#6b46ff",
+    home_url: "https://www.qianwen.com/",
+    login_url: "https://www.qianwen.com/",
+    access_requirement: "anonymous_allowed",
+    cookie_domains: ["www.qianwen.com", "qianwen.com"],
+  },
+  {
+    ai_platform_id: "doubao",
+    platform_name: "豆包",
+    short_name: "豆",
+    accent_color: "#00a870",
+    home_url: "https://www.doubao.com/",
+    login_url: "https://www.doubao.com/",
+    access_requirement: "anonymous_allowed",
+    cookie_domains: ["www.doubao.com", "doubao.com"],
+  },
+] satisfies Array<
+  Pick<
+    StoredMonitoringPlatformState,
+    | "ai_platform_id"
+    | "platform_name"
+    | "short_name"
+    | "accent_color"
+    | "home_url"
+    | "login_url"
+    | "access_requirement"
+    | "cookie_domains"
+  >
+>;
+
+export const supportedMonitoringPlatforms = monitoringPlatformDefinitions;
+
+export function createDefaultMonitoringPlatformStates(): StoredMonitoringPlatformState[] {
+  return supportedMonitoringPlatforms.map((platform) => ({
+    ...platform,
+    connected: false,
+    accessible: false,
+    detected_at: null,
+    reason_code: null,
+    reason_message: null,
+    message: null,
+  }));
+}
diff --git a/apps/browser-extension/src/monitoring-runtime.ts b/apps/browser-extension/src/monitoring-runtime.ts
new file mode 100644
index 0000000..77f07da
--- /dev/null
+++ b/apps/browser-extension/src/monitoring-runtime.ts
@@ -0,0 +1,729 @@
+import type {
+  ApiEnvelope,
+  JsonValue,
+  MonitoringHeartbeatPlatformPayload,
+  MonitoringHeartbeatResponse,
+  MonitoringLeaseTask,
+  MonitoringLeaseTasksPayload,
+  MonitoringLeaseTasksResponse,
+  MonitoringLocalPlatformState,
+  MonitoringPluginPingResponse,
+  MonitoringResumeTasksPayload,
+  MonitoringResumeTasksResponse,
+  MonitoringSkipTaskPayload,
+  MonitoringSkipTaskResponse,
+  MonitoringTaskResultPayload,
+  MonitoringTaskResultResponse,
+} from "@geo/shared-types";
+import { browser } from "wxt/browser";
+
+import { canQueryMonitoringPlatform, detectMonitoringPlatformState, queryMonitoringTask } from "./monitoring-adapters";
+import type { MonitoringAdapterTaskContext } from "./monitoring-adapters/types";
+import type { StoredMonitoringPlatformState } from "./monitoring-platforms";
+import { getExtensionState, patchExtensionState, type ExtensionStorageState, type StoredMonitoringScheduledTask } from "./storage";
+
+export type MonitoringAction = "ping" | "detectPlatforms" | "syncHeartbeat" | "runCycle" | "getState";
+export type MonitoringCycleMode = "manual" | "automatic";
+
+const monitoringCycleBatchLeaseLimit = 50;
+const monitoringAutomaticDelayMinMs = 5 * 60 * 1000;
+const monitoringAutomaticDelayMaxMs = 10 * 60 * 1000;
+const monitoringRemoteHeartbeatFreshnessMs = 10 * 60 * 1000;
+const monitoringBusinessTimeZone = "Asia/Shanghai";
+
+export interface MonitoringHeartbeatSyncResult {
+  success: boolean;
+  source: "remote" | "local";
+  platform_states: MonitoringLocalPlatformState[];
+  heartbeat?: MonitoringHeartbeatResponse | null;
+  message?: string | null;
+}
+
+export interface MonitoringCycleResult {
+  success: boolean;
+  leased_task_count: number;
+  processed_task_count: number;
+  failed_task_count: number;
+  skipped_task_count: number;
+  message?: string | null;
+}
+
+export interface MonitoringRuntimeStateSnapshot {
+  installation_key: string;
+  plugin_installation_id: number | null;
+  api_base_url: string | null;
+  monitoring_last_heartbeat_at: string | null;
+  monitoring_last_heartbeat_status: string | null;
+  monitoring_last_cycle_at: string | null;
+  monitoring_last_cycle_status: string | null;
+  monitoring_platforms: StoredMonitoringPlatformState[];
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+
+function normalizeText(value?: string | null): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function formatMonitoringBusinessDate(value: Date): string {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: monitoringBusinessTimeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(value);
+
+  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;
+  if (!year || !month || !day) {
+    throw new Error("monitoring_business_date_format_failed");
+  }
+
+  return `${year}-${month}-${day}`;
+}
+
+function currentMonitoringBusinessDate(): string {
+  return formatMonitoringBusinessDate(new Date());
+}
+
+function currentTimestampMs(): number {
+  return Date.now();
+}
+
+function toTimestampMs(value: string | null | undefined): number | null {
+  if (!value) {
+    return null;
+  }
+  const timestamp = new Date(value).getTime();
+  return Number.isNaN(timestamp) ? null : timestamp;
+}
+
+function randomMonitoringDelayMs(): number {
+  return monitoringAutomaticDelayMinMs + Math.floor(Math.random() * (monitoringAutomaticDelayMaxMs - monitoringAutomaticDelayMinMs + 1));
+}
+
+function hasFreshSuccessfulMonitoringHeartbeat(state: ExtensionStorageState): boolean {
+  if (state.monitoring_last_heartbeat_status !== "success") {
+    return false;
+  }
+
+  const lastHeartbeatAt = toTimestampMs(state.monitoring_last_heartbeat_at);
+  if (lastHeartbeatAt == null) {
+    return false;
+  }
+
+  return currentTimestampMs() - lastHeartbeatAt < monitoringRemoteHeartbeatFreshnessMs;
+}
+
+function isImmediateMonitoringTask(task: MonitoringLeaseTask | StoredMonitoringScheduledTask): boolean {
+  return task.trigger_source === "manual";
+}
+
+function sortMonitoringTaskQueue(tasks: StoredMonitoringScheduledTask[]): StoredMonitoringScheduledTask[] {
+  return [...tasks].sort((left, right) => {
+    const leftTime = toTimestampMs(left.next_execute_at) ?? 0;
+    const rightTime = toTimestampMs(right.next_execute_at) ?? 0;
+    if (leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+    return left.task_id - right.task_id;
+  });
+}
+
+function isMonitoringNotLoggedIn(platform: StoredMonitoringPlatformState): boolean {
+  return platform.reason_code === "not_logged_in" || (platform.access_requirement === "login_required" && !platform.connected);
+}
+
+function resolveAccessStatus(platform: StoredMonitoringPlatformState): string {
+  if (platform.accessible) {
+    return "accessible";
+  }
+  if (isMonitoringNotLoggedIn(platform)) {
+    return "not_logged_in";
+  }
+  return "unavailable";
+}
+
+function toMonitoringPlatformPayload(platform: StoredMonitoringPlatformState): MonitoringHeartbeatPlatformPayload {
+  return {
+    ai_platform_id: platform.ai_platform_id,
+    access_status: resolveAccessStatus(platform),
+    connected: platform.connected,
+    accessible: platform.accessible,
+    detected_at: platform.detected_at ?? null,
+    reason_code: platform.reason_code ?? null,
+    reason_message: platform.reason_message ?? null,
+  };
+}
+
+async function postMonitoringApi<T>(path: string, payload: unknown): Promise<T> {
+  const state = await getExtensionState();
+  if (!state.api_base_url) {
+    throw new Error("monitoring_api_base_url_missing");
+  }
+  if (!state.plugin_installation_id || !state.installation_token) {
+    throw new Error("monitoring_installation_credentials_missing");
+  }
+
+  const response = await fetch(new URL(path.replace(/^\//, ""), normalizeBaseUrl(state.api_base_url)).toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Geo-Installation-Id": String(state.plugin_installation_id),
+      "X-Geo-Installation-Token": state.installation_token,
+    },
+    body: JSON.stringify(payload),
+  });
+
+  const body = (await response.json()) as ApiEnvelope<T> | { message?: string };
+  if (!response.ok || !("data" in body)) {
+    throw new Error(body.message || "monitoring_plugin_request_failed");
+  }
+
+  return body.data;
+}
+
+async function detectAllMonitoringPlatforms(): Promise<StoredMonitoringPlatformState[]> {
+  const state = await getExtensionState();
+  return await Promise.all(state.monitoring_platforms.map((platform) => detectMonitoringPlatformState(platform)));
+}
+
+async function persistMonitoringPlatforms(platforms: StoredMonitoringPlatformState[]): Promise<StoredMonitoringPlatformState[]> {
+  const nextState = await patchExtensionState({
+    monitoring_platforms: platforms,
+  });
+  return nextState.monitoring_platforms;
+}
+
+function projectMonitoringPlatforms(platforms: StoredMonitoringPlatformState[]): MonitoringLocalPlatformState[] {
+  return platforms.map((platform) => ({
+    ai_platform_id: platform.ai_platform_id,
+    connected: platform.connected,
+    accessible: platform.accessible,
+    detected_at: platform.detected_at ?? null,
+    reason_code: platform.reason_code ?? null,
+    reason_message: platform.reason_message ?? null,
+    message: platform.message ?? null,
+  }));
+}
+
+function asMonitoringTaskContext(task: MonitoringLeaseTask): MonitoringAdapterTaskContext {
+  return {
+    task_id: task.task_id,
+    brand_id: task.brand_id,
+    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,
+    lease_token: task.lease_token,
+    lease_expires_at: task.lease_expires_at,
+  };
+}
+
+function asTaskResultPayload(task: MonitoringLeaseTask, result: Awaited<ReturnType<typeof queryMonitoringTask>>): MonitoringTaskResultPayload {
+  return {
+    lease_token: task.lease_token,
+    status: "succeeded",
+    provider_model: normalizeText(result.provider_model),
+    provider_request_id: normalizeText(result.provider_request_id),
+    request_id: normalizeText(result.request_id),
+    answer: normalizeText(result.answer),
+    raw_response_json: (result.raw_response_json as Record<string, JsonValue> | undefined) ?? {},
+    citations: result.citations ?? [],
+    search_results: result.search_results ?? [],
+    brand_mentioned: result.brand_mentioned ?? null,
+    brand_mention_position: normalizeText(result.brand_mention_position),
+    first_recommended: result.first_recommended ?? null,
+    sentiment_label: normalizeText(result.sentiment_label),
+    matched_brand_terms: result.matched_brand_terms ?? [],
+  };
+}
+
+async function markMonitoringTaskSkipped(task: MonitoringLeaseTask, reason: string, errorMessage?: string | null): Promise<MonitoringSkipTaskResponse> {
+  const payload: MonitoringSkipTaskPayload = {
+    lease_token: task.lease_token,
+    skip_reason: reason,
+    error_message: normalizeText(errorMessage),
+    completed_at: new Date().toISOString(),
+  };
+  return await postMonitoringApi<MonitoringSkipTaskResponse>(`/api/plugin/monitoring/tasks/${task.task_id}/skip`, payload);
+}
+
+async function submitMonitoringTaskResult(task: MonitoringLeaseTask, payload: MonitoringTaskResultPayload): Promise<MonitoringTaskResultResponse> {
+  return await postMonitoringApi<MonitoringTaskResultResponse>(`/api/plugin/monitoring/tasks/${task.task_id}/result`, payload);
+}
+
+async function processMonitoringLeasedTask(
+  platform: StoredMonitoringPlatformState,
+  task: MonitoringLeaseTask,
+): Promise<"processed" | "failed" | "skipped"> {
+  if (!(await canQueryMonitoringPlatform(platform))) {
+    await markMonitoringTaskSkipped(task, "adapter_not_ready", `monitoring adapter is not ready for ${platform.ai_platform_id}`);
+    return "skipped";
+  }
+
+  try {
+    const result = await queryMonitoringTask(platform, asMonitoringTaskContext(task));
+    await submitMonitoringTaskResult(task, asTaskResultPayload(task, result));
+    return "processed";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "monitoring_query_failed";
+    try {
+      await markMonitoringTaskSkipped(task, "query_failed", message);
+    } catch {
+      // Ignore secondary skip failures so the caller can continue draining the queue.
+    }
+    return "failed";
+  }
+}
+
+async function resumeMonitoringTasks(aiPlatformIDs: string[]): Promise<MonitoringLeaseTask[]> {
+  const payload: MonitoringResumeTasksPayload = {
+    ai_platform_ids: aiPlatformIDs,
+  };
+  const resumed = await postMonitoringApi<MonitoringResumeTasksResponse>("/api/plugin/monitoring/tasks/resume", payload);
+  return resumed.tasks;
+}
+
+async function leaseMonitoringTasks(aiPlatformIDs: string[]): Promise<MonitoringLeaseTasksResponse> {
+  const payload: MonitoringLeaseTasksPayload = {
+    limit: monitoringCycleBatchLeaseLimit,
+    ai_platform_ids: aiPlatformIDs,
+  };
+  return await postMonitoringApi<MonitoringLeaseTasksResponse>("/api/plugin/monitoring/tasks/lease", payload);
+}
+
+function mergeMonitoringQueueTasks(
+  existingQueue: StoredMonitoringScheduledTask[],
+  incomingTasks: MonitoringLeaseTask[],
+): StoredMonitoringScheduledTask[] {
+  if (incomingTasks.length === 0) {
+    return sortMonitoringTaskQueue(existingQueue);
+  }
+
+  const nowMs = currentTimestampMs();
+  const queueByTaskID = new Map(existingQueue.map((task) => [task.task_id, task]));
+  let latestDelayedExecuteAt = existingQueue.reduce((latest, task) => {
+    if (task.pacing_mode !== "delayed") {
+      return latest;
+    }
+    const executeAt = toTimestampMs(task.next_execute_at);
+    return executeAt == null ? latest : Math.max(latest, executeAt);
+  }, nowMs);
+
+  for (const task of incomingTasks) {
+    if (task.business_date !== currentMonitoringBusinessDate()) {
+      continue;
+    }
+
+    const existing = queueByTaskID.get(task.task_id);
+    if (existing) {
+      queueByTaskID.set(task.task_id, {
+        ...existing,
+        ...task,
+      });
+      continue;
+    }
+
+    const immediate = isImmediateMonitoringTask(task);
+    if (!immediate) {
+      latestDelayedExecuteAt = Math.max(latestDelayedExecuteAt, nowMs) + randomMonitoringDelayMs();
+    }
+
+    queueByTaskID.set(task.task_id, {
+      ...task,
+      pacing_mode: immediate ? "immediate" : "delayed",
+      scheduled_at: new Date(nowMs).toISOString(),
+      next_execute_at: immediate ? new Date(nowMs).toISOString() : new Date(latestDelayedExecuteAt).toISOString(),
+    });
+  }
+
+  return sortMonitoringTaskQueue(Array.from(queueByTaskID.values()));
+}
+
+async function persistMonitoringTaskQueue(queue: StoredMonitoringScheduledTask[]): Promise<StoredMonitoringScheduledTask[]> {
+  const nextState = await patchExtensionState({
+    monitoring_task_queue: sortMonitoringTaskQueue(queue),
+  });
+  return nextState.monitoring_task_queue;
+}
+
+async function pruneMonitoringTaskQueue(): Promise<StoredMonitoringScheduledTask[]> {
+  const state = await getExtensionState();
+  const today = currentMonitoringBusinessDate();
+  const retained: StoredMonitoringScheduledTask[] = [];
+
+  for (const task of state.monitoring_task_queue) {
+    if (task.business_date === today) {
+      retained.push(task);
+      continue;
+    }
+
+    try {
+      await markMonitoringTaskSkipped(
+        task,
+        "stale_business_date",
+        `monitoring task business_date ${task.business_date} is not the current business date`,
+      );
+    } catch {
+      // Best-effort cleanup for locally cached stale tasks.
+    }
+  }
+
+  return await persistMonitoringTaskQueue(retained);
+}
+
+async function syncMonitoringTaskQueue(aiPlatformIDs: string[]): Promise<StoredMonitoringScheduledTask[]> {
+  const localQueue = await pruneMonitoringTaskQueue();
+  const resumedTasks = await resumeMonitoringTasks(aiPlatformIDs);
+  const resumedTaskMap = new Map(resumedTasks.map((task) => [task.task_id, task]));
+
+  const matchedQueue: StoredMonitoringScheduledTask[] = [];
+  for (const task of localQueue) {
+    const resumedTask = resumedTaskMap.get(task.task_id);
+    if (!resumedTask) {
+      continue;
+    }
+    matchedQueue.push({
+      ...task,
+      ...resumedTask,
+    });
+    resumedTaskMap.delete(task.task_id);
+  }
+
+  const mergedQueue = mergeMonitoringQueueTasks(matchedQueue, Array.from(resumedTaskMap.values()));
+  return await persistMonitoringTaskQueue(mergedQueue);
+}
+
+async function appendMonitoringTasksToQueue(tasks: MonitoringLeaseTask[]): Promise<StoredMonitoringScheduledTask[]> {
+  const state = await getExtensionState();
+  const mergedQueue = mergeMonitoringQueueTasks(state.monitoring_task_queue, tasks);
+  return await persistMonitoringTaskQueue(mergedQueue);
+}
+
+async function removeMonitoringTaskFromQueue(taskID: number): Promise<StoredMonitoringScheduledTask[]> {
+  const state = await getExtensionState();
+  return await persistMonitoringTaskQueue(state.monitoring_task_queue.filter((task) => task.task_id !== taskID));
+}
+
+function isMonitoringTaskDue(task: StoredMonitoringScheduledTask, nowMs: number): boolean {
+  const executeAt = toTimestampMs(task.next_execute_at);
+  return executeAt == null || executeAt <= nowMs;
+}
+
+async function processQueuedMonitoringTask(
+  task: StoredMonitoringScheduledTask,
+  platformMap: Map<string, StoredMonitoringPlatformState>,
+): Promise<"processed" | "failed" | "skipped"> {
+  if (task.business_date !== currentMonitoringBusinessDate()) {
+    await markMonitoringTaskSkipped(
+      task,
+      "stale_business_date",
+      `monitoring task business_date ${task.business_date} is not the current business date`,
+    );
+    return "skipped";
+  }
+
+  const platform = platformMap.get(task.ai_platform_id);
+  if (!platform) {
+    await markMonitoringTaskSkipped(task, "platform_not_configured", `monitoring platform ${task.ai_platform_id} is not configured locally`);
+    return "skipped";
+  }
+
+  return await processMonitoringLeasedTask(platform, task);
+}
+
+async function processImmediateMonitoringTasks(
+  platformMap: Map<string, StoredMonitoringPlatformState>,
+): Promise<{ processedCount: number; failedCount: number; skippedCount: number }> {
+  let processedCount = 0;
+  let failedCount = 0;
+  let skippedCount = 0;
+
+  for (;;) {
+    const state = await getExtensionState();
+    const dueImmediateTask = state.monitoring_task_queue.find(
+      (task) => task.pacing_mode === "immediate" && isMonitoringTaskDue(task, currentTimestampMs()),
+    );
+    if (!dueImmediateTask) {
+      break;
+    }
+
+    const outcome = await processQueuedMonitoringTask(dueImmediateTask, platformMap);
+    await removeMonitoringTaskFromQueue(dueImmediateTask.task_id);
+
+    if (outcome === "processed") {
+      processedCount += 1;
+      continue;
+    }
+    if (outcome === "failed") {
+      failedCount += 1;
+      continue;
+    }
+    skippedCount += 1;
+  }
+
+  return {
+    processedCount,
+    failedCount,
+    skippedCount,
+  };
+}
+
+async function processNextDelayedMonitoringTask(
+  platformMap: Map<string, StoredMonitoringPlatformState>,
+): Promise<{ processedCount: number; failedCount: number; skippedCount: number }> {
+  const state = await getExtensionState();
+  const delayedTask = state.monitoring_task_queue.find(
+    (task) => task.pacing_mode === "delayed" && isMonitoringTaskDue(task, currentTimestampMs()),
+  );
+  if (!delayedTask) {
+    return {
+      processedCount: 0,
+      failedCount: 0,
+      skippedCount: 0,
+    };
+  }
+
+  const outcome = await processQueuedMonitoringTask(delayedTask, platformMap);
+  await removeMonitoringTaskFromQueue(delayedTask.task_id);
+
+  if (outcome === "processed") {
+    return { processedCount: 1, failedCount: 0, skippedCount: 0 };
+  }
+  if (outcome === "failed") {
+    return { processedCount: 0, failedCount: 1, skippedCount: 0 };
+  }
+  return { processedCount: 0, failedCount: 0, skippedCount: 1 };
+}
+
+export async function handleMonitoringAction(
+  action: MonitoringAction,
+): Promise<
+  MonitoringPluginPingResponse | MonitoringLocalPlatformState[] | MonitoringHeartbeatSyncResult | MonitoringCycleResult | MonitoringRuntimeStateSnapshot
+> {
+  switch (action) {
+    case "ping":
+      return await handleMonitoringPing();
+    case "detectPlatforms":
+      return await handleMonitoringDetectPlatforms();
+    case "syncHeartbeat":
+      return await handleMonitoringSyncHeartbeat(false);
+    case "runCycle":
+      return await runMonitoringCycle("manual");
+    case "getState":
+      return await handleMonitoringGetState();
+    default:
+      throw new Error("monitoring_action_not_supported");
+  }
+}
+
+export async function runMonitoringCycle(mode: MonitoringCycleMode): Promise<MonitoringCycleResult> {
+  return await handleMonitoringRunCycle(mode);
+}
+
+async function handleMonitoringPing(): Promise<MonitoringPluginPingResponse> {
+  const state = await getExtensionState();
+  return {
+    installed: true,
+    version: browser.runtime.getManifest().version,
+    capabilities: ["ping", "detect", "heartbeat", "lease", "background"],
+    installation_key: state.installation_key,
+    plugin_installation_id: state.plugin_installation_id,
+  };
+}
+
+async function handleMonitoringDetectPlatforms(): Promise<MonitoringLocalPlatformState[]> {
+  const platforms = await detectAllMonitoringPlatforms();
+  const persisted = await persistMonitoringPlatforms(platforms);
+  return projectMonitoringPlatforms(persisted);
+}
+
+async function handleMonitoringSyncHeartbeat(allowCachedRemote: boolean): Promise<MonitoringHeartbeatSyncResult> {
+  const detectedPlatforms = await detectAllMonitoringPlatforms();
+  const persistedPlatforms = await persistMonitoringPlatforms(detectedPlatforms);
+  const projectedPlatforms = projectMonitoringPlatforms(persistedPlatforms);
+  const heartbeatAt = new Date().toISOString();
+
+  const state = await getExtensionState();
+  if (!state.plugin_installation_id || !state.installation_token || !state.api_base_url) {
+    await patchExtensionState({
+      monitoring_last_heartbeat_at: heartbeatAt,
+      monitoring_last_heartbeat_status: "local_only",
+    });
+    return {
+      success: true,
+      source: "local",
+      platform_states: projectedPlatforms,
+      heartbeat: null,
+      message: "monitoring installation is not registered yet",
+    };
+  }
+
+  if (allowCachedRemote && hasFreshSuccessfulMonitoringHeartbeat(state)) {
+    return {
+      success: true,
+      source: "local",
+      platform_states: projectedPlatforms,
+      heartbeat: null,
+      message: "reused recent monitoring heartbeat",
+    };
+  }
+
+  try {
+    const heartbeat = await postMonitoringApi<MonitoringHeartbeatResponse>("/api/plugin/monitoring/heartbeat", {
+      platforms: persistedPlatforms.map(toMonitoringPlatformPayload),
+    });
+
+    await patchExtensionState({
+      monitoring_last_heartbeat_at: heartbeatAt,
+      monitoring_last_heartbeat_status: "success",
+    });
+
+    return {
+      success: true,
+      source: "remote",
+      platform_states: projectedPlatforms,
+      heartbeat,
+      message: null,
+    };
+  } catch (error) {
+    await patchExtensionState({
+      monitoring_last_heartbeat_at: heartbeatAt,
+      monitoring_last_heartbeat_status: "failed",
+    });
+    throw error;
+  }
+}
+
+async function handleMonitoringRunCycle(mode: MonitoringCycleMode): Promise<MonitoringCycleResult> {
+  let heartbeatResult: MonitoringHeartbeatSyncResult;
+  try {
+    heartbeatResult = await handleMonitoringSyncHeartbeat(mode === "automatic");
+  } catch (error) {
+    await patchExtensionState({
+      monitoring_last_cycle_at: new Date().toISOString(),
+      monitoring_last_cycle_status: "heartbeat_failed",
+    });
+    throw error;
+  }
+  const state = await getExtensionState();
+  const accessiblePlatforms = state.monitoring_platforms.filter((platform) => platform.accessible);
+  const queryReadyPlatforms = (
+    await Promise.all(
+      accessiblePlatforms.map(async (platform) => ({
+        platform,
+        canQuery: await canQueryMonitoringPlatform(platform),
+      })),
+    )
+  )
+    .filter((item) => item.canQuery)
+    .map((item) => item.platform);
+
+  if (!state.plugin_installation_id || !state.installation_token || !state.api_base_url) {
+    await patchExtensionState({
+      monitoring_last_cycle_at: new Date().toISOString(),
+      monitoring_last_cycle_status: "not_configured",
+    });
+    return {
+      success: false,
+      leased_task_count: 0,
+      processed_task_count: 0,
+      failed_task_count: 0,
+      skipped_task_count: 0,
+      message: "monitoring installation is not registered yet",
+    };
+  }
+
+  if (queryReadyPlatforms.length === 0) {
+    await patchExtensionState({
+      monitoring_last_cycle_at: new Date().toISOString(),
+      monitoring_last_cycle_status: "no_query_capable_platforms",
+    });
+    return {
+      success: heartbeatResult.success,
+      leased_task_count: 0,
+      processed_task_count: 0,
+      failed_task_count: 0,
+      skipped_task_count: 0,
+      message: "monitoring adapters are not query-ready yet",
+    };
+  }
+
+  const queryReadyPlatformIDs = queryReadyPlatforms.map((platform) => platform.ai_platform_id);
+  const platformMap = new Map(queryReadyPlatforms.map((platform) => [platform.ai_platform_id, platform] as const));
+
+  let leasedTaskCount = 0;
+  let processedCount = 0;
+  let failedCount = 0;
+  let skippedCount = 0;
+
+  let queue = await syncMonitoringTaskQueue(queryReadyPlatformIDs);
+  if (mode === "manual" || queue.length === 0) {
+    const leased = await leaseMonitoringTasks(queryReadyPlatformIDs);
+    leasedTaskCount += leased.lease_count;
+    if (leased.tasks.length > 0) {
+      queue = await appendMonitoringTasksToQueue(leased.tasks);
+    }
+  }
+
+  const immediateResult = await processImmediateMonitoringTasks(platformMap);
+  processedCount += immediateResult.processedCount;
+  failedCount += immediateResult.failedCount;
+  skippedCount += immediateResult.skippedCount;
+
+  if (mode === "automatic" && immediateResult.processedCount === 0) {
+    const delayedResult = await processNextDelayedMonitoringTask(platformMap);
+    processedCount += delayedResult.processedCount;
+    failedCount += delayedResult.failedCount;
+    skippedCount += delayedResult.skippedCount;
+  }
+
+  const remainingQueue = (await getExtensionState()).monitoring_task_queue;
+  const cycleStatus =
+    failedCount > 0
+      ? "partial_failed"
+      : processedCount > 0
+        ? "success"
+        : skippedCount > 0
+          ? "skipped"
+          : remainingQueue.length > 0
+            ? "scheduled"
+            : "idle";
+  await patchExtensionState({
+    monitoring_last_cycle_at: new Date().toISOString(),
+    monitoring_last_cycle_status: cycleStatus,
+  });
+
+  return {
+    success: failedCount === 0,
+    leased_task_count: leasedTaskCount,
+    processed_task_count: processedCount,
+    failed_task_count: failedCount,
+    skipped_task_count: skippedCount,
+    message: remainingQueue.length > 0 ? `scheduled ${remainingQueue.length} monitoring tasks` : null,
+  };
+}
+
+async function handleMonitoringGetState(): Promise<MonitoringRuntimeStateSnapshot> {
+  const state = await getExtensionState();
+  return {
+    installation_key: state.installation_key,
+    plugin_installation_id: state.plugin_installation_id,
+    api_base_url: state.api_base_url,
+    monitoring_last_heartbeat_at: state.monitoring_last_heartbeat_at,
+    monitoring_last_heartbeat_status: state.monitoring_last_heartbeat_status,
+    monitoring_last_cycle_at: state.monitoring_last_cycle_at,
+    monitoring_last_cycle_status: state.monitoring_last_cycle_status,
+    monitoring_platforms: state.monitoring_platforms,
+  };
+}
diff --git a/apps/browser-extension/src/storage.ts b/apps/browser-extension/src/storage.ts
index 7bf0c9d..9acf8ed 100644
--- a/apps/browser-extension/src/storage.ts
+++ b/apps/browser-extension/src/storage.ts
@@ -1,13 +1,50 @@
+import type { MonitoringLeaseTask } from "@geo/shared-types";
 import { browser } from "wxt/browser";
 
+import {
+  createDefaultMonitoringPlatformStates,
+  supportedMonitoringPlatforms,
+  type StoredMonitoringPlatformState,
+} from "./monitoring-platforms";
 import { createDefaultPlatformStates, supportedPlatforms, type StoredPlatformState } from "./platforms";
 
+export interface DoubaoMonitoringRuntimeState {
+  fp: string | null;
+  ms_token: string | null;
+  device_id: string | null;
+  web_id: string | null;
+  tea_uuid: string | null;
+  synced_at: string | null;
+  source_url: string | null;
+}
+
+export interface MonitoringPlatformRuntimeState {
+  doubao: DoubaoMonitoringRuntimeState | null;
+}
+
+export interface MonitoringPlatformRuntimeStatePatch {
+  doubao?: Partial<DoubaoMonitoringRuntimeState> | null;
+}
+
+export interface StoredMonitoringScheduledTask extends MonitoringLeaseTask {
+  pacing_mode: "immediate" | "delayed";
+  scheduled_at: string;
+  next_execute_at: string;
+}
+
 export interface ExtensionStorageState {
   installation_key: string;
   plugin_installation_id: number | null;
   installation_token: string | null;
   api_base_url: string | null;
   platforms: StoredPlatformState[];
+  monitoring_platforms: StoredMonitoringPlatformState[];
+  monitoring_last_heartbeat_at: string | null;
+  monitoring_last_heartbeat_status: string | null;
+  monitoring_last_cycle_at: string | null;
+  monitoring_last_cycle_status: string | null;
+  monitoring_task_queue: StoredMonitoringScheduledTask[];
+  monitoring_runtime: MonitoringPlatformRuntimeState;
   last_updated_at: string | null;
 }
 
@@ -33,6 +70,85 @@ function mergePlatformStates(platforms?: StoredPlatformState[]): StoredPlatformS
   });
 }
 
+function mergeMonitoringPlatformStates(platforms?: StoredMonitoringPlatformState[]): StoredMonitoringPlatformState[] {
+  const defaults = createDefaultMonitoringPlatformStates();
+  if (!platforms?.length) {
+    return defaults;
+  }
+
+  const incoming = new Map(platforms.map((platform) => [platform.ai_platform_id, platform]));
+  return defaults.map((platform) => {
+    const stored = incoming.get(platform.ai_platform_id);
+    return stored ? { ...platform, ...stored } : platform;
+  });
+}
+
+function mergeMonitoringScheduledTasks(tasks?: StoredMonitoringScheduledTask[]): StoredMonitoringScheduledTask[] {
+  if (!tasks?.length) {
+    return [];
+  }
+
+  return tasks
+    .filter((task) => typeof task?.task_id === "number" && task.task_id > 0)
+    .map((task) => ({
+      ...task,
+      pacing_mode: task.pacing_mode === "immediate" ? "immediate" : "delayed",
+      scheduled_at: task.scheduled_at ?? new Date().toISOString(),
+      next_execute_at: task.next_execute_at ?? new Date().toISOString(),
+    }));
+}
+
+function normalizeDoubaoMonitoringRuntimeState(
+  state?: Partial<DoubaoMonitoringRuntimeState> | null,
+): DoubaoMonitoringRuntimeState | null {
+  if (!state) {
+    return null;
+  }
+
+  return {
+    fp: state.fp ?? null,
+    ms_token: state.ms_token ?? null,
+    device_id: state.device_id ?? null,
+    web_id: state.web_id ?? null,
+    tea_uuid: state.tea_uuid ?? null,
+    synced_at: state.synced_at ?? null,
+    source_url: state.source_url ?? null,
+  };
+}
+
+function mergeMonitoringRuntimeState(
+  runtime?: MonitoringPlatformRuntimeStatePatch | null,
+): MonitoringPlatformRuntimeState {
+  return {
+    doubao: normalizeDoubaoMonitoringRuntimeState(runtime?.doubao),
+  };
+}
+
+function resolveNextMonitoringRuntimeState(
+  current: MonitoringPlatformRuntimeState,
+  patch?: MonitoringPlatformRuntimeStatePatch | null,
+): MonitoringPlatformRuntimeState {
+  if (patch == null) {
+    return current;
+  }
+
+  const nextDoubao =
+    typeof patch.doubao === "undefined"
+      ? current.doubao
+      : patch.doubao === null
+        ? null
+        : {
+            ...(current.doubao ?? {}),
+            ...patch.doubao,
+          };
+
+  return mergeMonitoringRuntimeState({
+    ...current,
+    ...patch,
+    doubao: nextDoubao,
+  });
+}
+
 async function writeState(nextState: ExtensionStorageState): Promise<void> {
   await browser.storage.local.set({
     [STORAGE_KEY]: nextState,
@@ -49,13 +165,24 @@ export async function getExtensionState(): Promise<ExtensionStorageState> {
     installation_token: stored?.installation_token ?? null,
     api_base_url: stored?.api_base_url ?? null,
     platforms: mergePlatformStates(stored?.platforms),
+    monitoring_platforms: mergeMonitoringPlatformStates(stored?.monitoring_platforms),
+    monitoring_last_heartbeat_at: stored?.monitoring_last_heartbeat_at ?? null,
+    monitoring_last_heartbeat_status: stored?.monitoring_last_heartbeat_status ?? null,
+    monitoring_last_cycle_at: stored?.monitoring_last_cycle_at ?? null,
+    monitoring_last_cycle_status: stored?.monitoring_last_cycle_status ?? null,
+    monitoring_task_queue: mergeMonitoringScheduledTasks(stored?.monitoring_task_queue),
+    monitoring_runtime: mergeMonitoringRuntimeState(stored?.monitoring_runtime),
     last_updated_at: stored?.last_updated_at ?? null,
   };
 
   const shouldPersist =
     !stored?.installation_key ||
     !stored?.platforms ||
-    stored.platforms.length !== supportedPlatforms.length;
+    stored.platforms.length !== supportedPlatforms.length ||
+    !stored?.monitoring_platforms ||
+    stored.monitoring_platforms.length !== supportedMonitoringPlatforms.length ||
+    typeof stored?.monitoring_task_queue === "undefined" ||
+    !stored?.monitoring_runtime;
 
   if (shouldPersist) {
     await writeState(nextState);
@@ -65,13 +192,29 @@ export async function getExtensionState(): Promise<ExtensionStorageState> {
 }
 
 export async function patchExtensionState(
-  patch: Partial<Omit<ExtensionStorageState, "platforms">> & { platforms?: StoredPlatformState[] },
+  patch: Partial<Omit<ExtensionStorageState, "platforms" | "monitoring_platforms" | "monitoring_runtime">> & {
+    platforms?: StoredPlatformState[];
+    monitoring_platforms?: StoredMonitoringPlatformState[];
+    monitoring_task_queue?: StoredMonitoringScheduledTask[];
+    monitoring_runtime?: MonitoringPlatformRuntimeStatePatch | null;
+  },
 ): Promise<ExtensionStorageState> {
   const current = await getExtensionState();
   const nextState: ExtensionStorageState = {
     ...current,
     ...patch,
     platforms: patch.platforms ? mergePlatformStates(patch.platforms) : current.platforms,
+    monitoring_platforms: patch.monitoring_platforms
+      ? mergeMonitoringPlatformStates(patch.monitoring_platforms)
+      : current.monitoring_platforms,
+    monitoring_task_queue:
+      typeof patch.monitoring_task_queue !== "undefined"
+        ? mergeMonitoringScheduledTasks(patch.monitoring_task_queue)
+        : current.monitoring_task_queue,
+    monitoring_runtime:
+      typeof patch.monitoring_runtime !== "undefined"
+        ? resolveNextMonitoringRuntimeState(current.monitoring_runtime, patch.monitoring_runtime)
+        : current.monitoring_runtime,
     last_updated_at: new Date().toISOString(),
   };
   await writeState(nextState);
@@ -97,3 +240,23 @@ export async function updatePlatformState(
 export async function resetPlatformStates(): Promise<ExtensionStorageState> {
   return patchExtensionState({ platforms: createDefaultPlatformStates() });
 }
+
+export async function updateMonitoringPlatformState(
+  platformId: string,
+  updater: Partial<StoredMonitoringPlatformState>,
+): Promise<ExtensionStorageState> {
+  const current = await getExtensionState();
+  const monitoringPlatforms = current.monitoring_platforms.map((platform) =>
+    platform.ai_platform_id === platformId
+      ? {
+          ...platform,
+          ...updater,
+        }
+      : platform,
+  );
+  return patchExtensionState({ monitoring_platforms: monitoringPlatforms });
+}
+
+export async function resetMonitoringPlatformStates(): Promise<ExtensionStorageState> {
+  return patchExtensionState({ monitoring_platforms: createDefaultMonitoringPlatformStates() });
+}
diff --git a/apps/browser-extension/wxt.config.ts b/apps/browser-extension/wxt.config.ts
index f84343d..6ffccdb 100644
--- a/apps/browser-extension/wxt.config.ts
+++ b/apps/browser-extension/wxt.config.ts
@@ -5,7 +5,7 @@ export default defineConfig({
   manifest: {
     name: "GEO Publisher",
     description: "Bind media accounts, execute local publish flows, and keep background detection tasks running.",
-    permissions: ["storage", "tabs", "alarms", "cookies", "declarativeNetRequest"],
+    permissions: ["scripting", "activeTab", "background","storage", "tabs", "tabGroups", "alarms", "cookies", "webRequest", "declarativeNetRequest"],
     host_permissions: ["http://*/*", "https://*/*"],
     declarative_net_request: {
       rule_resources: [
diff --git a/packages/shared-types/src/index.ts b/packages/shared-types/src/index.ts
index 8ea3765..ec7ef0b 100644
--- a/packages/shared-types/src/index.ts
+++ b/packages/shared-types/src/index.ts
@@ -403,6 +403,183 @@ export interface PublisherPluginPingResponse {
   plugin_installation_id?: number | null;
 }
 
+export interface MonitoringLocalPlatformState {
+  ai_platform_id: string;
+  connected: boolean;
+  accessible: boolean;
+  detected_at?: string | null;
+  reason_code?: string | null;
+  reason_message?: string | null;
+  message?: string | null;
+}
+
+export interface MonitoringPluginPingResponse {
+  installed: boolean;
+  version?: string;
+  capabilities?: Array<"ping" | "detect" | "heartbeat" | "lease" | "background">;
+  installation_key?: string;
+  plugin_installation_id?: number | null;
+}
+
+export interface MonitoringHeartbeatPlatformPayload {
+  ai_platform_id: string;
+  access_status?: string | null;
+  connected?: boolean | null;
+  accessible?: boolean | null;
+  detected_at?: string | null;
+  reason_code?: string | null;
+  reason_message?: string | null;
+}
+
+export interface MonitoringHeartbeatPayload {
+  platforms: MonitoringHeartbeatPlatformPayload[];
+}
+
+export interface MonitoringHeartbeatResponse {
+  installation_id: number;
+  business_date: string;
+  updated_platform_count: number;
+  reconciled_skipped_task_count: number;
+}
+
+export interface MonitoringHeartbeatSyncResult {
+  success: boolean;
+  source: "remote" | "local";
+  platform_states: MonitoringLocalPlatformState[];
+  heartbeat?: MonitoringHeartbeatResponse | null;
+  message?: string | null;
+}
+
+export interface MonitoringLeaseTasksPayload {
+  limit?: number;
+  ai_platform_ids?: string[];
+}
+
+export interface MonitoringResumeTasksPayload {
+  ai_platform_ids?: string[];
+}
+
+export interface MonitoringLeaseTask {
+  task_id: number;
+  brand_id: number;
+  question_id: number;
+  question_hash: string;
+  question_text: string;
+  ai_platform_id: string;
+  platform_name: string;
+  collector_type: string;
+  run_mode: string;
+  trigger_source: string;
+  business_date: string;
+  lease_token: string;
+  lease_expires_at: string;
+}
+
+export interface MonitoringLeaseTasksResponse {
+  business_date: string;
+  lease_count: number;
+  tasks: MonitoringLeaseTask[];
+}
+
+export interface MonitoringResumeTasksResponse {
+  business_date: string;
+  resume_count: number;
+  tasks: MonitoringLeaseTask[];
+}
+
+export interface MonitoringCycleResult {
+  success: boolean;
+  leased_task_count: number;
+  processed_task_count: number;
+  failed_task_count: number;
+  skipped_task_count: number;
+  message?: string | null;
+}
+
+export interface MonitoringCycleKickoffResponse {
+  accepted: boolean;
+  status: "started" | "already_running";
+  message?: string | null;
+}
+
+export interface MonitoringSourceItem {
+  url: string;
+  title?: string | null;
+  site_name?: string | null;
+  site_key?: string | null;
+  normalized_url?: string | null;
+  host?: string | null;
+  registrable_domain?: string | null;
+  subdomain?: string | null;
+  suffix?: string | null;
+  article_id?: number | null;
+  publish_record_id?: number | null;
+  resolution_status?: string | null;
+  resolution_confidence?: string | null;
+}
+
+export interface MonitoringTaskResultPayload {
+  lease_token: string;
+  status: "succeeded" | "failed";
+  provider_model?: string | null;
+  provider_request_id?: string | null;
+  request_id?: string | null;
+  answer?: string | null;
+  raw_response_json?: Record<string, JsonValue>;
+  citations?: MonitoringSourceItem[];
+  search_results?: MonitoringSourceItem[];
+  brand_mentioned?: boolean | null;
+  brand_mention_position?: string | null;
+  first_recommended?: boolean | null;
+  sentiment_label?: string | null;
+  matched_brand_terms?: string[];
+  error_message?: string | null;
+  completed_at?: string | null;
+}
+
+export interface MonitoringTaskResultResponse {
+  task_id: number;
+  run_id?: number | null;
+  task_status: string;
+  citation_source_count: number;
+  content_citation_count: number;
+}
+
+export interface MonitoringSkipTaskPayload {
+  lease_token: string;
+  skip_reason?: string | null;
+  error_message?: string | null;
+  completed_at?: string | null;
+}
+
+export interface MonitoringSkipTaskResponse {
+  task_id: number;
+  task_status: string;
+  skip_reason: string;
+  completed_at?: string | null;
+}
+
+export interface MonitoringRuntimeStateSnapshot {
+  installation_key: string;
+  plugin_installation_id: number | null;
+  api_base_url: string | null;
+  monitoring_last_heartbeat_at: string | null;
+  monitoring_last_heartbeat_status: string | null;
+  monitoring_last_cycle_at: string | null;
+  monitoring_last_cycle_status: string | null;
+  monitoring_platforms: Array<
+    MonitoringLocalPlatformState & {
+      platform_name: string;
+      short_name: string;
+      accent_color: string;
+      home_url: string;
+      login_url: string | null;
+      access_requirement: "login_required" | "anonymous_allowed";
+      cookie_domains: string[];
+    }
+  >;
+}
+
 export interface RegisterPluginInstallationRequest {
   installation_key: string;
   installation_name: string;
@@ -538,6 +715,155 @@ export interface Competitor {
   created_at: string;
 }
 
+export interface MonitoringOverview {
+  collection_mode: string;
+  mention_rate: number | null;
+  top1_mention_rate: number | null;
+  first_recommend_rate: number | null;
+  positive_mention_rate: number | null;
+  citation_rate: number | null;
+  desired_sample_count: number;
+  planned_sample_count: number;
+  actual_sample_count: number;
+  coverage_rate: number | null;
+  confidence_level: string;
+  last_sampled_at: string | null;
+  last_trigger_source: string | null;
+  prev_snapshot_mention_rate: number | null;
+  prev_snapshot_top1_mention_rate: number | null;
+  prev_snapshot_first_recommend_rate: number | null;
+  prev_snapshot_positive_mention_rate: number | null;
+}
+
+export interface MonitoringPlatformBreakdownItem {
+  ai_platform_id: string;
+  platform_name: string;
+  mention_rate: number | null;
+  top1_mention_rate: number | null;
+  platform_sample_status: string;
+  actual_sample_count: number;
+  last_sampled_at: string | null;
+}
+
+export interface MonitoringTimeBucket {
+  date: string;
+  sample_status: string;
+  metric_value: number | null;
+  mention_rate: number | null;
+  top1_mention_rate: number | null;
+  first_recommend_rate: number | null;
+  positive_mention_rate: number | null;
+  citation_rate: number | null;
+  planned_sample_count: number;
+  actual_sample_count: number;
+  coverage_rate: number | null;
+  trigger_source: string | null;
+  snapshot_updated_at: string | null;
+}
+
+export interface MonitoringHotQuestion {
+  question_id: number;
+  question_hash: string;
+  question_text: string;
+  mention_rate: number | null;
+  last_sampled_at: string | null;
+}
+
+export interface MonitoringCitationRankingItem {
+  ai_platform_id: string;
+  platform_name: string;
+  sample_status: string;
+  cited_answer_count: number;
+  cited_article_count: number;
+  citation_rate: number | null;
+}
+
+export interface MonitoringCitedArticle {
+  article_id: number;
+  article_title: string;
+  publish_platform: string;
+  citation_count: number;
+  citation_rate: number | null;
+}
+
+export interface MonitoringDashboardCompositeResponse {
+  overview: MonitoringOverview;
+  platform_breakdown: MonitoringPlatformBreakdownItem[];
+  brand_time_buckets: MonitoringTimeBucket[];
+  hot_questions: MonitoringHotQuestion[];
+  citation_ranking: MonitoringCitationRankingItem[];
+  cited_articles: MonitoringCitedArticle[];
+}
+
+export interface MonitoringQuestionDetailCitation {
+  cited_url: string;
+  cited_title: string | null;
+  site_name: string;
+  site_key: string;
+  favicon_url: string;
+  article_id: number | null;
+  article_title?: string | null;
+  resolution_status: string;
+  resolution_confidence: string;
+}
+
+export interface MonitoringQuestionDetailPlatform {
+  ai_platform_id: string;
+  platform_name: string;
+  sample_status: string;
+  run_id: number | null;
+  sampled_at: string | null;
+  provider_model: string | null;
+  answer_text: string | null;
+  brand_mentioned: boolean | null;
+  brand_mention_position: string | null;
+  citations: MonitoringQuestionDetailCitation[];
+}
+
+export interface MonitoringQuestionCitationAnalysisItem {
+  ai_platform_id: string;
+  platform_name: string;
+  site_name: string;
+  site_key: string;
+  site_domain: string;
+  citation_count: number;
+  citation_rate: number | null;
+  content_citation_count: number;
+}
+
+export interface MonitoringQuestionContentCitation {
+  article_id: number;
+  article_title: string;
+  publish_platform: string;
+  ai_platform_id: string;
+  platform_name: string;
+  citation_count: number;
+  citation_rate: number | null;
+}
+
+export interface MonitoringQuestionDetailResponse {
+  question_id: number;
+  question_hash: string;
+  question_text: string;
+  time_window: {
+    date_from: string;
+    date_to: string;
+  };
+  platforms: MonitoringQuestionDetailPlatform[];
+  citation_analysis: MonitoringQuestionCitationAnalysisItem[];
+  content_citations: MonitoringQuestionContentCitation[];
+}
+
+export interface MonitoringCollectNowResponse {
+  collection_mode: string;
+  refreshed_task_count: number;
+  created_task_count?: number;
+  leased_task_count: number;
+  completed_task_count: number;
+  has_effective_snapshot: boolean;
+  message: string;
+}
+
 export interface KnowledgeGroup {
   id: number;
   name: string;
diff --git a/server/Makefile b/server/Makefile
index 87d0a6d..7ed1cba 100644
--- a/server/Makefile
+++ b/server/Makefile
@@ -1,6 +1,7 @@
-.PHONY: dev-init dev-api migrate-up migrate-down migrate-create sqlc-generate tenant-scope-guard lint test tidy seed
+.PHONY: dev-init dev-api migrate-up migrate-down migrate-monitoring-up migrate-monitoring-down migrate-create sqlc-generate tenant-scope-guard lint test tidy seed
 
 DB_URL ?= postgres://geo:geo_dev@localhost:5432/geo?sslmode=disable
+MONITORING_DB_URL ?= postgres://geo:geo_dev@localhost:5433/geo_monitoring?sslmode=disable
 MIGRATE_CMD ?= go run -tags postgres github.com/golang-migrate/migrate/v4/cmd/migrate@v4.19.1
 
 dev-init: ## Start infra, run migrations, seed data
@@ -8,6 +9,7 @@ dev-init: ## Start infra, run migrations, seed data
 	@echo "Waiting for postgres..."
 	@sleep 3
 	$(MAKE) migrate-up
+	$(MAKE) migrate-monitoring-up
 	$(MAKE) seed
 
 dev-api: ## Run tenant-api server
@@ -19,6 +21,12 @@ migrate-up: ## Run all pending migrations
 migrate-down: ## Rollback last migration
 	$(MIGRATE_CMD) -path migrations -database "$(DB_URL)" down 1
 
+migrate-monitoring-up: ## Run all pending monitoring migrations
+	$(MIGRATE_CMD) -path migrations_monitoring -database "$(MONITORING_DB_URL)" up
+
+migrate-monitoring-down: ## Rollback last monitoring migration
+	$(MIGRATE_CMD) -path migrations_monitoring -database "$(MONITORING_DB_URL)" down 1
+
 migrate-create: ## Create new migration (usage: make migrate-create NAME=xxx)
 	$(MIGRATE_CMD) create -ext sql -dir migrations -seq $(NAME)
 
diff --git a/server/cmd/dev-seed/main.go b/server/cmd/dev-seed/main.go
index e971ec4..f690645 100644
--- a/server/cmd/dev-seed/main.go
+++ b/server/cmd/dev-seed/main.go
@@ -2,17 +2,88 @@ package main
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/json"
 	"fmt"
 	"log"
 	"os"
+	"strings"
+	"time"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"golang.org/x/crypto/bcrypt"
 
+	sharedauth "github.com/geo-platform/tenant-api/internal/shared/auth"
 	"github.com/geo-platform/tenant-api/internal/shared/config"
 	"github.com/geo-platform/tenant-api/internal/tenant/prompts"
 )
 
+type seedState struct {
+	TenantID             int64
+	UserID               int64
+	PlanID               int64
+	BrandID              int64
+	KeywordPrimaryID     int64
+	KeywordSecondaryID   int64
+	QuestionPrimaryID    int64
+	QuestionSecondaryID  int64
+	QuestionTertiaryID   int64
+	ArticleID            int64
+	PluginInstallationID int64
+}
+
+type monitoringRunSeed struct {
+	BusinessDate      time.Time
+	CompletedAt       time.Time
+	QuestionID        int64
+	QuestionText      string
+	QuestionHash      []byte
+	AIPlatformID      string
+	ProviderModel     string
+	AnswerText        string
+	BrandMentioned    bool
+	MentionPosition   string
+	FirstRecommended  bool
+	SentimentLabel    string
+	MatchedBrandTerms []string
+	Citations         []citationSeed
+}
+
+type citationSeed struct {
+	URL                  string
+	Title                string
+	NormalizedURL        string
+	Host                 string
+	RegistrableDomain    string
+	SiteKey              string
+	ArticleID            *int64
+	PublishRecordID      *int64
+	ResolutionStatus     string
+	ResolutionConfidence string
+}
+
+type dailySeed struct {
+	Date                   time.Time
+	SampleStatus           string
+	DesiredSampleCount     int
+	PlannedSampleCount     int
+	ActualSampleCount      int
+	CoverageRate           float64
+	ConfidenceLevel        string
+	TriggerSource          string
+	MentionedCount         int
+	Top1MentionedCount     int
+	FirstRecommendedCount  int
+	PositiveMentionedCount int
+	CitedAnswerCount       int
+	MentionRate            float64
+	Top1MentionRate        float64
+	FirstRecommendRate     float64
+	PositiveMentionRate    float64
+	CitationRate           float64
+}
+
 func main() {
 	configPath := "configs/config.yaml"
 	if p := os.Getenv("CONFIG_PATH"); p != "" {
@@ -25,30 +96,193 @@ func main() {
 	}
 
 	ctx := context.Background()
-	pool, err := pgxpool.New(ctx, cfg.Database.DSN())
+	businessPool, err := pgxpool.New(ctx, cfg.Database.DSN())
 	if err != nil {
-		log.Fatalf("connect db: %v", err)
+		log.Fatalf("connect business db: %v", err)
 	}
-	defer pool.Close()
+	defer businessPool.Close()
 
+	monitoringPool, err := pgxpool.New(ctx, cfg.MonitoringDatabase.DSN())
+	if err != nil {
+		log.Fatalf("connect monitoring db: %v", err)
+	}
+	defer monitoringPool.Close()
+
+	if err := businessPool.Ping(ctx); err != nil {
+		log.Fatalf("ping business db: %v", err)
+	}
+	if err := monitoringPool.Ping(ctx); err != nil {
+		log.Fatalf("ping monitoring db: %v", err)
+	}
+
+	state, err := seedBusinessData(ctx, businessPool)
+	if err != nil {
+		log.Fatalf("seed business data: %v", err)
+	}
+
+	if err := seedMonitoringData(ctx, monitoringPool, state); err != nil {
+		log.Fatalf("seed monitoring data: %v", err)
+	}
+
+	fmt.Println("Seed data inserted successfully.")
+	fmt.Printf("  Tenant ID: %d\n", state.TenantID)
+	fmt.Printf("  User ID:   %d (admin@geo.local / Admin@123)\n", state.UserID)
+	fmt.Printf("  Plan ID:   %d (free)\n", state.PlanID)
+	fmt.Printf("  Brand ID:  %d (轻氧口腔)\n", state.BrandID)
+	fmt.Printf("  Plugin Installation ID: %d\n", state.PluginInstallationID)
+	fmt.Println("  Templates: 4 platform presets")
+	fmt.Println("  Monitoring: brand daily snapshots + question runs + citation facts")
+}
+
+func seedBusinessData(ctx context.Context, pool *pgxpool.Pool) (*seedState, error) {
 	hash, err := bcrypt.GenerateFromPassword([]byte("Admin@123"), bcrypt.DefaultCost)
 	if err != nil {
-		log.Fatalf("hash password: %v", err)
+		return nil, fmt.Errorf("hash password: %w", err)
 	}
 
 	tx, err := pool.Begin(ctx)
 	if err != nil {
-		log.Fatalf("begin tx: %v", err)
+		return nil, fmt.Errorf("begin tx: %w", err)
 	}
 	defer func() {
 		_ = tx.Rollback(ctx)
 	}()
 
-	// Tenant
+	state := &seedState{}
+
+	state.TenantID, err = ensureTenant(ctx, tx)
+	if err != nil {
+		return nil, err
+	}
+	state.UserID, err = ensureUser(ctx, tx, string(hash))
+	if err != nil {
+		return nil, err
+	}
+	if err := ensureMembership(ctx, tx, state.TenantID, state.UserID); err != nil {
+		return nil, err
+	}
+	state.PlanID, err = ensurePlan(ctx, tx)
+	if err != nil {
+		return nil, err
+	}
+	if err := ensureSubscription(ctx, tx, state.TenantID, state.PlanID); err != nil {
+		return nil, err
+	}
+	if err := ensureQuotaLedger(ctx, tx, state.TenantID); err != nil {
+		return nil, err
+	}
+	if err := ensureTemplates(ctx, tx); err != nil {
+		return nil, err
+	}
+
+	state.BrandID, err = ensureBrand(ctx, tx, state.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	state.KeywordPrimaryID, err = ensureKeyword(ctx, tx, state.TenantID, state.BrandID, "北京口腔医院")
+	if err != nil {
+		return nil, err
+	}
+	state.KeywordSecondaryID, err = ensureKeyword(ctx, tx, state.TenantID, state.BrandID, "牙齿种植")
+	if err != nil {
+		return nil, err
+	}
+
+	state.QuestionPrimaryID, err = ensureQuestion(ctx, tx, state.TenantID, state.BrandID, state.KeywordPrimaryID, "北京口腔医院推荐？")
+	if err != nil {
+		return nil, err
+	}
+	state.QuestionSecondaryID, err = ensureQuestion(ctx, tx, state.TenantID, state.BrandID, state.KeywordSecondaryID, "北京种植牙哪家靠谱？")
+	if err != nil {
+		return nil, err
+	}
+	state.QuestionTertiaryID, err = ensureQuestion(ctx, tx, state.TenantID, state.BrandID, state.KeywordPrimaryID, "北京牙齿矫正医院怎么选？")
+	if err != nil {
+		return nil, err
+	}
+
+	if err := ensureCompetitor(ctx, tx, state.TenantID, state.BrandID); err != nil {
+		return nil, err
+	}
+
+	state.ArticleID, err = ensureArticle(ctx, tx, state.TenantID)
+	if err != nil {
+		return nil, err
+	}
+
+	state.PluginInstallationID, err = ensurePluginInstallation(ctx, tx, state.TenantID, state.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := ensureMonitoringQuota(ctx, tx, state); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, fmt.Errorf("commit business seed: %w", err)
+	}
+
+	return state, nil
+}
+
+func seedMonitoringData(ctx context.Context, pool *pgxpool.Pool, state *seedState) error {
+	tx, err := pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("begin monitoring tx: %w", err)
+	}
+	defer func() {
+		_ = tx.Rollback(ctx)
+	}()
+
+	if err := clearMonitoringData(ctx, tx, state); err != nil {
+		return err
+	}
+
+	if err := insertSiteMappings(ctx, tx, state.TenantID); err != nil {
+		return err
+	}
+
+	questionHashes := map[int64][]byte{
+		state.QuestionPrimaryID:   makeQuestionHash("北京口腔医院推荐？"),
+		state.QuestionSecondaryID: makeQuestionHash("北京种植牙哪家靠谱？"),
+		state.QuestionTertiaryID:  makeQuestionHash("北京牙齿矫正医院怎么选？"),
+	}
+
+	if err := insertQuestionSnapshots(ctx, tx, state, questionHashes); err != nil {
+		return err
+	}
+	if err := insertPlatformAccessSnapshots(ctx, tx, state); err != nil {
+		return err
+	}
+	if err := insertArticleAlias(ctx, tx, state); err != nil {
+		return err
+	}
+	if err := insertDailySnapshots(ctx, tx, state); err != nil {
+		return err
+	}
+	if err := insertPlatformDailySnapshots(ctx, tx, state); err != nil {
+		return err
+	}
+	if err := insertTaskSeeds(ctx, tx, state, questionHashes); err != nil {
+		return err
+	}
+	if err := insertRunSeeds(ctx, tx, state, questionHashes); err != nil {
+		return err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return fmt.Errorf("commit monitoring seed: %w", err)
+	}
+	return nil
+}
+
+func ensureTenant(ctx context.Context, tx pgx.Tx) (int64, error) {
 	var tenantID int64
-	err = tx.QueryRow(ctx, `
+	err := tx.QueryRow(ctx, `
 		WITH ensured AS (
-			INSERT INTO tenants (name, status) VALUES ('GEO Demo', 'active')
+			INSERT INTO tenants (name, status)
+			VALUES ('GEO Demo', 'active')
 			ON CONFLICT DO NOTHING
 			RETURNING id
 		)
@@ -57,13 +291,12 @@ func main() {
 		SELECT id FROM tenants WHERE name = 'GEO Demo'
 		LIMIT 1
 	`).Scan(&tenantID)
-	if err != nil {
-		log.Fatalf("insert tenant: %v", err)
-	}
+	return tenantID, wrapSeedErr("insert tenant", err)
+}
 
-	// User
+func ensureUser(ctx context.Context, tx pgx.Tx, passwordHash string) (int64, error) {
 	var userID int64
-	err = tx.QueryRow(ctx, `
+	err := tx.QueryRow(ctx, `
 		WITH ensured AS (
 			INSERT INTO users (email, password_hash, name, status)
 			VALUES ('admin@geo.local', $1, 'Admin', 'active')
@@ -74,24 +307,22 @@ func main() {
 		UNION ALL
 		SELECT id FROM users WHERE email = 'admin@geo.local'
 		LIMIT 1
-	`, string(hash)).Scan(&userID)
-	if err != nil {
-		log.Fatalf("insert user: %v", err)
-	}
+	`, passwordHash).Scan(&userID)
+	return userID, wrapSeedErr("insert user", err)
+}
 
-	// Membership
-	_, err = tx.Exec(ctx, `
+func ensureMembership(ctx context.Context, tx pgx.Tx, tenantID, userID int64) error {
+	_, err := tx.Exec(ctx, `
 		INSERT INTO tenant_memberships (tenant_id, user_id, tenant_role)
 		VALUES ($1, $2, 'tenant_admin')
 		ON CONFLICT DO NOTHING
 	`, tenantID, userID)
-	if err != nil {
-		log.Fatalf("insert membership: %v", err)
-	}
+	return wrapSeedErr("insert membership", err)
+}
 
-	// Plan
+func ensurePlan(ctx context.Context, tx pgx.Tx) (int64, error) {
 	var planID int64
-	err = tx.QueryRow(ctx, `
+	err := tx.QueryRow(ctx, `
 		WITH ensured AS (
 			INSERT INTO plans (plan_code, name, quota_policy_json, status)
 			VALUES ('free', 'Free Plan', '{"article_generation": 100}', 'active')
@@ -103,12 +334,11 @@ func main() {
 		SELECT id FROM plans WHERE plan_code = 'free'
 		LIMIT 1
 	`).Scan(&planID)
-	if err != nil {
-		log.Fatalf("insert plan: %v", err)
-	}
+	return planID, wrapSeedErr("insert plan", err)
+}
 
-	// Subscription
-	_, err = tx.Exec(ctx, `
+func ensureSubscription(ctx context.Context, tx pgx.Tx, tenantID, planID int64) error {
+	_, err := tx.Exec(ctx, `
 		INSERT INTO tenant_plan_subscriptions (tenant_id, plan_id, start_at, end_at, status)
 		SELECT $1, $2, NOW(), NOW() + INTERVAL '1 year', 'active'
 		WHERE NOT EXISTS (
@@ -119,12 +349,11 @@ func main() {
 			  AND status = 'active'
 		)
 	`, tenantID, planID)
-	if err != nil {
-		log.Fatalf("insert subscription: %v", err)
-	}
+	return wrapSeedErr("insert subscription", err)
+}
 
-	// Quota ledger
-	_, err = tx.Exec(ctx, `
+func ensureQuotaLedger(ctx context.Context, tx pgx.Tx, tenantID int64) error {
+	_, err := tx.Exec(ctx, `
 		INSERT INTO tenant_quota_ledgers (tenant_id, quota_type, delta, balance_after, reason)
 		SELECT $1, 'article_generation', 100, 100, 'initial_allocation'
 		WHERE NOT EXISTS (
@@ -135,21 +364,18 @@ func main() {
 			  AND reason = 'initial_allocation'
 		)
 	`, tenantID)
-	if err != nil {
-		log.Fatalf("insert quota: %v", err)
-	}
+	return wrapSeedErr("insert quota", err)
+}
 
-	// Platform templates
-	templates := prompts.PlatformTemplateSeeds()
-
-	for _, t := range templates {
-		_, err = tx.Exec(ctx, `
+func ensureTemplates(ctx context.Context, tx pgx.Tx) error {
+	for _, tpl := range prompts.PlatformTemplateSeeds() {
+		_, err := tx.Exec(ctx, `
 			INSERT INTO article_templates (scope, origin_type, template_key, template_name, prompt_template, prompt_visibility, card_config_json, status)
 			VALUES ('platform', 'platform', $1, $2, $3, 'visible', $4::jsonb, 'active')
 			ON CONFLICT DO NOTHING
-		`, t.Key, t.Name, t.PromptTemplate, t.CardConfigJSON)
+		`, tpl.Key, tpl.Name, tpl.PromptTemplate, tpl.CardConfigJSON)
 		if err != nil {
-			log.Fatalf("insert template %s: %v", t.Key, err)
+			return wrapSeedErr("insert template", err)
 		}
 
 		_, err = tx.Exec(ctx, `
@@ -163,19 +389,685 @@ func main() {
 			WHERE scope = 'platform'
 			  AND template_key = $1
 			  AND deleted_at IS NULL
-		`, t.Key, t.Name, t.PromptTemplate, t.CardConfigJSON)
+		`, tpl.Key, tpl.Name, tpl.PromptTemplate, tpl.CardConfigJSON)
 		if err != nil {
-			log.Fatalf("update template %s: %v", t.Key, err)
+			return wrapSeedErr("update template", err)
+		}
+	}
+	return nil
+}
+
+func ensureBrand(ctx context.Context, tx pgx.Tx, tenantID int64) (int64, error) {
+	var brandID int64
+	err := tx.QueryRow(ctx, `
+		WITH ensured AS (
+			INSERT INTO brands (tenant_id, name, website, description, status)
+			VALUES ($1, '轻氧口腔', 'https://www.qingyang-dental.example', '北京口腔诊疗品牌示例', 'active')
+			ON CONFLICT DO NOTHING
+			RETURNING id
+		)
+		SELECT id FROM ensured
+		UNION ALL
+		SELECT id FROM brands WHERE tenant_id = $1 AND name = '轻氧口腔' AND deleted_at IS NULL
+		LIMIT 1
+	`, tenantID).Scan(&brandID)
+	return brandID, wrapSeedErr("insert brand", err)
+}
+
+func ensureKeyword(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, name string) (int64, error) {
+	var keywordID int64
+	err := tx.QueryRow(ctx, `
+		WITH ensured AS (
+			INSERT INTO brand_keywords (tenant_id, brand_id, name, status)
+			VALUES ($1, $2, $3, 'active')
+			ON CONFLICT DO NOTHING
+			RETURNING id
+		)
+		SELECT id FROM ensured
+		UNION ALL
+		SELECT id FROM brand_keywords
+		WHERE tenant_id = $1 AND brand_id = $2 AND name = $3 AND deleted_at IS NULL
+		LIMIT 1
+	`, tenantID, brandID, name).Scan(&keywordID)
+	return keywordID, wrapSeedErr("insert keyword", err)
+}
+
+func ensureQuestion(ctx context.Context, tx pgx.Tx, tenantID, brandID, keywordID int64, questionText string) (int64, error) {
+	var questionID int64
+	err := tx.QueryRow(ctx, `
+		SELECT id
+		FROM brand_questions
+		WHERE tenant_id = $1 AND brand_id = $2 AND keyword_id = $3 AND question_text = $4 AND deleted_at IS NULL
+		LIMIT 1
+	`, tenantID, brandID, keywordID, questionText).Scan(&questionID)
+	if err == nil {
+		return questionID, nil
+	}
+	if err != pgx.ErrNoRows {
+		return 0, wrapSeedErr("query question", err)
+	}
+
+	err = tx.QueryRow(ctx, `
+		INSERT INTO brand_questions (tenant_id, brand_id, keyword_id, question_text, status)
+		VALUES ($1, $2, $3, $4, 'active')
+		RETURNING id
+	`, tenantID, brandID, keywordID, questionText).Scan(&questionID)
+	return questionID, wrapSeedErr("insert question", err)
+}
+
+func ensureCompetitor(ctx context.Context, tx pgx.Tx, tenantID, brandID int64) error {
+	_, err := tx.Exec(ctx, `
+		INSERT INTO competitors (tenant_id, brand_id, name, website, description, product_lines_json)
+		SELECT $1, $2, '瑞尔齿科', 'https://www.arrailgroup.com', '北京连锁齿科竞品示例', '["牙齿种植","正畸"]'::jsonb
+		WHERE NOT EXISTS (
+			SELECT 1
+			FROM competitors
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND name = '瑞尔齿科'
+			  AND deleted_at IS NULL
+		)
+	`, tenantID, brandID)
+	return wrapSeedErr("insert competitor", err)
+}
+
+func ensureArticle(ctx context.Context, tx pgx.Tx, tenantID int64) (int64, error) {
+	var articleID int64
+	err := tx.QueryRow(ctx, `
+		SELECT a.id
+		FROM articles a
+		JOIN article_versions av ON av.id = a.current_version_id
+		WHERE a.tenant_id = $1
+		  AND av.title = '北京口腔医院全面测评'
+		  AND a.deleted_at IS NULL
+		LIMIT 1
+	`, tenantID).Scan(&articleID)
+	if err == nil {
+		return articleID, nil
+	}
+	if err != pgx.ErrNoRows {
+		return 0, wrapSeedErr("query article", err)
+	}
+
+	err = tx.QueryRow(ctx, `
+		INSERT INTO articles (tenant_id, source_type, generate_status, publish_status)
+		VALUES ($1, 'free_create', 'completed', 'published')
+		RETURNING id
+	`, tenantID).Scan(&articleID)
+	if err != nil {
+		return 0, wrapSeedErr("insert article", err)
+	}
+
+	var versionID int64
+	err = tx.QueryRow(ctx, `
+		INSERT INTO article_versions (article_id, version_no, title, markdown_content, word_count, source_label)
+		VALUES ($1, 1, '北京口腔医院全面测评', '# 北京口腔医院全面测评', 1280, 'GEO Demo')
+		RETURNING id
+	`, articleID).Scan(&versionID)
+	if err != nil {
+		return 0, wrapSeedErr("insert article version", err)
+	}
+
+	_, err = tx.Exec(ctx, `
+		UPDATE articles
+		SET current_version_id = $2, updated_at = NOW()
+		WHERE id = $1
+	`, articleID, versionID)
+	if err != nil {
+		return 0, wrapSeedErr("update article current version", err)
+	}
+
+	return articleID, nil
+}
+
+func ensurePluginInstallation(ctx context.Context, tx pgx.Tx, tenantID, userID int64) (int64, error) {
+	installationKey := "demo-monitoring-installation"
+	tokenHash := sharedauth.HashToken("demo-monitoring-installation-token")
+
+	var installationID int64
+	err := tx.QueryRow(ctx, `
+		WITH ensured AS (
+			INSERT INTO plugin_installations (
+				tenant_id, user_id, installation_key, installation_name, browser_name,
+				client_version, installation_token_hash, status, last_seen_at
+			)
+			VALUES (
+				$1, $2, $3, 'GEO Monitoring Chrome', 'Chrome',
+				'0.1.0', $4, 'active', NOW()
+			)
+			ON CONFLICT DO NOTHING
+			RETURNING id
+		)
+		SELECT id FROM ensured
+		UNION ALL
+		SELECT id
+		FROM plugin_installations
+		WHERE tenant_id = $1 AND installation_key = $3 AND deleted_at IS NULL
+		LIMIT 1
+	`, tenantID, userID, installationKey, tokenHash).Scan(&installationID)
+	if err != nil {
+		return 0, wrapSeedErr("insert plugin installation", err)
+	}
+
+	_, err = tx.Exec(ctx, `
+		UPDATE plugin_installations
+		SET status = 'active',
+			installation_token_hash = $2,
+			last_seen_at = NOW(),
+			updated_at = NOW()
+		WHERE id = $1
+	`, installationID, tokenHash)
+	if err != nil {
+		return 0, wrapSeedErr("touch plugin installation", err)
+	}
+	return installationID, nil
+}
+
+func ensureMonitoringQuota(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	enabledPlatforms, _ := json.Marshal([]string{"deepseek", "qwen", "doubao"})
+	_, err := tx.Exec(ctx, `
+		INSERT INTO tenant_monitoring_quotas (
+			tenant_id, max_brands, collection_mode, question_selection_mode, collect_frequency,
+			enabled_platforms, primary_installation_id, task_daily_hard_cap, plan_tier
+		)
+		VALUES ($1, 1, 'plugin', 'best_effort_all', 'daily', $2::jsonb, $3, 36, 'free')
+		ON CONFLICT (tenant_id) DO UPDATE
+		SET collection_mode = EXCLUDED.collection_mode,
+			question_selection_mode = EXCLUDED.question_selection_mode,
+			collect_frequency = EXCLUDED.collect_frequency,
+			enabled_platforms = EXCLUDED.enabled_platforms,
+			primary_installation_id = EXCLUDED.primary_installation_id,
+			task_daily_hard_cap = EXCLUDED.task_daily_hard_cap,
+			plan_tier = EXCLUDED.plan_tier,
+			updated_at = NOW()
+	`, state.TenantID, string(enabledPlatforms), state.PluginInstallationID)
+	return wrapSeedErr("upsert monitoring quota", err)
+}
+
+func clearMonitoringData(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	pairs := []string{
+		`DELETE FROM monitoring_citation_facts WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM question_monitor_parse_results WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM question_monitor_runs WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM monitoring_collect_tasks WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM monitoring_brand_platform_daily WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM monitoring_brand_daily WHERE tenant_id = $1 AND brand_id = $2`,
+		`DELETE FROM monitoring_question_config_snapshots WHERE tenant_id = $1 AND brand_id = $2`,
+	}
+	for _, query := range pairs {
+		if _, err := tx.Exec(ctx, query, state.TenantID, state.BrandID); err != nil {
+			return wrapSeedErr("clear monitoring data", err)
 		}
 	}
 
-	if err := tx.Commit(ctx); err != nil {
-		log.Fatalf("commit: %v", err)
+	singles := []string{
+		`DELETE FROM monitoring_platform_access_snapshots WHERE tenant_id = $1`,
+		`DELETE FROM monitoring_article_url_aliases WHERE tenant_id = $1`,
+		`DELETE FROM site_domain_mappings WHERE tenant_id = $1`,
+	}
+	for _, query := range singles {
+		if _, err := tx.Exec(ctx, query, state.TenantID); err != nil {
+			return wrapSeedErr("clear monitoring data", err)
+		}
+	}
+	return nil
+}
+
+func insertSiteMappings(ctx context.Context, tx pgx.Tx, tenantID int64) error {
+	mappings := []struct {
+		domain   string
+		siteKey  string
+		siteName string
+	}{
+		{"zhihu.com", "zhihu.com", "知乎"},
+		{"weixin.qq.com", "weixin.qq.com", "微信公众号"},
+		{"haodf.com", "haodf.com", "好大夫在线"},
+	}
+	for _, item := range mappings {
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO site_domain_mappings (tenant_id, registrable_domain, site_key, site_name, is_active)
+			VALUES ($1, $2, $3, $4, TRUE)
+		`, tenantID, item.domain, item.siteKey, item.siteName); err != nil {
+			return wrapSeedErr("insert site mapping", err)
+		}
+	}
+	return nil
+}
+
+func insertQuestionSnapshots(ctx context.Context, tx pgx.Tx, state *seedState, hashes map[int64][]byte) error {
+	questions := []struct {
+		ID        int64
+		KeywordID int64
+		Text      string
+	}{
+		{state.QuestionPrimaryID, state.KeywordPrimaryID, "北京口腔医院推荐？"},
+		{state.QuestionSecondaryID, state.KeywordSecondaryID, "北京种植牙哪家靠谱？"},
+		{state.QuestionTertiaryID, state.KeywordPrimaryID, "北京牙齿矫正医院怎么选？"},
 	}
 
-	fmt.Println("Seed data inserted successfully.")
-	fmt.Printf("  Tenant ID: %d\n", tenantID)
-	fmt.Printf("  User ID:   %d (admin@geo.local / Admin@123)\n", userID)
-	fmt.Printf("  Plan ID:   %d (free)\n", planID)
-	fmt.Println("  Templates: 4 platform presets")
+	for _, item := range questions {
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_question_config_snapshots (
+				tenant_id, brand_id, question_id, keyword_id, question_hash, question_text_snapshot,
+				monitor_enabled, projected_at
+			)
+			VALUES ($1, $2, $3, $4, $5, $6, TRUE, NOW())
+		`, state.TenantID, state.BrandID, item.ID, item.KeywordID, hashes[item.ID], item.Text); err != nil {
+			return wrapSeedErr("insert question snapshot", err)
+		}
+	}
+	return nil
+}
+
+func insertPlatformAccessSnapshots(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	businessDate := time.Now().UTC().Format("2006-01-02")
+	entries := []struct {
+		PlatformID    string
+		AccessStatus  string
+		Connected     bool
+		Accessible    bool
+		ReasonCode    *string
+		ReasonMessage *string
+	}{
+		{"deepseek", "accessible", true, true, nil, nil},
+		{"qwen", "not_logged_in", false, false, stringPtr("session_missing"), stringPtr("插件检测到通义千问登录态已失效")},
+		{"doubao", "accessible", true, true, nil, nil},
+	}
+
+	for _, item := range entries {
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_platform_access_snapshots (
+				tenant_id, installation_id, ai_platform_id, business_date, access_status,
+				connected, accessible, detected_at, reason_code, reason_message
+			)
+			VALUES ($1, $2, $3, $4::date, $5, $6, $7, NOW(), $8, $9)
+		`, state.TenantID, state.PluginInstallationID, item.PlatformID, businessDate, item.AccessStatus, item.Connected, item.Accessible, item.ReasonCode, item.ReasonMessage); err != nil {
+			return wrapSeedErr("insert platform access snapshot", err)
+		}
+	}
+
+	return nil
+}
+
+func insertArticleAlias(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	_, err := tx.Exec(ctx, `
+		INSERT INTO monitoring_article_url_aliases (
+			tenant_id, article_id, platform_id, publish_platform_name_snapshot,
+			article_title_snapshot, original_url, normalized_url, last_path_segment, confidence
+		)
+		VALUES (
+			$1, $2, 'weixin_gzh', '微信公众号',
+			'北京口腔医院全面测评',
+			'https://mp.weixin.qq.com/s/geo-demo-monitoring',
+			'https://mp.weixin.qq.com/s/geo-demo-monitoring',
+			'geo-demo-monitoring',
+			'high'
+		)
+	`, state.TenantID, state.ArticleID)
+	return wrapSeedErr("insert article alias", err)
+}
+
+func insertDailySnapshots(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	today := time.Now().UTC().Truncate(24 * time.Hour)
+	seeds := []dailySeed{
+		{today.AddDate(0, 0, -6), "partial", 30, 18, 12, 0.6667, "medium", "automatic", 4, 2, 3, 7, 2, 0.3333, 0.1667, 0.2500, 0.5833, 0.1667},
+		{today.AddDate(0, 0, -5), "sampled", 30, 21, 16, 0.7619, "high", "automatic", 6, 3, 4, 10, 3, 0.3750, 0.1875, 0.2500, 0.6250, 0.1875},
+		{today.AddDate(0, 0, -4), "unsampled", 30, 0, 0, 0.0, "low", "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		{today.AddDate(0, 0, -3), "sampled", 30, 24, 18, 0.7500, "high", "automatic", 7, 4, 5, 12, 4, 0.3889, 0.2222, 0.2778, 0.6667, 0.2222},
+		{today.AddDate(0, 0, -2), "partial", 30, 21, 13, 0.6190, "medium", "automatic", 5, 2, 3, 9, 2, 0.3846, 0.1538, 0.2308, 0.6923, 0.1538},
+		{today.AddDate(0, 0, -1), "sampled", 30, 21, 15, 0.7143, "high", "automatic", 6, 3, 4, 10, 3, 0.4000, 0.2000, 0.2667, 0.6667, 0.2000},
+		{today, "sampled", 30, 21, 15, 0.7143, "high", "automatic", 7, 3, 4, 11, 4, 0.4667, 0.2000, 0.2667, 0.7333, 0.2667},
+	}
+
+	for _, item := range seeds {
+		var triggerSource interface{}
+		var coverageRate interface{}
+		var mentionRate interface{}
+		var top1Rate interface{}
+		var firstRate interface{}
+		var positiveRate interface{}
+		var citationRate interface{}
+		var snapshotUpdatedAt interface{}
+
+		if item.TriggerSource != "" {
+			triggerSource = item.TriggerSource
+			snapshotUpdatedAt = item.Date.Add(9*time.Hour + 20*time.Minute)
+		}
+		if item.ActualSampleCount > 0 {
+			coverageRate = item.CoverageRate
+			mentionRate = item.MentionRate
+			top1Rate = item.Top1MentionRate
+			firstRate = item.FirstRecommendRate
+			positiveRate = item.PositiveMentionRate
+			citationRate = item.CitationRate
+		}
+
+		_, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_brand_daily (
+				tenant_id, brand_id, collector_type, business_date, sample_status,
+				desired_sample_count, planned_sample_count, actual_sample_count,
+				coverage_rate, confidence_level, trigger_source, snapshot_updated_at,
+				mentioned_count, top1_mentioned_count, first_recommended_count, positive_mentioned_count,
+				cited_answer_count, mention_rate, top1_mention_rate, first_recommend_rate,
+				positive_mention_rate, citation_rate
+			)
+			VALUES (
+				$1, $2, 'plugin', $3::date, $4, $5, $6, $7, $8, $9, $10, $11,
+				$12, $13, $14, $15, $16, $17, $18, $19, $20, $21
+			)
+		`, state.TenantID, state.BrandID, item.Date.Format("2006-01-02"), item.SampleStatus,
+			item.DesiredSampleCount, item.PlannedSampleCount, item.ActualSampleCount,
+			coverageRate, item.ConfidenceLevel, triggerSource, snapshotUpdatedAt,
+			item.MentionedCount, item.Top1MentionedCount, item.FirstRecommendedCount, item.PositiveMentionedCount,
+			item.CitedAnswerCount, mentionRate, top1Rate, firstRate, positiveRate, citationRate,
+		)
+		if err != nil {
+			return wrapSeedErr("insert monitoring_brand_daily", err)
+		}
+	}
+	return nil
+}
+
+func insertPlatformDailySnapshots(ctx context.Context, tx pgx.Tx, state *seedState) error {
+	businessDate := time.Now().UTC().Format("2006-01-02")
+	type platformDaily struct {
+		ID            string
+		Status        string
+		Planned       int
+		Actual        int
+		MentionRate   interface{}
+		Top1Rate      interface{}
+		LastSampledAt interface{}
+	}
+	items := []platformDaily{
+		{"deepseek", "sampled", 8, 8, 0.5000, 0.2500, time.Now().UTC().Add(-25 * time.Minute)},
+		{"doubao", "sampled", 7, 7, 0.4286, 0.1429, time.Now().UTC().Add(-40 * time.Minute)},
+		{"qwen", "not_logged_in", 6, 0, nil, nil, nil},
+	}
+	for _, item := range items {
+		_, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_brand_platform_daily (
+				tenant_id, brand_id, ai_platform_id, collector_type, business_date,
+				platform_sample_status, planned_sample_count, actual_sample_count,
+				mention_rate, top1_mention_rate, last_sampled_at
+			)
+			VALUES ($1, $2, $3, 'plugin', $4::date, $5, $6, $7, $8, $9, $10)
+		`, state.TenantID, state.BrandID, item.ID, businessDate, item.Status, item.Planned, item.Actual, item.MentionRate, item.Top1Rate, item.LastSampledAt)
+		if err != nil {
+			return wrapSeedErr("insert monitoring_brand_platform_daily", err)
+		}
+	}
+	return nil
+}
+
+func insertTaskSeeds(ctx context.Context, tx pgx.Tx, state *seedState, hashes map[int64][]byte) error {
+	businessDate := time.Now().UTC().Format("2006-01-02")
+	tasks := []struct {
+		QuestionID    int64
+		PlatformID    string
+		Status        string
+		TriggerSource string
+		SkipReason    *string
+		CompletedAt   interface{}
+	}{
+		{state.QuestionPrimaryID, "deepseek", "completed", "automatic", nil, time.Now().UTC().Add(-24 * time.Minute)},
+		{state.QuestionPrimaryID, "doubao", "completed", "automatic", nil, time.Now().UTC().Add(-36 * time.Minute)},
+		{state.QuestionPrimaryID, "qwen", "skipped", "automatic", stringPtr("platform_not_accessible"), nil},
+		{state.QuestionSecondaryID, "deepseek", "completed", "automatic", nil, time.Now().UTC().Add(-18 * time.Minute)},
+		{state.QuestionSecondaryID, "doubao", "pending", "automatic", nil, nil},
+		{state.QuestionSecondaryID, "qwen", "pending", "automatic", nil, nil},
+		{state.QuestionTertiaryID, "deepseek", "pending", "automatic", nil, nil},
+		{state.QuestionTertiaryID, "doubao", "completed", "automatic", nil, time.Now().UTC().Add(-42 * time.Minute)},
+	}
+	for _, item := range tasks {
+		_, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_collect_tasks (
+				tenant_id, brand_id, question_id, question_hash, ai_platform_id, collector_type,
+				trigger_source, run_mode, business_date, planned_at, status,
+				completed_at, skip_reason
+			)
+			VALUES (
+				$1, $2, $3, $4, $5, 'plugin', $6, 'plugin_standard', $7::date, NOW(), $8, $9, $10
+			)
+		`, state.TenantID, state.BrandID, item.QuestionID, hashes[item.QuestionID], item.PlatformID, item.TriggerSource, businessDate, item.Status, item.CompletedAt, item.SkipReason)
+		if err != nil {
+			return wrapSeedErr("insert monitoring_collect_task", err)
+		}
+	}
+	return nil
+}
+
+func insertRunSeeds(ctx context.Context, tx pgx.Tx, state *seedState, hashes map[int64][]byte) error {
+	now := time.Now().UTC()
+	runs := []monitoringRunSeed{
+		{
+			BusinessDate:      now,
+			CompletedAt:       now.Add(-25 * time.Minute),
+			QuestionID:        state.QuestionPrimaryID,
+			QuestionText:      "北京口腔医院推荐？",
+			QuestionHash:      hashes[state.QuestionPrimaryID],
+			AIPlatformID:      "deepseek",
+			ProviderModel:     "deepseek-chat",
+			AnswerText:        "根据口碑和诊疗体验，`轻氧口腔` 在医生沟通、正畸方案透明度和术后复诊上都比较稳妥。\n\n如果你更关注连锁规模，也可以对比瑞尔齿科。",
+			BrandMentioned:    true,
+			MentionPosition:   "top1",
+			FirstRecommended:  true,
+			SentimentLabel:    "positive",
+			MatchedBrandTerms: []string{"轻氧口腔"},
+			Citations: []citationSeed{
+				{
+					URL:                  "https://www.zhihu.com/question/123456",
+					Title:                "北京口腔医院哪家比较好？",
+					NormalizedURL:        "https://www.zhihu.com/question/123456",
+					Host:                 "www.zhihu.com",
+					RegistrableDomain:    "zhihu.com",
+					SiteKey:              "zhihu.com",
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "high",
+				},
+				{
+					URL:                  "https://mp.weixin.qq.com/s/geo-demo-monitoring",
+					Title:                "北京口腔医院全面测评",
+					NormalizedURL:        "https://mp.weixin.qq.com/s/geo-demo-monitoring",
+					Host:                 "mp.weixin.qq.com",
+					RegistrableDomain:    "weixin.qq.com",
+					SiteKey:              "weixin.qq.com",
+					ArticleID:            &state.ArticleID,
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "high",
+				},
+			},
+		},
+		{
+			BusinessDate:      now,
+			CompletedAt:       now.Add(-38 * time.Minute),
+			QuestionID:        state.QuestionPrimaryID,
+			QuestionText:      "北京口腔医院推荐？",
+			QuestionHash:      hashes[state.QuestionPrimaryID],
+			AIPlatformID:      "doubao",
+			ProviderModel:     "doubao-seed-2-0-mini-260215",
+			AnswerText:        "如果你希望流程顺畅、医生解释细致，`轻氧口腔` 值得优先了解；如果预算非常敏感，可以再横向看看公立口腔医院。",
+			BrandMentioned:    true,
+			MentionPosition:   "mentioned",
+			FirstRecommended:  false,
+			SentimentLabel:    "positive",
+			MatchedBrandTerms: []string{"轻氧口腔"},
+			Citations: []citationSeed{
+				{
+					URL:                  "https://www.haodf.com/neirong/wenzhang/99887766.html",
+					Title:                "北京口腔医院就诊经验",
+					NormalizedURL:        "https://www.haodf.com/neirong/wenzhang/99887766.html",
+					Host:                 "www.haodf.com",
+					RegistrableDomain:    "haodf.com",
+					SiteKey:              "haodf.com",
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "medium",
+				},
+			},
+		},
+		{
+			BusinessDate:      now,
+			CompletedAt:       now.Add(-18 * time.Minute),
+			QuestionID:        state.QuestionSecondaryID,
+			QuestionText:      "北京种植牙哪家靠谱？",
+			QuestionHash:      hashes[state.QuestionSecondaryID],
+			AIPlatformID:      "deepseek",
+			ProviderModel:     "deepseek-chat",
+			AnswerText:        "在种植牙方案说明、价格透明度和术后复查安排上，`轻氧口腔` 的体验更稳定，适合作为首选参考。",
+			BrandMentioned:    true,
+			MentionPosition:   "top1",
+			FirstRecommended:  true,
+			SentimentLabel:    "positive",
+			MatchedBrandTerms: []string{"轻氧口腔"},
+			Citations: []citationSeed{
+				{
+					URL:                  "https://mp.weixin.qq.com/s/geo-demo-monitoring",
+					Title:                "北京口腔医院全面测评",
+					NormalizedURL:        "https://mp.weixin.qq.com/s/geo-demo-monitoring",
+					Host:                 "mp.weixin.qq.com",
+					RegistrableDomain:    "weixin.qq.com",
+					SiteKey:              "weixin.qq.com",
+					ArticleID:            &state.ArticleID,
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "high",
+				},
+			},
+		},
+		{
+			BusinessDate:      now,
+			CompletedAt:       now.Add(-42 * time.Minute),
+			QuestionID:        state.QuestionTertiaryID,
+			QuestionText:      "北京牙齿矫正医院怎么选？",
+			QuestionHash:      hashes[state.QuestionTertiaryID],
+			AIPlatformID:      "doubao",
+			ProviderModel:     "doubao-seed-2-0-mini-260215",
+			AnswerText:        "正畸更看重医生方案沟通和复诊便利性，`轻氧口腔` 的优势在于复诊节奏安排比较清晰。",
+			BrandMentioned:    true,
+			MentionPosition:   "mentioned",
+			FirstRecommended:  false,
+			SentimentLabel:    "positive",
+			MatchedBrandTerms: []string{"轻氧口腔"},
+			Citations: []citationSeed{
+				{
+					URL:                  "https://www.zhihu.com/question/9988123",
+					Title:                "牙齿矫正医院怎么挑？",
+					NormalizedURL:        "https://www.zhihu.com/question/9988123",
+					Host:                 "www.zhihu.com",
+					RegistrableDomain:    "zhihu.com",
+					SiteKey:              "zhihu.com",
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "high",
+				},
+			},
+		},
+		{
+			BusinessDate:      now.AddDate(0, 0, -1),
+			CompletedAt:       now.AddDate(0, 0, -1).Add(9*time.Hour + 18*time.Minute),
+			QuestionID:        state.QuestionPrimaryID,
+			QuestionText:      "北京口腔医院推荐？",
+			QuestionHash:      hashes[state.QuestionPrimaryID],
+			AIPlatformID:      "deepseek",
+			ProviderModel:     "deepseek-chat",
+			AnswerText:        "昨天的样本里，`轻氧口腔` 依然是优先推荐项，主要原因是体验稳定和医生解释清楚。",
+			BrandMentioned:    true,
+			MentionPosition:   "top1",
+			FirstRecommended:  true,
+			SentimentLabel:    "positive",
+			MatchedBrandTerms: []string{"轻氧口腔"},
+			Citations: []citationSeed{
+				{
+					URL:                  "https://www.zhihu.com/question/123456",
+					Title:                "北京口腔医院哪家比较好？",
+					NormalizedURL:        "https://www.zhihu.com/question/123456",
+					Host:                 "www.zhihu.com",
+					RegistrableDomain:    "zhihu.com",
+					SiteKey:              "zhihu.com",
+					ResolutionStatus:     "resolved",
+					ResolutionConfidence: "high",
+				},
+			},
+		},
+	}
+
+	for _, item := range runs {
+		var runID int64
+		err := tx.QueryRow(ctx, `
+			INSERT INTO question_monitor_runs (
+				tenant_id, brand_id, question_id, question_text_snapshot, question_hash,
+				ai_platform_id, collector_type, trigger_source, run_mode, business_date,
+				provider_model, raw_answer_text, status, completed_at, raw_response_json
+			)
+			VALUES (
+				$1, $2, $3, $4, $5, $6, 'plugin', 'automatic', 'plugin_standard', $7::date,
+				$8, $9, 'succeeded', $10, $11::jsonb
+			)
+			RETURNING id
+		`, state.TenantID, state.BrandID, item.QuestionID, item.QuestionText, item.QuestionHash, item.AIPlatformID,
+			item.BusinessDate.Format("2006-01-02"), item.ProviderModel, item.AnswerText, item.CompletedAt,
+			mustJSON(map[string]any{"source": "dev-seed", "platform": item.AIPlatformID}),
+		).Scan(&runID)
+		if err != nil {
+			return wrapSeedErr("insert question_monitor_runs", err)
+		}
+
+		_, err = tx.Exec(ctx, `
+			INSERT INTO question_monitor_parse_results (
+				tenant_id, run_id, brand_id, question_id, question_hash, ai_platform_id,
+				business_date, brand_mentioned, brand_mention_position, first_recommended,
+				sentiment_label, matched_brand_terms, parse_version, parse_status
+			)
+			VALUES (
+				$1, $2, $3, $4, $5, $6, $7::date, $8, $9, $10, $11, $12::jsonb, 'v1', 'succeeded'
+			)
+		`, state.TenantID, runID, state.BrandID, item.QuestionID, item.QuestionHash, item.AIPlatformID,
+			item.BusinessDate.Format("2006-01-02"), item.BrandMentioned, item.MentionPosition, item.FirstRecommended,
+			item.SentimentLabel, mustJSON(item.MatchedBrandTerms),
+		)
+		if err != nil {
+			return wrapSeedErr("insert question_monitor_parse_results", err)
+		}
+
+		for _, citation := range item.Citations {
+			_, err = tx.Exec(ctx, `
+				INSERT INTO monitoring_citation_facts (
+					tenant_id, run_id, brand_id, ai_platform_id, business_date, cited_url,
+					cited_title, normalized_url, host, registrable_domain, site_key,
+					article_id, publish_record_id, resolution_status, resolution_confidence
+				)
+				VALUES (
+					$1, $2, $3, $4, $5::date, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
+				)
+			`, state.TenantID, runID, state.BrandID, item.AIPlatformID, item.BusinessDate.Format("2006-01-02"),
+				citation.URL, citation.Title, citation.NormalizedURL, citation.Host, citation.RegistrableDomain,
+				citation.SiteKey, citation.ArticleID, citation.PublishRecordID, citation.ResolutionStatus, citation.ResolutionConfidence,
+			)
+			if err != nil {
+				return wrapSeedErr("insert monitoring_citation_facts", err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func makeQuestionHash(text string) []byte {
+	normalized := strings.TrimSpace(strings.ToLower(text))
+	sum := sha256.Sum256([]byte(normalized))
+	return sum[:16]
+}
+
+func mustJSON(value any) string {
+	data, _ := json.Marshal(value)
+	return string(data)
+}
+
+func stringPtr(value string) *string {
+	return &value
+}
+
+func wrapSeedErr(step string, err error) error {
+	if err == nil {
+		return nil
+	}
+	return fmt.Errorf("%s: %w", step, err)
 }
diff --git a/server/cmd/tenant-api/main.go b/server/cmd/tenant-api/main.go
index 58aca2b..702f7e9 100644
--- a/server/cmd/tenant-api/main.go
+++ b/server/cmd/tenant-api/main.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"os"
@@ -8,6 +9,7 @@ import (
 	"syscall"
 
 	"github.com/geo-platform/tenant-api/internal/bootstrap"
+	tenantapp "github.com/geo-platform/tenant-api/internal/tenant/app"
 	"github.com/geo-platform/tenant-api/internal/tenant/transport"
 )
 
@@ -23,6 +25,16 @@ func main() {
 	}
 	defer app.Close()
 
+	workerCtx, workerCancel := context.WithCancel(context.Background())
+	defer workerCancel()
+
+	monitoringCallbackService := tenantapp.NewMonitoringCallbackService(app.DB, app.MonitoringDB, app.RabbitMQ, app.LLM, app.Logger)
+	tenantapp.NewMonitoringResultIngestWorker(monitoringCallbackService, app.RabbitMQ, app.Logger).Start(workerCtx)
+	tenantapp.NewMonitoringProjectionRebuildWorker(monitoringCallbackService, app.RabbitMQ, app.Logger).Start(workerCtx)
+	tenantapp.NewMonitoringResultRecoveryWorker(app.MonitoringDB, monitoringCallbackService, app.Logger).Start(workerCtx)
+	tenantapp.NewMonitoringLeaseRecoveryWorker(app.MonitoringDB, app.Logger).Start(workerCtx)
+	tenantapp.NewMonitoringReceivedInspectionWorker(app.MonitoringDB, app.Logger).Start(workerCtx)
+
 	transport.RegisterRoutes(app)
 
 	addr := fmt.Sprintf(":%d", app.Config.Server.Port)
@@ -37,5 +49,6 @@ func main() {
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 	<-quit
+	workerCancel()
 	app.Logger.Info("shutting down...")
 }
diff --git a/server/configs/config.local.yaml.example b/server/configs/config.local.yaml.example
index 3722f7a..258b1fb 100644
--- a/server/configs/config.local.yaml.example
+++ b/server/configs/config.local.yaml.example
@@ -12,6 +12,28 @@ database:
   password: geo_dev
   dbname: geo
 
+monitoring_database:
+  host: localhost
+  port: 5433
+  user: geo
+  password: geo_dev
+  dbname: geo_monitoring
+  sslmode: disable
+  max_open_conns: 25
+  max_idle_conns: 5
+
+rabbitmq:
+  url: amqp://geo:geo_dev@localhost:5672/geo
+  monitor_result_exchange: monitor.result
+  monitor_result_routing_key: monitor.result.ingest
+  monitor_result_queue: monitor.result.ingest
+  monitor_result_dlx: monitor.result.dlx
+  monitor_result_dlq: monitor.result.ingest.dlq
+  monitor_result_dlq_routing_key: monitor.result.ingest.dlq
+  consumer_prefetch: 10
+  # Prefer environment override when needed:
+  # export RABBITMQ_URL=amqp://geo:geo_dev@localhost:5672/geo
+
 redis:
   addr: localhost:6379
 
diff --git a/server/configs/config.yaml b/server/configs/config.yaml
index 4528238..d2e65fb 100644
--- a/server/configs/config.yaml
+++ b/server/configs/config.yaml
@@ -12,6 +12,32 @@ database:
   max_open_conns: 25
   max_idle_conns: 5
 
+monitoring_database:
+  host: localhost
+  port: 5433
+  user: geo
+  password: geo_dev
+  dbname: geo_monitoring
+  sslmode: disable
+  max_open_conns: 25
+  max_idle_conns: 5
+
+rabbitmq:
+  url: amqp://geo:geo_dev@localhost:5672/geo
+  monitor_result_exchange: monitor.result
+  monitor_result_routing_key: monitor.result.ingest
+  monitor_result_queue: monitor.result.ingest
+  monitor_result_dlx: monitor.result.dlx
+  monitor_result_dlq: monitor.result.ingest.dlq
+  monitor_result_dlq_routing_key: monitor.result.ingest.dlq
+  monitor_projection_exchange: monitor.projection
+  monitor_projection_routing_key: monitor.projection.rebuild
+  monitor_projection_queue: monitor.projection.rebuild
+  monitor_projection_dlx: monitor.projection.dlx
+  monitor_projection_dlq: monitor.projection.rebuild.dlq
+  monitor_projection_dlq_routing_key: monitor.projection.rebuild.dlq
+  consumer_prefetch: 10
+
 redis:
   addr: localhost:6379
   db: 0
diff --git a/server/docker-compose.yaml b/server/docker-compose.yaml
index 1667bd5..cc648df 100644
--- a/server/docker-compose.yaml
+++ b/server/docker-compose.yaml
@@ -11,6 +11,31 @@ services:
     volumes:
       - pgdata:/var/lib/postgresql/data
 
+  monitoring-postgres:
+    image: postgres:16
+    container_name: geo-monitoring-postgres
+    ports:
+      - "5433:5432"
+    environment:
+      POSTGRES_DB: geo_monitoring
+      POSTGRES_USER: geo
+      POSTGRES_PASSWORD: geo_dev
+    volumes:
+      - monitoring_pgdata:/var/lib/postgresql/data
+
+  rabbitmq:
+    image: rabbitmq:management-alpine
+    container_name: geo-rabbitmq
+    ports:
+      - "5672:5672"
+      - "15672:15672"
+    environment:
+      RABBITMQ_DEFAULT_USER: geo
+      RABBITMQ_DEFAULT_PASS: geo_dev
+      RABBITMQ_DEFAULT_VHOST: geo
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+
   redis:
     image: redis:7-alpine
     container_name: geo-redis
@@ -41,5 +66,7 @@ services:
 
 volumes:
   pgdata:
+  monitoring_pgdata:
+  rabbitmq_data:
   qdrant_data:
   minio_data:
diff --git a/server/go.mod b/server/go.mod
index 6be294d..70e9a01 100644
--- a/server/go.mod
+++ b/server/go.mod
@@ -4,6 +4,8 @@ go 1.22.2
 
 require (
 	github.com/alicebob/miniredis/v2 v2.37.0
+	github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible
+	github.com/extrame/xls v0.0.1
 	github.com/gin-gonic/gin v1.9.1
 	github.com/golang-jwt/jwt/v5 v5.2.1
 	github.com/google/uuid v1.6.0
@@ -11,7 +13,9 @@ require (
 	github.com/ledongthuc/pdf v0.0.0-20240314090751-a2a84ec735c3
 	github.com/minio/minio-go/v7 v7.0.83
 	github.com/qdrant/go-client v1.13.0
+	github.com/rabbitmq/amqp091-go v1.10.0
 	github.com/redis/go-redis/v9 v9.5.1
+	github.com/sergi/go-diff v1.4.0
 	github.com/spf13/viper v1.18.2
 	github.com/stretchr/testify v1.9.0
 	github.com/volcengine/volcengine-go-sdk v1.2.22
@@ -22,7 +26,6 @@ require (
 )
 
 require (
-	github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible // indirect
 	github.com/bytedance/sonic v1.9.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
@@ -30,7 +33,6 @@ require (
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/extrame/ole2 v0.0.0-20160812065207-d69429661ad7 // indirect
-	github.com/extrame/xls v0.0.1 // indirect
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
@@ -62,7 +64,6 @@ require (
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
-	github.com/sergi/go-diff v1.4.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
diff --git a/server/go.sum b/server/go.sum
index 936accc..56f2c6d 100644
--- a/server/go.sum
+++ b/server/go.sum
@@ -141,6 +141,8 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/qdrant/go-client v1.13.0 h1:qeWKCs1vxvfF2MLLFnP2qDG0R8wI18HyAoSfc7wJim8=
 github.com/qdrant/go-client v1.13.0/go.mod h1:iO8ts78jL4x6LDHFOViyYWELVtIBDTjOykBmiOTHLnQ=
+github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
+github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
 github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8=
 github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
 github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM=
@@ -279,7 +281,6 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EV
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
diff --git a/server/internal/bootstrap/bootstrap.go b/server/internal/bootstrap/bootstrap.go
index 2daae0b..c7815d0 100644
--- a/server/internal/bootstrap/bootstrap.go
+++ b/server/internal/bootstrap/bootstrap.go
@@ -15,6 +15,7 @@ import (
 	"github.com/geo-platform/tenant-api/internal/shared/cache"
 	"github.com/geo-platform/tenant-api/internal/shared/config"
 	"github.com/geo-platform/tenant-api/internal/shared/llm"
+	"github.com/geo-platform/tenant-api/internal/shared/messaging/rabbitmq"
 	"github.com/geo-platform/tenant-api/internal/shared/middleware"
 	"github.com/geo-platform/tenant-api/internal/shared/objectstorage"
 	"github.com/geo-platform/tenant-api/internal/shared/observability"
@@ -29,6 +30,8 @@ type App struct {
 	Config            *config.Config
 	Logger            *zap.Logger
 	DB                *pgxpool.Pool
+	MonitoringDB      *pgxpool.Pool
+	RabbitMQ          *rabbitmq.Client
 	Redis             *goredis.Client
 	Engine            *gin.Engine
 	JWT               *auth.Manager
@@ -60,12 +63,27 @@ func New(configPath string) (*App, error) {
 		return nil, fmt.Errorf("init postgres: %w", err)
 	}
 
+	monitoringPool, err := postgres.NewPool(ctx, cfg.MonitoringDatabase)
+	if err != nil {
+		pool.Close()
+		return nil, fmt.Errorf("init monitoring postgres: %w", err)
+	}
+
 	rdb, err := redis.NewClient(ctx, cfg.Redis)
 	if err != nil {
 		pool.Close()
+		monitoringPool.Close()
 		return nil, fmt.Errorf("init redis: %w", err)
 	}
 
+	mqClient, err := rabbitmq.New(ctx, cfg.RabbitMQ)
+	if err != nil {
+		pool.Close()
+		monitoringPool.Close()
+		_ = rdb.Close()
+		return nil, fmt.Errorf("init rabbitmq: %w", err)
+	}
+
 	jwtMgr := auth.NewManager(cfg.JWT.Secret, cfg.JWT.AccessTTL, cfg.JWT.RefreshTTL)
 	sessions := auth.NewSessionStore(rdb)
 	llmClient := llm.New(cfg.LLM)
@@ -84,6 +102,7 @@ func New(configPath string) (*App, error) {
 	engine.Use(
 		middleware.Recovery(logger),
 		middleware.RequestID(),
+		middleware.Logger(logger),
 		middleware.CORS(),
 	)
 
@@ -95,10 +114,18 @@ func New(configPath string) (*App, error) {
 			response.Error(c, response.ErrServiceUnavailable(50301, "postgres_unavailable", "database is not reachable"))
 			return
 		}
+		if err := monitoringPool.Ping(c.Request.Context()); err != nil {
+			response.Error(c, response.ErrServiceUnavailable(50303, "monitoring_postgres_unavailable", "monitoring database is not reachable"))
+			return
+		}
 		if err := rdb.Ping(c.Request.Context()).Err(); err != nil {
 			response.Error(c, response.ErrServiceUnavailable(50302, "redis_unavailable", "redis is not reachable"))
 			return
 		}
+		if err := mqClient.Ping(c.Request.Context()); err != nil {
+			response.Error(c, response.ErrServiceUnavailable(50304, "rabbitmq_unavailable", "rabbitmq is not reachable"))
+			return
+		}
 		response.Success(c, gin.H{"status": "ready"})
 	})
 
@@ -106,6 +133,8 @@ func New(configPath string) (*App, error) {
 		Config:            cfg,
 		Logger:            logger,
 		DB:                pool,
+		MonitoringDB:      monitoringPool,
+		RabbitMQ:          mqClient,
 		Redis:             rdb,
 		Engine:            engine,
 		JWT:               jwtMgr,
@@ -129,6 +158,12 @@ func (a *App) Close() {
 		cancel()
 	}
 	a.DB.Close()
+	if a.MonitoringDB != nil {
+		a.MonitoringDB.Close()
+	}
+	if a.RabbitMQ != nil {
+		_ = a.RabbitMQ.Close()
+	}
 	_ = a.Redis.Close()
 	_ = a.Logger.Sync()
 }
diff --git a/server/internal/shared/config/config.go b/server/internal/shared/config/config.go
index e089e17..406c32c 100644
--- a/server/internal/shared/config/config.go
+++ b/server/internal/shared/config/config.go
@@ -10,17 +10,19 @@ import (
 )
 
 type Config struct {
-	Server        ServerConfig        `mapstructure:"server"`
-	Database      DatabaseConfig      `mapstructure:"database"`
-	Redis         RedisConfig         `mapstructure:"redis"`
-	Qdrant        QdrantConfig        `mapstructure:"qdrant"`
-	ObjectStorage ObjectStorageConfig `mapstructure:"object_storage"`
-	Cache         CacheConfig         `mapstructure:"cache"`
-	JWT           JWTConfig           `mapstructure:"jwt"`
-	Log           LogConfig           `mapstructure:"log"`
-	LLM           LLMConfig           `mapstructure:"llm"`
-	Retrieval     RetrievalConfig     `mapstructure:"retrieval"`
-	Generation    GenerationConfig    `mapstructure:"generation"`
+	Server             ServerConfig        `mapstructure:"server"`
+	Database           DatabaseConfig      `mapstructure:"database"`
+	MonitoringDatabase DatabaseConfig      `mapstructure:"monitoring_database"`
+	RabbitMQ           RabbitMQConfig      `mapstructure:"rabbitmq"`
+	Redis              RedisConfig         `mapstructure:"redis"`
+	Qdrant             QdrantConfig        `mapstructure:"qdrant"`
+	ObjectStorage      ObjectStorageConfig `mapstructure:"object_storage"`
+	Cache              CacheConfig         `mapstructure:"cache"`
+	JWT                JWTConfig           `mapstructure:"jwt"`
+	Log                LogConfig           `mapstructure:"log"`
+	LLM                LLMConfig           `mapstructure:"llm"`
+	Retrieval          RetrievalConfig     `mapstructure:"retrieval"`
+	Generation         GenerationConfig    `mapstructure:"generation"`
 }
 
 type ServerConfig struct {
@@ -49,6 +51,23 @@ type RedisConfig struct {
 	DB   int    `mapstructure:"db"`
 }
 
+type RabbitMQConfig struct {
+	URL                          string `mapstructure:"url"`
+	MonitorResultExchange        string `mapstructure:"monitor_result_exchange"`
+	MonitorResultRoutingKey      string `mapstructure:"monitor_result_routing_key"`
+	MonitorResultQueue           string `mapstructure:"monitor_result_queue"`
+	MonitorResultDLX             string `mapstructure:"monitor_result_dlx"`
+	MonitorResultDLQ             string `mapstructure:"monitor_result_dlq"`
+	MonitorResultDLQRouteKey     string `mapstructure:"monitor_result_dlq_routing_key"`
+	MonitorProjectionExchange    string `mapstructure:"monitor_projection_exchange"`
+	MonitorProjectionRoutingKey  string `mapstructure:"monitor_projection_routing_key"`
+	MonitorProjectionQueue       string `mapstructure:"monitor_projection_queue"`
+	MonitorProjectionDLX         string `mapstructure:"monitor_projection_dlx"`
+	MonitorProjectionDLQ         string `mapstructure:"monitor_projection_dlq"`
+	MonitorProjectionDLQRouteKey string `mapstructure:"monitor_projection_dlq_routing_key"`
+	ConsumerPrefetch             int    `mapstructure:"consumer_prefetch"`
+}
+
 type QdrantConfig struct {
 	URL        string        `mapstructure:"url"`
 	APIKey     string        `mapstructure:"api_key"`
@@ -139,6 +158,7 @@ func Load(configPath string) (*Config, error) {
 	}
 
 	applyEnvOverrides(&cfg)
+	normalizeRabbitMQConfig(&cfg.RabbitMQ)
 
 	return &cfg, nil
 }
@@ -157,6 +177,9 @@ func applyEnvOverrides(cfg *Config) {
 	if apiKey, ok := lookupNonEmptyEnv("QDRANT_API_KEY"); ok {
 		cfg.Qdrant.APIKey = apiKey
 	}
+	if rabbitmqURL, ok := lookupNonEmptyEnv("RABBITMQ_URL"); ok {
+		cfg.RabbitMQ.URL = rabbitmqURL
+	}
 	if url, ok := lookupNonEmptyEnv("QDRANT_URL"); ok {
 		cfg.Qdrant.URL = url
 	}
@@ -201,6 +224,50 @@ func applyEnvOverrides(cfg *Config) {
 	}
 }
 
+func normalizeRabbitMQConfig(cfg *RabbitMQConfig) {
+	if cfg == nil {
+		return
+	}
+
+	if strings.TrimSpace(cfg.MonitorResultExchange) == "" {
+		cfg.MonitorResultExchange = "monitor.result"
+	}
+	if strings.TrimSpace(cfg.MonitorResultRoutingKey) == "" {
+		cfg.MonitorResultRoutingKey = "monitor.result.ingest"
+	}
+	if strings.TrimSpace(cfg.MonitorResultQueue) == "" {
+		cfg.MonitorResultQueue = "monitor.result.ingest"
+	}
+	if strings.TrimSpace(cfg.MonitorResultDLX) == "" {
+		cfg.MonitorResultDLX = "monitor.result.dlx"
+	}
+	if strings.TrimSpace(cfg.MonitorResultDLQ) == "" {
+		cfg.MonitorResultDLQ = "monitor.result.ingest.dlq"
+	}
+	if strings.TrimSpace(cfg.MonitorResultDLQRouteKey) == "" {
+		cfg.MonitorResultDLQRouteKey = "monitor.result.ingest.dlq"
+	}
+
+	if strings.TrimSpace(cfg.MonitorProjectionExchange) == "" {
+		cfg.MonitorProjectionExchange = "monitor.projection"
+	}
+	if strings.TrimSpace(cfg.MonitorProjectionRoutingKey) == "" {
+		cfg.MonitorProjectionRoutingKey = "monitor.projection.rebuild"
+	}
+	if strings.TrimSpace(cfg.MonitorProjectionQueue) == "" {
+		cfg.MonitorProjectionQueue = "monitor.projection.rebuild"
+	}
+	if strings.TrimSpace(cfg.MonitorProjectionDLX) == "" {
+		cfg.MonitorProjectionDLX = "monitor.projection.dlx"
+	}
+	if strings.TrimSpace(cfg.MonitorProjectionDLQ) == "" {
+		cfg.MonitorProjectionDLQ = "monitor.projection.rebuild.dlq"
+	}
+	if strings.TrimSpace(cfg.MonitorProjectionDLQRouteKey) == "" {
+		cfg.MonitorProjectionDLQRouteKey = "monitor.projection.rebuild.dlq"
+	}
+}
+
 func lookupFirstNonEmptyEnv(keys ...string) (string, bool) {
 	for _, key := range keys {
 		if value, ok := lookupNonEmptyEnv(key); ok {
diff --git a/server/internal/shared/messaging/rabbitmq/client.go b/server/internal/shared/messaging/rabbitmq/client.go
new file mode 100644
index 0000000..69c0c15
--- /dev/null
+++ b/server/internal/shared/messaging/rabbitmq/client.go
@@ -0,0 +1,325 @@
+package rabbitmq
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+
+	"github.com/geo-platform/tenant-api/internal/shared/config"
+)
+
+type Client struct {
+	cfg    config.RabbitMQConfig
+	mu     sync.Mutex
+	conn   *amqp.Connection
+	closed bool
+}
+
+func New(_ context.Context, cfg config.RabbitMQConfig) (*Client, error) {
+	if strings.TrimSpace(cfg.URL) == "" {
+		return nil, fmt.Errorf("rabbitmq url is required")
+	}
+
+	client := &Client{cfg: cfg}
+	if _, err := client.ensureConnection(); err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}
+
+func (c *Client) Close() error {
+	if c == nil {
+		return nil
+	}
+
+	c.mu.Lock()
+	c.closed = true
+	conn := c.conn
+	c.conn = nil
+	c.mu.Unlock()
+
+	if conn == nil || conn.IsClosed() {
+		return nil
+	}
+	return conn.Close()
+}
+
+func (c *Client) Ping(_ context.Context) error {
+	_, ch, err := c.openChannel()
+	if err != nil {
+		return err
+	}
+	defer ch.Close()
+
+	return nil
+}
+
+func (c *Client) PublishMonitorResultIngest(ctx context.Context, body []byte) error {
+	return c.publish(ctx, c.cfg.MonitorResultExchange, c.cfg.MonitorResultRoutingKey, body)
+}
+
+func (c *Client) PublishMonitorProjectionRebuild(ctx context.Context, body []byte) error {
+	return c.publish(ctx, c.cfg.MonitorProjectionExchange, c.cfg.MonitorProjectionRoutingKey, body)
+}
+
+func (c *Client) publish(ctx context.Context, exchange, routingKey string, body []byte) error {
+	for attempt := 0; attempt < 2; attempt++ {
+		conn, ch, err := c.openChannel()
+		if err != nil {
+			return err
+		}
+
+		publishErr := ch.PublishWithContext(ctx, exchange, routingKey, false, false, amqp.Publishing{
+			ContentType:  "application/json",
+			DeliveryMode: amqp.Persistent,
+			Body:         body,
+		})
+		_ = ch.Close()
+		if publishErr == nil {
+			return nil
+		}
+
+		c.invalidateConnection(conn)
+		if attempt == 1 {
+			return fmt.Errorf("publish rabbitmq message: %w", publishErr)
+		}
+	}
+
+	return fmt.Errorf("publish rabbitmq message: retry exhausted")
+}
+
+func (c *Client) ConsumeMonitorResultIngest(consumerName string) (<-chan amqp.Delivery, *amqp.Channel, error) {
+	return c.consume(consumerName, c.cfg.MonitorResultQueue)
+}
+
+func (c *Client) ConsumeMonitorProjectionRebuild(consumerName string) (<-chan amqp.Delivery, *amqp.Channel, error) {
+	return c.consume(consumerName, c.cfg.MonitorProjectionQueue)
+}
+
+func (c *Client) consume(consumerName, queue string) (<-chan amqp.Delivery, *amqp.Channel, error) {
+	for attempt := 0; attempt < 2; attempt++ {
+		conn, ch, err := c.openChannel()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if c.cfg.ConsumerPrefetch > 0 {
+			if err := ch.Qos(c.cfg.ConsumerPrefetch, 0, false); err != nil {
+				_ = ch.Close()
+				c.invalidateConnection(conn)
+				if attempt == 1 {
+					return nil, nil, fmt.Errorf("configure rabbitmq qos: %w", err)
+				}
+				continue
+			}
+		}
+
+		deliveries, err := ch.Consume(
+			queue,
+			consumerName,
+			false,
+			false,
+			false,
+			false,
+			nil,
+		)
+		if err != nil {
+			_ = ch.Close()
+			c.invalidateConnection(conn)
+			if attempt == 1 {
+				return nil, nil, fmt.Errorf("consume rabbitmq queue: %w", err)
+			}
+			continue
+		}
+
+		return deliveries, ch, nil
+	}
+
+	return nil, nil, fmt.Errorf("consume rabbitmq queue: retry exhausted")
+}
+
+func (c *Client) ensureConnection() (*amqp.Connection, error) {
+	if c == nil {
+		return nil, fmt.Errorf("rabbitmq client is nil")
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.closed {
+		return nil, fmt.Errorf("rabbitmq client is closed")
+	}
+	if c.conn != nil && !c.conn.IsClosed() {
+		return c.conn, nil
+	}
+	if c.conn != nil {
+		_ = c.conn.Close()
+		c.conn = nil
+	}
+
+	conn, err := amqp.Dial(c.cfg.URL)
+	if err != nil {
+		return nil, fmt.Errorf("dial rabbitmq: %w", err)
+	}
+	if err := c.ensureTopology(conn); err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	c.conn = conn
+	return conn, nil
+}
+
+func (c *Client) openChannel() (*amqp.Connection, *amqp.Channel, error) {
+	for attempt := 0; attempt < 2; attempt++ {
+		conn, err := c.ensureConnection()
+		if err != nil {
+			return nil, nil, err
+		}
+
+		ch, err := conn.Channel()
+		if err == nil {
+			return conn, ch, nil
+		}
+
+		c.invalidateConnection(conn)
+		if attempt == 1 {
+			return nil, nil, fmt.Errorf("open rabbitmq channel: %w", err)
+		}
+	}
+
+	return nil, nil, fmt.Errorf("open rabbitmq channel: retry exhausted")
+}
+
+func (c *Client) invalidateConnection(conn *amqp.Connection) {
+	if c == nil || conn == nil {
+		return
+	}
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if c.conn != conn {
+		return
+	}
+	c.conn = nil
+	if !conn.IsClosed() {
+		_ = conn.Close()
+	}
+}
+
+func (c *Client) ensureTopology(conn *amqp.Connection) error {
+	ch, err := conn.Channel()
+	if err != nil {
+		return fmt.Errorf("open rabbitmq channel: %w", err)
+	}
+	defer ch.Close()
+
+	if err := c.ensureWorkQueue(
+		ch,
+		c.cfg.MonitorResultExchange,
+		c.cfg.MonitorResultRoutingKey,
+		c.cfg.MonitorResultQueue,
+		c.cfg.MonitorResultDLX,
+		c.cfg.MonitorResultDLQ,
+		c.cfg.MonitorResultDLQRouteKey,
+	); err != nil {
+		return err
+	}
+
+	if err := c.ensureWorkQueue(
+		ch,
+		c.cfg.MonitorProjectionExchange,
+		c.cfg.MonitorProjectionRoutingKey,
+		c.cfg.MonitorProjectionQueue,
+		c.cfg.MonitorProjectionDLX,
+		c.cfg.MonitorProjectionDLQ,
+		c.cfg.MonitorProjectionDLQRouteKey,
+	); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Client) ensureWorkQueue(ch *amqp.Channel, exchange, routingKey, queue, dlx, dlq, dlqRoutingKey string) error {
+	if err := ch.ExchangeDeclare(
+		exchange,
+		"direct",
+		true,
+		false,
+		false,
+		false,
+		nil,
+	); err != nil {
+		return fmt.Errorf("declare rabbitmq exchange %s: %w", exchange, err)
+	}
+
+	if err := ch.ExchangeDeclare(
+		dlx,
+		"direct",
+		true,
+		false,
+		false,
+		false,
+		nil,
+	); err != nil {
+		return fmt.Errorf("declare rabbitmq dlx %s: %w", dlx, err)
+	}
+
+	queueArgs := amqp.Table{
+		"x-queue-type":              "quorum",
+		"x-dead-letter-exchange":    dlx,
+		"x-dead-letter-routing-key": dlqRoutingKey,
+	}
+	if _, err := ch.QueueDeclare(
+		queue,
+		true,
+		false,
+		false,
+		false,
+		queueArgs,
+	); err != nil {
+		return fmt.Errorf("declare rabbitmq queue %s: %w", queue, err)
+	}
+
+	if err := ch.QueueBind(
+		queue,
+		routingKey,
+		exchange,
+		false,
+		nil,
+	); err != nil {
+		return fmt.Errorf("bind rabbitmq queue %s: %w", queue, err)
+	}
+
+	dlqArgs := amqp.Table{
+		"x-queue-type": "quorum",
+	}
+	if _, err := ch.QueueDeclare(
+		dlq,
+		true,
+		false,
+		false,
+		false,
+		dlqArgs,
+	); err != nil {
+		return fmt.Errorf("declare rabbitmq dlq %s: %w", dlq, err)
+	}
+
+	if err := ch.QueueBind(
+		dlq,
+		dlqRoutingKey,
+		dlx,
+		false,
+		nil,
+	); err != nil {
+		return fmt.Errorf("bind rabbitmq dlq %s: %w", dlq, err)
+	}
+
+	return nil
+}
diff --git a/server/internal/shared/middleware/logger.go b/server/internal/shared/middleware/logger.go
index 57fe046..9418505 100644
--- a/server/internal/shared/middleware/logger.go
+++ b/server/internal/shared/middleware/logger.go
@@ -31,6 +31,9 @@ func Logger(logger *zap.Logger) gin.HandlerFunc {
 			if appErr.Detail != "" {
 				fields = append(fields, zap.String("app_detail", appErr.Detail))
 			}
+			if appErr.Cause != nil {
+				fields = append(fields, zap.Error(appErr.Cause))
+			}
 		} else if len(c.Errors) > 0 {
 			fields = append(fields, zap.String("error", c.Errors.String()))
 		}
diff --git a/server/internal/tenant/app/brand_monitoring_cleanup.go b/server/internal/tenant/app/brand_monitoring_cleanup.go
new file mode 100644
index 0000000..ae31fc2
--- /dev/null
+++ b/server/internal/tenant/app/brand_monitoring_cleanup.go
@@ -0,0 +1,192 @@
+package app
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+const (
+	monitoringSkipReasonBrandDeleted    = "brand_deleted"
+	monitoringSkipReasonKeywordDeleted  = "keyword_deleted"
+	monitoringSkipReasonQuestionDeleted = "question_deleted"
+)
+
+var monitoringProjectionExcludedSkipReasons = []string{
+	monitoringSkipReasonBrandDeleted,
+	monitoringSkipReasonKeywordDeleted,
+	monitoringSkipReasonQuestionDeleted,
+}
+
+func (s *BrandService) cleanupMonitoringAfterBrandDelete(ctx context.Context, tenantID, brandID int64) error {
+	return s.cleanupMonitoringDeletion(ctx, tenantID, brandID, cleanupMonitoringDeletionOptions{
+		skipReason:       monitoringSkipReasonBrandDeleted,
+		errorMessage:     "brand deleted from brand library",
+		deleteAllByBrand: true,
+	})
+}
+
+func (s *BrandService) cleanupMonitoringAfterKeywordDelete(ctx context.Context, tenantID, brandID, keywordID int64, questionIDs []int64) error {
+	return s.cleanupMonitoringDeletion(ctx, tenantID, brandID, cleanupMonitoringDeletionOptions{
+		keywordID:    &keywordID,
+		questionIDs:  questionIDs,
+		skipReason:   monitoringSkipReasonKeywordDeleted,
+		errorMessage: "keyword deleted from brand library",
+	})
+}
+
+func (s *BrandService) cleanupMonitoringAfterQuestionDelete(ctx context.Context, tenantID, brandID, questionID int64) error {
+	return s.cleanupMonitoringDeletion(ctx, tenantID, brandID, cleanupMonitoringDeletionOptions{
+		questionIDs:  []int64{questionID},
+		skipReason:   monitoringSkipReasonQuestionDeleted,
+		errorMessage: "question deleted from brand library",
+	})
+}
+
+type cleanupMonitoringDeletionOptions struct {
+	keywordID        *int64
+	questionIDs      []int64
+	skipReason       string
+	errorMessage     string
+	deleteAllByBrand bool
+}
+
+func (s *BrandService) cleanupMonitoringDeletion(ctx context.Context, tenantID, brandID int64, options cleanupMonitoringDeletionOptions) error {
+	if s.monitoringPool == nil {
+		return nil
+	}
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return response.ErrInternal(50041, "begin_failed", "failed to start monitoring cleanup")
+	}
+	defer tx.Rollback(ctx)
+
+	if err := s.markMonitoringQuestionSnapshotsDeleted(ctx, tx, tenantID, brandID, options); err != nil {
+		return err
+	}
+
+	businessDay := monitoringBusinessToday()
+	if err := s.skipMonitoringTasksForDeletion(ctx, tx, tenantID, brandID, businessDay, options); err != nil {
+		return err
+	}
+
+	if err := s.rebuildMonitoringBrandProjection(ctx, tx, tenantID, brandID, businessDay); err != nil {
+		return err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return response.ErrInternal(50041, "commit_failed", "failed to commit monitoring cleanup")
+	}
+
+	return nil
+}
+
+func (s *BrandService) markMonitoringQuestionSnapshotsDeleted(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, options cleanupMonitoringDeletionOptions) error {
+	switch {
+	case options.deleteAllByBrand:
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_question_config_snapshots
+			SET deleted_at = COALESCE(deleted_at, NOW()),
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND deleted_at IS NULL
+		`, tenantID, brandID); err != nil {
+			return response.ErrInternal(50041, "snapshot_delete_failed", "failed to invalidate brand monitoring snapshots")
+		}
+	case options.keywordID != nil:
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_question_config_snapshots
+			SET deleted_at = COALESCE(deleted_at, NOW()),
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND keyword_id = $3
+			  AND deleted_at IS NULL
+		`, tenantID, brandID, *options.keywordID); err != nil {
+			return response.ErrInternal(50041, "snapshot_delete_failed", "failed to invalidate keyword monitoring snapshots")
+		}
+	default:
+		if len(options.questionIDs) == 0 {
+			return nil
+		}
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_question_config_snapshots
+			SET deleted_at = COALESCE(deleted_at, NOW()),
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND question_id = ANY($3)
+			  AND deleted_at IS NULL
+		`, tenantID, brandID, options.questionIDs); err != nil {
+			return response.ErrInternal(50041, "snapshot_delete_failed", "failed to invalidate question monitoring snapshots")
+		}
+	}
+
+	return nil
+}
+
+func (s *BrandService) skipMonitoringTasksForDeletion(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDay time.Time, options cleanupMonitoringDeletionOptions) error {
+	dateText := businessDay.Format("2006-01-02")
+
+	switch {
+	case options.deleteAllByBrand:
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_collect_tasks
+			SET status = 'skipped',
+			    lease_token_hash = NULL,
+			    leased_to_executor = NULL,
+			    leased_at = NULL,
+			    lease_expires_at = NULL,
+			    completed_at = COALESCE(completed_at, NOW()),
+			    skip_reason = $4,
+			    error_message = $5,
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND collector_type = $3
+			  AND business_date = $6::date
+			  AND status IN ('pending', 'leased', 'received', 'expired')
+		`, tenantID, brandID, monitoringCollectorType, options.skipReason, options.errorMessage, dateText); err != nil {
+			return response.ErrInternal(50041, "task_skip_failed", "failed to invalidate brand monitoring tasks")
+		}
+	default:
+		if len(options.questionIDs) == 0 {
+			return nil
+		}
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_collect_tasks
+			SET status = 'skipped',
+			    lease_token_hash = NULL,
+			    leased_to_executor = NULL,
+			    leased_at = NULL,
+			    lease_expires_at = NULL,
+			    completed_at = COALESCE(completed_at, NOW()),
+			    skip_reason = $4,
+			    error_message = $5,
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND collector_type = $3
+			  AND business_date = $6::date
+			  AND question_id = ANY($7)
+			  AND status IN ('pending', 'leased', 'received', 'expired')
+		`, tenantID, brandID, monitoringCollectorType, options.skipReason, options.errorMessage, dateText, options.questionIDs); err != nil {
+			return response.ErrInternal(50041, "task_skip_failed", "failed to invalidate question monitoring tasks")
+		}
+	}
+
+	return nil
+}
+
+func (s *BrandService) rebuildMonitoringBrandProjection(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDay time.Time) error {
+	callbackService := &MonitoringCallbackService{
+		businessPool:   s.pool,
+		monitoringPool: s.monitoringPool,
+	}
+	return callbackService.rebuildBrandDailyProjection(ctx, tx, tenantID, brandID, businessDay)
+}
diff --git a/server/internal/tenant/app/brand_service.go b/server/internal/tenant/app/brand_service.go
index abff050..5f0b531 100644
--- a/server/internal/tenant/app/brand_service.go
+++ b/server/internal/tenant/app/brand_service.go
@@ -15,12 +15,13 @@ import (
 )
 
 type BrandService struct {
-	pool      *pgxpool.Pool
-	auditLogs *auditlog.AsyncWriter
+	pool           *pgxpool.Pool
+	monitoringPool *pgxpool.Pool
+	auditLogs      *auditlog.AsyncWriter
 }
 
-func NewBrandService(pool *pgxpool.Pool, auditLogs *auditlog.AsyncWriter) *BrandService {
-	return &BrandService{pool: pool, auditLogs: auditLogs}
+func NewBrandService(pool, monitoringPool *pgxpool.Pool, auditLogs *auditlog.AsyncWriter) *BrandService {
+	return &BrandService{pool: pool, monitoringPool: monitoringPool, auditLogs: auditLogs}
 }
 
 // --- Brand CRUD ---
@@ -174,6 +175,10 @@ func (s *BrandService) Delete(ctx context.Context, id int64) error {
 	_, _ = tx.Exec(ctx, `UPDATE brand_questions SET deleted_at = NOW(), updated_at = NOW() WHERE brand_id = $1 AND tenant_id = $2 AND deleted_at IS NULL`, id, actor.TenantID)
 	_, _ = tx.Exec(ctx, `UPDATE competitors SET deleted_at = NOW(), updated_at = NOW() WHERE brand_id = $1 AND tenant_id = $2 AND deleted_at IS NULL`, id, actor.TenantID)
 
+	if err := s.cleanupMonitoringAfterBrandDelete(ctx, actor.TenantID, id); err != nil {
+		return err
+	}
+
 	afterJSON, _ := json.Marshal(map[string]interface{}{"id": id, "action": "cascade_soft_delete"})
 	if err := tx.Commit(ctx); err != nil {
 		return err
@@ -265,13 +270,65 @@ func (s *BrandService) UpdateKeyword(ctx context.Context, brandID, keywordID int
 
 func (s *BrandService) DeleteKeyword(ctx context.Context, brandID, keywordID int64) error {
 	actor := auth.MustActor(ctx)
-	tag, err := s.pool.Exec(ctx, `
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("begin tx: %w", err)
+	}
+	defer func() {
+		_ = tx.Rollback(ctx)
+	}()
+
+	questionRows, err := tx.Query(ctx, `
+		SELECT id
+		FROM brand_questions
+		WHERE brand_id = $1
+		  AND keyword_id = $2
+		  AND tenant_id = $3
+		  AND deleted_at IS NULL
+	`, brandID, keywordID, actor.TenantID)
+	if err != nil {
+		return response.ErrInternal(50010, "query_failed", "failed to load keyword questions")
+	}
+	questionIDs := make([]int64, 0)
+	for questionRows.Next() {
+		var questionID int64
+		if scanErr := questionRows.Scan(&questionID); scanErr != nil {
+			return response.ErrInternal(50010, "scan_failed", scanErr.Error())
+		}
+		questionIDs = append(questionIDs, questionID)
+	}
+	if err := questionRows.Err(); err != nil {
+		return response.ErrInternal(50010, "scan_failed", err.Error())
+	}
+	questionRows.Close()
+
+	tag, err := tx.Exec(ctx, `
 		UPDATE brand_keywords SET deleted_at = NOW(), updated_at = NOW()
 		WHERE id = $1 AND brand_id = $2 AND tenant_id = $3 AND deleted_at IS NULL
 	`, keywordID, brandID, actor.TenantID)
 	if err != nil || tag.RowsAffected() == 0 {
 		return response.ErrNotFound(40421, "keyword_not_found", "keyword not found")
 	}
+
+	if _, err := tx.Exec(ctx, `
+		UPDATE brand_questions
+		SET deleted_at = NOW(), updated_at = NOW()
+		WHERE brand_id = $1
+		  AND keyword_id = $2
+		  AND tenant_id = $3
+		  AND deleted_at IS NULL
+	`, brandID, keywordID, actor.TenantID); err != nil {
+		return response.ErrInternal(50010, "update_failed", "failed to soft delete questions under keyword")
+	}
+
+	if err := s.cleanupMonitoringAfterKeywordDelete(ctx, actor.TenantID, brandID, keywordID, questionIDs); err != nil {
+		return err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -378,13 +435,30 @@ func (s *BrandService) UpdateQuestion(ctx context.Context, brandID, questionID i
 
 func (s *BrandService) DeleteQuestion(ctx context.Context, brandID, questionID int64) error {
 	actor := auth.MustActor(ctx)
-	tag, err := s.pool.Exec(ctx, `
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("begin tx: %w", err)
+	}
+	defer func() {
+		_ = tx.Rollback(ctx)
+	}()
+
+	tag, err := tx.Exec(ctx, `
 		UPDATE brand_questions SET deleted_at = NOW(), updated_at = NOW()
 		WHERE id = $1 AND brand_id = $2 AND tenant_id = $3 AND deleted_at IS NULL
 	`, questionID, brandID, actor.TenantID)
 	if err != nil || tag.RowsAffected() == 0 {
 		return response.ErrNotFound(40422, "question_not_found", "question not found")
 	}
+
+	if err := s.cleanupMonitoringAfterQuestionDelete(ctx, actor.TenantID, brandID, questionID); err != nil {
+		return err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return err
+	}
+
 	return nil
 }
 
diff --git a/server/internal/tenant/app/media_service.go b/server/internal/tenant/app/media_service.go
index 0c4bb9a..42beea7 100644
--- a/server/internal/tenant/app/media_service.go
+++ b/server/internal/tenant/app/media_service.go
@@ -288,6 +288,10 @@ func (s *MediaService) RegisterPluginInstallation(ctx context.Context, req Regis
 		}
 	}
 
+	if err := ensureMonitoringPrimaryInstallation(ctx, tx, actor.TenantID, installationID); err != nil {
+		return nil, err
+	}
+
 	if err := tx.Commit(ctx); err != nil {
 		return nil, response.ErrInternal(50065, "installation_commit_failed", "failed to commit plugin installation")
 	}
@@ -300,6 +304,21 @@ func (s *MediaService) RegisterPluginInstallation(ctx context.Context, req Regis
 	}, nil
 }
 
+func ensureMonitoringPrimaryInstallation(ctx context.Context, tx pgx.Tx, tenantID, installationID int64) error {
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO tenant_monitoring_quotas (
+			tenant_id, primary_installation_id
+		)
+		VALUES ($1, $2)
+		ON CONFLICT (tenant_id) DO UPDATE
+		SET primary_installation_id = COALESCE(tenant_monitoring_quotas.primary_installation_id, EXCLUDED.primary_installation_id),
+			updated_at = NOW()
+	`, tenantID, installationID); err != nil {
+		return response.ErrInternal(50068, "monitoring_quota_update_failed", "failed to assign monitoring plugin installation")
+	}
+	return nil
+}
+
 func (s *MediaService) ListPlatformAccounts(ctx context.Context) ([]PlatformAccountResponse, error) {
 	actor := auth.MustActor(ctx)
 	rows, err := s.pool.Query(ctx, `
diff --git a/server/internal/tenant/app/monitoring_answer_llm_parse.go b/server/internal/tenant/app/monitoring_answer_llm_parse.go
new file mode 100644
index 0000000..af0d853
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_answer_llm_parse.go
@@ -0,0 +1,173 @@
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	sharedllm "github.com/geo-platform/tenant-api/internal/shared/llm"
+)
+
+const (
+	monitoringAnswerParseLLMModel           = "doubao-seed-2-0-lite-260215"
+	monitoringAnswerParseLLMTimeout         = 30 * time.Second
+	monitoringAnswerParseLLMMaxOutputTokens = 600
+)
+
+var monitoringAnswerParseLLMSchema = []byte(`{
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "brand_mentioned",
+    "brand_mention_position",
+    "first_recommended",
+    "sentiment_label",
+    "matched_brand_terms"
+  ],
+  "properties": {
+    "brand_mentioned": {
+      "type": "boolean"
+    },
+    "brand_mention_position": {
+      "type": "string",
+      "enum": ["top1", "mentioned", "not_mentioned"]
+    },
+    "first_recommended": {
+      "type": "boolean"
+    },
+    "sentiment_label": {
+      "type": "string",
+      "enum": ["positive", "neutral", "negative", "unknown"]
+    },
+    "matched_brand_terms": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}`)
+
+type monitoringAnswerLLMParsePayload struct {
+	BrandMentioned       bool     `json:"brand_mentioned"`
+	BrandMentionPosition string   `json:"brand_mention_position"`
+	FirstRecommended     bool     `json:"first_recommended"`
+	SentimentLabel       string   `json:"sentiment_label"`
+	MatchedBrandTerms    []string `json:"matched_brand_terms"`
+}
+
+func parseMonitoringAnswerWithLLM(
+	ctx context.Context,
+	client sharedllm.Client,
+	answer string,
+	brandName string,
+) (monitoringAnswerParseSummary, error) {
+	answer = strings.TrimSpace(answer)
+	brandName = strings.TrimSpace(brandName)
+	if answer == "" {
+		return monitoringAnswerParseSummary{}, fmt.Errorf("answer is empty")
+	}
+	if brandName == "" {
+		return monitoringAnswerParseSummary{}, fmt.Errorf("brand name is empty")
+	}
+
+	result, err := client.Generate(ctx, sharedllm.GenerateRequest{
+		Model:           monitoringAnswerParseLLMModel,
+		Prompt:          buildMonitoringAnswerParsePrompt(answer, brandName),
+		Timeout:         monitoringAnswerParseLLMTimeout,
+		MaxOutputTokens: monitoringAnswerParseLLMMaxOutputTokens,
+		ResponseFormat: &sharedllm.ResponseFormat{
+			Type:        sharedllm.ResponseFormatTypeJSONSchema,
+			Name:        "monitoring_answer_parse",
+			Description: "Parse brand mention signals from an AI answer for brand monitoring.",
+			SchemaJSON:  monitoringAnswerParseLLMSchema,
+			Strict:      true,
+		},
+	}, nil)
+	if err != nil {
+		return monitoringAnswerParseSummary{}, err
+	}
+
+	return decodeMonitoringAnswerLLMParseResult(result.Content)
+}
+
+func buildMonitoringAnswerParsePrompt(answer string, brandName string) string {
+	var builder strings.Builder
+	builder.WriteString("你是品牌监测解析助手。\n")
+	builder.WriteString("请只基于给定回答内容，判断目标品牌在回答中的提及、排序、推荐与情感，不要猜测回答外的信息。\n")
+	builder.WriteString("\n判断规则：\n")
+	builder.WriteString("1. brand_mentioned：回答中是否明确提到目标品牌，或可明确判断是在指代该品牌。\n")
+	builder.WriteString("2. brand_mention_position：\n")
+	builder.WriteString("   - top1：目标品牌被排在第一位，或被明确表述为首选/最推荐。\n")
+	builder.WriteString("   - mentioned：目标品牌被提到，但不是第一位。\n")
+	builder.WriteString("   - not_mentioned：未提到目标品牌。\n")
+	builder.WriteString("3. first_recommended：是否明确把目标品牌作为首选推荐。\n")
+	builder.WriteString("4. sentiment_label：结合品牌相关表述判断 positive / neutral / negative / unknown。\n")
+	builder.WriteString("5. matched_brand_terms：把回答里实际出现、并用于指代该品牌的词语原样列出；没有就返回空数组。\n")
+	builder.WriteString("\n只返回 JSON。\n")
+	builder.WriteString("\n目标品牌：")
+	builder.WriteString(brandName)
+	builder.WriteString("\n回答内容：\n")
+	builder.WriteString(answer)
+	return builder.String()
+}
+
+func decodeMonitoringAnswerLLMParseResult(raw string) (monitoringAnswerParseSummary, error) {
+	var lastErr error
+	for _, candidate := range extractJSONCandidates(raw) {
+		var payload monitoringAnswerLLMParsePayload
+		if err := json.Unmarshal([]byte(candidate), &payload); err != nil {
+			lastErr = err
+			continue
+		}
+		return monitoringAnswerParseSummary{
+			BrandMentioned:       payload.BrandMentioned,
+			BrandMentionPosition: normalizeMonitoringBrandMentionPosition(payload.BrandMentionPosition, payload.BrandMentioned),
+			FirstRecommended:     payload.FirstRecommended,
+			SentimentLabel:       normalizeMonitoringSentiment(payload.SentimentLabel, payload.BrandMentioned),
+			MatchedBrandTerms:    normalizeMonitoringBrandTermList(payload.MatchedBrandTerms),
+		}, nil
+	}
+	if lastErr == nil {
+		lastErr = fmt.Errorf("empty content")
+	}
+	return monitoringAnswerParseSummary{}, fmt.Errorf("decode monitoring answer parse result: %w", lastErr)
+}
+
+func normalizeMonitoringBrandMentionPosition(value string, brandMentioned bool) string {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "top1":
+		if !brandMentioned {
+			return "not_mentioned"
+		}
+		return "top1"
+	case "mentioned":
+		if !brandMentioned {
+			return "not_mentioned"
+		}
+		return "mentioned"
+	case "not_mentioned":
+		return "not_mentioned"
+	default:
+		if brandMentioned {
+			return "mentioned"
+		}
+		return "not_mentioned"
+	}
+}
+
+func normalizeMonitoringSentiment(value string, brandMentioned bool) string {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "positive", "neutral", "negative":
+		return strings.ToLower(strings.TrimSpace(value))
+	case "unknown":
+		return "unknown"
+	default:
+		if brandMentioned {
+			return "neutral"
+		}
+		return "unknown"
+	}
+}
diff --git a/server/internal/tenant/app/monitoring_answer_parse.go b/server/internal/tenant/app/monitoring_answer_parse.go
new file mode 100644
index 0000000..1444bd7
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_answer_parse.go
@@ -0,0 +1,246 @@
+package app
+
+import (
+	"strings"
+	"unicode"
+)
+
+type monitoringStoredParseFields struct {
+	BrandMentioned       *bool
+	BrandMentionPosition *string
+	FirstRecommended     *bool
+	SentimentLabel       *string
+	MatchedBrandTerms    []string
+}
+
+type monitoringAnswerParseSummary struct {
+	BrandMentioned       bool
+	BrandMentionPosition string
+	FirstRecommended     bool
+	SentimentLabel       string
+	MatchedBrandTerms    []string
+}
+
+var monitoringPositiveSignals = []string{
+	"推荐", "首选", "优先", "更推荐", "值得", "靠谱", "专业", "优质", "高端", "不错", "合适", "满意", "口碑", "领先",
+}
+
+var monitoringNegativeSignals = []string{
+	"不推荐", "慎选", "避坑", "不好", "较差", "很差", "问题", "投诉", "负面", "不靠谱", "一般", "短板", "缺点", "不足",
+}
+
+func resolveMonitoringAnswerParseSummary(
+	answer string,
+	brandName string,
+	stored monitoringStoredParseFields,
+) monitoringAnswerParseSummary {
+	return overlayMonitoringStoredParseSummary(
+		deriveMonitoringAnswerParseSummary(answer, brandName),
+		stored,
+	)
+}
+
+func overlayMonitoringStoredParseSummary(
+	base monitoringAnswerParseSummary,
+	stored monitoringStoredParseFields,
+) monitoringAnswerParseSummary {
+	result := base
+
+	if stored.BrandMentioned != nil {
+		result.BrandMentioned = *stored.BrandMentioned
+	}
+	if value := strings.TrimSpace(monitoringStringValue(stored.BrandMentionPosition)); value != "" {
+		result.BrandMentionPosition = value
+	}
+	if stored.FirstRecommended != nil {
+		result.FirstRecommended = *stored.FirstRecommended
+	}
+	if value := strings.TrimSpace(monitoringStringValue(stored.SentimentLabel)); value != "" {
+		result.SentimentLabel = value
+	}
+	if len(stored.MatchedBrandTerms) > 0 {
+		result.MatchedBrandTerms = normalizeMonitoringBrandTermList(stored.MatchedBrandTerms)
+	}
+
+	if result.BrandMentioned && result.BrandMentionPosition == "" {
+		result.BrandMentionPosition = "mentioned"
+	}
+	if !result.BrandMentioned && result.BrandMentionPosition == "" {
+		result.BrandMentionPosition = "not_mentioned"
+	}
+	if result.BrandMentioned && result.SentimentLabel == "" {
+		result.SentimentLabel = "neutral"
+	}
+	if !result.BrandMentioned && result.SentimentLabel == "" {
+		result.SentimentLabel = "unknown"
+	}
+
+	return result
+}
+
+func deriveMonitoringAnswerParseSummary(answer string, brandName string) monitoringAnswerParseSummary {
+	result := monitoringAnswerParseSummary{
+		BrandMentionPosition: "not_mentioned",
+		SentimentLabel:       "unknown",
+		MatchedBrandTerms:    []string{},
+	}
+
+	answer = strings.TrimSpace(answer)
+	if answer == "" {
+		return result
+	}
+
+	brandTerms := buildMonitoringBrandTerms(brandName)
+	if len(brandTerms) == 0 {
+		return result
+	}
+
+	answerLower := strings.ToLower(answer)
+	answerNormalized := normalizeMonitoringTextForMatch(answer)
+	matchedTerms := findMonitoringMatchedBrandTerms(answerLower, answerNormalized, brandTerms)
+	if len(matchedTerms) == 0 {
+		return result
+	}
+
+	result.BrandMentioned = true
+	result.BrandMentionPosition = "mentioned"
+	result.MatchedBrandTerms = matchedTerms
+
+	if isMonitoringTop1Mention(answerLower, matchedTerms) {
+		result.BrandMentionPosition = "top1"
+	}
+
+	result.FirstRecommended = isMonitoringFirstRecommended(answerLower, matchedTerms, result.BrandMentionPosition)
+	result.SentimentLabel = deriveMonitoringSentimentLabel(answerLower, matchedTerms, result.FirstRecommended)
+	return result
+}
+
+func buildMonitoringBrandTerms(brandName string) []string {
+	return normalizeMonitoringBrandTermList([]string{strings.TrimSpace(brandName)})
+}
+
+func normalizeMonitoringBrandTermList(values []string) []string {
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			continue
+		}
+		if _, ok := seen[trimmed]; ok {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		result = append(result, trimmed)
+	}
+	return result
+}
+
+func normalizeMonitoringTextForMatch(value string) string {
+	var builder strings.Builder
+	builder.Grow(len(value))
+	for _, item := range strings.ToLower(value) {
+		if unicode.IsLetter(item) || unicode.IsNumber(item) {
+			builder.WriteRune(item)
+		}
+	}
+	return builder.String()
+}
+
+func findMonitoringMatchedBrandTerms(answerLower, answerNormalized string, brandTerms []string) []string {
+	matched := make([]string, 0, len(brandTerms))
+	for _, term := range brandTerms {
+		termLower := strings.ToLower(strings.TrimSpace(term))
+		if termLower == "" {
+			continue
+		}
+		termNormalized := normalizeMonitoringTextForMatch(termLower)
+		if strings.Contains(answerLower, termLower) || (termNormalized != "" && strings.Contains(answerNormalized, termNormalized)) {
+			matched = append(matched, term)
+		}
+	}
+	return normalizeMonitoringBrandTermList(matched)
+}
+
+func isMonitoringTop1Mention(answerLower string, matchedTerms []string) bool {
+	segment := strings.ToLower(firstMonitoringRunes(strings.TrimSpace(answerLower), 96))
+	if segment == "" {
+		return false
+	}
+	for _, term := range matchedTerms {
+		termLower := strings.ToLower(strings.TrimSpace(term))
+		if termLower != "" && strings.Contains(segment, termLower) {
+			return true
+		}
+	}
+	return false
+}
+
+func isMonitoringFirstRecommended(answerLower string, matchedTerms []string, mentionPosition string) bool {
+	if mentionPosition == "top1" {
+		return true
+	}
+
+	for _, term := range matchedTerms {
+		termLower := strings.ToLower(strings.TrimSpace(term))
+		if termLower == "" {
+			continue
+		}
+
+		patterns := []string{
+			"推荐" + termLower,
+			"首选" + termLower,
+			"优先" + termLower,
+			"建议选择" + termLower,
+			"建议选" + termLower,
+			"更推荐" + termLower,
+			termLower + "是首选",
+			termLower + "更合适",
+			termLower + "更值得",
+			termLower + "值得推荐",
+		}
+		for _, pattern := range patterns {
+			if strings.Contains(answerLower, pattern) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func deriveMonitoringSentimentLabel(answerLower string, matchedTerms []string, firstRecommended bool) string {
+	negativeCount := 0
+	for _, signal := range monitoringNegativeSignals {
+		if strings.Contains(answerLower, signal) {
+			negativeCount++
+		}
+	}
+	if negativeCount > 0 {
+		return "negative"
+	}
+
+	positiveCount := 0
+	for _, signal := range monitoringPositiveSignals {
+		if strings.Contains(answerLower, signal) {
+			positiveCount++
+		}
+	}
+	if firstRecommended || positiveCount > 0 {
+		return "positive"
+	}
+	if len(matchedTerms) > 0 {
+		return "neutral"
+	}
+	return "unknown"
+}
+
+func firstMonitoringRunes(value string, limit int) string {
+	if limit <= 0 {
+		return ""
+	}
+	runes := []rune(value)
+	if len(runes) <= limit {
+		return string(runes)
+	}
+	return string(runes[:limit])
+}
diff --git a/server/internal/tenant/app/monitoring_callback_service.go b/server/internal/tenant/app/monitoring_callback_service.go
new file mode 100644
index 0000000..798e1d7
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_callback_service.go
@@ -0,0 +1,2306 @@
+package app
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"go.uber.org/zap"
+	"golang.org/x/net/publicsuffix"
+
+	sharedauth "github.com/geo-platform/tenant-api/internal/shared/auth"
+	sharedllm "github.com/geo-platform/tenant-api/internal/shared/llm"
+	"github.com/geo-platform/tenant-api/internal/shared/messaging/rabbitmq"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+const (
+	defaultMonitoringLeaseLimit        = 3
+	maxMonitoringLeaseLimit            = 50
+	monitoringLeaseTTL                 = 15 * time.Minute
+	monitoringTaskResultQueueIOTimeout = 5 * time.Second
+)
+
+type MonitoringCallbackService struct {
+	businessPool   *pgxpool.Pool
+	monitoringPool *pgxpool.Pool
+	rabbitMQ       *rabbitmq.Client
+	llm            sharedllm.Client
+	logger         *zap.Logger
+}
+
+func NewMonitoringCallbackService(
+	businessPool, monitoringPool *pgxpool.Pool,
+	rabbitMQClient *rabbitmq.Client,
+	llmClient sharedllm.Client,
+	logger *zap.Logger,
+) *MonitoringCallbackService {
+	return &MonitoringCallbackService{
+		businessPool:   businessPool,
+		monitoringPool: monitoringPool,
+		rabbitMQ:       rabbitMQClient,
+		llm:            llmClient,
+		logger:         logger,
+	}
+}
+
+type MonitoringTaskResultRequest struct {
+	LeaseToken           string                 `json:"lease_token" binding:"required"`
+	Status               string                 `json:"status"`
+	ProviderModel        *string                `json:"provider_model"`
+	ProviderRequestID    *string                `json:"provider_request_id"`
+	RequestID            *string                `json:"request_id"`
+	Answer               *string                `json:"answer"`
+	RawResponseJSON      map[string]interface{} `json:"raw_response_json"`
+	Citations            []MonitoringSourceItem `json:"citations"`
+	SearchResults        []MonitoringSourceItem `json:"search_results"`
+	BrandMentioned       *bool                  `json:"brand_mentioned"`
+	BrandMentionPosition *string                `json:"brand_mention_position"`
+	FirstRecommended     *bool                  `json:"first_recommended"`
+	SentimentLabel       *string                `json:"sentiment_label"`
+	MatchedBrandTerms    []string               `json:"matched_brand_terms"`
+	ErrorMessage         *string                `json:"error_message"`
+	CompletedAt          *time.Time             `json:"completed_at"`
+}
+
+type MonitoringSourceItem struct {
+	URL                  string  `json:"url"`
+	Title                *string `json:"title"`
+	SiteName             *string `json:"site_name"`
+	SiteKey              *string `json:"site_key"`
+	NormalizedURL        *string `json:"normalized_url"`
+	Host                 *string `json:"host"`
+	RegistrableDomain    *string `json:"registrable_domain"`
+	Subdomain            *string `json:"subdomain"`
+	Suffix               *string `json:"suffix"`
+	ArticleID            *int64  `json:"article_id"`
+	PublishRecordID      *int64  `json:"publish_record_id"`
+	ResolutionStatus     *string `json:"resolution_status"`
+	ResolutionConfidence *string `json:"resolution_confidence"`
+}
+
+type MonitoringHeartbeatRequest struct {
+	Platforms []MonitoringHeartbeatPlatform `json:"platforms"`
+}
+
+type MonitoringHeartbeatPlatform struct {
+	AIPlatformID  string     `json:"ai_platform_id"`
+	AccessStatus  *string    `json:"access_status"`
+	Connected     *bool      `json:"connected"`
+	Accessible    *bool      `json:"accessible"`
+	DetectedAt    *time.Time `json:"detected_at"`
+	ReasonCode    *string    `json:"reason_code"`
+	ReasonMessage *string    `json:"reason_message"`
+}
+
+type MonitoringHeartbeatResponse struct {
+	InstallationID             int64  `json:"installation_id"`
+	BusinessDate               string `json:"business_date"`
+	UpdatedPlatformCount       int    `json:"updated_platform_count"`
+	ReconciledSkippedTaskCount int64  `json:"reconciled_skipped_task_count"`
+}
+
+type MonitoringLeaseTasksRequest struct {
+	Limit         int      `json:"limit"`
+	AIPlatformIDs []string `json:"ai_platform_ids"`
+}
+
+type MonitoringResumeTasksRequest struct {
+	AIPlatformIDs []string `json:"ai_platform_ids"`
+}
+
+type MonitoringLeaseTasksResponse struct {
+	BusinessDate string                `json:"business_date"`
+	LeaseCount   int                   `json:"lease_count"`
+	Tasks        []MonitoringLeaseTask `json:"tasks"`
+}
+
+type MonitoringResumeTasksResponse struct {
+	BusinessDate string                `json:"business_date"`
+	ResumeCount  int                   `json:"resume_count"`
+	Tasks        []MonitoringLeaseTask `json:"tasks"`
+}
+
+type MonitoringLeaseTask struct {
+	TaskID         int64  `json:"task_id"`
+	BrandID        int64  `json:"brand_id"`
+	QuestionID     int64  `json:"question_id"`
+	QuestionHash   string `json:"question_hash"`
+	QuestionText   string `json:"question_text"`
+	AIPlatformID   string `json:"ai_platform_id"`
+	PlatformName   string `json:"platform_name"`
+	CollectorType  string `json:"collector_type"`
+	RunMode        string `json:"run_mode"`
+	TriggerSource  string `json:"trigger_source"`
+	BusinessDate   string `json:"business_date"`
+	LeaseToken     string `json:"lease_token"`
+	LeaseExpiresAt string `json:"lease_expires_at"`
+}
+
+type MonitoringTaskResultResponse struct {
+	TaskID               int64  `json:"task_id"`
+	RunID                *int64 `json:"run_id"`
+	TaskStatus           string `json:"task_status"`
+	CitationSourceCount  int    `json:"citation_source_count"`
+	ContentCitationCount int    `json:"content_citation_count"`
+}
+
+type MonitoringSkipTaskRequest struct {
+	LeaseToken   string     `json:"lease_token" binding:"required"`
+	SkipReason   *string    `json:"skip_reason"`
+	ErrorMessage *string    `json:"error_message"`
+	CompletedAt  *time.Time `json:"completed_at"`
+}
+
+type MonitoringSkipTaskResponse struct {
+	TaskID      int64   `json:"task_id"`
+	TaskStatus  string  `json:"task_status"`
+	SkipReason  string  `json:"skip_reason"`
+	CompletedAt *string `json:"completed_at"`
+}
+
+type monitoringInstallationIdentity struct {
+	ID       int64
+	TenantID int64
+}
+
+type monitoringPlatformAccessSnapshotState struct {
+	AccessStatus  string
+	Connected     bool
+	Accessible    bool
+	ReasonCode    *string
+	ReasonMessage *string
+}
+
+type monitoringCollectTask struct {
+	ID               int64
+	TenantID         int64
+	BrandID          int64
+	QuestionID       int64
+	QuestionHash     []byte
+	AIPlatformID     string
+	CollectorType    string
+	RunMode          string
+	BusinessDate     time.Time
+	Status           string
+	LeaseTokenHash   sql.NullString
+	LeasedToExecutor sql.NullString
+	LeaseExpiresAt   sql.NullTime
+	CompletedAt      sql.NullTime
+	SkipReason       sql.NullString
+	TriggerSource    string
+	QuestionText     string
+}
+
+type monitoringLeasedTaskRow struct {
+	ID            int64
+	BrandID       int64
+	QuestionID    int64
+	QuestionHash  []byte
+	AIPlatformID  string
+	CollectorType string
+	RunMode       string
+	TriggerSource string
+	BusinessDate  time.Time
+	QuestionText  string
+}
+
+type monitoringAliasResolution struct {
+	ArticleID        *int64
+	PublishRecordID  *int64
+	NormalizedURLKey string
+}
+
+type monitoringCitationFact struct {
+	CitedURL             string
+	CitedTitle           *string
+	NormalizedURL        string
+	Host                 string
+	RegistrableDomain    string
+	Subdomain            *string
+	Suffix               *string
+	SiteKey              string
+	ArticleID            *int64
+	PublishRecordID      *int64
+	ResolutionStatus     string
+	ResolutionConfidence string
+}
+
+type monitoringTaskResultEnvelope struct {
+	Version               string                      `json:"version"`
+	TaskID                int64                       `json:"task_id"`
+	TenantID              int64                       `json:"tenant_id"`
+	InstallationID        int64                       `json:"installation_id"`
+	ReceivedAt            time.Time                   `json:"received_at"`
+	QueueStatus           string                      `json:"queue_status"`
+	QueueClaimedAt        *time.Time                  `json:"queue_claimed_at"`
+	QueueEnqueuedAt       *time.Time                  `json:"queue_enqueued_at"`
+	LastQueuePublishError *string                     `json:"last_queue_publish_error"`
+	ReceivedAlertedAt     *time.Time                  `json:"received_alerted_at"`
+	ReceivedAlertCount    int                         `json:"received_alert_count"`
+	CallbackResult        MonitoringTaskResultRequest `json:"callback_result"`
+}
+
+type monitoringTaskResultQueueMetaPatch struct {
+	QueueStatus           string     `json:"queue_status"`
+	QueueClaimedAt        *time.Time `json:"queue_claimed_at"`
+	QueueEnqueuedAt       *time.Time `json:"queue_enqueued_at"`
+	LastQueuePublishError *string    `json:"last_queue_publish_error"`
+}
+
+func (s *MonitoringCallbackService) HandleTaskResult(ctx context.Context, installationID int64, installationToken string, taskID int64, req MonitoringTaskResultRequest) (*MonitoringTaskResultResponse, error) {
+	installation, err := s.authenticateInstallation(ctx, installationID, installationToken)
+	if err != nil {
+		return nil, err
+	}
+
+	task, err := s.loadCollectTask(ctx, installation.TenantID, taskID)
+	if err != nil {
+		return nil, err
+	}
+
+	if task.CollectorType != monitoringCollectorType {
+		return nil, response.ErrConflict(40941, "collector_type_mismatch", "task collector type is not plugin")
+	}
+
+	if task.LeasedToExecutor.Valid && strings.TrimSpace(task.LeasedToExecutor.String) != "" && task.LeasedToExecutor.String != strconv.FormatInt(installation.ID, 10) {
+		return nil, response.ErrUnauthorized(40141, "lease_owner_mismatch", "task is leased to another installation")
+	}
+
+	if strings.TrimSpace(task.LeaseTokenHash.String) == "" {
+		return nil, response.ErrConflict(40941, "lease_token_missing", "task does not have an active lease token")
+	}
+
+	if sharedauth.HashToken(strings.TrimSpace(req.LeaseToken)) != task.LeaseTokenHash.String {
+		return nil, response.ErrUnauthorized(40141, "invalid_lease_token", "lease token is invalid")
+	}
+
+	if task.Status == "completed" {
+		runID, citationSourceCount, contentCitationCount, loadErr := s.loadExistingRunSummary(ctx, task)
+		if loadErr != nil {
+			return nil, loadErr
+		}
+		_ = s.touchInstallation(ctx, installation.ID)
+		return &MonitoringTaskResultResponse{
+			TaskID:               task.ID,
+			RunID:                runID,
+			TaskStatus:           task.Status,
+			CitationSourceCount:  citationSourceCount,
+			ContentCitationCount: contentCitationCount,
+		}, nil
+	}
+
+	switch task.Status {
+	case "leased", "received", "failed", "expired", "pending":
+	default:
+		return nil, response.ErrConflict(40941, "task_status_invalid", "task status does not allow result submission")
+	}
+
+	if normalizeRunStatus(req.Status) == "" {
+		return nil, response.ErrBadRequest(40041, "invalid_status", "status must be succeeded or failed")
+	}
+
+	receivedAt := time.Now().UTC().Round(0)
+	envelope := newMonitoringTaskResultEnvelope(task, installation.ID, receivedAt, req)
+	requestPayloadJSON, err := json.Marshal(envelope)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "payload_encode_failed", "failed to encode monitoring callback payload")
+	}
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring callback receive")
+	}
+	defer tx.Rollback(ctx)
+
+	if err := s.markTaskResultReceived(ctx, tx, task.ID, receivedAt, requestPayloadJSON); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring callback receive")
+	}
+
+	_ = s.touchInstallation(ctx, installation.ID)
+
+	publishCtx, cancel := context.WithTimeout(context.Background(), monitoringTaskResultQueueIOTimeout)
+	defer cancel()
+
+	if err := s.publishTaskResultEnvelope(publishCtx, requestPayloadJSON); err != nil {
+		s.tryPatchTaskResultQueueMeta(task.ID, receivedAt, monitoringTaskResultQueueMetaPatch{
+			QueueStatus:           "publish_failed",
+			LastQueuePublishError: optionalString(err.Error()),
+		})
+		return nil, response.ErrServiceUnavailable(50341, "monitoring_result_queue_unavailable", "failed to queue monitoring result")
+	}
+
+	enqueuedAt := time.Now().UTC().Round(0)
+	s.tryPatchTaskResultQueueMeta(task.ID, receivedAt, monitoringTaskResultQueueMetaPatch{
+		QueueStatus:     "queued",
+		QueueEnqueuedAt: &enqueuedAt,
+	})
+
+	return &MonitoringTaskResultResponse{
+		TaskID:               task.ID,
+		TaskStatus:           "received",
+		CitationSourceCount:  0,
+		ContentCitationCount: 0,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) Heartbeat(ctx context.Context, installationID int64, installationToken string, req MonitoringHeartbeatRequest) (*MonitoringHeartbeatResponse, error) {
+	installation, err := s.authenticateInstallation(ctx, installationID, installationToken)
+	if err != nil {
+		return nil, err
+	}
+
+	isPrimaryInstallation, err := s.resolveHeartbeatPrimaryInstallation(ctx, installation.TenantID, installation.ID)
+	if err != nil {
+		return nil, err
+	}
+
+	now := time.Now().UTC()
+	businessDay, businessDate := monitoringBusinessDayAndDateAt(now)
+	platforms, err := normalizeHeartbeatPlatforms(req.Platforms, now)
+	if err != nil {
+		return nil, err
+	}
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring heartbeat")
+	}
+	defer tx.Rollback(ctx)
+
+	var reconciledSkippedTaskCount int64
+	affectedBrandIDs := make(map[int64]struct{})
+	for _, platform := range platforms {
+		accessChanged, err := s.upsertPlatformAccessSnapshot(ctx, tx, installation, businessDate, platform)
+		if err != nil {
+			return nil, err
+		}
+
+		if !isPrimaryInstallation {
+			continue
+		}
+
+		needsProjectionRefresh := accessChanged
+		if monitoringStringValue(platform.AccessStatus) != "accessible" {
+			count, reconcileErr := s.reconcilePendingTasksForPlatform(ctx, tx, installation.TenantID, businessDate, platform.AIPlatformID)
+			if reconcileErr != nil {
+				return nil, reconcileErr
+			}
+			reconciledSkippedTaskCount += count
+			if count > 0 {
+				needsProjectionRefresh = true
+			}
+		}
+
+		if !needsProjectionRefresh {
+			continue
+		}
+
+		brandIDs, loadErr := s.loadMonitoringAffectedBrandIDs(ctx, tx, installation.TenantID, businessDay, platform.AIPlatformID)
+		if loadErr != nil {
+			return nil, loadErr
+		}
+		for _, brandID := range brandIDs {
+			affectedBrandIDs[brandID] = struct{}{}
+		}
+	}
+
+	if isPrimaryInstallation {
+		for brandID := range affectedBrandIDs {
+			if err := s.rebuildBrandDailyProjection(ctx, tx, installation.TenantID, brandID, businessDay); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring heartbeat")
+	}
+
+	_ = s.touchInstallation(ctx, installation.ID)
+	if isPrimaryInstallation && len(affectedBrandIDs) > 0 {
+		s.dispatchMonitoringProjectionRebuilds(installation.TenantID, businessDay, affectedBrandIDs, "heartbeat")
+	}
+
+	return &MonitoringHeartbeatResponse{
+		InstallationID:             installation.ID,
+		BusinessDate:               businessDate,
+		UpdatedPlatformCount:       len(platforms),
+		ReconciledSkippedTaskCount: reconciledSkippedTaskCount,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) LeaseTasks(ctx context.Context, installationID int64, installationToken string, req MonitoringLeaseTasksRequest) (*MonitoringLeaseTasksResponse, error) {
+	installation, err := s.authenticateInstallation(ctx, installationID, installationToken)
+	if err != nil {
+		return nil, err
+	}
+
+	limit := normalizeMonitoringLeaseLimit(req.Limit)
+	eligiblePlatformIDs := normalizeMonitoringLeasePlatformIDs(req.AIPlatformIDs)
+	now := time.Now().UTC()
+	businessDay, businessDate := monitoringBusinessDayAndDateAt(now)
+	leaseExpiresAt := now.Add(monitoringLeaseTTL)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring task lease")
+	}
+	defer tx.Rollback(ctx)
+
+	if _, err := expireMonitoringLeasedTasks(ctx, tx, &installation.TenantID, now); err != nil {
+		return nil, err
+	}
+	if _, err := requeueMonitoringExpiredTasks(ctx, tx, installation.TenantID, businessDay); err != nil {
+		return nil, err
+	}
+
+	rows, err := s.selectPendingLeaseTasks(ctx, tx, installation.TenantID, businessDate, limit, eligiblePlatformIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		if err := tx.Commit(ctx); err != nil {
+			return nil, response.ErrInternal(50041, "commit_failed", "failed to finish empty monitoring lease")
+		}
+		_ = s.touchInstallation(ctx, installation.ID)
+		return &MonitoringLeaseTasksResponse{
+			BusinessDate: businessDate,
+			LeaseCount:   0,
+			Tasks:        []MonitoringLeaseTask{},
+		}, nil
+	}
+
+	tasks := make([]MonitoringLeaseTask, 0, len(rows))
+	for _, row := range rows {
+		leaseToken, tokenErr := newSessionToken()
+		if tokenErr != nil {
+			return nil, response.ErrInternal(50041, "lease_token_failed", "failed to generate monitoring lease token")
+		}
+		if err := s.markTaskLeased(ctx, tx, installation.ID, row.ID, leaseToken, now, leaseExpiresAt); err != nil {
+			return nil, err
+		}
+		tasks = append(tasks, MonitoringLeaseTask{
+			TaskID:         row.ID,
+			BrandID:        row.BrandID,
+			QuestionID:     row.QuestionID,
+			QuestionHash:   encodeQuestionHash(row.QuestionHash),
+			QuestionText:   row.QuestionText,
+			AIPlatformID:   row.AIPlatformID,
+			PlatformName:   platformDisplayName(row.AIPlatformID),
+			CollectorType:  row.CollectorType,
+			RunMode:        row.RunMode,
+			TriggerSource:  row.TriggerSource,
+			BusinessDate:   row.BusinessDate.Format("2006-01-02"),
+			LeaseToken:     leaseToken,
+			LeaseExpiresAt: leaseExpiresAt.Format(time.RFC3339),
+		})
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring task lease")
+	}
+
+	_ = s.touchInstallation(ctx, installation.ID)
+
+	return &MonitoringLeaseTasksResponse{
+		BusinessDate: businessDate,
+		LeaseCount:   len(tasks),
+		Tasks:        tasks,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) ResumeTasks(ctx context.Context, installationID int64, installationToken string, req MonitoringResumeTasksRequest) (*MonitoringResumeTasksResponse, error) {
+	installation, err := s.authenticateInstallation(ctx, installationID, installationToken)
+	if err != nil {
+		return nil, err
+	}
+
+	eligiblePlatformIDs := normalizeMonitoringLeasePlatformIDs(req.AIPlatformIDs)
+	now := time.Now().UTC()
+	businessDay, businessDate := monitoringBusinessDayAndDateAt(now)
+	leaseExpiresAt := now.Add(monitoringLeaseTTL)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring task resume")
+	}
+	defer tx.Rollback(ctx)
+
+	if _, err := expireMonitoringLeasedTasks(ctx, tx, &installation.TenantID, now); err != nil {
+		return nil, err
+	}
+	if _, err := requeueMonitoringExpiredTasks(ctx, tx, installation.TenantID, businessDay); err != nil {
+		return nil, err
+	}
+
+	rows, err := s.selectLeasedTasksForInstallation(ctx, tx, installation.TenantID, installation.ID, businessDate, eligiblePlatformIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		if err := tx.Commit(ctx); err != nil {
+			return nil, response.ErrInternal(50041, "commit_failed", "failed to finish empty monitoring resume")
+		}
+		_ = s.touchInstallation(ctx, installation.ID)
+		return &MonitoringResumeTasksResponse{
+			BusinessDate: businessDate,
+			ResumeCount:  0,
+			Tasks:        []MonitoringLeaseTask{},
+		}, nil
+	}
+
+	tasks := make([]MonitoringLeaseTask, 0, len(rows))
+	for _, row := range rows {
+		leaseToken, tokenErr := newSessionToken()
+		if tokenErr != nil {
+			return nil, response.ErrInternal(50041, "lease_token_failed", "failed to generate monitoring resume token")
+		}
+		if err := s.markTaskLeased(ctx, tx, installation.ID, row.ID, leaseToken, now, leaseExpiresAt); err != nil {
+			return nil, err
+		}
+		tasks = append(tasks, MonitoringLeaseTask{
+			TaskID:         row.ID,
+			BrandID:        row.BrandID,
+			QuestionID:     row.QuestionID,
+			QuestionHash:   encodeQuestionHash(row.QuestionHash),
+			QuestionText:   row.QuestionText,
+			AIPlatformID:   row.AIPlatformID,
+			PlatformName:   platformDisplayName(row.AIPlatformID),
+			CollectorType:  row.CollectorType,
+			RunMode:        row.RunMode,
+			TriggerSource:  row.TriggerSource,
+			BusinessDate:   row.BusinessDate.Format("2006-01-02"),
+			LeaseToken:     leaseToken,
+			LeaseExpiresAt: leaseExpiresAt.Format(time.RFC3339),
+		})
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring task resume")
+	}
+
+	_ = s.touchInstallation(ctx, installation.ID)
+
+	return &MonitoringResumeTasksResponse{
+		BusinessDate: businessDate,
+		ResumeCount:  len(tasks),
+		Tasks:        tasks,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) SkipTask(ctx context.Context, installationID int64, installationToken string, taskID int64, req MonitoringSkipTaskRequest) (*MonitoringSkipTaskResponse, error) {
+	installation, err := s.authenticateInstallation(ctx, installationID, installationToken)
+	if err != nil {
+		return nil, err
+	}
+
+	task, err := s.loadCollectTask(ctx, installation.TenantID, taskID)
+	if err != nil {
+		return nil, err
+	}
+
+	if task.CollectorType != monitoringCollectorType {
+		return nil, response.ErrConflict(40941, "collector_type_mismatch", "task collector type is not plugin")
+	}
+	if err := validateTaskLease(task, installation.ID, req.LeaseToken); err != nil {
+		return nil, err
+	}
+
+	if task.Status == "skipped" {
+		_ = s.touchInstallation(ctx, installation.ID)
+		return &MonitoringSkipTaskResponse{
+			TaskID:      task.ID,
+			TaskStatus:  task.Status,
+			SkipReason:  strings.TrimSpace(task.SkipReason.String),
+			CompletedAt: formatNullTime(task.CompletedAt),
+		}, nil
+	}
+
+	switch task.Status {
+	case "leased", "received", "failed", "expired", "pending":
+	default:
+		return nil, response.ErrConflict(40941, "task_status_invalid", "task status does not allow skip submission")
+	}
+
+	completedAt := time.Now().UTC()
+	if req.CompletedAt != nil && !req.CompletedAt.IsZero() {
+		completedAt = req.CompletedAt.UTC()
+	}
+
+	skipReason := normalizeSkipReason(req.SkipReason)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring task skip")
+	}
+	defer tx.Rollback(ctx)
+
+	if _, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = 'skipped',
+		    callback_received_at = NOW(),
+		    completed_at = $2,
+		    skip_reason = $3,
+		    error_message = $4,
+		    updated_at = NOW()
+		WHERE id = $1
+	`, task.ID, completedAt, skipReason, nullableString(req.ErrorMessage)); err != nil {
+		return nil, response.ErrInternal(50041, "task_update_failed", "failed to update monitoring task skip status")
+	}
+
+	if err := s.rebuildBrandDailyProjection(ctx, tx, task.TenantID, task.BrandID, task.BusinessDate); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring task skip")
+	}
+
+	_ = s.touchInstallation(ctx, installation.ID)
+
+	completedAtText := completedAt.Format(time.RFC3339)
+	return &MonitoringSkipTaskResponse{
+		TaskID:      task.ID,
+		TaskStatus:  "skipped",
+		SkipReason:  skipReason,
+		CompletedAt: &completedAtText,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) ProcessQueuedTaskResult(ctx context.Context, envelope monitoringTaskResultEnvelope) (*MonitoringTaskResultResponse, error) {
+	if envelope.TaskID <= 0 {
+		return nil, response.ErrBadRequest(40041, "invalid_task_id", "task id is required")
+	}
+
+	task, err := s.loadCollectTaskByID(ctx, envelope.TaskID)
+	if err != nil {
+		if appErr, ok := err.(*response.AppError); ok && appErr.HTTPStatus == 404 {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	if envelope.TenantID > 0 && envelope.TenantID != task.TenantID {
+		return nil, response.ErrConflict(40941, "task_tenant_mismatch", "task tenant does not match queued monitoring result")
+	}
+
+	if task.Status != "received" {
+		return nil, nil
+	}
+
+	return s.processTaskResult(ctx, task, envelope.CallbackResult)
+}
+
+func (s *MonitoringCallbackService) authenticateInstallation(ctx context.Context, installationID int64, installationToken string) (*monitoringInstallationIdentity, error) {
+	tokenHash := sharedauth.HashToken(strings.TrimSpace(installationToken))
+
+	row := &monitoringInstallationIdentity{}
+	if err := s.businessPool.QueryRow(ctx, `
+		SELECT id, tenant_id
+		FROM plugin_installations
+		WHERE id = $1
+		  AND installation_token_hash = $2
+		  AND status = 'active'
+		  AND deleted_at IS NULL
+	`, installationID, tokenHash).Scan(&row.ID, &row.TenantID); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrUnauthorized(40141, "plugin_installation_unauthorized", "plugin installation is invalid or expired")
+		}
+		return nil, response.ErrInternal(50041, "plugin_installation_lookup_failed", "failed to validate plugin installation")
+	}
+
+	return row, nil
+}
+
+func (s *MonitoringCallbackService) resolveHeartbeatPrimaryInstallation(ctx context.Context, tenantID, installationID int64) (bool, error) {
+	var preferred sql.NullInt64
+	err := s.businessPool.QueryRow(ctx, `
+		SELECT primary_installation_id
+		FROM tenant_monitoring_quotas
+		WHERE tenant_id = $1
+	`, tenantID).Scan(&preferred)
+	if err != nil && err != pgx.ErrNoRows {
+		return false, response.ErrInternal(50041, "query_failed", "failed to inspect primary monitoring installation")
+	}
+
+	if !preferred.Valid || preferred.Int64 == installationID {
+		if !preferred.Valid {
+			if err := s.persistHeartbeatPrimaryInstallationID(ctx, tenantID, installationID); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	}
+
+	online, err := s.isMonitoringInstallationRecentlyOnline(ctx, tenantID, preferred.Int64)
+	if err != nil {
+		return false, err
+	}
+	if online {
+		return false, nil
+	}
+
+	if err := s.persistHeartbeatPrimaryInstallationID(ctx, tenantID, installationID); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (s *MonitoringCallbackService) isMonitoringInstallationRecentlyOnline(ctx context.Context, tenantID, installationID int64) (bool, error) {
+	var lastSeenAt sql.NullTime
+	err := s.businessPool.QueryRow(ctx, `
+		SELECT last_seen_at
+		FROM plugin_installations
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND status = 'active'
+		  AND deleted_at IS NULL
+	`, installationID, tenantID).Scan(&lastSeenAt)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return false, nil
+		}
+		return false, response.ErrInternal(50041, "query_failed", "failed to inspect monitoring installation heartbeat")
+	}
+
+	if !lastSeenAt.Valid {
+		return false, nil
+	}
+	return time.Since(lastSeenAt.Time) <= monitoringOnlineDuration, nil
+}
+
+func (s *MonitoringCallbackService) persistHeartbeatPrimaryInstallationID(ctx context.Context, tenantID, installationID int64) error {
+	if _, err := s.businessPool.Exec(ctx, `
+		INSERT INTO tenant_monitoring_quotas (
+			tenant_id, primary_installation_id
+		)
+		VALUES ($1, $2)
+		ON CONFLICT (tenant_id) DO UPDATE
+		SET primary_installation_id = EXCLUDED.primary_installation_id,
+			updated_at = NOW()
+	`, tenantID, installationID); err != nil {
+		return response.ErrInternal(50041, "update_failed", "failed to persist primary monitoring installation")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) loadCollectTask(ctx context.Context, tenantID, taskID int64) (*monitoringCollectTask, error) {
+	item := &monitoringCollectTask{}
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			id,
+			tenant_id,
+			brand_id,
+			question_id,
+			question_hash,
+			ai_platform_id,
+			collector_type,
+			run_mode,
+			business_date,
+			status,
+			lease_token_hash,
+			leased_to_executor,
+			lease_expires_at,
+			completed_at,
+			skip_reason,
+			trigger_source,
+			COALESCE((
+				SELECT question_text_snapshot
+				FROM monitoring_question_config_snapshots
+				WHERE tenant_id = t.tenant_id
+				  AND brand_id = t.brand_id
+				  AND question_id = t.question_id
+				  AND question_hash = t.question_hash
+				  AND deleted_at IS NULL
+				ORDER BY projected_at DESC, id DESC
+				LIMIT 1
+			), '') AS question_text_snapshot
+		FROM monitoring_collect_tasks t
+		WHERE id = $1
+		  AND tenant_id = $2
+	`, taskID, tenantID).Scan(
+		&item.ID,
+		&item.TenantID,
+		&item.BrandID,
+		&item.QuestionID,
+		&item.QuestionHash,
+		&item.AIPlatformID,
+		&item.CollectorType,
+		&item.RunMode,
+		&item.BusinessDate,
+		&item.Status,
+		&item.LeaseTokenHash,
+		&item.LeasedToExecutor,
+		&item.LeaseExpiresAt,
+		&item.CompletedAt,
+		&item.SkipReason,
+		&item.TriggerSource,
+		&item.QuestionText,
+	); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrNotFound(40441, "monitoring_task_not_found", "monitoring task not found")
+		}
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load monitoring task")
+	}
+
+	return item, nil
+}
+
+func (s *MonitoringCallbackService) loadCollectTaskByID(ctx context.Context, taskID int64) (*monitoringCollectTask, error) {
+	item := &monitoringCollectTask{}
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			id,
+			tenant_id,
+			brand_id,
+			question_id,
+			question_hash,
+			ai_platform_id,
+			collector_type,
+			run_mode,
+			business_date,
+			status,
+			lease_token_hash,
+			leased_to_executor,
+			lease_expires_at,
+			completed_at,
+			skip_reason,
+			trigger_source,
+			COALESCE((
+				SELECT question_text_snapshot
+				FROM monitoring_question_config_snapshots
+				WHERE tenant_id = t.tenant_id
+				  AND brand_id = t.brand_id
+				  AND question_id = t.question_id
+				  AND question_hash = t.question_hash
+				  AND deleted_at IS NULL
+				ORDER BY projected_at DESC, id DESC
+				LIMIT 1
+			), '') AS question_text_snapshot
+		FROM monitoring_collect_tasks t
+		WHERE id = $1
+	`, taskID).Scan(
+		&item.ID,
+		&item.TenantID,
+		&item.BrandID,
+		&item.QuestionID,
+		&item.QuestionHash,
+		&item.AIPlatformID,
+		&item.CollectorType,
+		&item.RunMode,
+		&item.BusinessDate,
+		&item.Status,
+		&item.LeaseTokenHash,
+		&item.LeasedToExecutor,
+		&item.LeaseExpiresAt,
+		&item.CompletedAt,
+		&item.SkipReason,
+		&item.TriggerSource,
+		&item.QuestionText,
+	); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrNotFound(40441, "monitoring_task_not_found", "monitoring task not found")
+		}
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load monitoring task")
+	}
+
+	return item, nil
+}
+
+func (s *MonitoringCallbackService) selectPendingLeaseTasks(
+	ctx context.Context,
+	tx pgx.Tx,
+	tenantID int64,
+	businessDate string,
+	limit int,
+	eligiblePlatformIDs []string,
+) ([]monitoringLeasedTaskRow, error) {
+	queryArgs := []interface{}{tenantID, monitoringCollectorType, businessDate, limit}
+	query := `
+			SELECT
+				t.id,
+			t.brand_id,
+			t.question_id,
+			t.question_hash,
+			t.ai_platform_id,
+			t.collector_type,
+			t.run_mode,
+			t.trigger_source,
+			t.business_date,
+			COALESCE((
+				SELECT question_text_snapshot
+				FROM monitoring_question_config_snapshots
+				WHERE tenant_id = t.tenant_id
+				  AND brand_id = t.brand_id
+				  AND question_id = t.question_id
+				  AND question_hash = t.question_hash
+				  AND deleted_at IS NULL
+				ORDER BY projected_at DESC, id DESC
+				LIMIT 1
+			), '') AS question_text_snapshot
+			FROM monitoring_collect_tasks t
+			WHERE t.tenant_id = $1
+			  AND t.collector_type = $2
+			  AND t.status = 'pending'
+			  AND t.business_date = $3::date
+			  AND EXISTS (
+				SELECT 1
+				FROM monitoring_question_config_snapshots s
+				WHERE s.tenant_id = t.tenant_id
+				  AND s.brand_id = t.brand_id
+				  AND s.question_id = t.question_id
+				  AND s.question_hash = t.question_hash
+				  AND s.monitor_enabled = TRUE
+				  AND s.deleted_at IS NULL
+				  AND s.superseded_at IS NULL
+			  )
+		`
+	if len(eligiblePlatformIDs) > 0 {
+		query += `
+		  AND t.ai_platform_id = ANY($5::text[])
+		`
+		queryArgs = append(queryArgs, eligiblePlatformIDs)
+	}
+	query += `
+		ORDER BY t.planned_at ASC, t.id ASC
+		FOR UPDATE SKIP LOCKED
+		LIMIT $4
+	`
+
+	rows, err := tx.Query(ctx, query, queryArgs...)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "lease_query_failed", "failed to select monitoring lease tasks")
+	}
+	defer rows.Close()
+
+	result := make([]monitoringLeasedTaskRow, 0, limit)
+	for rows.Next() {
+		var item monitoringLeasedTaskRow
+		if scanErr := rows.Scan(
+			&item.ID,
+			&item.BrandID,
+			&item.QuestionID,
+			&item.QuestionHash,
+			&item.AIPlatformID,
+			&item.CollectorType,
+			&item.RunMode,
+			&item.TriggerSource,
+			&item.BusinessDate,
+			&item.QuestionText,
+		); scanErr != nil {
+			return nil, response.ErrInternal(50041, "lease_scan_failed", "failed to parse monitoring lease task")
+		}
+		result = append(result, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50041, "lease_scan_failed", "failed to iterate monitoring lease tasks")
+	}
+
+	return result, nil
+}
+
+func (s *MonitoringCallbackService) selectLeasedTasksForInstallation(
+	ctx context.Context,
+	tx pgx.Tx,
+	tenantID, installationID int64,
+	businessDate string,
+	eligiblePlatformIDs []string,
+) ([]monitoringLeasedTaskRow, error) {
+	queryArgs := []interface{}{tenantID, monitoringCollectorType, businessDate, strconv.FormatInt(installationID, 10)}
+	query := `
+			SELECT
+				t.id,
+			t.brand_id,
+			t.question_id,
+			t.question_hash,
+			t.ai_platform_id,
+			t.collector_type,
+			t.run_mode,
+			t.trigger_source,
+			t.business_date,
+			COALESCE((
+				SELECT question_text_snapshot
+				FROM monitoring_question_config_snapshots
+				WHERE tenant_id = t.tenant_id
+				  AND brand_id = t.brand_id
+				  AND question_id = t.question_id
+				  AND question_hash = t.question_hash
+				  AND deleted_at IS NULL
+				ORDER BY projected_at DESC, id DESC
+				LIMIT 1
+			), '') AS question_text_snapshot
+			FROM monitoring_collect_tasks t
+			WHERE t.tenant_id = $1
+			  AND t.collector_type = $2
+			  AND t.status = 'leased'
+			  AND t.business_date = $3::date
+			  AND t.leased_to_executor = $4
+			  AND EXISTS (
+				SELECT 1
+				FROM monitoring_question_config_snapshots s
+				WHERE s.tenant_id = t.tenant_id
+				  AND s.brand_id = t.brand_id
+				  AND s.question_id = t.question_id
+				  AND s.question_hash = t.question_hash
+				  AND s.monitor_enabled = TRUE
+				  AND s.deleted_at IS NULL
+				  AND s.superseded_at IS NULL
+			  )
+		`
+	if len(eligiblePlatformIDs) > 0 {
+		query += `
+		  AND t.ai_platform_id = ANY($5::text[])
+		`
+		queryArgs = append(queryArgs, eligiblePlatformIDs)
+	}
+	query += `
+		ORDER BY t.leased_at ASC NULLS LAST, t.planned_at ASC, t.id ASC
+		FOR UPDATE SKIP LOCKED
+	`
+
+	rows, err := tx.Query(ctx, query, queryArgs...)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "resume_query_failed", "failed to select monitoring resumed tasks")
+	}
+	defer rows.Close()
+
+	result := make([]monitoringLeasedTaskRow, 0)
+	for rows.Next() {
+		var item monitoringLeasedTaskRow
+		if scanErr := rows.Scan(
+			&item.ID,
+			&item.BrandID,
+			&item.QuestionID,
+			&item.QuestionHash,
+			&item.AIPlatformID,
+			&item.CollectorType,
+			&item.RunMode,
+			&item.TriggerSource,
+			&item.BusinessDate,
+			&item.QuestionText,
+		); scanErr != nil {
+			return nil, response.ErrInternal(50041, "resume_scan_failed", "failed to parse monitoring resumed task")
+		}
+		result = append(result, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50041, "resume_scan_failed", "failed to iterate monitoring resumed tasks")
+	}
+
+	return result, nil
+}
+
+func (s *MonitoringCallbackService) markTaskLeased(ctx context.Context, tx pgx.Tx, installationID, taskID int64, leaseToken string, leasedAt, leaseExpiresAt time.Time) error {
+	if _, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = 'leased',
+		    lease_token_hash = $2,
+		    leased_to_executor = $3,
+		    leased_at = $4,
+		    lease_expires_at = $5,
+		    skip_reason = NULL,
+		    error_message = NULL,
+		    updated_at = NOW()
+		WHERE id = $1
+	`, taskID, sharedauth.HashToken(strings.TrimSpace(leaseToken)), strconv.FormatInt(installationID, 10), leasedAt, leaseExpiresAt); err != nil {
+		return response.ErrInternal(50041, "lease_update_failed", "failed to update monitoring lease task")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) markTaskResultReceived(ctx context.Context, tx pgx.Tx, taskID int64, receivedAt time.Time, requestPayloadJSON []byte) error {
+	if _, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = 'received',
+		    callback_received_at = $2,
+		    completed_at = NULL,
+		    skip_reason = NULL,
+		    error_message = NULL,
+		    request_payload_json = (
+				CASE
+					WHEN request_payload_json IS NULL OR jsonb_typeof(request_payload_json) <> 'object'
+						THEN '{}'::jsonb
+					ELSE request_payload_json
+				END
+			) || $3::jsonb,
+		    updated_at = NOW()
+		WHERE id = $1
+	`, taskID, receivedAt, requestPayloadJSON); err != nil {
+		return response.ErrInternal(50041, "task_receive_failed", "failed to persist monitoring callback payload")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) upsertPlatformAccessSnapshot(ctx context.Context, tx pgx.Tx, installation *monitoringInstallationIdentity, businessDate string, platform MonitoringHeartbeatPlatform) (bool, error) {
+	previous, err := s.loadPlatformAccessSnapshotState(ctx, tx, installation.TenantID, installation.ID, businessDate, platform.AIPlatformID)
+	if err != nil {
+		return false, err
+	}
+
+	nextState := monitoringPlatformAccessSnapshotState{
+		AccessStatus:  monitoringStringValue(platform.AccessStatus),
+		Connected:     derefBool(platform.Connected),
+		Accessible:    derefBool(platform.Accessible),
+		ReasonCode:    optionalString(monitoringStringValue(platform.ReasonCode)),
+		ReasonMessage: optionalString(monitoringStringValue(platform.ReasonMessage)),
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO monitoring_platform_access_snapshots (
+			tenant_id, installation_id, ai_platform_id, business_date, access_status,
+			connected, accessible, detected_at, reason_code, reason_message
+		)
+		VALUES ($1, $2, $3, $4::date, $5, $6, $7, $8, $9, $10)
+		ON CONFLICT (tenant_id, installation_id, ai_platform_id, business_date)
+		DO UPDATE SET
+			access_status = EXCLUDED.access_status,
+			connected = EXCLUDED.connected,
+			accessible = EXCLUDED.accessible,
+			detected_at = EXCLUDED.detected_at,
+			reason_code = EXCLUDED.reason_code,
+			reason_message = EXCLUDED.reason_message,
+			updated_at = NOW()
+	`,
+		installation.TenantID,
+		installation.ID,
+		platform.AIPlatformID,
+		businessDate,
+		platform.AccessStatus,
+		derefBool(platform.Connected),
+		derefBool(platform.Accessible),
+		resolveHeartbeatDetectedAt(platform.DetectedAt),
+		nullableString(platform.ReasonCode),
+		nullableString(platform.ReasonMessage),
+	); err != nil {
+		return false, response.ErrInternal(50041, "access_snapshot_upsert_failed", "failed to persist monitoring platform access snapshot")
+	}
+	return hasPlatformAccessSnapshotChanged(previous, nextState), nil
+}
+
+func (s *MonitoringCallbackService) loadPlatformAccessSnapshotState(ctx context.Context, tx pgx.Tx, tenantID, installationID int64, businessDate, aiPlatformID string) (*monitoringPlatformAccessSnapshotState, error) {
+	item := &monitoringPlatformAccessSnapshotState{}
+	var reasonCode sql.NullString
+	var reasonMessage sql.NullString
+	if err := tx.QueryRow(ctx, `
+		SELECT access_status, connected, accessible, reason_code, reason_message
+		FROM monitoring_platform_access_snapshots
+		WHERE tenant_id = $1
+		  AND installation_id = $2
+		  AND ai_platform_id = $3
+		  AND business_date = $4::date
+	`, tenantID, installationID, aiPlatformID, businessDate).Scan(
+		&item.AccessStatus,
+		&item.Connected,
+		&item.Accessible,
+		&reasonCode,
+		&reasonMessage,
+	); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, nil
+		}
+		return nil, response.ErrInternal(50041, "access_snapshot_lookup_failed", "failed to inspect monitoring platform access snapshot")
+	}
+	item.ReasonCode = optionalString(reasonCode.String)
+	item.ReasonMessage = optionalString(reasonMessage.String)
+	return item, nil
+}
+
+func hasPlatformAccessSnapshotChanged(previous *monitoringPlatformAccessSnapshotState, next monitoringPlatformAccessSnapshotState) bool {
+	if previous == nil {
+		return true
+	}
+
+	if previous.AccessStatus != next.AccessStatus ||
+		previous.Connected != next.Connected ||
+		previous.Accessible != next.Accessible {
+		return true
+	}
+	if monitoringStringValue(previous.ReasonCode) != monitoringStringValue(next.ReasonCode) {
+		return true
+	}
+	if monitoringStringValue(previous.ReasonMessage) != monitoringStringValue(next.ReasonMessage) {
+		return true
+	}
+
+	return false
+}
+
+func (s *MonitoringCallbackService) reconcilePendingTasksForPlatform(ctx context.Context, tx pgx.Tx, tenantID int64, businessDate, aiPlatformID string) (int64, error) {
+	tag, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = 'skipped',
+		    skip_reason = 'platform_not_accessible',
+		    error_message = 'platform heartbeat reported not accessible',
+		    completed_at = NOW(),
+		    updated_at = NOW()
+		WHERE tenant_id = $1
+		  AND ai_platform_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND status = 'pending'
+	`, tenantID, aiPlatformID, monitoringCollectorType, businessDate)
+	if err != nil {
+		return 0, response.ErrInternal(50041, "task_reconcile_failed", "failed to reconcile pending monitoring tasks")
+	}
+	return tag.RowsAffected(), nil
+}
+
+func (s *MonitoringCallbackService) upsertRun(ctx context.Context, tx pgx.Tx, task *monitoringCollectTask, req MonitoringTaskResultRequest, runStatus string, completedAt time.Time, rawPayload []byte) (int64, error) {
+	var runID int64
+	if err := tx.QueryRow(ctx, `
+		INSERT INTO question_monitor_runs (
+			tenant_id, brand_id, question_id, question_text_snapshot, question_hash,
+			ai_platform_id, collector_type, trigger_source, run_mode, business_date,
+			provider_model, provider_request_id, request_id, raw_answer_text, raw_response_json,
+			status, completed_at
+		)
+		VALUES (
+			$1, $2, $3, $4, $5,
+			$6, $7, $8, $9, $10::date,
+			$11, $12, $13, $14, $15,
+			$16, $17
+		)
+		ON CONFLICT (
+			tenant_id, brand_id, question_id, ai_platform_id, collector_type, run_mode, business_date
+		)
+		DO UPDATE SET
+			question_text_snapshot = EXCLUDED.question_text_snapshot,
+			question_hash = EXCLUDED.question_hash,
+			provider_model = EXCLUDED.provider_model,
+			provider_request_id = EXCLUDED.provider_request_id,
+			request_id = EXCLUDED.request_id,
+			raw_answer_text = EXCLUDED.raw_answer_text,
+			raw_response_json = EXCLUDED.raw_response_json,
+			status = EXCLUDED.status,
+			completed_at = EXCLUDED.completed_at,
+			updated_at = NOW()
+		RETURNING id
+	`,
+		task.TenantID,
+		task.BrandID,
+		task.QuestionID,
+		task.QuestionText,
+		task.QuestionHash,
+		task.AIPlatformID,
+		task.CollectorType,
+		task.TriggerSource,
+		task.RunMode,
+		task.BusinessDate.Format("2006-01-02"),
+		nullableString(req.ProviderModel),
+		nullableString(req.ProviderRequestID),
+		nullableString(req.RequestID),
+		nullableString(req.Answer),
+		rawPayload,
+		runStatus,
+		completedAt,
+	).Scan(&runID); err != nil {
+		return 0, response.ErrInternal(50041, "run_upsert_failed", "failed to persist monitoring run")
+	}
+	return runID, nil
+}
+
+func (s *MonitoringCallbackService) upsertParseResult(ctx context.Context, tx pgx.Tx, task *monitoringCollectTask, runID int64, req MonitoringTaskResultRequest, parseVersion string) error {
+	matchedTermsJSON, err := json.Marshal(req.MatchedBrandTerms)
+	if err != nil {
+		return response.ErrInternal(50041, "parse_payload_failed", "failed to encode matched brand terms")
+	}
+	if strings.TrimSpace(parseVersion) == "" {
+		parseVersion = "server_heuristic_v1"
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO question_monitor_parse_results (
+			tenant_id, run_id, brand_id, question_id, question_hash, ai_platform_id, business_date,
+			brand_mentioned, brand_mention_position, first_recommended, sentiment_label, matched_brand_terms,
+			parse_version, parse_status
+		)
+		VALUES (
+			$1, $2, $3, $4, $5, $6, $7::date,
+			$8, $9, $10, $11, $12,
+			$13, 'succeeded'
+		)
+		ON CONFLICT (tenant_id, run_id)
+		DO UPDATE SET
+			brand_mentioned = EXCLUDED.brand_mentioned,
+			brand_mention_position = EXCLUDED.brand_mention_position,
+			first_recommended = EXCLUDED.first_recommended,
+			sentiment_label = EXCLUDED.sentiment_label,
+			matched_brand_terms = EXCLUDED.matched_brand_terms,
+			parse_version = EXCLUDED.parse_version,
+			parse_status = EXCLUDED.parse_status,
+			updated_at = NOW()
+	`,
+		task.TenantID,
+		runID,
+		task.BrandID,
+		task.QuestionID,
+		task.QuestionHash,
+		task.AIPlatformID,
+		task.BusinessDate.Format("2006-01-02"),
+		nullableBool(req.BrandMentioned),
+		nullableString(req.BrandMentionPosition),
+		nullableBool(req.FirstRecommended),
+		nullableString(req.SentimentLabel),
+		matchedTermsJSON,
+		parseVersion,
+	); err != nil {
+		return response.ErrInternal(50041, "parse_result_upsert_failed", "failed to persist parse result")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) processTaskResult(ctx context.Context, task *monitoringCollectTask, req MonitoringTaskResultRequest) (*MonitoringTaskResultResponse, error) {
+	runStatus := normalizeRunStatus(req.Status)
+	if runStatus == "" {
+		return nil, response.ErrBadRequest(40041, "invalid_status", "status must be succeeded or failed")
+	}
+
+	parseReq := req
+	parseVersion := ""
+	if runStatus == "succeeded" {
+		var enrichErr error
+		parseReq, parseVersion, enrichErr = s.enrichMonitoringParsePayload(ctx, task, req)
+		if enrichErr != nil {
+			return nil, enrichErr
+		}
+	}
+
+	completedAt := time.Now().UTC().Round(0)
+	if req.CompletedAt != nil && !req.CompletedAt.IsZero() {
+		completedAt = req.CompletedAt.UTC().Round(0)
+	}
+
+	rawPayload, sourceInputs := buildMonitoringRawPayload(req)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring result ingest")
+	}
+	defer tx.Rollback(ctx)
+
+	runID, err := s.upsertRun(ctx, tx, task, req, runStatus, completedAt, rawPayload)
+	if err != nil {
+		return nil, err
+	}
+
+	if runStatus == "succeeded" {
+		if err := s.upsertParseResult(ctx, tx, task, runID, parseReq, parseVersion); err != nil {
+			return nil, err
+		}
+	}
+
+	citationSourceCount := 0
+	contentCitationCount := 0
+	if err := s.replaceCitationFacts(ctx, tx, task.TenantID, runID); err != nil {
+		return nil, err
+	}
+	if runStatus == "succeeded" {
+		facts, buildErr := s.buildCitationFacts(ctx, tx, task.TenantID, sourceInputs)
+		if buildErr != nil {
+			return nil, buildErr
+		}
+		for _, fact := range facts {
+			if err := s.insertCitationFact(ctx, tx, task, runID, fact); err != nil {
+				return nil, err
+			}
+			citationSourceCount++
+			if fact.ArticleID != nil {
+				contentCitationCount++
+			}
+		}
+	}
+
+	taskStatus := "completed"
+	if runStatus == "failed" {
+		taskStatus = "failed"
+	}
+	if err := s.updateCollectTaskStatus(ctx, tx, task.ID, taskStatus, completedAt, req.ErrorMessage); err != nil {
+		return nil, err
+	}
+
+	if err := s.rebuildBrandDailyProjection(ctx, tx, task.TenantID, task.BrandID, task.BusinessDate); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring result ingest")
+	}
+
+	return &MonitoringTaskResultResponse{
+		TaskID:               task.ID,
+		RunID:                &runID,
+		TaskStatus:           taskStatus,
+		CitationSourceCount:  citationSourceCount,
+		ContentCitationCount: contentCitationCount,
+	}, nil
+}
+
+func (s *MonitoringCallbackService) replaceCitationFacts(ctx context.Context, tx pgx.Tx, tenantID, runID int64) error {
+	if _, err := tx.Exec(ctx, `
+		DELETE FROM monitoring_citation_facts
+		WHERE tenant_id = $1 AND run_id = $2
+	`, tenantID, runID); err != nil {
+		return response.ErrInternal(50041, "citation_cleanup_failed", "failed to reset existing citation facts")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) loadMonitoringBrandName(ctx context.Context, tenantID, brandID int64) (string, error) {
+	var brandName string
+	if err := s.businessPool.QueryRow(ctx, `
+		SELECT name
+		FROM brands
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND deleted_at IS NULL
+	`, brandID, tenantID).Scan(&brandName); err != nil {
+		if err == pgx.ErrNoRows {
+			return "", response.ErrInternal(50041, "brand_lookup_failed", "failed to resolve monitoring brand")
+		}
+		return "", response.ErrInternal(50041, "brand_lookup_failed", "failed to resolve monitoring brand")
+	}
+	return strings.TrimSpace(brandName), nil
+}
+
+func (s *MonitoringCallbackService) enrichMonitoringParsePayload(ctx context.Context, task *monitoringCollectTask, req MonitoringTaskResultRequest) (MonitoringTaskResultRequest, string, error) {
+	brandName, err := s.loadMonitoringBrandName(ctx, task.TenantID, task.BrandID)
+	if err != nil {
+		return req, "", err
+	}
+
+	answer := monitoringStringValue(req.Answer)
+	stored := buildMonitoringStoredParseFields(req)
+	summary := resolveMonitoringAnswerParseSummary(answer, brandName, stored)
+	parseVersion := resolveMonitoringParseVersion(req)
+
+	if shouldUseMonitoringLLMParse(req) && strings.TrimSpace(answer) != "" && s.llm != nil && s.llm.Validate() == nil {
+		llmSummary, llmErr := parseMonitoringAnswerWithLLM(ctx, s.llm, answer, brandName)
+		if llmErr != nil {
+			if s.logger != nil {
+				s.logger.Warn("monitoring answer llm parse failed",
+					zap.Int64("task_id", task.ID),
+					zap.Int64("tenant_id", task.TenantID),
+					zap.Int64("brand_id", task.BrandID),
+					zap.Int64("question_id", task.QuestionID),
+					zap.String("ai_platform_id", task.AIPlatformID),
+					zap.Error(llmErr),
+				)
+			}
+		} else {
+			summary = overlayMonitoringStoredParseSummary(llmSummary, stored)
+			if !hasMonitoringParsePayload(req) {
+				parseVersion = "server_llm_v1"
+			}
+		}
+	}
+
+	enriched := req
+	enriched.BrandMentioned = monitoringBoolPointer(summary.BrandMentioned)
+	enriched.BrandMentionPosition = optionalString(summary.BrandMentionPosition)
+	enriched.FirstRecommended = monitoringBoolPointer(summary.FirstRecommended)
+	enriched.SentimentLabel = optionalString(summary.SentimentLabel)
+	enriched.MatchedBrandTerms = append([]string(nil), summary.MatchedBrandTerms...)
+	return enriched, parseVersion, nil
+}
+
+func buildMonitoringStoredParseFields(req MonitoringTaskResultRequest) monitoringStoredParseFields {
+	return monitoringStoredParseFields{
+		BrandMentioned:       cloneBool(req.BrandMentioned),
+		BrandMentionPosition: cloneString(req.BrandMentionPosition),
+		FirstRecommended:     cloneBool(req.FirstRecommended),
+		SentimentLabel:       cloneString(req.SentimentLabel),
+		MatchedBrandTerms:    append([]string(nil), req.MatchedBrandTerms...),
+	}
+}
+
+func resolveMonitoringParseVersion(req MonitoringTaskResultRequest) string {
+	if hasMonitoringParsePayload(req) {
+		return "plugin_v1"
+	}
+	return "server_heuristic_v1"
+}
+
+func shouldUseMonitoringLLMParse(req MonitoringTaskResultRequest) bool {
+	return !hasCompleteMonitoringParsePayload(req)
+}
+
+func (s *MonitoringCallbackService) buildCitationFacts(ctx context.Context, tx pgx.Tx, tenantID int64, inputs []MonitoringSourceItem) ([]monitoringCitationFact, error) {
+	if len(inputs) == 0 {
+		return nil, nil
+	}
+
+	normalizedURLs := make([]string, 0, len(inputs))
+	seenURLs := make(map[string]struct{}, len(inputs))
+	for _, item := range inputs {
+		key := strings.TrimSpace(monitoringStringValue(item.NormalizedURL))
+		if key == "" {
+			key = normalizeCitationURL(item.URL)
+		}
+		if key == "" {
+			continue
+		}
+		if _, ok := seenURLs[key]; ok {
+			continue
+		}
+		seenURLs[key] = struct{}{}
+		normalizedURLs = append(normalizedURLs, key)
+	}
+
+	aliasMap, err := s.loadAliasResolutions(ctx, tx, tenantID, normalizedURLs)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]monitoringCitationFact, 0, len(inputs))
+	seenFacts := make(map[string]struct{}, len(inputs))
+	for _, input := range inputs {
+		fact, ok := buildMonitoringCitationFact(input, aliasMap)
+		if !ok {
+			continue
+		}
+
+		dedupKey := fact.NormalizedURL + "|" + strconv.FormatInt(derefInt64(fact.ArticleID), 10) + "|" + strconv.FormatInt(derefInt64(fact.PublishRecordID), 10)
+		if _, exists := seenFacts[dedupKey]; exists {
+			continue
+		}
+		seenFacts[dedupKey] = struct{}{}
+		result = append(result, fact)
+	}
+
+	return result, nil
+}
+
+func (s *MonitoringCallbackService) loadAliasResolutions(ctx context.Context, tx pgx.Tx, tenantID int64, normalizedURLs []string) (map[string]monitoringAliasResolution, error) {
+	result := make(map[string]monitoringAliasResolution)
+	if len(normalizedURLs) == 0 {
+		return result, nil
+	}
+
+	rows, err := tx.Query(ctx, `
+		SELECT normalized_url, article_id, publish_record_id
+		FROM monitoring_article_url_aliases
+		WHERE tenant_id = $1
+		  AND normalized_url = ANY($2)
+	`, tenantID, normalizedURLs)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "alias_lookup_failed", "failed to resolve article aliases")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var normalizedURL string
+		var articleID sql.NullInt64
+		var publishRecordID sql.NullInt64
+		if scanErr := rows.Scan(&normalizedURL, &articleID, &publishRecordID); scanErr != nil {
+			return nil, response.ErrInternal(50041, "alias_scan_failed", "failed to parse article alias resolution")
+		}
+		result[normalizedURL] = monitoringAliasResolution{
+			ArticleID:        nullableInt64Value(articleID),
+			PublishRecordID:  nullableInt64Value(publishRecordID),
+			NormalizedURLKey: normalizedURL,
+		}
+	}
+
+	return result, nil
+}
+
+func (s *MonitoringCallbackService) insertCitationFact(ctx context.Context, tx pgx.Tx, task *monitoringCollectTask, runID int64, fact monitoringCitationFact) error {
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO monitoring_citation_facts (
+			tenant_id, run_id, brand_id, ai_platform_id, business_date,
+			cited_url, cited_title, normalized_url, host, registrable_domain,
+			subdomain, suffix, site_key, article_id, publish_record_id,
+			resolution_status, resolution_confidence
+		)
+		VALUES (
+			$1, $2, $3, $4, $5::date,
+			$6, $7, $8, $9, $10,
+			$11, $12, $13, $14, $15,
+			$16, $17
+		)
+	`,
+		task.TenantID,
+		runID,
+		task.BrandID,
+		task.AIPlatformID,
+		task.BusinessDate.Format("2006-01-02"),
+		fact.CitedURL,
+		nullableString(fact.CitedTitle),
+		fact.NormalizedURL,
+		fact.Host,
+		fact.RegistrableDomain,
+		nullableString(fact.Subdomain),
+		nullableString(fact.Suffix),
+		fact.SiteKey,
+		nullableInt64(fact.ArticleID),
+		nullableInt64(fact.PublishRecordID),
+		fact.ResolutionStatus,
+		fact.ResolutionConfidence,
+	); err != nil {
+		return response.ErrInternal(50041, "citation_insert_failed", "failed to persist citation facts")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) updateCollectTaskStatus(ctx context.Context, tx pgx.Tx, taskID int64, status string, completedAt time.Time, errorMessage *string) error {
+	if _, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = $2,
+		    callback_received_at = NOW(),
+		    completed_at = $3,
+		    error_message = $4,
+		    updated_at = NOW()
+		WHERE id = $1
+	`, taskID, status, completedAt, nullableString(errorMessage)); err != nil {
+		return response.ErrInternal(50041, "task_update_failed", "failed to update monitoring task status")
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) loadExistingRunSummary(ctx context.Context, task *monitoringCollectTask) (*int64, int, int, error) {
+	var runID sql.NullInt64
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT id
+		FROM question_monitor_runs
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND question_id = $3
+		  AND ai_platform_id = $4
+		  AND collector_type = $5
+		  AND run_mode = $6
+		  AND business_date = $7::date
+		LIMIT 1
+	`,
+		task.TenantID,
+		task.BrandID,
+		task.QuestionID,
+		task.AIPlatformID,
+		task.CollectorType,
+		task.RunMode,
+		task.BusinessDate.Format("2006-01-02"),
+	).Scan(&runID); err != nil && err != pgx.ErrNoRows {
+		return nil, 0, 0, response.ErrInternal(50041, "run_lookup_failed", "failed to inspect existing monitoring run")
+	}
+
+	if !runID.Valid {
+		return nil, 0, 0, nil
+	}
+
+	var citationSourceCount int
+	var contentCitationCount int
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			COUNT(*)::int AS citation_source_count,
+			COUNT(*) FILTER (WHERE article_id IS NOT NULL)::int AS content_citation_count
+		FROM monitoring_citation_facts
+		WHERE tenant_id = $1
+		  AND run_id = $2
+	`, task.TenantID, runID.Int64).Scan(&citationSourceCount, &contentCitationCount); err != nil {
+		return nil, 0, 0, response.ErrInternal(50041, "citation_lookup_failed", "failed to inspect existing citation facts")
+	}
+
+	value := runID.Int64
+	return &value, citationSourceCount, contentCitationCount, nil
+}
+
+func (s *MonitoringCallbackService) touchInstallation(ctx context.Context, installationID int64) error {
+	_, err := s.businessPool.Exec(ctx, `
+		UPDATE plugin_installations
+		SET last_seen_at = NOW(), updated_at = NOW()
+		WHERE id = $1
+	`, installationID)
+	return err
+}
+
+func (s *MonitoringCallbackService) publishTaskResultEnvelope(ctx context.Context, payload []byte) error {
+	if s == nil || s.rabbitMQ == nil {
+		return response.ErrServiceUnavailable(50341, "monitoring_result_queue_unavailable", "rabbitmq client is not configured")
+	}
+	if err := s.rabbitMQ.PublishMonitorResultIngest(ctx, payload); err != nil {
+		return response.ErrServiceUnavailable(50341, "monitoring_result_queue_unavailable", err.Error())
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) tryPatchTaskResultQueueMeta(taskID int64, receivedAt time.Time, patch monitoringTaskResultQueueMetaPatch) {
+	if s == nil || s.monitoringPool == nil {
+		return
+	}
+
+	patchJSON, err := json.Marshal(patch)
+	if err != nil {
+		if s.logger != nil {
+			s.logger.Warn("monitoring queue metadata patch encode failed", zap.Error(err), zap.Int64("task_id", taskID))
+		}
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), monitoringTaskResultQueueIOTimeout)
+	defer cancel()
+
+	if _, err := s.monitoringPool.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET request_payload_json = (
+				CASE
+					WHEN request_payload_json IS NULL OR jsonb_typeof(request_payload_json) <> 'object'
+						THEN '{}'::jsonb
+					ELSE request_payload_json
+				END
+			) || $3::jsonb,
+			updated_at = NOW()
+		WHERE id = $1
+		  AND callback_received_at = $2
+	`, taskID, receivedAt, patchJSON); err != nil && s.logger != nil {
+		s.logger.Warn("monitoring queue metadata patch failed", zap.Error(err), zap.Int64("task_id", taskID))
+	}
+}
+
+func buildMonitoringRawPayload(req MonitoringTaskResultRequest) ([]byte, []MonitoringSourceItem) {
+	payload := make(map[string]interface{}, len(req.RawResponseJSON)+4)
+	for key, value := range req.RawResponseJSON {
+		payload[key] = value
+	}
+
+	if _, ok := payload["answer"]; !ok && req.Answer != nil {
+		payload["answer"] = strings.TrimSpace(*req.Answer)
+	}
+	if _, ok := payload["citations"]; !ok && len(req.Citations) > 0 {
+		payload["citations"] = req.Citations
+	}
+	if _, ok := payload["search_results"]; !ok && len(req.SearchResults) > 0 {
+		payload["search_results"] = req.SearchResults
+	}
+	if _, ok := payload["status"]; !ok && strings.TrimSpace(req.Status) != "" {
+		payload["status"] = strings.TrimSpace(req.Status)
+	}
+
+	sourceInputs := append([]MonitoringSourceItem{}, req.Citations...)
+	sourceInputs = append(sourceInputs, req.SearchResults...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["citations"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["references"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["sources"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["thought_references"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["thinking_references"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["search_results"])...)
+	sourceInputs = append(sourceInputs, extractMonitoringSourceItems(payload["searchResults"])...)
+
+	if len(payload) == 0 {
+		return nil, sourceInputs
+	}
+
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return nil, sourceInputs
+	}
+	return data, sourceInputs
+}
+
+func newMonitoringTaskResultEnvelope(task *monitoringCollectTask, installationID int64, receivedAt time.Time, req MonitoringTaskResultRequest) monitoringTaskResultEnvelope {
+	return monitoringTaskResultEnvelope{
+		Version:               "v1",
+		TaskID:                task.ID,
+		TenantID:              task.TenantID,
+		InstallationID:        installationID,
+		ReceivedAt:            receivedAt,
+		QueueStatus:           "pending",
+		QueueClaimedAt:        nil,
+		QueueEnqueuedAt:       nil,
+		LastQueuePublishError: nil,
+		ReceivedAlertedAt:     nil,
+		ReceivedAlertCount:    0,
+		CallbackResult:        req,
+	}
+}
+
+func extractMonitoringSourceItems(value interface{}) []MonitoringSourceItem {
+	items, ok := value.([]interface{})
+	if !ok {
+		return nil
+	}
+
+	result := make([]MonitoringSourceItem, 0, len(items))
+	for _, item := range items {
+		switch typed := item.(type) {
+		case string:
+			if strings.TrimSpace(typed) == "" {
+				continue
+			}
+			result = append(result, MonitoringSourceItem{URL: typed})
+		case map[string]interface{}:
+			entry := MonitoringSourceItem{
+				URL:                  firstString(typed, "url", "cited_url", "link"),
+				Title:                optionalString(firstString(typed, "title", "cited_title", "name")),
+				SiteName:             optionalString(firstString(typed, "site_name")),
+				SiteKey:              optionalString(firstString(typed, "site_key")),
+				NormalizedURL:        optionalString(firstString(typed, "normalized_url")),
+				Host:                 optionalString(firstString(typed, "host")),
+				RegistrableDomain:    optionalString(firstString(typed, "registrable_domain")),
+				Subdomain:            optionalString(firstString(typed, "subdomain")),
+				Suffix:               optionalString(firstString(typed, "suffix")),
+				ResolutionStatus:     optionalString(firstString(typed, "resolution_status")),
+				ResolutionConfidence: optionalString(firstString(typed, "resolution_confidence")),
+			}
+			if articleID := firstInt64(typed, "article_id"); articleID != nil {
+				entry.ArticleID = articleID
+			}
+			if publishRecordID := firstInt64(typed, "publish_record_id"); publishRecordID != nil {
+				entry.PublishRecordID = publishRecordID
+			}
+			result = append(result, entry)
+		}
+	}
+
+	return result
+}
+
+func buildMonitoringCitationFact(input MonitoringSourceItem, aliasMap map[string]monitoringAliasResolution) (monitoringCitationFact, bool) {
+	rawURL := strings.TrimSpace(input.URL)
+	normalizedURL := strings.TrimSpace(monitoringStringValue(input.NormalizedURL))
+	if normalizedURL == "" {
+		normalizedURL = normalizeCitationURL(rawURL)
+	}
+
+	host := strings.TrimSpace(monitoringStringValue(input.Host))
+	registrableDomain := strings.TrimSpace(monitoringStringValue(input.RegistrableDomain))
+	subdomain := cloneString(input.Subdomain)
+	suffix := cloneString(input.Suffix)
+
+	if parsedHost, parsedRegistrableDomain, parsedSubdomain, parsedSuffix := deriveCitationURLParts(rawURL, normalizedURL); host == "" {
+		host = parsedHost
+		if registrableDomain == "" {
+			registrableDomain = parsedRegistrableDomain
+		}
+		if subdomain == nil && parsedSubdomain != nil {
+			subdomain = parsedSubdomain
+		}
+		if suffix == nil && parsedSuffix != nil {
+			suffix = parsedSuffix
+		}
+	}
+
+	if host == "" {
+		host = strings.TrimSpace(monitoringStringValue(input.SiteKey))
+	}
+	if host == "" {
+		host = registrableDomain
+	}
+	if registrableDomain == "" {
+		registrableDomain = host
+	}
+	if normalizedURL == "" {
+		normalizedURL = strings.TrimSpace(rawURL)
+	}
+	if rawURL == "" {
+		rawURL = normalizedURL
+	}
+
+	if rawURL == "" || normalizedURL == "" || host == "" || registrableDomain == "" {
+		return monitoringCitationFact{}, false
+	}
+
+	siteKey := strings.TrimSpace(monitoringStringValue(input.SiteKey))
+	if siteKey == "" {
+		siteKey = registrableDomain
+	}
+
+	articleID := cloneInt64(input.ArticleID)
+	publishRecordID := cloneInt64(input.PublishRecordID)
+	if alias, ok := aliasMap[normalizedURL]; ok {
+		if articleID == nil {
+			articleID = cloneInt64(alias.ArticleID)
+		}
+		if publishRecordID == nil {
+			publishRecordID = cloneInt64(alias.PublishRecordID)
+		}
+	}
+
+	resolutionStatus := strings.TrimSpace(monitoringStringValue(input.ResolutionStatus))
+	if resolutionStatus == "" {
+		resolutionStatus = "resolved"
+	}
+	resolutionConfidence := strings.TrimSpace(monitoringStringValue(input.ResolutionConfidence))
+	if resolutionConfidence == "" {
+		resolutionConfidence = "high"
+	}
+
+	return monitoringCitationFact{
+		CitedURL:             rawURL,
+		CitedTitle:           cloneString(input.Title),
+		NormalizedURL:        normalizedURL,
+		Host:                 host,
+		RegistrableDomain:    registrableDomain,
+		Subdomain:            subdomain,
+		Suffix:               suffix,
+		SiteKey:              siteKey,
+		ArticleID:            articleID,
+		PublishRecordID:      publishRecordID,
+		ResolutionStatus:     resolutionStatus,
+		ResolutionConfidence: resolutionConfidence,
+	}, true
+}
+
+func normalizeRunStatus(value string) string {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "", "succeeded", "success", "completed":
+		return "succeeded"
+	case "failed", "error":
+		return "failed"
+	default:
+		return ""
+	}
+}
+
+func normalizeMonitoringLeaseLimit(value int) int {
+	if value <= 0 {
+		return defaultMonitoringLeaseLimit
+	}
+	if value > maxMonitoringLeaseLimit {
+		return maxMonitoringLeaseLimit
+	}
+	return value
+}
+
+func normalizeMonitoringLeasePlatformIDs(values []string) []string {
+	if len(values) == 0 {
+		return nil
+	}
+
+	result := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		platformID := strings.TrimSpace(value)
+		if platformID == "" {
+			continue
+		}
+		if _, ok := seen[platformID]; ok {
+			continue
+		}
+		seen[platformID] = struct{}{}
+		result = append(result, platformID)
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+func normalizeHeartbeatPlatforms(items []MonitoringHeartbeatPlatform, fallbackDetectedAt time.Time) ([]MonitoringHeartbeatPlatform, error) {
+	if len(items) == 0 {
+		return nil, nil
+	}
+
+	result := make([]MonitoringHeartbeatPlatform, 0, len(items))
+	seen := make(map[string]struct{}, len(items))
+	for _, item := range items {
+		platformID := strings.TrimSpace(item.AIPlatformID)
+		if platformID == "" {
+			return nil, response.ErrBadRequest(40041, "invalid_platform_status", "ai_platform_id is required")
+		}
+
+		status, connected, accessible, err := normalizeMonitoringAccessStatus(item.AccessStatus, item.Connected, item.Accessible)
+		if err != nil {
+			return nil, err
+		}
+		item.AIPlatformID = platformID
+		item.AccessStatus = &status
+		item.Connected = &connected
+		item.Accessible = &accessible
+		if item.DetectedAt == nil || item.DetectedAt.IsZero() {
+			value := fallbackDetectedAt
+			item.DetectedAt = &value
+		} else {
+			value := item.DetectedAt.UTC()
+			item.DetectedAt = &value
+		}
+		if item.ReasonCode != nil {
+			item.ReasonCode = optionalString(*item.ReasonCode)
+		}
+		if item.ReasonMessage != nil {
+			item.ReasonMessage = optionalString(*item.ReasonMessage)
+		}
+
+		if _, ok := seen[platformID]; ok {
+			continue
+		}
+		seen[platformID] = struct{}{}
+		result = append(result, item)
+	}
+
+	return result, nil
+}
+
+func normalizeMonitoringAccessStatus(accessStatus *string, connected *bool, accessible *bool) (string, bool, bool, error) {
+	if accessStatus != nil {
+		switch strings.ToLower(strings.TrimSpace(*accessStatus)) {
+		case "accessible":
+			return "accessible", true, true, nil
+		case "not_logged_in":
+			return "not_logged_in", false, false, nil
+		case "unavailable":
+			return "unavailable", derefBool(connected), false, nil
+		case "":
+		default:
+			return "", false, false, response.ErrBadRequest(40041, "invalid_access_status", "access_status must be accessible, not_logged_in, or unavailable")
+		}
+	}
+
+	if accessible != nil {
+		if *accessible {
+			return "accessible", true, true, nil
+		}
+		if connected != nil && !*connected {
+			return "not_logged_in", false, false, nil
+		}
+		return "unavailable", derefBool(connected), false, nil
+	}
+
+	if connected != nil {
+		if *connected {
+			return "accessible", true, true, nil
+		}
+		return "not_logged_in", false, false, nil
+	}
+
+	return "", false, false, response.ErrBadRequest(40041, "invalid_access_status", "access status requires access_status, connected, or accessible")
+}
+
+func validateTaskLease(task *monitoringCollectTask, installationID int64, leaseToken string) error {
+	if task.LeasedToExecutor.Valid && strings.TrimSpace(task.LeasedToExecutor.String) != "" && task.LeasedToExecutor.String != strconv.FormatInt(installationID, 10) {
+		return response.ErrUnauthorized(40141, "lease_owner_mismatch", "task is leased to another installation")
+	}
+
+	if strings.TrimSpace(task.LeaseTokenHash.String) == "" {
+		return response.ErrConflict(40941, "lease_token_missing", "task does not have an active lease token")
+	}
+
+	if sharedauth.HashToken(strings.TrimSpace(leaseToken)) != task.LeaseTokenHash.String {
+		return response.ErrUnauthorized(40141, "invalid_lease_token", "lease token is invalid")
+	}
+
+	return nil
+}
+
+func normalizeSkipReason(value *string) string {
+	if value == nil {
+		return "plugin_skipped"
+	}
+	trimmed := strings.TrimSpace(*value)
+	if trimmed == "" {
+		return "plugin_skipped"
+	}
+	return trimmed
+}
+
+func hasMonitoringParsePayload(req MonitoringTaskResultRequest) bool {
+	return req.BrandMentioned != nil ||
+		strings.TrimSpace(monitoringStringValue(req.BrandMentionPosition)) != "" ||
+		req.FirstRecommended != nil ||
+		strings.TrimSpace(monitoringStringValue(req.SentimentLabel)) != "" ||
+		len(req.MatchedBrandTerms) > 0
+}
+
+func hasCompleteMonitoringParsePayload(req MonitoringTaskResultRequest) bool {
+	return req.BrandMentioned != nil &&
+		strings.TrimSpace(monitoringStringValue(req.BrandMentionPosition)) != "" &&
+		req.FirstRecommended != nil &&
+		strings.TrimSpace(monitoringStringValue(req.SentimentLabel)) != "" &&
+		req.MatchedBrandTerms != nil
+}
+
+func normalizeCitationURL(raw string) string {
+	trimmed := strings.TrimSpace(raw)
+	if trimmed == "" {
+		return ""
+	}
+
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return trimmed
+	}
+
+	parsed.Host = strings.ToLower(parsed.Host)
+	parsed.Fragment = ""
+	parsed.RawFragment = ""
+	parsed.RawQuery = ""
+
+	if parsed.Path != "/" {
+		parsed.Path = strings.TrimRight(parsed.Path, "/")
+	}
+
+	return parsed.String()
+}
+
+func deriveCitationURLParts(rawURL, normalizedURL string) (string, string, *string, *string) {
+	candidate := strings.TrimSpace(normalizedURL)
+	if candidate == "" {
+		candidate = strings.TrimSpace(rawURL)
+	}
+	if candidate == "" {
+		return "", "", nil, nil
+	}
+
+	parsed, err := url.Parse(candidate)
+	if err != nil {
+		return "", "", nil, nil
+	}
+
+	host := strings.ToLower(strings.TrimSpace(parsed.Hostname()))
+	if host == "" {
+		return "", "", nil, nil
+	}
+
+	registrableDomain, err := publicsuffix.EffectiveTLDPlusOne(host)
+	if err != nil {
+		registrableDomain = host
+	}
+
+	suffixValue, _ := publicsuffix.PublicSuffix(host)
+	var suffix *string
+	if suffixValue != "" {
+		suffix = &suffixValue
+	}
+
+	var subdomain *string
+	if registrableDomain != "" && host != registrableDomain {
+		value := strings.TrimSuffix(host, "."+registrableDomain)
+		value = strings.TrimSuffix(value, ".")
+		if value != "" {
+			subdomain = &value
+		}
+	}
+
+	return host, registrableDomain, subdomain, suffix
+}
+
+func firstString(values map[string]interface{}, keys ...string) string {
+	for _, key := range keys {
+		raw, ok := values[key]
+		if !ok {
+			continue
+		}
+		switch typed := raw.(type) {
+		case string:
+			if trimmed := strings.TrimSpace(typed); trimmed != "" {
+				return trimmed
+			}
+		}
+	}
+	return ""
+}
+
+func firstInt64(values map[string]interface{}, keys ...string) *int64 {
+	for _, key := range keys {
+		raw, ok := values[key]
+		if !ok {
+			continue
+		}
+		switch typed := raw.(type) {
+		case float64:
+			value := int64(typed)
+			return &value
+		case int64:
+			value := typed
+			return &value
+		case int:
+			value := int64(typed)
+			return &value
+		case string:
+			trimmed := strings.TrimSpace(typed)
+			if trimmed == "" {
+				continue
+			}
+			value, err := strconv.ParseInt(trimmed, 10, 64)
+			if err == nil {
+				return &value
+			}
+		}
+	}
+	return nil
+}
+
+func optionalString(value string) *string {
+	if strings.TrimSpace(value) == "" {
+		return nil
+	}
+	text := strings.TrimSpace(value)
+	return &text
+}
+
+func monitoringStringValue(value *string) string {
+	if value == nil {
+		return ""
+	}
+	return strings.TrimSpace(*value)
+}
+
+func resolveHeartbeatDetectedAt(value *time.Time) time.Time {
+	if value == nil || value.IsZero() {
+		return time.Now().UTC()
+	}
+	return value.UTC()
+}
+
+func cloneString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	trimmed := strings.TrimSpace(*value)
+	if trimmed == "" {
+		return nil
+	}
+	copyValue := trimmed
+	return &copyValue
+}
+
+func cloneBool(value *bool) *bool {
+	if value == nil {
+		return nil
+	}
+	copyValue := *value
+	return &copyValue
+}
+
+func cloneInt64(value *int64) *int64 {
+	if value == nil {
+		return nil
+	}
+	copyValue := *value
+	return &copyValue
+}
+
+func nullableBool(value *bool) interface{} {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+func monitoringBoolPointer(value bool) *bool {
+	copyValue := value
+	return &copyValue
+}
+
+func derefBool(value *bool) bool {
+	if value == nil {
+		return false
+	}
+	return *value
+}
+
+func derefInt64(value *int64) int64 {
+	if value == nil {
+		return 0
+	}
+	return *value
+}
diff --git a/server/internal/tenant/app/monitoring_errors.go b/server/internal/tenant/app/monitoring_errors.go
new file mode 100644
index 0000000..cef34e1
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_errors.go
@@ -0,0 +1,9 @@
+package app
+
+import "github.com/geo-platform/tenant-api/internal/shared/response"
+
+func monitoringInternalError(code int, message, detail string, cause error) *response.AppError {
+	appErr := response.ErrInternal(code, message, detail)
+	appErr.Cause = cause
+	return appErr
+}
diff --git a/server/internal/tenant/app/monitoring_lease_recovery.go b/server/internal/tenant/app/monitoring_lease_recovery.go
new file mode 100644
index 0000000..3a2dc99
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_lease_recovery.go
@@ -0,0 +1,79 @@
+package app
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+const (
+	monitoringLeaseMaxRetryCount    = 1
+	monitoringLeaseExpiredErrPrefix = "monitoring lease expired before result callback"
+)
+
+func expireMonitoringLeasedTasks(ctx context.Context, tx pgx.Tx, tenantID *int64, now time.Time) (int64, error) {
+	tag, err := tx.Exec(ctx, `
+			UPDATE monitoring_collect_tasks
+			SET status = 'expired',
+		    lease_token_hash = NULL,
+		    leased_to_executor = NULL,
+		    leased_at = NULL,
+		    lease_expires_at = NULL,
+		    error_message = COALESCE(NULLIF(error_message, ''), $1),
+		    request_payload_json = (
+				CASE
+					WHEN request_payload_json IS NULL OR jsonb_typeof(request_payload_json) <> 'object'
+						THEN '{}'::jsonb
+					ELSE request_payload_json
+				END
+				) || jsonb_build_object(
+					'lease_retry_count',
+					(
+						CASE
+							WHEN COALESCE(request_payload_json ->> 'lease_retry_count', '') ~ '^[0-9]+$'
+								THEN (request_payload_json ->> 'lease_retry_count')::int
+							ELSE 0
+						END
+					) + 1
+				),
+			    updated_at = NOW()
+		WHERE collector_type = $2
+		  AND status = 'leased'
+		  AND lease_expires_at IS NOT NULL
+		  AND lease_expires_at < $3
+		  AND ($4::bigint IS NULL OR tenant_id = $4)
+	`, monitoringLeaseExpiredErrPrefix, monitoringCollectorType, now.UTC(), nullableInt64(tenantID))
+	if err != nil {
+		return 0, monitoringInternalError(50041, "lease_expire_failed", "failed to expire overdue monitoring lease tasks", err)
+	}
+	return tag.RowsAffected(), nil
+}
+
+func requeueMonitoringExpiredTasks(ctx context.Context, tx pgx.Tx, tenantID int64, businessDate time.Time) (int64, error) {
+	tag, err := tx.Exec(ctx, `
+		UPDATE monitoring_collect_tasks
+		SET status = 'pending',
+		    planned_at = NOW(),
+		    callback_received_at = NULL,
+		    completed_at = NULL,
+		    skip_reason = NULL,
+		    error_message = NULL,
+		    updated_at = NOW()
+		WHERE tenant_id = $1
+		  AND collector_type = $2
+		  AND business_date = $3::date
+		  AND status = 'expired'
+		  AND (
+			CASE
+				WHEN COALESCE(request_payload_json ->> 'lease_retry_count', '') ~ '^[0-9]+$'
+					THEN (request_payload_json ->> 'lease_retry_count')::int
+				ELSE 0
+			END
+		  ) <= $4
+	`, tenantID, monitoringCollectorType, businessDate.Format("2006-01-02"), monitoringLeaseMaxRetryCount)
+	if err != nil {
+		return 0, monitoringInternalError(50041, "lease_requeue_failed", "failed to recycle expired monitoring lease tasks", err)
+	}
+	return tag.RowsAffected(), nil
+}
diff --git a/server/internal/tenant/app/monitoring_lease_recovery_worker.go b/server/internal/tenant/app/monitoring_lease_recovery_worker.go
new file mode 100644
index 0000000..9a0278c
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_lease_recovery_worker.go
@@ -0,0 +1,116 @@
+package app
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+	"go.uber.org/zap"
+
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+const (
+	defaultMonitoringLeaseRecoveryInterval = 30 * time.Minute
+	defaultMonitoringLeaseRecoveryTimeout  = 30 * time.Second
+)
+
+type MonitoringLeaseRecoveryWorker struct {
+	monitoringPool *pgxpool.Pool
+	logger         *zap.Logger
+	interval       time.Duration
+	timeout        time.Duration
+}
+
+func NewMonitoringLeaseRecoveryWorker(monitoringPool *pgxpool.Pool, logger *zap.Logger) *MonitoringLeaseRecoveryWorker {
+	return &MonitoringLeaseRecoveryWorker{
+		monitoringPool: monitoringPool,
+		logger:         logger,
+		interval:       defaultMonitoringLeaseRecoveryInterval,
+		timeout:        defaultMonitoringLeaseRecoveryTimeout,
+	}
+}
+
+func (w *MonitoringLeaseRecoveryWorker) Start(ctx context.Context) {
+	go w.run(ctx)
+}
+
+func (w *MonitoringLeaseRecoveryWorker) run(ctx context.Context) {
+	w.runOnce(ctx)
+
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			w.runOnce(ctx)
+		}
+	}
+}
+
+func (w *MonitoringLeaseRecoveryWorker) runOnce(parent context.Context) {
+	if w.monitoringPool == nil {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(parent, w.timeout)
+	defer cancel()
+
+	tx, err := w.monitoringPool.Begin(ctx)
+	if err != nil {
+		w.logger.Warn("monitoring lease recovery begin failed", zap.Error(err))
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	expiredCount, err := expireMonitoringLeasedTasks(ctx, tx, nil, time.Now().UTC())
+	if err != nil {
+		w.logger.Warn("monitoring lease recovery failed", monitoringWorkerErrorFields(err)...)
+		return
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		w.logger.Warn("monitoring lease recovery commit failed", zap.Error(err))
+		return
+	}
+
+	if expiredCount > 0 {
+		w.logger.Info("monitoring lease recovery completed", zap.Int64("expired_task_count", expiredCount))
+	}
+}
+
+func normalizeMonitoringWorkerError(err error) error {
+	if err == nil {
+		return nil
+	}
+	if appErr, ok := err.(*response.AppError); ok {
+		return appErr
+	}
+	return err
+}
+
+func monitoringWorkerErrorFields(err error) []zap.Field {
+	normalized := normalizeMonitoringWorkerError(err)
+	if normalized == nil {
+		return nil
+	}
+
+	if appErr, ok := normalized.(*response.AppError); ok {
+		fields := []zap.Field{
+			zap.String("error_code", appErr.Message),
+			zap.Int("app_code", appErr.Code),
+		}
+		if appErr.Detail != "" {
+			fields = append(fields, zap.String("detail", appErr.Detail))
+		}
+		if appErr.Cause != nil {
+			fields = append(fields, zap.Error(appErr.Cause))
+		}
+		return fields
+	}
+
+	return []zap.Field{zap.Error(normalized)}
+}
diff --git a/server/internal/tenant/app/monitoring_projection.go b/server/internal/tenant/app/monitoring_projection.go
new file mode 100644
index 0000000..96e36b0
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_projection.go
@@ -0,0 +1,540 @@
+package app
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type monitoringBrandDailyAggregate struct {
+	PlannedSampleCount     int64
+	ActualSampleCount      int64
+	MentionedCount         int64
+	Top1MentionedCount     int64
+	FirstRecommendedCount  int64
+	PositiveMentionedCount int64
+	CitedAnswerCount       int64
+	SnapshotUpdatedAt      sql.NullTime
+	LatestTriggerSource    sql.NullString
+}
+
+type monitoringPlatformDailyAggregate struct {
+	AIPlatformID       string
+	PlannedSampleCount int64
+	ActualSampleCount  int64
+	MentionedCount     int64
+	Top1MentionedCount int64
+	LastSampledAt      sql.NullTime
+	AccessStatus       string
+}
+
+func (s *MonitoringCallbackService) rebuildBrandDailyProjection(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDate time.Time) error {
+	platforms, err := loadMonitoringProjectionPlatforms(ctx, s.businessPool, tenantID)
+	if err != nil {
+		return err
+	}
+
+	enabledQuestionCount, err := s.loadMonitoringEnabledQuestionCount(ctx, tx, tenantID, brandID, businessDate)
+	if err != nil {
+		return err
+	}
+
+	brandAgg, err := s.loadMonitoringBrandDailyAggregate(ctx, tx, tenantID, brandID, businessDate)
+	if err != nil {
+		return err
+	}
+
+	platformAggs, err := s.loadMonitoringPlatformDailyAggregates(ctx, tx, tenantID, brandID, businessDate, platforms)
+	if err != nil {
+		return err
+	}
+
+	desiredSampleCount := enabledQuestionCount * int64(len(platforms))
+	coverageRate := divideAsPointer(brandAgg.ActualSampleCount, brandAgg.PlannedSampleCount)
+	mentionRate := averageMonitoringPlatformMentionRate(platformAggs)
+	top1MentionRate := divideAsPointer(brandAgg.Top1MentionedCount, brandAgg.ActualSampleCount)
+	firstRecommendRate := divideAsPointer(brandAgg.FirstRecommendedCount, brandAgg.ActualSampleCount)
+	positiveMentionRate := divideAsPointer(brandAgg.PositiveMentionedCount, brandAgg.ActualSampleCount)
+	citationRate := divideAsPointer(brandAgg.CitedAnswerCount, brandAgg.ActualSampleCount)
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO monitoring_brand_daily (
+			tenant_id, brand_id, collector_type, business_date, sample_status,
+			desired_sample_count, planned_sample_count, actual_sample_count,
+			coverage_rate, confidence_level, trigger_source, snapshot_updated_at,
+			mentioned_count, top1_mentioned_count, first_recommended_count, positive_mentioned_count,
+			cited_answer_count, mention_rate, top1_mention_rate, first_recommend_rate,
+			positive_mention_rate, citation_rate
+		)
+		VALUES (
+			$1, $2, $3, $4::date, $5,
+			$6, $7, $8,
+			$9, $10, $11, $12,
+			$13, $14, $15, $16,
+			$17, $18, $19, $20,
+			$21, $22
+		)
+		ON CONFLICT (tenant_id, brand_id, collector_type, business_date)
+		DO UPDATE SET
+			sample_status = EXCLUDED.sample_status,
+			desired_sample_count = EXCLUDED.desired_sample_count,
+			planned_sample_count = EXCLUDED.planned_sample_count,
+			actual_sample_count = EXCLUDED.actual_sample_count,
+			coverage_rate = EXCLUDED.coverage_rate,
+			confidence_level = EXCLUDED.confidence_level,
+			trigger_source = EXCLUDED.trigger_source,
+			snapshot_updated_at = EXCLUDED.snapshot_updated_at,
+			mentioned_count = EXCLUDED.mentioned_count,
+			top1_mentioned_count = EXCLUDED.top1_mentioned_count,
+			first_recommended_count = EXCLUDED.first_recommended_count,
+			positive_mentioned_count = EXCLUDED.positive_mentioned_count,
+			cited_answer_count = EXCLUDED.cited_answer_count,
+			mention_rate = EXCLUDED.mention_rate,
+			top1_mention_rate = EXCLUDED.top1_mention_rate,
+			first_recommend_rate = EXCLUDED.first_recommend_rate,
+			positive_mention_rate = EXCLUDED.positive_mention_rate,
+			citation_rate = EXCLUDED.citation_rate,
+			updated_at = NOW()
+	`,
+		tenantID,
+		brandID,
+		monitoringCollectorType,
+		monitoringBusinessDateText(businessDate),
+		deriveMonitoringBrandSampleStatus(brandAgg.ActualSampleCount, brandAgg.PlannedSampleCount, coverageRate),
+		desiredSampleCount,
+		brandAgg.PlannedSampleCount,
+		brandAgg.ActualSampleCount,
+		nullableFloat64(coverageRate),
+		deriveMonitoringConfidenceLevel(brandAgg.ActualSampleCount, brandAgg.PlannedSampleCount, coverageRate),
+		nullableString(stringPointer(brandAgg.LatestTriggerSource)),
+		nullableTime(brandAgg.SnapshotUpdatedAt),
+		brandAgg.MentionedCount,
+		brandAgg.Top1MentionedCount,
+		brandAgg.FirstRecommendedCount,
+		brandAgg.PositiveMentionedCount,
+		brandAgg.CitedAnswerCount,
+		nullableFloat64(mentionRate),
+		nullableFloat64(top1MentionRate),
+		nullableFloat64(firstRecommendRate),
+		nullableFloat64(positiveMentionRate),
+		nullableFloat64(citationRate),
+	); err != nil {
+		return monitoringInternalError(50041, "brand_daily_projection_failed", "failed to persist monitoring brand daily projection", err)
+	}
+
+	if err := s.replaceMonitoringPlatformDailyProjection(ctx, tx, tenantID, brandID, businessDate, platformAggs); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func loadMonitoringProjectionPlatforms(ctx context.Context, businessPool *pgxpool.Pool, tenantID int64) ([]monitoringPlatformMetadata, error) {
+	enabled := []string{"deepseek", "qwen", "doubao"}
+
+	var enabledJSON []byte
+	if err := businessPool.QueryRow(ctx, `
+		SELECT enabled_platforms
+		FROM tenant_monitoring_quotas
+		WHERE tenant_id = $1
+	`, tenantID).Scan(&enabledJSON); err != nil {
+		if err == pgx.ErrNoRows {
+			return resolveMonitoringPlatforms(enabled), nil
+		}
+		return nil, monitoringInternalError(50041, "quota_lookup_failed", "failed to load monitoring quota", err)
+	}
+
+	if len(enabledJSON) > 0 {
+		var configured []string
+		if jsonErr := json.Unmarshal(enabledJSON, &configured); jsonErr == nil && len(configured) > 0 {
+			enabled = configured
+		}
+	}
+
+	return resolveMonitoringPlatforms(enabled), nil
+}
+
+func (s *MonitoringCallbackService) loadMonitoringEnabledQuestionCount(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDate time.Time) (int64, error) {
+	dayEnd := monitoringCanonicalBusinessDay(businessDate).AddDate(0, 0, 1)
+
+	var count int64
+	if err := tx.QueryRow(ctx, `
+		SELECT COUNT(DISTINCT question_id)
+		FROM monitoring_question_config_snapshots
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND monitor_enabled = TRUE
+		  AND projected_at < $3
+		  AND (superseded_at IS NULL OR superseded_at >= $3)
+		  AND (deleted_at IS NULL OR deleted_at >= $3)
+	`, tenantID, brandID, dayEnd).Scan(&count); err != nil {
+		return 0, monitoringInternalError(50041, "question_snapshot_lookup_failed", "failed to load monitoring question snapshots", err)
+	}
+
+	return count, nil
+}
+
+func (s *MonitoringCallbackService) loadMonitoringBrandDailyAggregate(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDate time.Time) (monitoringBrandDailyAggregate, error) {
+	agg := monitoringBrandDailyAggregate{}
+	dateText := monitoringBusinessDateText(businessDate)
+
+	if err := tx.QueryRow(ctx, `
+		SELECT COUNT(*)
+		FROM monitoring_collect_tasks
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND NOT (status = 'skipped' AND skip_reason = ANY($5::text[]))
+	`, tenantID, brandID, monitoringCollectorType, dateText, monitoringProjectionExcludedSkipReasons).Scan(&agg.PlannedSampleCount); err != nil {
+		return agg, monitoringInternalError(50041, "task_projection_lookup_failed", "failed to load monitoring task counts", err)
+	}
+
+	if err := tx.QueryRow(ctx, `
+		SELECT COUNT(*), MAX(completed_at)
+		FROM question_monitor_runs
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND status = 'succeeded'
+	`, tenantID, brandID, monitoringCollectorType, dateText).Scan(&agg.ActualSampleCount, &agg.SnapshotUpdatedAt); err != nil {
+		return agg, monitoringInternalError(50041, "run_projection_lookup_failed", "failed to load monitoring run counts", err)
+	}
+
+	if err := tx.QueryRow(ctx, `
+		SELECT
+			COUNT(*) FILTER (WHERE p.brand_mentioned IS TRUE)::bigint,
+			COUNT(*) FILTER (WHERE p.brand_mention_position = 'top1')::bigint,
+			COUNT(*) FILTER (WHERE p.first_recommended IS TRUE)::bigint,
+			COUNT(*) FILTER (WHERE p.sentiment_label = 'positive')::bigint
+		FROM question_monitor_runs r
+		LEFT JOIN question_monitor_parse_results p
+			ON p.tenant_id = r.tenant_id AND p.run_id = r.id
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.collector_type = $3
+		  AND r.business_date = $4::date
+		  AND r.status = 'succeeded'
+	`, tenantID, brandID, monitoringCollectorType, dateText).Scan(
+		&agg.MentionedCount,
+		&agg.Top1MentionedCount,
+		&agg.FirstRecommendedCount,
+		&agg.PositiveMentionedCount,
+	); err != nil {
+		return agg, monitoringInternalError(50041, "parse_projection_lookup_failed", "failed to load monitoring parse aggregates", err)
+	}
+
+	if err := tx.QueryRow(ctx, `
+		SELECT COUNT(DISTINCT cf.run_id)
+		FROM monitoring_citation_facts cf
+		JOIN question_monitor_runs r
+			ON r.tenant_id = cf.tenant_id AND r.id = cf.run_id
+		WHERE cf.tenant_id = $1
+		  AND cf.brand_id = $2
+		  AND cf.article_id IS NOT NULL
+		  AND r.collector_type = $3
+		  AND r.business_date = $4::date
+		  AND r.status = 'succeeded'
+	`, tenantID, brandID, monitoringCollectorType, dateText).Scan(&agg.CitedAnswerCount); err != nil {
+		return agg, monitoringInternalError(50041, "citation_projection_lookup_failed", "failed to load monitoring citation aggregates", err)
+	}
+
+	if err := tx.QueryRow(ctx, `
+		SELECT trigger_source
+		FROM question_monitor_runs
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND status = 'succeeded'
+		ORDER BY completed_at DESC NULLS LAST, id DESC
+		LIMIT 1
+	`, tenantID, brandID, monitoringCollectorType, dateText).Scan(&agg.LatestTriggerSource); err != nil && err != pgx.ErrNoRows {
+		return agg, monitoringInternalError(50041, "trigger_source_lookup_failed", "failed to load monitoring trigger source", err)
+	}
+
+	return agg, nil
+}
+
+func (s *MonitoringCallbackService) loadMonitoringPlatformDailyAggregates(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDate time.Time, platforms []monitoringPlatformMetadata) ([]monitoringPlatformDailyAggregate, error) {
+	dateText := monitoringBusinessDateText(businessDate)
+
+	taskCounts := make(map[string]int64, len(platforms))
+	taskRows, err := tx.Query(ctx, `
+		SELECT ai_platform_id, COUNT(*)
+		FROM monitoring_collect_tasks
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND NOT (status = 'skipped' AND skip_reason = ANY($5::text[]))
+		GROUP BY ai_platform_id
+	`, tenantID, brandID, monitoringCollectorType, dateText, monitoringProjectionExcludedSkipReasons)
+	if err != nil {
+		return nil, monitoringInternalError(50041, "platform_task_projection_lookup_failed", "failed to load monitoring platform task counts", err)
+	}
+	for taskRows.Next() {
+		var platformID string
+		var plannedSampleCount int64
+		if scanErr := taskRows.Scan(&platformID, &plannedSampleCount); scanErr != nil {
+			taskRows.Close()
+			return nil, monitoringInternalError(50041, "platform_task_projection_scan_failed", "failed to parse monitoring platform task counts", scanErr)
+		}
+		taskCounts[platformID] = plannedSampleCount
+	}
+	if err := taskRows.Err(); err != nil {
+		taskRows.Close()
+		return nil, monitoringInternalError(50041, "platform_task_projection_scan_failed", "failed to iterate monitoring platform task counts", err)
+	}
+	taskRows.Close()
+
+	runAggs := make(map[string]monitoringPlatformDailyAggregate, len(platforms))
+	runRows, err := tx.Query(ctx, `
+		SELECT
+			r.ai_platform_id,
+			COUNT(*)::bigint AS actual_sample_count,
+			COUNT(*) FILTER (WHERE p.brand_mentioned IS TRUE)::bigint AS mentioned_count,
+			COUNT(*) FILTER (WHERE p.brand_mention_position = 'top1')::bigint AS top1_mentioned_count,
+			MAX(r.completed_at) AS last_sampled_at
+		FROM question_monitor_runs r
+		LEFT JOIN question_monitor_parse_results p
+			ON p.tenant_id = r.tenant_id AND p.run_id = r.id
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.collector_type = $3
+		  AND r.business_date = $4::date
+		  AND r.status = 'succeeded'
+		GROUP BY r.ai_platform_id
+	`, tenantID, brandID, monitoringCollectorType, dateText)
+	if err != nil {
+		return nil, monitoringInternalError(50041, "platform_run_projection_lookup_failed", "failed to load monitoring platform run aggregates", err)
+	}
+	for runRows.Next() {
+		var item monitoringPlatformDailyAggregate
+		if scanErr := runRows.Scan(
+			&item.AIPlatformID,
+			&item.ActualSampleCount,
+			&item.MentionedCount,
+			&item.Top1MentionedCount,
+			&item.LastSampledAt,
+		); scanErr != nil {
+			runRows.Close()
+			return nil, monitoringInternalError(50041, "platform_run_projection_scan_failed", "failed to parse monitoring platform run aggregates", scanErr)
+		}
+		runAggs[item.AIPlatformID] = item
+	}
+	if err := runRows.Err(); err != nil {
+		runRows.Close()
+		return nil, monitoringInternalError(50041, "platform_run_projection_scan_failed", "failed to iterate monitoring platform run aggregates", err)
+	}
+	runRows.Close()
+
+	accessStates := make(map[string]string, len(platforms))
+	accessRows, err := tx.Query(ctx, `
+		SELECT DISTINCT ON (ai_platform_id) ai_platform_id, access_status
+		FROM monitoring_platform_access_snapshots
+		WHERE tenant_id = $1
+		  AND business_date = $2::date
+		ORDER BY ai_platform_id ASC, detected_at DESC, id DESC
+	`, tenantID, dateText)
+	if err != nil {
+		return nil, monitoringInternalError(50041, "platform_access_projection_lookup_failed", "failed to load monitoring platform access states", err)
+	}
+	for accessRows.Next() {
+		var platformID string
+		var accessStatus string
+		if scanErr := accessRows.Scan(&platformID, &accessStatus); scanErr != nil {
+			accessRows.Close()
+			return nil, monitoringInternalError(50041, "platform_access_projection_scan_failed", "failed to parse monitoring platform access states", scanErr)
+		}
+		accessStates[platformID] = accessStatus
+	}
+	if err := accessRows.Err(); err != nil {
+		accessRows.Close()
+		return nil, monitoringInternalError(50041, "platform_access_projection_scan_failed", "failed to iterate monitoring platform access states", err)
+	}
+	accessRows.Close()
+
+	items := make([]monitoringPlatformDailyAggregate, 0, len(platforms))
+	for _, platform := range platforms {
+		item := runAggs[platform.ID]
+		item.AIPlatformID = platform.ID
+		item.PlannedSampleCount = taskCounts[platform.ID]
+		item.AccessStatus = accessStates[platform.ID]
+		items = append(items, item)
+	}
+
+	return items, nil
+}
+
+func averageMonitoringPlatformMentionRate(items []monitoringPlatformDailyAggregate) *float64 {
+	if len(items) == 0 {
+		return nil
+	}
+
+	total := 0.0
+	count := 0
+	for _, item := range items {
+		rate := divideAsPointer(item.MentionedCount, item.ActualSampleCount)
+		if rate == nil {
+			continue
+		}
+		total += *rate
+		count++
+	}
+	if count == 0 {
+		return nil
+	}
+
+	average := total / float64(count)
+	return &average
+}
+
+func (s *MonitoringCallbackService) replaceMonitoringPlatformDailyProjection(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, businessDate time.Time, items []monitoringPlatformDailyAggregate) error {
+	dateText := monitoringBusinessDateText(businessDate)
+
+	if _, err := tx.Exec(ctx, `
+		DELETE FROM monitoring_brand_platform_daily
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+	`, tenantID, brandID, monitoringCollectorType, dateText); err != nil {
+		return monitoringInternalError(50041, "platform_daily_projection_cleanup_failed", "failed to reset monitoring platform daily projection", err)
+	}
+
+	for _, item := range items {
+		mentionRate := divideAsPointer(item.MentionedCount, item.ActualSampleCount)
+		top1MentionRate := divideAsPointer(item.Top1MentionedCount, item.ActualSampleCount)
+
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_brand_platform_daily (
+				tenant_id, brand_id, ai_platform_id, collector_type, business_date,
+				platform_sample_status, planned_sample_count, actual_sample_count,
+				mention_rate, top1_mention_rate, last_sampled_at
+			)
+			VALUES (
+				$1, $2, $3, $4, $5::date,
+				$6, $7, $8,
+				$9, $10, $11
+			)
+		`,
+			tenantID,
+			brandID,
+			item.AIPlatformID,
+			monitoringCollectorType,
+			dateText,
+			deriveMonitoringPlatformSampleStatus(item.ActualSampleCount, item.PlannedSampleCount, item.AccessStatus),
+			item.PlannedSampleCount,
+			item.ActualSampleCount,
+			nullableFloat64(mentionRate),
+			nullableFloat64(top1MentionRate),
+			nullableTime(item.LastSampledAt),
+		); err != nil {
+			return monitoringInternalError(50041, "platform_daily_projection_failed", "failed to persist monitoring platform daily projection", err)
+		}
+	}
+
+	return nil
+}
+
+func (s *MonitoringCallbackService) loadMonitoringAffectedBrandIDs(ctx context.Context, tx pgx.Tx, tenantID int64, businessDate time.Time, aiPlatformID string) ([]int64, error) {
+	rows, err := tx.Query(ctx, `
+		SELECT DISTINCT brand_id
+		FROM monitoring_collect_tasks
+		WHERE tenant_id = $1
+		  AND ai_platform_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		ORDER BY brand_id ASC
+	`, tenantID, aiPlatformID, monitoringCollectorType, monitoringBusinessDateText(businessDate))
+	if err != nil {
+		return nil, monitoringInternalError(50041, "affected_brand_lookup_failed", "failed to load monitoring brands for projection", err)
+	}
+	defer rows.Close()
+
+	brandIDs := make([]int64, 0)
+	for rows.Next() {
+		var brandID int64
+		if scanErr := rows.Scan(&brandID); scanErr != nil {
+			return nil, monitoringInternalError(50041, "affected_brand_scan_failed", "failed to parse monitoring brands for projection", scanErr)
+		}
+		brandIDs = append(brandIDs, brandID)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, monitoringInternalError(50041, "affected_brand_scan_failed", "failed to iterate monitoring brands for projection", err)
+	}
+
+	return brandIDs, nil
+}
+
+func deriveMonitoringBrandSampleStatus(actualSampleCount, plannedSampleCount int64, coverageRate *float64) string {
+	if actualSampleCount <= 0 {
+		return "unsampled"
+	}
+	if plannedSampleCount <= 0 {
+		return "sampled"
+	}
+	if coverageRate != nil && *coverageRate >= 0.7 {
+		return "sampled"
+	}
+	return "partial"
+}
+
+func deriveMonitoringConfidenceLevel(actualSampleCount, plannedSampleCount int64, coverageRate *float64) string {
+	if actualSampleCount <= 0 {
+		return "low"
+	}
+	if plannedSampleCount <= 0 {
+		return "high"
+	}
+	if coverageRate == nil {
+		return "low"
+	}
+	switch {
+	case *coverageRate >= 0.7:
+		return "high"
+	case *coverageRate >= 0.4:
+		return "medium"
+	default:
+		return "low"
+	}
+}
+
+func deriveMonitoringPlatformSampleStatus(actualSampleCount, plannedSampleCount int64, accessStatus string) string {
+	if actualSampleCount > 0 {
+		return "sampled"
+	}
+	switch accessStatus {
+	case "not_logged_in":
+		return "not_logged_in"
+	case "unavailable":
+		return "unavailable"
+	}
+	if plannedSampleCount > 0 {
+		return "pending"
+	}
+	if accessStatus == "accessible" {
+		return "pending"
+	}
+	return "pending"
+}
+
+func nullableFloat64(value *float64) interface{} {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+func nullableTime(value sql.NullTime) interface{} {
+	if !value.Valid {
+		return nil
+	}
+	return value.Time
+}
diff --git a/server/internal/tenant/app/monitoring_projection_rebuild_queue.go b/server/internal/tenant/app/monitoring_projection_rebuild_queue.go
new file mode 100644
index 0000000..46ce01e
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_projection_rebuild_queue.go
@@ -0,0 +1,194 @@
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+	"go.uber.org/zap"
+)
+
+const (
+	monitoringProjectionQueueIOTimeout  = 5 * time.Second
+	monitoringProjectionFallbackTimeout = 2 * time.Minute
+	monitoringProjectionQueueMessageVer = "v1"
+)
+
+type monitoringProjectionRebuildEnvelope struct {
+	Version      string `json:"version"`
+	TenantID     int64  `json:"tenant_id"`
+	BrandID      int64  `json:"brand_id"`
+	BusinessDate string `json:"business_date"`
+	Source       string `json:"source"`
+}
+
+func encodeMonitoringProjectionRebuildEnvelope(tenantID, brandID int64, businessDay time.Time, source string) ([]byte, error) {
+	businessDay = monitoringCanonicalBusinessDay(businessDay)
+
+	return json.Marshal(monitoringProjectionRebuildEnvelope{
+		Version:      monitoringProjectionQueueMessageVer,
+		TenantID:     tenantID,
+		BrandID:      brandID,
+		BusinessDate: businessDay.Format("2006-01-02"),
+		Source:       source,
+	})
+}
+
+func decodeMonitoringProjectionRebuildEnvelope(payload []byte) (*monitoringProjectionRebuildEnvelope, error) {
+	if len(payload) == 0 {
+		return nil, fmt.Errorf("monitoring projection rebuild payload is empty")
+	}
+
+	var envelope monitoringProjectionRebuildEnvelope
+	if err := json.Unmarshal(payload, &envelope); err != nil {
+		return nil, err
+	}
+	if envelope.TenantID <= 0 {
+		return nil, fmt.Errorf("monitoring projection rebuild payload missing tenant_id")
+	}
+	if envelope.BrandID <= 0 {
+		return nil, fmt.Errorf("monitoring projection rebuild payload missing brand_id")
+	}
+	if _, err := parseMonitoringBusinessDateInLocation(envelope.BusinessDate, monitoringBusinessLocation()); err != nil {
+		return nil, fmt.Errorf("monitoring projection rebuild payload has invalid business_date")
+	}
+
+	return &envelope, nil
+}
+
+func (s *MonitoringCallbackService) publishProjectionRebuildEnvelope(ctx context.Context, payload []byte) error {
+	if s == nil || s.rabbitMQ == nil {
+		return response.ErrServiceUnavailable(50341, "monitoring_projection_queue_unavailable", "rabbitmq client is not configured")
+	}
+	if err := s.rabbitMQ.PublishMonitorProjectionRebuild(ctx, payload); err != nil {
+		return response.ErrServiceUnavailable(50341, "monitoring_projection_queue_unavailable", err.Error())
+	}
+	return nil
+}
+
+func (s *MonitoringCallbackService) dispatchMonitoringProjectionRebuilds(tenantID int64, businessDay time.Time, brandIDs map[int64]struct{}, source string) {
+	if s == nil || len(brandIDs) == 0 {
+		return
+	}
+
+	sortedBrandIDs := sortedMonitoringProjectionBrandIDs(brandIDs)
+	failedBrandIDs := make([]int64, 0)
+
+	for _, brandID := range sortedBrandIDs {
+		payload, err := encodeMonitoringProjectionRebuildEnvelope(tenantID, brandID, businessDay, source)
+		if err != nil {
+			failedBrandIDs = append(failedBrandIDs, brandID)
+			if s.logger != nil {
+				s.logger.Warn("monitoring projection rebuild payload encode failed", zap.Int64("tenant_id", tenantID), zap.Int64("brand_id", brandID), zap.Error(err))
+			}
+			continue
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), monitoringProjectionQueueIOTimeout)
+		err = s.publishProjectionRebuildEnvelope(ctx, payload)
+		cancel()
+		if err != nil {
+			failedBrandIDs = append(failedBrandIDs, brandID)
+			if s.logger != nil {
+				s.logger.Warn("monitoring projection rebuild enqueue failed", zap.Int64("tenant_id", tenantID), zap.Int64("brand_id", brandID), zap.Error(err))
+			}
+		}
+	}
+
+	if len(failedBrandIDs) == 0 {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), monitoringProjectionFallbackTimeout)
+	defer cancel()
+
+	if err := s.rebuildBrandDailyProjectionBatch(ctx, tenantID, businessDay, failedBrandIDs); err != nil {
+		if s.logger != nil {
+			s.logger.Warn("monitoring projection rebuild fallback failed",
+				zap.Int64("tenant_id", tenantID),
+				zap.Int("brand_count", len(failedBrandIDs)),
+				zap.Error(err),
+			)
+		}
+		return
+	}
+
+	if s.logger != nil {
+		s.logger.Info("monitoring projection rebuild fallback completed",
+			zap.Int64("tenant_id", tenantID),
+			zap.Int("brand_count", len(failedBrandIDs)),
+		)
+	}
+}
+
+func (s *MonitoringCallbackService) ProcessProjectionRebuildEnvelope(ctx context.Context, envelope monitoringProjectionRebuildEnvelope) error {
+	businessDay, err := parseMonitoringBusinessDateInLocation(envelope.BusinessDate, monitoringBusinessLocation())
+	if err != nil {
+		return response.ErrBadRequest(40041, "invalid_business_date", "projection rebuild business_date is invalid")
+	}
+
+	return s.rebuildBrandDailyProjectionBatch(ctx, envelope.TenantID, businessDay, []int64{envelope.BrandID})
+}
+
+func (s *MonitoringCallbackService) rebuildBrandDailyProjectionBatch(ctx context.Context, tenantID int64, businessDay time.Time, brandIDs []int64) error {
+	if s == nil || s.monitoringPool == nil || len(brandIDs) == 0 {
+		return nil
+	}
+
+	businessDay = monitoringCanonicalBusinessDay(businessDay)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return response.ErrInternal(50041, "begin_failed", "failed to start monitoring projection rebuild")
+	}
+	defer tx.Rollback(ctx)
+
+	for _, brandID := range uniqueSortedMonitoringProjectionBrandIDs(brandIDs) {
+		if err := s.rebuildBrandDailyProjection(ctx, tx, tenantID, brandID, businessDay); err != nil {
+			return err
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return response.ErrInternal(50041, "commit_failed", "failed to commit monitoring projection rebuild")
+	}
+
+	return nil
+}
+
+func sortedMonitoringProjectionBrandIDs(items map[int64]struct{}) []int64 {
+	result := make([]int64, 0, len(items))
+	for brandID := range items {
+		result = append(result, brandID)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		return result[i] < result[j]
+	})
+	return result
+}
+
+func uniqueSortedMonitoringProjectionBrandIDs(items []int64) []int64 {
+	if len(items) == 0 {
+		return nil
+	}
+
+	seen := make(map[int64]struct{}, len(items))
+	result := make([]int64, 0, len(items))
+	for _, brandID := range items {
+		if brandID <= 0 {
+			continue
+		}
+		if _, ok := seen[brandID]; ok {
+			continue
+		}
+		seen[brandID] = struct{}{}
+		result = append(result, brandID)
+	}
+	sort.Slice(result, func(i, j int) bool {
+		return result[i] < result[j]
+	})
+	return result
+}
diff --git a/server/internal/tenant/app/monitoring_projection_rebuild_worker.go b/server/internal/tenant/app/monitoring_projection_rebuild_worker.go
new file mode 100644
index 0000000..8c601fb
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_projection_rebuild_worker.go
@@ -0,0 +1,133 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+	"go.uber.org/zap"
+
+	"github.com/geo-platform/tenant-api/internal/shared/messaging/rabbitmq"
+)
+
+const (
+	defaultMonitoringProjectionRebuildRetryInterval  = 5 * time.Second
+	defaultMonitoringProjectionRebuildProcessTimeout = 2 * time.Minute
+)
+
+var errMonitoringProjectionRebuildConsumerClosed = errors.New("monitoring projection rebuild consumer channel closed")
+
+type MonitoringProjectionRebuildWorker struct {
+	rabbitMQ       *rabbitmq.Client
+	service        *MonitoringCallbackService
+	logger         *zap.Logger
+	retryInterval  time.Duration
+	processTimeout time.Duration
+	consumerName   string
+}
+
+func NewMonitoringProjectionRebuildWorker(service *MonitoringCallbackService, rabbitMQClient *rabbitmq.Client, logger *zap.Logger) *MonitoringProjectionRebuildWorker {
+	return &MonitoringProjectionRebuildWorker{
+		rabbitMQ:       rabbitMQClient,
+		service:        service,
+		logger:         logger,
+		retryInterval:  defaultMonitoringProjectionRebuildRetryInterval,
+		processTimeout: defaultMonitoringProjectionRebuildProcessTimeout,
+		consumerName:   fmt.Sprintf("tenant-api-monitor-projection-%d", os.Getpid()),
+	}
+}
+
+func (w *MonitoringProjectionRebuildWorker) Start(ctx context.Context) {
+	go w.run(ctx)
+}
+
+func (w *MonitoringProjectionRebuildWorker) run(ctx context.Context) {
+	if w.rabbitMQ == nil || w.service == nil {
+		return
+	}
+
+	for {
+		if err := w.consumeOnce(ctx); err != nil && ctx.Err() == nil {
+			if w.logger != nil {
+				if errors.Is(err, errMonitoringProjectionRebuildConsumerClosed) {
+					w.logger.Info("monitoring projection rebuild consumer channel closed, retrying")
+				} else {
+					w.logger.Warn("monitoring projection rebuild worker stopped unexpectedly", zap.Error(err))
+				}
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(w.retryInterval):
+		}
+	}
+}
+
+func (w *MonitoringProjectionRebuildWorker) consumeOnce(ctx context.Context) error {
+	deliveries, ch, err := w.rabbitMQ.ConsumeMonitorProjectionRebuild(w.consumerName)
+	if err != nil {
+		return err
+	}
+	defer ch.Close()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case delivery, ok := <-deliveries:
+			if !ok {
+				return errMonitoringProjectionRebuildConsumerClosed
+			}
+			w.handleDelivery(ctx, delivery)
+		}
+	}
+}
+
+func (w *MonitoringProjectionRebuildWorker) handleDelivery(parent context.Context, delivery amqp.Delivery) {
+	envelope, err := decodeMonitoringProjectionRebuildEnvelope(delivery.Body)
+	if err != nil {
+		w.rejectDelivery(delivery, false, err, 0, 0)
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(parent, w.processTimeout)
+	defer cancel()
+
+	if err := w.service.ProcessProjectionRebuildEnvelope(ctx, *envelope); err != nil {
+		requeue := shouldRequeueMonitoringResultError(err, delivery.Redelivered)
+		w.rejectDelivery(delivery, requeue, err, envelope.TenantID, envelope.BrandID)
+		return
+	}
+
+	if err := delivery.Ack(false); err != nil && w.logger != nil {
+		w.logger.Warn("monitoring projection rebuild ack failed",
+			zap.Error(err),
+			zap.Int64("tenant_id", envelope.TenantID),
+			zap.Int64("brand_id", envelope.BrandID),
+		)
+	}
+}
+
+func (w *MonitoringProjectionRebuildWorker) rejectDelivery(delivery amqp.Delivery, requeue bool, err error, tenantID, brandID int64) {
+	if nackErr := delivery.Nack(false, requeue); nackErr != nil && w.logger != nil {
+		w.logger.Warn("monitoring projection rebuild nack failed",
+			zap.Error(nackErr),
+			zap.Int64("tenant_id", tenantID),
+			zap.Int64("brand_id", brandID),
+		)
+	}
+	if w.logger != nil {
+		w.logger.Warn("monitoring projection rebuild processing failed",
+			zap.Error(err),
+			zap.Bool("requeue", requeue),
+			zap.Bool("redelivered", delivery.Redelivered),
+			zap.Int64("tenant_id", tenantID),
+			zap.Int64("brand_id", brandID),
+		)
+	}
+}
diff --git a/server/internal/tenant/app/monitoring_received_inspection.go b/server/internal/tenant/app/monitoring_received_inspection.go
new file mode 100644
index 0000000..0a1afe6
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_received_inspection.go
@@ -0,0 +1,113 @@
+package app
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+const (
+	defaultMonitoringReceivedAlertThreshold = 15 * time.Minute
+	defaultMonitoringReceivedInspectLimit   = 100
+)
+
+type monitoringStaleReceivedTask struct {
+	ID                 int64
+	TenantID           int64
+	BrandID            int64
+	QuestionID         int64
+	AIPlatformID       string
+	CollectorType      string
+	BusinessDate       time.Time
+	CallbackReceivedAt time.Time
+}
+
+func markMonitoringStaleReceivedTasks(ctx context.Context, tx pgx.Tx, now time.Time, threshold time.Duration, limit int) ([]monitoringStaleReceivedTask, error) {
+	if limit <= 0 {
+		limit = defaultMonitoringReceivedInspectLimit
+	}
+
+	rows, err := tx.Query(ctx, `
+		WITH candidates AS (
+			SELECT
+				id,
+				tenant_id,
+				brand_id,
+				question_id,
+				ai_platform_id,
+				collector_type,
+				business_date,
+				callback_received_at
+			FROM monitoring_collect_tasks
+			WHERE collector_type = $1
+			  AND status = 'received'
+			  AND callback_received_at IS NOT NULL
+			  AND callback_received_at < $2
+			  AND (
+				request_payload_json IS NULL
+				OR jsonb_typeof(request_payload_json) <> 'object'
+				OR COALESCE(NULLIF(request_payload_json ->> 'received_alerted_at', ''), '') = ''
+			  )
+			ORDER BY callback_received_at ASC, id ASC
+			FOR UPDATE SKIP LOCKED
+			LIMIT $3
+		)
+			UPDATE monitoring_collect_tasks t
+			SET request_payload_json = (
+					CASE
+						WHEN t.request_payload_json IS NULL OR jsonb_typeof(t.request_payload_json) <> 'object'
+							THEN '{}'::jsonb
+					ELSE t.request_payload_json
+				END
+			) || jsonb_build_object(
+				'received_alerted_at', $4::text,
+				'received_alert_count', (
+					CASE
+						WHEN COALESCE(t.request_payload_json ->> 'received_alert_count', '') ~ '^[0-9]+$'
+							THEN (t.request_payload_json ->> 'received_alert_count')::int
+							ELSE 0
+						END
+					) + 1
+				),
+				updated_at = NOW()
+		FROM candidates c
+		WHERE t.id = c.id
+		RETURNING
+			c.id,
+			c.tenant_id,
+			c.brand_id,
+			c.question_id,
+			c.ai_platform_id,
+			c.collector_type,
+			c.business_date,
+			c.callback_received_at
+	`, monitoringCollectorType, now.Add(-threshold), limit, now.UTC().Format(time.RFC3339))
+	if err != nil {
+		return nil, monitoringInternalError(50041, "received_watchdog_query_failed", "failed to inspect stale received monitoring tasks", err)
+	}
+	defer rows.Close()
+
+	result := make([]monitoringStaleReceivedTask, 0)
+	for rows.Next() {
+		var item monitoringStaleReceivedTask
+		if scanErr := rows.Scan(
+			&item.ID,
+			&item.TenantID,
+			&item.BrandID,
+			&item.QuestionID,
+			&item.AIPlatformID,
+			&item.CollectorType,
+			&item.BusinessDate,
+			&item.CallbackReceivedAt,
+		); scanErr != nil {
+			return nil, monitoringInternalError(50041, "received_watchdog_scan_failed", "failed to parse stale received monitoring tasks", scanErr)
+		}
+		result = append(result, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, monitoringInternalError(50041, "received_watchdog_scan_failed", "failed to iterate stale received monitoring tasks", err)
+	}
+
+	return result, nil
+}
diff --git a/server/internal/tenant/app/monitoring_received_inspection_worker.go b/server/internal/tenant/app/monitoring_received_inspection_worker.go
new file mode 100644
index 0000000..535df2c
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_received_inspection_worker.go
@@ -0,0 +1,105 @@
+package app
+
+import (
+	"context"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+	"go.uber.org/zap"
+)
+
+const (
+	defaultMonitoringReceivedInspectionInterval = 5 * time.Minute
+	defaultMonitoringReceivedInspectionTimeout  = 30 * time.Second
+)
+
+type MonitoringReceivedInspectionWorker struct {
+	monitoringPool *pgxpool.Pool
+	logger         *zap.Logger
+	interval       time.Duration
+	timeout        time.Duration
+	threshold      time.Duration
+	limit          int
+}
+
+func NewMonitoringReceivedInspectionWorker(monitoringPool *pgxpool.Pool, logger *zap.Logger) *MonitoringReceivedInspectionWorker {
+	return &MonitoringReceivedInspectionWorker{
+		monitoringPool: monitoringPool,
+		logger:         logger,
+		interval:       defaultMonitoringReceivedInspectionInterval,
+		timeout:        defaultMonitoringReceivedInspectionTimeout,
+		threshold:      defaultMonitoringReceivedAlertThreshold,
+		limit:          defaultMonitoringReceivedInspectLimit,
+	}
+}
+
+func (w *MonitoringReceivedInspectionWorker) Start(ctx context.Context) {
+	go w.run(ctx)
+}
+
+func (w *MonitoringReceivedInspectionWorker) run(ctx context.Context) {
+	w.runOnce(ctx)
+
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			w.runOnce(ctx)
+		}
+	}
+}
+
+func (w *MonitoringReceivedInspectionWorker) runOnce(parent context.Context) {
+	if w.monitoringPool == nil {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(parent, w.timeout)
+	defer cancel()
+
+	tx, err := w.monitoringPool.Begin(ctx)
+	if err != nil {
+		w.logger.Warn("monitoring received watchdog begin failed", zap.Error(err))
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	now := time.Now().UTC()
+	items, err := markMonitoringStaleReceivedTasks(ctx, tx, now, w.threshold, w.limit)
+	if err != nil {
+		w.logger.Warn("monitoring received watchdog failed", monitoringWorkerErrorFields(err)...)
+		return
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		w.logger.Warn("monitoring received watchdog commit failed", zap.Error(err))
+		return
+	}
+
+	if len(items) == 0 {
+		return
+	}
+
+	w.logger.Warn("monitoring received watchdog found overdue tasks",
+		zap.Int("task_count", len(items)),
+		zap.Duration("threshold", w.threshold),
+	)
+
+	for _, item := range items {
+		w.logger.Warn("monitoring task stuck in received state",
+			zap.Int64("task_id", item.ID),
+			zap.Int64("tenant_id", item.TenantID),
+			zap.Int64("brand_id", item.BrandID),
+			zap.Int64("question_id", item.QuestionID),
+			zap.String("collector_type", item.CollectorType),
+			zap.String("ai_platform_id", item.AIPlatformID),
+			zap.String("business_date", item.BusinessDate.Format("2006-01-02")),
+			zap.Time("callback_received_at", item.CallbackReceivedAt.UTC()),
+			zap.Duration("received_lag", now.Sub(item.CallbackReceivedAt.UTC())),
+		)
+	}
+}
diff --git a/server/internal/tenant/app/monitoring_result_ingest_worker.go b/server/internal/tenant/app/monitoring_result_ingest_worker.go
new file mode 100644
index 0000000..7876e34
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_result_ingest_worker.go
@@ -0,0 +1,134 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+	"go.uber.org/zap"
+
+	"github.com/geo-platform/tenant-api/internal/shared/messaging/rabbitmq"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+const (
+	defaultMonitoringResultWorkerRetryInterval  = 5 * time.Second
+	defaultMonitoringResultWorkerProcessTimeout = 2 * time.Minute
+)
+
+var errMonitoringResultConsumerClosed = errors.New("monitoring result consumer channel closed")
+
+type MonitoringResultIngestWorker struct {
+	rabbitMQ       *rabbitmq.Client
+	service        *MonitoringCallbackService
+	logger         *zap.Logger
+	retryInterval  time.Duration
+	processTimeout time.Duration
+	consumerName   string
+}
+
+func NewMonitoringResultIngestWorker(service *MonitoringCallbackService, rabbitMQClient *rabbitmq.Client, logger *zap.Logger) *MonitoringResultIngestWorker {
+	return &MonitoringResultIngestWorker{
+		rabbitMQ:       rabbitMQClient,
+		service:        service,
+		logger:         logger,
+		retryInterval:  defaultMonitoringResultWorkerRetryInterval,
+		processTimeout: defaultMonitoringResultWorkerProcessTimeout,
+		consumerName:   fmt.Sprintf("tenant-api-monitor-result-%d", os.Getpid()),
+	}
+}
+
+func (w *MonitoringResultIngestWorker) Start(ctx context.Context) {
+	go w.run(ctx)
+}
+
+func (w *MonitoringResultIngestWorker) run(ctx context.Context) {
+	if w.rabbitMQ == nil || w.service == nil {
+		return
+	}
+
+	for {
+		if err := w.consumeOnce(ctx); err != nil && ctx.Err() == nil {
+			if w.logger != nil {
+				if errors.Is(err, errMonitoringResultConsumerClosed) {
+					w.logger.Info("monitoring result consumer channel closed, retrying")
+				} else {
+					w.logger.Warn("monitoring result worker stopped unexpectedly", zap.Error(err))
+				}
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			return
+		case <-time.After(w.retryInterval):
+		}
+	}
+}
+
+func (w *MonitoringResultIngestWorker) consumeOnce(ctx context.Context) error {
+	deliveries, ch, err := w.rabbitMQ.ConsumeMonitorResultIngest(w.consumerName)
+	if err != nil {
+		return err
+	}
+	defer ch.Close()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case delivery, ok := <-deliveries:
+			if !ok {
+				return errMonitoringResultConsumerClosed
+			}
+			w.handleDelivery(ctx, delivery)
+		}
+	}
+}
+
+func (w *MonitoringResultIngestWorker) handleDelivery(parent context.Context, delivery amqp.Delivery) {
+	envelope, err := decodeMonitoringTaskResultEnvelope(delivery.Body)
+	if err != nil {
+		w.rejectDelivery(delivery, false, err, 0)
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(parent, w.processTimeout)
+	defer cancel()
+
+	if _, err := w.service.ProcessQueuedTaskResult(ctx, *envelope); err != nil {
+		requeue := shouldRequeueMonitoringResultError(err, delivery.Redelivered)
+		w.rejectDelivery(delivery, requeue, err, envelope.TaskID)
+		return
+	}
+
+	if err := delivery.Ack(false); err != nil && w.logger != nil {
+		w.logger.Warn("monitoring result ack failed", zap.Error(err), zap.Int64("task_id", envelope.TaskID))
+	}
+}
+
+func (w *MonitoringResultIngestWorker) rejectDelivery(delivery amqp.Delivery, requeue bool, err error, taskID int64) {
+	if nackErr := delivery.Nack(false, requeue); nackErr != nil && w.logger != nil {
+		w.logger.Warn("monitoring result nack failed", zap.Error(nackErr), zap.Int64("task_id", taskID))
+	}
+	if w.logger != nil {
+		w.logger.Warn("monitoring result processing failed",
+			zap.Error(err),
+			zap.Bool("requeue", requeue),
+			zap.Bool("redelivered", delivery.Redelivered),
+			zap.Int64("task_id", taskID),
+		)
+	}
+}
+
+func shouldRequeueMonitoringResultError(err error, redelivered bool) bool {
+	if redelivered {
+		return false
+	}
+
+	appErr := response.Normalize(err)
+	return appErr.HTTPStatus >= 500
+}
diff --git a/server/internal/tenant/app/monitoring_result_ingest_worker_test.go b/server/internal/tenant/app/monitoring_result_ingest_worker_test.go
new file mode 100644
index 0000000..0057441
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_result_ingest_worker_test.go
@@ -0,0 +1,93 @@
+package app
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+func TestShouldRequeueMonitoringResultError(t *testing.T) {
+	t.Run("requeue internal error on first delivery", func(t *testing.T) {
+		requeue := shouldRequeueMonitoringResultError(
+			response.ErrInternal(50041, "ingest_failed", "db unavailable"),
+			false,
+		)
+		assert.True(t, requeue)
+	})
+
+	t.Run("do not requeue bad request", func(t *testing.T) {
+		requeue := shouldRequeueMonitoringResultError(
+			response.ErrBadRequest(40041, "invalid_status", "status must be succeeded or failed"),
+			false,
+		)
+		assert.False(t, requeue)
+	})
+
+	t.Run("do not requeue redelivered internal error", func(t *testing.T) {
+		requeue := shouldRequeueMonitoringResultError(
+			response.ErrInternal(50041, "ingest_failed", "db unavailable"),
+			true,
+		)
+		assert.False(t, requeue)
+	})
+}
+
+func TestNewMonitoringTaskResultEnvelope(t *testing.T) {
+	receivedAt := time.Date(2026, 4, 10, 12, 0, 0, 0, time.UTC)
+	req := MonitoringTaskResultRequest{
+		LeaseToken: "lease-token",
+		Status:     "succeeded",
+	}
+	task := &monitoringCollectTask{
+		ID:       12,
+		TenantID: 34,
+	}
+
+	envelope := newMonitoringTaskResultEnvelope(task, 56, receivedAt, req)
+
+	assert.Equal(t, "v1", envelope.Version)
+	assert.Equal(t, int64(12), envelope.TaskID)
+	assert.Equal(t, int64(34), envelope.TenantID)
+	assert.Equal(t, int64(56), envelope.InstallationID)
+	assert.Equal(t, receivedAt, envelope.ReceivedAt)
+	assert.Equal(t, "pending", envelope.QueueStatus)
+	assert.Nil(t, envelope.QueueEnqueuedAt)
+	assert.Nil(t, envelope.LastQueuePublishError)
+	assert.Nil(t, envelope.ReceivedAlertedAt)
+	assert.Zero(t, envelope.ReceivedAlertCount)
+	assert.Equal(t, req, envelope.CallbackResult)
+}
+
+func TestDecodeMonitoringTaskResultEnvelope(t *testing.T) {
+	t.Run("decode valid payload", func(t *testing.T) {
+		raw, err := json.Marshal(monitoringTaskResultEnvelope{
+			Version:        "v1",
+			TaskID:         12,
+			TenantID:       34,
+			InstallationID: 56,
+			ReceivedAt:     time.Date(2026, 4, 10, 12, 0, 0, 0, time.UTC),
+			QueueStatus:    "queued",
+			CallbackResult: MonitoringTaskResultRequest{LeaseToken: "lease-token", Status: "succeeded"},
+		})
+		require.NoError(t, err)
+
+		envelope, err := decodeMonitoringTaskResultEnvelope(raw)
+		require.NoError(t, err)
+		assert.Equal(t, int64(12), envelope.TaskID)
+		assert.Equal(t, "queued", envelope.QueueStatus)
+	})
+
+	t.Run("reject payload without task id", func(t *testing.T) {
+		raw, err := json.Marshal(map[string]interface{}{"version": "v1"})
+		require.NoError(t, err)
+
+		_, err = decodeMonitoringTaskResultEnvelope(raw)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "task_id")
+	})
+}
diff --git a/server/internal/tenant/app/monitoring_result_recovery_worker.go b/server/internal/tenant/app/monitoring_result_recovery_worker.go
new file mode 100644
index 0000000..ab4c753
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_result_recovery_worker.go
@@ -0,0 +1,204 @@
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"go.uber.org/zap"
+)
+
+const (
+	defaultMonitoringResultRecoveryInterval = 1 * time.Minute
+	defaultMonitoringResultRecoveryTimeout  = 30 * time.Second
+	defaultMonitoringResultRecoveryLimit    = 100
+)
+
+type MonitoringResultRecoveryWorker struct {
+	monitoringPool *pgxpool.Pool
+	service        *MonitoringCallbackService
+	logger         *zap.Logger
+	interval       time.Duration
+	timeout        time.Duration
+	limit          int
+}
+
+type monitoringRecoverableTaskResult struct {
+	ID                 int64
+	CallbackReceivedAt time.Time
+	RequestPayloadJSON []byte
+}
+
+func NewMonitoringResultRecoveryWorker(monitoringPool *pgxpool.Pool, service *MonitoringCallbackService, logger *zap.Logger) *MonitoringResultRecoveryWorker {
+	return &MonitoringResultRecoveryWorker{
+		monitoringPool: monitoringPool,
+		service:        service,
+		logger:         logger,
+		interval:       defaultMonitoringResultRecoveryInterval,
+		timeout:        defaultMonitoringResultRecoveryTimeout,
+		limit:          defaultMonitoringResultRecoveryLimit,
+	}
+}
+
+func (w *MonitoringResultRecoveryWorker) Start(ctx context.Context) {
+	go w.run(ctx)
+}
+
+func (w *MonitoringResultRecoveryWorker) run(ctx context.Context) {
+	w.runOnce(ctx)
+
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			w.runOnce(ctx)
+		}
+	}
+}
+
+func (w *MonitoringResultRecoveryWorker) runOnce(parent context.Context) {
+	if w.monitoringPool == nil || w.service == nil {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(parent, w.timeout)
+	defer cancel()
+
+	tx, err := w.monitoringPool.Begin(ctx)
+	if err != nil {
+		w.logger.Warn("monitoring result recovery begin failed", zap.Error(err))
+		return
+	}
+	defer tx.Rollback(ctx)
+
+	items, err := loadMonitoringRecoverableTaskResults(ctx, tx, w.limit)
+	if err != nil {
+		w.logger.Warn("monitoring result recovery failed", monitoringWorkerErrorFields(err)...)
+		return
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		w.logger.Warn("monitoring result recovery commit failed", zap.Error(err))
+		return
+	}
+
+	if len(items) == 0 {
+		return
+	}
+
+	republishedCount := 0
+	for _, item := range items {
+		if w.tryRepublish(parent, item) {
+			republishedCount++
+		}
+	}
+
+	if republishedCount > 0 && w.logger != nil {
+		w.logger.Info("monitoring result recovery republished tasks", zap.Int("task_count", republishedCount))
+	}
+}
+
+func (w *MonitoringResultRecoveryWorker) tryRepublish(parent context.Context, item monitoringRecoverableTaskResult) bool {
+	if _, err := decodeMonitoringTaskResultEnvelope(item.RequestPayloadJSON); err != nil {
+		w.service.tryPatchTaskResultQueueMeta(item.ID, item.CallbackReceivedAt, monitoringTaskResultQueueMetaPatch{
+			QueueStatus:           "invalid_payload",
+			QueueClaimedAt:        nil,
+			QueueEnqueuedAt:       nil,
+			LastQueuePublishError: optionalString(err.Error()),
+		})
+		if w.logger != nil {
+			w.logger.Warn("monitoring result recovery skipped invalid payload", zap.Int64("task_id", item.ID), zap.Error(err))
+		}
+		return false
+	}
+
+	ctx, cancel := context.WithTimeout(parent, monitoringTaskResultQueueIOTimeout)
+	defer cancel()
+
+	if err := w.service.publishTaskResultEnvelope(ctx, item.RequestPayloadJSON); err != nil {
+		w.service.tryPatchTaskResultQueueMeta(item.ID, item.CallbackReceivedAt, monitoringTaskResultQueueMetaPatch{
+			QueueStatus:           "publish_failed",
+			QueueClaimedAt:        nil,
+			QueueEnqueuedAt:       nil,
+			LastQueuePublishError: optionalString(err.Error()),
+		})
+		if w.logger != nil {
+			w.logger.Warn("monitoring result recovery republish failed", zap.Int64("task_id", item.ID), zap.Error(err))
+		}
+		return false
+	}
+
+	enqueuedAt := time.Now().UTC().Round(0)
+	w.service.tryPatchTaskResultQueueMeta(item.ID, item.CallbackReceivedAt, monitoringTaskResultQueueMetaPatch{
+		QueueStatus:           "queued",
+		QueueClaimedAt:        nil,
+		QueueEnqueuedAt:       &enqueuedAt,
+		LastQueuePublishError: nil,
+	})
+
+	return true
+}
+
+func loadMonitoringRecoverableTaskResults(ctx context.Context, tx pgx.Tx, limit int) ([]monitoringRecoverableTaskResult, error) {
+	if limit <= 0 {
+		limit = defaultMonitoringResultRecoveryLimit
+	}
+
+	rows, err := tx.Query(ctx, `
+		SELECT
+			id,
+			callback_received_at,
+			request_payload_json
+		FROM monitoring_collect_tasks
+		WHERE collector_type = $1
+		  AND status = 'received'
+		  AND callback_received_at IS NOT NULL
+		  AND request_payload_json IS NOT NULL
+		  AND jsonb_typeof(request_payload_json) = 'object'
+		  AND COALESCE(NULLIF(request_payload_json ->> 'queue_status', ''), 'pending') IN ('pending', 'publish_failed')
+		ORDER BY callback_received_at ASC, id ASC
+		FOR UPDATE SKIP LOCKED
+		LIMIT $2
+	`, monitoringCollectorType, limit)
+	if err != nil {
+		return nil, monitoringInternalError(50041, "result_recovery_query_failed", "failed to load recoverable monitoring results", err)
+	}
+	defer rows.Close()
+
+	result := make([]monitoringRecoverableTaskResult, 0, limit)
+	for rows.Next() {
+		var item monitoringRecoverableTaskResult
+		if scanErr := rows.Scan(&item.ID, &item.CallbackReceivedAt, &item.RequestPayloadJSON); scanErr != nil {
+			return nil, monitoringInternalError(50041, "result_recovery_scan_failed", "failed to parse recoverable monitoring results", scanErr)
+		}
+		result = append(result, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, monitoringInternalError(50041, "result_recovery_scan_failed", "failed to iterate recoverable monitoring results", err)
+	}
+
+	return result, nil
+}
+
+func decodeMonitoringTaskResultEnvelope(payload []byte) (*monitoringTaskResultEnvelope, error) {
+	if len(payload) == 0 {
+		return nil, fmt.Errorf("monitoring task result payload is empty")
+	}
+
+	var envelope monitoringTaskResultEnvelope
+	if err := json.Unmarshal(payload, &envelope); err != nil {
+		return nil, err
+	}
+	if envelope.TaskID <= 0 {
+		return nil, fmt.Errorf("monitoring task result payload missing task_id")
+	}
+
+	return &envelope, nil
+}
diff --git a/server/internal/tenant/app/monitoring_service.go b/server/internal/tenant/app/monitoring_service.go
new file mode 100644
index 0000000..e3a97e2
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_service.go
@@ -0,0 +1,2456 @@
+package app
+
+import (
+	"context"
+	"crypto/md5"
+	"database/sql"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"github.com/geo-platform/tenant-api/internal/shared/auth"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+const (
+	defaultTrackingDays               = 7
+	maxTrackingDays                   = 30
+	monitoringCollectorType           = "plugin"
+	monitoringOnlineDuration          = 20 * time.Minute
+	monitoringCollectNowQuestionLimit = 5
+)
+
+type MonitoringService struct {
+	businessPool   *pgxpool.Pool
+	monitoringPool *pgxpool.Pool
+}
+
+func NewMonitoringService(businessPool, monitoringPool *pgxpool.Pool) *MonitoringService {
+	return &MonitoringService{
+		businessPool:   businessPool,
+		monitoringPool: monitoringPool,
+	}
+}
+
+type MonitoringDashboardCompositeResponse struct {
+	Overview          MonitoringOverview          `json:"overview"`
+	PlatformBreakdown []MonitoringPlatformDaily   `json:"platform_breakdown"`
+	BrandTimeBuckets  []MonitoringTimeBucket      `json:"brand_time_buckets"`
+	HotQuestions      []MonitoringHotQuestion     `json:"hot_questions"`
+	CitationRanking   []MonitoringCitationRanking `json:"citation_ranking"`
+	CitedArticles     []MonitoringCitedArticle    `json:"cited_articles"`
+}
+
+type MonitoringOverview struct {
+	CollectionMode                  string   `json:"collection_mode"`
+	MentionRate                     *float64 `json:"mention_rate"`
+	Top1MentionRate                 *float64 `json:"top1_mention_rate"`
+	FirstRecommendRate              *float64 `json:"first_recommend_rate"`
+	PositiveMentionRate             *float64 `json:"positive_mention_rate"`
+	CitationRate                    *float64 `json:"citation_rate"`
+	DesiredSampleCount              int64    `json:"desired_sample_count"`
+	PlannedSampleCount              int64    `json:"planned_sample_count"`
+	ActualSampleCount               int64    `json:"actual_sample_count"`
+	CoverageRate                    *float64 `json:"coverage_rate"`
+	ConfidenceLevel                 string   `json:"confidence_level"`
+	LastSampledAt                   *string  `json:"last_sampled_at"`
+	LastTriggerSource               *string  `json:"last_trigger_source"`
+	PrevSnapshotMentionRate         *float64 `json:"prev_snapshot_mention_rate"`
+	PrevSnapshotTop1MentionRate     *float64 `json:"prev_snapshot_top1_mention_rate"`
+	PrevSnapshotFirstRecommendRate  *float64 `json:"prev_snapshot_first_recommend_rate"`
+	PrevSnapshotPositiveMentionRate *float64 `json:"prev_snapshot_positive_mention_rate"`
+}
+
+type MonitoringPlatformDaily struct {
+	AIPlatformID         string   `json:"ai_platform_id"`
+	PlatformName         string   `json:"platform_name"`
+	MentionRate          *float64 `json:"mention_rate"`
+	Top1MentionRate      *float64 `json:"top1_mention_rate"`
+	PlatformSampleStatus string   `json:"platform_sample_status"`
+	ActualSampleCount    int64    `json:"actual_sample_count"`
+	LastSampledAt        *string  `json:"last_sampled_at"`
+}
+
+type MonitoringTimeBucket struct {
+	Date                string   `json:"date"`
+	SampleStatus        string   `json:"sample_status"`
+	MetricValue         *float64 `json:"metric_value"`
+	MentionRate         *float64 `json:"mention_rate"`
+	Top1MentionRate     *float64 `json:"top1_mention_rate"`
+	FirstRecommendRate  *float64 `json:"first_recommend_rate"`
+	PositiveMentionRate *float64 `json:"positive_mention_rate"`
+	CitationRate        *float64 `json:"citation_rate"`
+	PlannedSampleCount  int64    `json:"planned_sample_count"`
+	ActualSampleCount   int64    `json:"actual_sample_count"`
+	CoverageRate        *float64 `json:"coverage_rate"`
+	TriggerSource       *string  `json:"trigger_source"`
+	SnapshotUpdatedAt   *string  `json:"snapshot_updated_at"`
+}
+
+type MonitoringHotQuestion struct {
+	QuestionID    int64    `json:"question_id"`
+	QuestionHash  string   `json:"question_hash"`
+	QuestionText  string   `json:"question_text"`
+	MentionRate   *float64 `json:"mention_rate"`
+	LastSampledAt *string  `json:"last_sampled_at"`
+}
+
+type MonitoringCitationRanking struct {
+	AIPlatformID      string   `json:"ai_platform_id"`
+	PlatformName      string   `json:"platform_name"`
+	SampleStatus      string   `json:"sample_status"`
+	CitedAnswerCount  int64    `json:"cited_answer_count"`
+	CitedArticleCount int64    `json:"cited_article_count"`
+	CitationRate      *float64 `json:"citation_rate"`
+}
+
+type MonitoringCitedArticle struct {
+	ArticleID       int64    `json:"article_id"`
+	ArticleTitle    string   `json:"article_title"`
+	PublishPlatform string   `json:"publish_platform"`
+	CitationCount   int64    `json:"citation_count"`
+	CitationRate    *float64 `json:"citation_rate"`
+}
+
+type MonitoringQuestionDetailResponse struct {
+	QuestionID       int64                               `json:"question_id"`
+	QuestionHash     string                              `json:"question_hash"`
+	QuestionText     string                              `json:"question_text"`
+	TimeWindow       MonitoringQuestionDetailTimeWindow  `json:"time_window"`
+	Platforms        []MonitoringQuestionDetailPlatform  `json:"platforms"`
+	CitationAnalysis []MonitoringQuestionCitationStats   `json:"citation_analysis"`
+	ContentCitations []MonitoringQuestionContentCitation `json:"content_citations"`
+}
+
+type MonitoringQuestionDetailTimeWindow struct {
+	DateFrom string `json:"date_from"`
+	DateTo   string `json:"date_to"`
+}
+
+type MonitoringQuestionDetailPlatform struct {
+	AIPlatformID         string                             `json:"ai_platform_id"`
+	PlatformName         string                             `json:"platform_name"`
+	SampleStatus         string                             `json:"sample_status"`
+	RunID                *int64                             `json:"run_id"`
+	SampledAt            *string                            `json:"sampled_at"`
+	ProviderModel        *string                            `json:"provider_model"`
+	AnswerText           *string                            `json:"answer_text"`
+	BrandMentioned       *bool                              `json:"brand_mentioned"`
+	BrandMentionPosition *string                            `json:"brand_mention_position"`
+	Citations            []MonitoringQuestionDetailCitation `json:"citations"`
+}
+
+type MonitoringQuestionDetailCitation struct {
+	CitedURL             string  `json:"cited_url"`
+	CitedTitle           *string `json:"cited_title"`
+	SiteName             string  `json:"site_name"`
+	SiteKey              string  `json:"site_key"`
+	FaviconURL           string  `json:"favicon_url"`
+	ArticleID            *int64  `json:"article_id"`
+	ArticleTitle         *string `json:"article_title,omitempty"`
+	ResolutionStatus     string  `json:"resolution_status"`
+	ResolutionConfidence string  `json:"resolution_confidence"`
+}
+
+type MonitoringQuestionCitationStats struct {
+	AIPlatformID         string   `json:"ai_platform_id"`
+	PlatformName         string   `json:"platform_name"`
+	SiteName             string   `json:"site_name"`
+	SiteKey              string   `json:"site_key"`
+	SiteDomain           string   `json:"site_domain"`
+	CitationCount        int64    `json:"citation_count"`
+	CitationRate         *float64 `json:"citation_rate"`
+	ContentCitationCount int64    `json:"content_citation_count"`
+}
+
+type MonitoringQuestionContentCitation struct {
+	ArticleID       int64    `json:"article_id"`
+	ArticleTitle    string   `json:"article_title"`
+	PublishPlatform string   `json:"publish_platform"`
+	AIPlatformID    string   `json:"ai_platform_id"`
+	PlatformName    string   `json:"platform_name"`
+	CitationCount   int64    `json:"citation_count"`
+	CitationRate    *float64 `json:"citation_rate"`
+}
+
+type MonitoringCollectNowResponse struct {
+	CollectionMode       string `json:"collection_mode"`
+	RefreshedTaskCount   int64  `json:"refreshed_task_count"`
+	CreatedTaskCount     int64  `json:"created_task_count"`
+	LeasedTaskCount      int64  `json:"leased_task_count"`
+	CompletedTaskCount   int64  `json:"completed_task_count"`
+	HasEffectiveSnapshot bool   `json:"has_effective_snapshot"`
+	Message              string `json:"message"`
+}
+
+type monitoringQuotaConfig struct {
+	CollectionMode        string
+	PrimaryInstallationID *int64
+	EnabledPlatforms      []string
+}
+
+type monitoringBrandIdentity struct {
+	ID   int64
+	Name string
+}
+
+type monitoringAccessState struct {
+	AccessStatus string
+}
+
+type monitoringLatestPlatformRun struct {
+	PlatformID           string
+	RunID                int64
+	CompletedAt          sql.NullTime
+	ProviderModel        sql.NullString
+	AnswerText           sql.NullString
+	BrandMentioned       sql.NullBool
+	BrandMentionPosition sql.NullString
+}
+
+type monitoringDerivedRateStats struct {
+	Total            int64
+	MentionedCount   int64
+	Top1Count        int64
+	FirstRecommend   int64
+	PositiveMentions int64
+}
+
+type monitoringDerivedMetrics struct {
+	ByDate         map[string]monitoringDerivedRateStats
+	ByDatePlatform map[string]map[string]monitoringDerivedRateStats
+	ByDateQuestion map[string]map[int64]monitoringDerivedRateStats
+	ByQuestion     map[int64]monitoringDerivedRateStats
+}
+
+type monitoringPlatformMetadata struct {
+	ID   string
+	Name string
+}
+
+type monitoringConfiguredQuestion struct {
+	ID           int64
+	KeywordID    int64
+	QuestionText string
+	QuestionHash []byte
+}
+
+var defaultMonitoringPlatforms = []monitoringPlatformMetadata{
+	{ID: "deepseek", Name: "DeepSeek"},
+	{ID: "qwen", Name: "通义千问"},
+	{ID: "doubao", Name: "豆包"},
+}
+
+var monitoringPlatformNames = map[string]string{
+	"deepseek": "DeepSeek",
+	"qwen":     "通义千问",
+	"doubao":   "豆包",
+	"kimi":     "Kimi",
+	"yuanbao":  "腾讯元宝",
+}
+
+func (s *MonitoringService) DashboardComposite(ctx context.Context, brandID int64, keywordID *int64, days int, businessDate string) (*MonitoringDashboardCompositeResponse, error) {
+	actor := auth.MustActor(ctx)
+
+	brand, err := s.resolveBrand(ctx, actor.TenantID, brandID)
+	if err != nil {
+		return nil, err
+	}
+
+	if keywordID != nil {
+		if err := s.ensureKeywordBelongsToBrand(ctx, actor.TenantID, brand.ID, *keywordID); err != nil {
+			return nil, err
+		}
+	}
+
+	quota, err := s.loadQuota(ctx, actor.TenantID)
+	if err != nil {
+		return nil, err
+	}
+
+	configuredQuestions, err := s.loadConfiguredQuestions(ctx, actor.TenantID, brand.ID, keywordID)
+	if err != nil {
+		return nil, err
+	}
+	questionIDs := configuredQuestionIDs(configuredQuestions)
+
+	platforms := resolveMonitoringPlatforms(quota.EnabledPlatforms)
+	startDate, endDate, err := resolveDashboardDateWindow(days, businessDate)
+	if err != nil {
+		return nil, err
+	}
+	derivedMetrics, err := s.loadDerivedParseMetrics(ctx, actor.TenantID, brand.ID, brand.Name, startDate, endDate)
+	if err != nil {
+		return nil, err
+	}
+	overview, _, err := s.loadOverview(ctx, actor.TenantID, brand.ID, startDate, endDate, quota.CollectionMode, derivedMetrics)
+	if err != nil {
+		return nil, err
+	}
+
+	accessStates, err := s.loadAccessStates(ctx, actor.TenantID, quota.PrimaryInstallationID, endDate)
+	if err != nil {
+		return nil, err
+	}
+
+	platformBreakdown, err := s.loadPlatformBreakdown(ctx, actor.TenantID, brand.ID, endDate, quota.CollectionMode, platforms, accessStates, derivedMetrics)
+	if err != nil {
+		return nil, err
+	}
+
+	timeBuckets, err := s.loadTimeBuckets(ctx, actor.TenantID, brand.ID, startDate, endDate, quota.CollectionMode, derivedMetrics)
+	if err != nil {
+		return nil, err
+	}
+
+	hotQuestions, err := s.loadHotQuestions(ctx, actor.TenantID, brand.ID, configuredQuestions, endDate, derivedMetrics)
+	if err != nil {
+		return nil, err
+	}
+
+	citationRanking, err := s.loadCitationRanking(ctx, actor.TenantID, brand.ID, questionIDs, startDate, endDate, accessStates)
+	if err != nil {
+		return nil, err
+	}
+
+	citedArticles, err := s.loadCitedArticles(ctx, actor.TenantID, brand.ID, questionIDs, startDate, endDate)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MonitoringDashboardCompositeResponse{
+		Overview:          overview,
+		PlatformBreakdown: platformBreakdown,
+		BrandTimeBuckets:  timeBuckets,
+		HotQuestions:      hotQuestions,
+		CitationRanking:   citationRanking,
+		CitedArticles:     citedArticles,
+	}, nil
+}
+
+func (s *MonitoringService) QuestionDetail(ctx context.Context, brandID, questionID int64, dateFrom, dateTo string, questionHash string, aiPlatformID *string) (*MonitoringQuestionDetailResponse, error) {
+	actor := auth.MustActor(ctx)
+
+	brand, err := s.resolveBrand(ctx, actor.TenantID, brandID)
+	if err != nil {
+		return nil, err
+	}
+
+	fromDate, toDate, err := parseDetailDateRange(dateFrom, dateTo)
+	if err != nil {
+		return nil, err
+	}
+
+	quota, err := s.loadQuota(ctx, actor.TenantID)
+	if err != nil {
+		return nil, err
+	}
+	platforms := resolveMonitoringPlatforms(quota.EnabledPlatforms)
+
+	questionText, err := s.loadQuestionText(ctx, actor.TenantID, brand.ID, questionID)
+	if err != nil {
+		return nil, err
+	}
+
+	hashBytes := []byte(nil)
+	if strings.TrimSpace(questionHash) != "" {
+		hashBytes, err = decodeQuestionHash(questionHash)
+		if err != nil {
+			return nil, response.ErrBadRequest(40031, "invalid_question_hash", "question_hash must be a v1 hex digest")
+		}
+	} else {
+		hashBytes, err = s.loadLatestQuestionHash(ctx, actor.TenantID, brand.ID, questionID, fromDate, toDate)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	accessStates, err := s.loadAccessStates(ctx, actor.TenantID, quota.PrimaryInstallationID, toDate)
+	if err != nil {
+		return nil, err
+	}
+
+	latestRuns, err := s.loadLatestPlatformRuns(ctx, actor.TenantID, brand.ID, brand.Name, questionID, hashBytes, fromDate, toDate, aiPlatformID)
+	if err != nil {
+		return nil, err
+	}
+
+	runIDs := make([]int64, 0, len(latestRuns))
+	for _, item := range latestRuns {
+		runIDs = append(runIDs, item.RunID)
+	}
+
+	citationMap, err := s.loadCitationsForRuns(ctx, actor.TenantID, runIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	platformPayload := make([]MonitoringQuestionDetailPlatform, 0, len(platforms))
+	for _, platform := range platforms {
+		if aiPlatformID != nil && strings.TrimSpace(*aiPlatformID) != "" && platform.ID != strings.TrimSpace(*aiPlatformID) {
+			continue
+		}
+
+		if run, ok := latestRuns[platform.ID]; ok {
+			runID := run.RunID
+			platformPayload = append(platformPayload, MonitoringQuestionDetailPlatform{
+				AIPlatformID:         platform.ID,
+				PlatformName:         platform.Name,
+				SampleStatus:         "sampled",
+				RunID:                &runID,
+				SampledAt:            formatNullTime(run.CompletedAt),
+				ProviderModel:        stringPointer(run.ProviderModel),
+				AnswerText:           stringPointer(run.AnswerText),
+				BrandMentioned:       boolPointer(run.BrandMentioned),
+				BrandMentionPosition: stringPointer(run.BrandMentionPosition),
+				Citations:            citationMap[run.RunID],
+			})
+			continue
+		}
+
+		platformPayload = append(platformPayload, MonitoringQuestionDetailPlatform{
+			AIPlatformID: platform.ID,
+			PlatformName: platform.Name,
+			SampleStatus: derivePlatformSampleStatus("", accessStates[platform.ID]),
+			Citations:    []MonitoringQuestionDetailCitation{},
+		})
+	}
+
+	citationAnalysis, err := s.loadQuestionCitationAnalysis(ctx, actor.TenantID, brand.ID, questionID, hashBytes, fromDate, toDate, aiPlatformID)
+	if err != nil {
+		return nil, err
+	}
+
+	contentCitations, err := s.loadQuestionContentCitations(ctx, actor.TenantID, brand.ID, questionID, hashBytes, fromDate, toDate, aiPlatformID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MonitoringQuestionDetailResponse{
+		QuestionID:   questionID,
+		QuestionHash: encodeQuestionHash(hashBytes),
+		QuestionText: questionText,
+		TimeWindow: MonitoringQuestionDetailTimeWindow{
+			DateFrom: fromDate.Format("2006-01-02"),
+			DateTo:   toDate.Format("2006-01-02"),
+		},
+		Platforms:        platformPayload,
+		CitationAnalysis: citationAnalysis,
+		ContentCitations: contentCitations,
+	}, nil
+}
+
+func (s *MonitoringService) CollectNow(ctx context.Context, brandID int64, keywordID *int64) (*MonitoringCollectNowResponse, error) {
+	actor := auth.MustActor(ctx)
+
+	brand, err := s.resolveBrand(ctx, actor.TenantID, brandID)
+	if err != nil {
+		return nil, err
+	}
+
+	if keywordID != nil {
+		if err := s.ensureKeywordBelongsToBrand(ctx, actor.TenantID, brand.ID, *keywordID); err != nil {
+			return nil, err
+		}
+	}
+
+	quota, err := s.loadQuota(ctx, actor.TenantID)
+	if err != nil {
+		return nil, err
+	}
+
+	configuredQuestions, err := s.loadConfiguredQuestions(ctx, actor.TenantID, brand.ID, keywordID)
+	if err != nil {
+		return nil, err
+	}
+
+	limitApplied := false
+	if len(configuredQuestions) > monitoringCollectNowQuestionLimit {
+		configuredQuestions = configuredQuestions[:monitoringCollectNowQuestionLimit]
+		limitApplied = true
+	}
+	if len(configuredQuestions) == 0 {
+		return &MonitoringCollectNowResponse{
+			CollectionMode:       quota.CollectionMode,
+			RefreshedTaskCount:   0,
+			CreatedTaskCount:     0,
+			LeasedTaskCount:      0,
+			CompletedTaskCount:   0,
+			HasEffectiveSnapshot: true,
+			Message:              "当前关键词下暂无品牌库问题，未创建采集任务",
+		}, nil
+	}
+
+	platforms := resolveMonitoringPlatforms(quota.EnabledPlatforms)
+	questionIDs := configuredQuestionIDs(configuredQuestions)
+
+	installationID, err := s.resolveCollectNowInstallationID(ctx, actor.TenantID, quota.PrimaryInstallationID)
+	if err != nil {
+		return nil, err
+	}
+	if installationID == nil {
+		return nil, response.ErrConflict(40941, "installation_offline", "primary monitoring installation is offline")
+	}
+
+	if err := s.ensureInstallationOnline(ctx, actor.TenantID, *installationID); err != nil {
+		return nil, err
+	}
+
+	now := time.Now().UTC()
+	todayTime, today := monitoringBusinessDayAndDateAt(now)
+
+	tx, err := s.monitoringPool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "begin_failed", "failed to start monitoring collect-now transaction")
+	}
+	defer tx.Rollback(ctx)
+
+	if _, err := expireMonitoringLeasedTasks(ctx, tx, &actor.TenantID, now); err != nil {
+		return nil, err
+	}
+
+	if err := s.syncMonitoringQuestionSnapshots(ctx, tx, actor.TenantID, brand.ID, configuredQuestions, keywordID == nil); err != nil {
+		return nil, err
+	}
+
+	refreshedCount, createdCount, err := s.ensureCollectNowTasks(ctx, tx, actor.TenantID, brand.ID, configuredQuestions, platforms, todayTime)
+	if err != nil {
+		return nil, err
+	}
+
+	var leasedCount int64
+	var completedCount int64
+	if err := tx.QueryRow(ctx, `
+		SELECT
+			COUNT(*) FILTER (WHERE status = 'leased') AS leased_count,
+			COUNT(*) FILTER (WHERE status = 'completed') AS completed_count
+		FROM monitoring_collect_tasks
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+		  AND question_id = ANY($5)
+	`, actor.TenantID, brand.ID, monitoringCollectorType, today, questionIDs).Scan(&leasedCount, &completedCount); err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to inspect monitoring tasks")
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50041, "commit_failed", "failed to commit monitoring collect-now")
+	}
+
+	hasEffectiveSnapshot := false
+	message := "已触发所选关键词立即采集，正在后台执行"
+	switch {
+	case createdCount > 0 && refreshedCount > 0:
+		message = "已补种并重置所选关键词今日任务，正在后台执行"
+	case createdCount > 0:
+		message = "已补种所选关键词的采集任务，正在后台执行"
+	case refreshedCount > 0:
+		message = "已重置所选关键词今日任务，正在后台执行"
+	case leasedCount > 0:
+		hasEffectiveSnapshot = true
+		message = "所选关键词已有执行中的任务，已继续在后台执行"
+	case completedCount > 0:
+		message = "已触发所选关键词重新采集，新的结果会覆盖今日结果"
+	default:
+		hasEffectiveSnapshot = true
+		message = "所选关键词暂无可重新调度的任务"
+	}
+	if limitApplied && (createdCount > 0 || refreshedCount > 0) {
+		message = fmt.Sprintf("%s（本次最多执行 %d 个问题）", message, monitoringCollectNowQuestionLimit)
+	}
+
+	return &MonitoringCollectNowResponse{
+		CollectionMode:       quota.CollectionMode,
+		RefreshedTaskCount:   refreshedCount,
+		CreatedTaskCount:     createdCount,
+		LeasedTaskCount:      leasedCount,
+		CompletedTaskCount:   completedCount,
+		HasEffectiveSnapshot: hasEffectiveSnapshot,
+		Message:              message,
+	}, nil
+}
+
+func (s *MonitoringService) resolveCollectNowInstallationID(ctx context.Context, tenantID int64, preferred *int64) (*int64, error) {
+	if preferred != nil {
+		online, err := s.isInstallationOnline(ctx, tenantID, *preferred)
+		if err != nil {
+			return nil, err
+		}
+		if online {
+			return preferred, nil
+		}
+	}
+
+	fallbackID, err := s.findLatestOnlineInstallation(ctx, tenantID)
+	if err != nil {
+		return nil, err
+	}
+	if fallbackID == nil {
+		return nil, nil
+	}
+
+	if preferred == nil || *preferred != *fallbackID {
+		if err := s.persistPrimaryInstallationID(ctx, tenantID, *fallbackID); err != nil {
+			return nil, err
+		}
+	}
+
+	return fallbackID, nil
+}
+
+func (s *MonitoringService) findLatestOnlineInstallation(ctx context.Context, tenantID int64) (*int64, error) {
+	var installationID int64
+	err := s.businessPool.QueryRow(ctx, `
+		SELECT id
+		FROM plugin_installations
+		WHERE tenant_id = $1
+		  AND status = 'active'
+		  AND deleted_at IS NULL
+		  AND last_seen_at IS NOT NULL
+		  AND last_seen_at >= NOW() - $2::interval
+		ORDER BY last_seen_at DESC, updated_at DESC, id DESC
+		LIMIT 1
+	`, tenantID, formatPgInterval(monitoringOnlineDuration)).Scan(&installationID)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, nil
+		}
+		return nil, response.ErrInternal(50041, "query_failed", "failed to inspect online monitoring installation")
+	}
+	return &installationID, nil
+}
+
+func (s *MonitoringService) persistPrimaryInstallationID(ctx context.Context, tenantID, installationID int64) error {
+	if _, err := s.businessPool.Exec(ctx, `
+		INSERT INTO tenant_monitoring_quotas (
+			tenant_id, primary_installation_id
+		)
+		VALUES ($1, $2)
+		ON CONFLICT (tenant_id) DO UPDATE
+		SET primary_installation_id = EXCLUDED.primary_installation_id,
+			updated_at = NOW()
+	`, tenantID, installationID); err != nil {
+		return response.ErrInternal(50041, "update_failed", "failed to persist primary monitoring installation")
+	}
+	return nil
+}
+
+func formatPgInterval(duration time.Duration) string {
+	return fmt.Sprintf("%d seconds", int64(duration/time.Second))
+}
+
+func (s *MonitoringService) resolveBrand(ctx context.Context, tenantID, brandID int64) (*monitoringBrandIdentity, error) {
+	targetBrandID := brandID
+	if targetBrandID == 0 {
+		if err := s.businessPool.QueryRow(ctx, `
+			SELECT id
+			FROM brands
+			WHERE tenant_id = $1 AND deleted_at IS NULL
+			ORDER BY created_at ASC
+			LIMIT 1
+		`, tenantID).Scan(&targetBrandID); err != nil {
+			if err == pgx.ErrNoRows {
+				return nil, response.ErrNotFound(40441, "brand_not_found", "no brand found for tenant")
+			}
+			return nil, response.ErrInternal(50041, "query_failed", "failed to resolve brand")
+		}
+	}
+
+	brand := &monitoringBrandIdentity{}
+	if err := s.businessPool.QueryRow(ctx, `
+		SELECT id, name
+		FROM brands
+		WHERE id = $1 AND tenant_id = $2 AND deleted_at IS NULL
+	`, targetBrandID, tenantID).Scan(&brand.ID, &brand.Name); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, response.ErrNotFound(40441, "brand_not_found", "brand not found")
+		}
+		return nil, response.ErrInternal(50041, "query_failed", "failed to resolve brand")
+	}
+	return brand, nil
+}
+
+func (s *MonitoringService) ensureKeywordBelongsToBrand(ctx context.Context, tenantID, brandID, keywordID int64) error {
+	var exists bool
+	if err := s.businessPool.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1
+			FROM brand_keywords
+			WHERE id = $1 AND tenant_id = $2 AND brand_id = $3 AND deleted_at IS NULL
+		)
+	`, keywordID, tenantID, brandID).Scan(&exists); err != nil {
+		return response.ErrInternal(50041, "query_failed", "failed to validate keyword")
+	}
+	if !exists {
+		return response.ErrBadRequest(40041, "invalid_keyword", "keyword does not belong to the selected brand")
+	}
+	return nil
+}
+
+func (s *MonitoringService) loadConfiguredQuestions(ctx context.Context, tenantID, brandID int64, keywordID *int64) ([]monitoringConfiguredQuestion, error) {
+	rows, err := s.businessPool.Query(ctx, `
+		SELECT q.id, q.keyword_id, q.question_text
+		FROM brand_questions q
+		JOIN brand_keywords k
+			ON k.id = q.keyword_id
+		   AND k.tenant_id = q.tenant_id
+		   AND k.brand_id = q.brand_id
+		   AND k.deleted_at IS NULL
+		   AND k.status = 'active'
+		WHERE q.tenant_id = $1
+		  AND q.brand_id = $2
+		  AND q.deleted_at IS NULL
+		  AND q.status = 'active'
+		  AND ($3::bigint IS NULL OR q.keyword_id = $3)
+		ORDER BY q.keyword_id ASC, q.id ASC
+	`, tenantID, brandID, nullableInt64(keywordID))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load configured monitoring questions")
+	}
+	defer rows.Close()
+
+	items := make([]monitoringConfiguredQuestion, 0)
+	for rows.Next() {
+		var item monitoringConfiguredQuestion
+		if scanErr := rows.Scan(&item.ID, &item.KeywordID, &item.QuestionText); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse configured monitoring questions")
+		}
+		item.QuestionHash = seededQuestionHash(item.QuestionText)
+		items = append(items, item)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate configured monitoring questions")
+	}
+
+	return items, nil
+}
+
+func configuredQuestionIDs(questions []monitoringConfiguredQuestion) []int64 {
+	ids := make([]int64, 0, len(questions))
+	for _, item := range questions {
+		ids = append(ids, item.ID)
+	}
+	return ids
+}
+
+func (s *MonitoringService) syncMonitoringQuestionSnapshots(ctx context.Context, tx pgx.Tx, tenantID, brandID int64, questions []monitoringConfiguredQuestion, pruneMissing bool) error {
+	if pruneMissing {
+		if len(questions) == 0 {
+			if _, err := tx.Exec(ctx, `
+				UPDATE monitoring_question_config_snapshots
+				SET deleted_at = COALESCE(deleted_at, NOW()),
+				    updated_at = NOW()
+				WHERE tenant_id = $1
+				  AND brand_id = $2
+				  AND deleted_at IS NULL
+			`, tenantID, brandID); err != nil {
+				return response.ErrInternal(50041, "snapshot_prune_failed", "failed to prune monitoring question snapshots")
+			}
+		} else if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_question_config_snapshots
+			SET deleted_at = COALESCE(deleted_at, NOW()),
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+		  AND deleted_at IS NULL
+			  AND NOT (question_id = ANY($3))
+		`, tenantID, brandID, configuredQuestionIDs(questions)); err != nil {
+			return response.ErrInternal(50041, "snapshot_prune_failed", "failed to prune monitoring question snapshots")
+		}
+	}
+
+	for _, question := range questions {
+		if _, err := tx.Exec(ctx, `
+			UPDATE monitoring_question_config_snapshots
+			SET superseded_at = COALESCE(superseded_at, NOW()),
+			    deleted_at = NULL,
+			    updated_at = NOW()
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND question_id = $3
+			  AND question_hash <> $4
+			  AND superseded_at IS NULL
+		`, tenantID, brandID, question.ID, question.QuestionHash); err != nil {
+			return response.ErrInternal(50041, "snapshot_update_failed", "failed to supersede monitoring question snapshot")
+		}
+
+		if _, err := tx.Exec(ctx, `
+			INSERT INTO monitoring_question_config_snapshots (
+				tenant_id, brand_id, question_id, keyword_id, question_hash,
+				question_text_snapshot, monitor_enabled, projected_at
+			)
+			VALUES ($1, $2, $3, $4, $5, $6, TRUE, NOW())
+			ON CONFLICT (tenant_id, question_id, question_hash)
+			DO UPDATE SET
+				brand_id = EXCLUDED.brand_id,
+				keyword_id = EXCLUDED.keyword_id,
+				question_text_snapshot = EXCLUDED.question_text_snapshot,
+				monitor_enabled = TRUE,
+				superseded_at = NULL,
+				deleted_at = NULL,
+				projected_at = NOW(),
+				updated_at = NOW()
+		`, tenantID, brandID, question.ID, question.KeywordID, question.QuestionHash, question.QuestionText); err != nil {
+			return response.ErrInternal(50041, "snapshot_upsert_failed", "failed to persist monitoring question snapshot")
+		}
+	}
+
+	return nil
+}
+
+func (s *MonitoringService) ensureCollectNowTasks(
+	ctx context.Context,
+	tx pgx.Tx,
+	tenantID, brandID int64,
+	questions []monitoringConfiguredQuestion,
+	platforms []monitoringPlatformMetadata,
+	businessDate time.Time,
+) (int64, int64, error) {
+	const runMode = "plugin_standard"
+
+	dateText := businessDate.Format("2006-01-02")
+	var refreshedCount int64
+	var createdCount int64
+
+	for _, question := range questions {
+		for _, platform := range platforms {
+			tag, err := tx.Exec(ctx, `
+				UPDATE monitoring_collect_tasks
+				SET question_hash = $7,
+				    status = 'pending',
+				    planned_at = NOW(),
+				    trigger_source = 'manual',
+				    lease_token_hash = NULL,
+				    leased_to_executor = NULL,
+				    leased_at = NULL,
+				    lease_expires_at = NULL,
+				    callback_received_at = NULL,
+				    completed_at = NULL,
+				    skip_reason = NULL,
+				    request_payload_json = NULL,
+				    error_message = NULL,
+				    updated_at = NOW()
+				WHERE tenant_id = $1
+				  AND brand_id = $2
+				  AND question_id = $3
+				  AND ai_platform_id = $4
+				  AND collector_type = $5
+				  AND run_mode = $6
+				  AND business_date = $8::date
+				  AND status IN ('pending', 'expired', 'failed', 'completed', 'skipped')
+			`, tenantID, brandID, question.ID, platform.ID, monitoringCollectorType, runMode, question.QuestionHash, dateText)
+			if err != nil {
+				return 0, 0, response.ErrInternal(50041, "update_failed", "failed to refresh monitoring tasks")
+			}
+			refreshedCount += tag.RowsAffected()
+
+			tag, err = tx.Exec(ctx, `
+				INSERT INTO monitoring_collect_tasks (
+					tenant_id, brand_id, question_id, question_hash, ai_platform_id,
+					collector_type, trigger_source, run_mode, business_date, planned_at, status
+				)
+				VALUES (
+					$1, $2, $3, $4, $5,
+					$6, 'manual', $7, $8::date, NOW(), 'pending'
+				)
+				ON CONFLICT (
+					tenant_id, brand_id, question_id, ai_platform_id, collector_type, run_mode, business_date
+				)
+				DO NOTHING
+			`, tenantID, brandID, question.ID, question.QuestionHash, platform.ID, monitoringCollectorType, runMode, dateText)
+			if err != nil {
+				return 0, 0, response.ErrInternal(50041, "insert_failed", "failed to create monitoring tasks")
+			}
+			createdCount += tag.RowsAffected()
+		}
+	}
+
+	return refreshedCount, createdCount, nil
+}
+
+func (s *MonitoringService) loadQuota(ctx context.Context, tenantID int64) (monitoringQuotaConfig, error) {
+	cfg := monitoringQuotaConfig{
+		CollectionMode:   monitoringCollectorType,
+		EnabledPlatforms: []string{"deepseek", "qwen", "doubao"},
+	}
+
+	var enabledJSON []byte
+	var installationID sql.NullInt64
+	err := s.businessPool.QueryRow(ctx, `
+		SELECT collection_mode, enabled_platforms, primary_installation_id
+		FROM tenant_monitoring_quotas
+		WHERE tenant_id = $1
+	`, tenantID).Scan(&cfg.CollectionMode, &enabledJSON, &installationID)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return cfg, nil
+		}
+		return cfg, response.ErrInternal(50041, "query_failed", "failed to load monitoring quota")
+	}
+
+	if len(enabledJSON) > 0 {
+		var enabled []string
+		if jsonErr := json.Unmarshal(enabledJSON, &enabled); jsonErr == nil && len(enabled) > 0 {
+			cfg.EnabledPlatforms = enabled
+		}
+	}
+	if installationID.Valid {
+		id := installationID.Int64
+		cfg.PrimaryInstallationID = &id
+	}
+	if strings.TrimSpace(cfg.CollectionMode) == "" {
+		cfg.CollectionMode = monitoringCollectorType
+	}
+	return cfg, nil
+}
+
+func newMonitoringDerivedMetrics() monitoringDerivedMetrics {
+	return monitoringDerivedMetrics{
+		ByDate:         make(map[string]monitoringDerivedRateStats),
+		ByDatePlatform: make(map[string]map[string]monitoringDerivedRateStats),
+		ByDateQuestion: make(map[string]map[int64]monitoringDerivedRateStats),
+		ByQuestion:     make(map[int64]monitoringDerivedRateStats),
+	}
+}
+
+func (stats *monitoringDerivedRateStats) add(summary monitoringAnswerParseSummary) {
+	stats.Total++
+	if summary.BrandMentioned {
+		stats.MentionedCount++
+	}
+	if summary.BrandMentionPosition == "top1" {
+		stats.Top1Count++
+	}
+	if summary.FirstRecommended {
+		stats.FirstRecommend++
+	}
+	if summary.SentimentLabel == "positive" {
+		stats.PositiveMentions++
+	}
+}
+
+func (stats monitoringDerivedRateStats) hasSamples() bool {
+	return stats.Total > 0
+}
+
+func (stats monitoringDerivedRateStats) mentionRate() *float64 {
+	return divideAsPointer(stats.MentionedCount, stats.Total)
+}
+
+func averageDerivedRateByPlatform(
+	statsByPlatform map[string]monitoringDerivedRateStats,
+	extractor func(monitoringDerivedRateStats) *float64,
+) *float64 {
+	if len(statsByPlatform) == 0 {
+		return nil
+	}
+
+	total := 0.0
+	count := 0
+	for _, stats := range statsByPlatform {
+		value := extractor(stats)
+		if value == nil {
+			continue
+		}
+		total += *value
+		count++
+	}
+	if count == 0 {
+		return nil
+	}
+
+	average := total / float64(count)
+	return &average
+}
+
+func (stats monitoringDerivedRateStats) top1MentionRate() *float64 {
+	return divideAsPointer(stats.Top1Count, stats.Total)
+}
+
+func (stats monitoringDerivedRateStats) firstRecommendRate() *float64 {
+	return divideAsPointer(stats.FirstRecommend, stats.Total)
+}
+
+func (stats monitoringDerivedRateStats) positiveMentionRate() *float64 {
+	return divideAsPointer(stats.PositiveMentions, stats.Total)
+}
+
+func (s *MonitoringService) loadDerivedParseMetrics(ctx context.Context, tenantID, brandID int64, brandName string, startDate, endDate time.Time) (monitoringDerivedMetrics, error) {
+	metrics := newMonitoringDerivedMetrics()
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			r.business_date,
+			r.ai_platform_id,
+			r.question_id,
+			r.raw_answer_text,
+			p.brand_mentioned,
+			p.brand_mention_position,
+			p.first_recommended,
+			p.sentiment_label,
+			p.matched_brand_terms
+		FROM question_monitor_runs r
+		LEFT JOIN question_monitor_parse_results p
+			ON p.tenant_id = r.tenant_id AND p.run_id = r.id
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.collector_type = $3
+		  AND r.status = 'succeeded'
+		  AND r.business_date BETWEEN $4::date AND $5::date
+	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"))
+	if err != nil {
+		return metrics, response.ErrInternal(50041, "query_failed", "failed to load monitoring derived parse metrics")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var businessDate time.Time
+		var platformID string
+		var questionID int64
+		var answerText sql.NullString
+		var brandMentioned sql.NullBool
+		var brandMentionPosition sql.NullString
+		var firstRecommended sql.NullBool
+		var sentimentLabel sql.NullString
+		var matchedBrandTermsJSON []byte
+		if scanErr := rows.Scan(
+			&businessDate,
+			&platformID,
+			&questionID,
+			&answerText,
+			&brandMentioned,
+			&brandMentionPosition,
+			&firstRecommended,
+			&sentimentLabel,
+			&matchedBrandTermsJSON,
+		); scanErr != nil {
+			return metrics, response.ErrInternal(50041, "scan_failed", "failed to parse monitoring derived metrics")
+		}
+
+		summary := resolveMonitoringAnswerParseSummary(
+			answerText.String,
+			brandName,
+			monitoringStoredParseFields{
+				BrandMentioned:       boolPointer(brandMentioned),
+				BrandMentionPosition: stringPointer(brandMentionPosition),
+				FirstRecommended:     boolPointer(firstRecommended),
+				SentimentLabel:       stringPointer(sentimentLabel),
+				MatchedBrandTerms:    decodeMonitoringMatchedBrandTerms(matchedBrandTermsJSON),
+			},
+		)
+
+		dateKey := businessDate.Format("2006-01-02")
+		dateStats := metrics.ByDate[dateKey]
+		dateStats.add(summary)
+		metrics.ByDate[dateKey] = dateStats
+
+		platformStatsByDate, ok := metrics.ByDatePlatform[dateKey]
+		if !ok {
+			platformStatsByDate = make(map[string]monitoringDerivedRateStats)
+			metrics.ByDatePlatform[dateKey] = platformStatsByDate
+		}
+		platformStats := platformStatsByDate[platformID]
+		platformStats.add(summary)
+		platformStatsByDate[platformID] = platformStats
+
+		questionStatsByDate, ok := metrics.ByDateQuestion[dateKey]
+		if !ok {
+			questionStatsByDate = make(map[int64]monitoringDerivedRateStats)
+			metrics.ByDateQuestion[dateKey] = questionStatsByDate
+		}
+		questionStatsForDate := questionStatsByDate[questionID]
+		questionStatsForDate.add(summary)
+		questionStatsByDate[questionID] = questionStatsForDate
+
+		questionStats := metrics.ByQuestion[questionID]
+		questionStats.add(summary)
+		metrics.ByQuestion[questionID] = questionStats
+	}
+
+	if err := rows.Err(); err != nil {
+		return metrics, response.ErrInternal(50041, "scan_failed", "failed to iterate monitoring derived metrics")
+	}
+
+	return metrics, nil
+}
+
+func decodeMonitoringMatchedBrandTerms(raw []byte) []string {
+	if len(raw) == 0 {
+		return nil
+	}
+
+	var items []string
+	if err := json.Unmarshal(raw, &items); err != nil {
+		return nil
+	}
+	return normalizeMonitoringBrandTermList(items)
+}
+
+func (s *MonitoringService) loadOverview(ctx context.Context, tenantID, brandID int64, startDate, endDate time.Time, collectionMode string, derived monitoringDerivedMetrics) (MonitoringOverview, time.Time, error) {
+	overview := MonitoringOverview{
+		CollectionMode:  collectionMode,
+		ConfidenceLevel: "low",
+	}
+	latestDate := endDate
+
+	current, found, err := s.loadOverviewSnapshotForDate(ctx, tenantID, brandID, collectionMode, endDate)
+	if err != nil {
+		return overview, latestDate, err
+	}
+	if !found {
+		return overview, latestDate, nil
+	}
+
+	applyOverviewSnapshot(&overview, current, derived)
+	if current.ActualSampleCount <= 0 {
+		return overview, latestDate, nil
+	}
+
+	latestDate = current.Date
+	previous, foundPrevious, err := s.loadLatestSampledOverviewSnapshot(ctx, tenantID, brandID, collectionMode, startDate, current.Date.AddDate(0, 0, -1))
+	if err != nil {
+		return overview, latestDate, err
+	}
+	if !foundPrevious {
+		return overview, latestDate, nil
+	}
+
+	applyDerivedRatesToOverviewSnapshot(&previous, derived)
+	overview.PrevSnapshotMentionRate = floatPointer(previous.MentionRate)
+	overview.PrevSnapshotTop1MentionRate = floatPointer(previous.Top1MentionRate)
+	overview.PrevSnapshotFirstRecommendRate = floatPointer(previous.FirstRecommendRate)
+	overview.PrevSnapshotPositiveMentionRate = floatPointer(previous.PositiveMentionRate)
+
+	return overview, latestDate, nil
+}
+
+type monitoringOverviewSnapshot struct {
+	Date                time.Time
+	DesiredSampleCount  int64
+	PlannedSampleCount  int64
+	ActualSampleCount   int64
+	CoverageRate        sql.NullFloat64
+	ConfidenceLevel     string
+	TriggerSource       sql.NullString
+	SnapshotUpdatedAt   sql.NullTime
+	MentionRate         sql.NullFloat64
+	Top1MentionRate     sql.NullFloat64
+	FirstRecommendRate  sql.NullFloat64
+	PositiveMentionRate sql.NullFloat64
+	CitationRate        sql.NullFloat64
+}
+
+func (s *MonitoringService) loadOverviewSnapshotForDate(ctx context.Context, tenantID, brandID int64, collectionMode string, businessDate time.Time) (monitoringOverviewSnapshot, bool, error) {
+	var item monitoringOverviewSnapshot
+	err := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			business_date,
+			desired_sample_count,
+			planned_sample_count,
+			actual_sample_count,
+			coverage_rate::double precision,
+			confidence_level,
+			trigger_source,
+			snapshot_updated_at,
+			mention_rate::double precision,
+			top1_mention_rate::double precision,
+			first_recommend_rate::double precision,
+			positive_mention_rate::double precision,
+			citation_rate::double precision
+		FROM monitoring_brand_daily
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+	`, tenantID, brandID, collectionMode, businessDate.Format("2006-01-02")).Scan(
+		&item.Date,
+		&item.DesiredSampleCount,
+		&item.PlannedSampleCount,
+		&item.ActualSampleCount,
+		&item.CoverageRate,
+		&item.ConfidenceLevel,
+		&item.TriggerSource,
+		&item.SnapshotUpdatedAt,
+		&item.MentionRate,
+		&item.Top1MentionRate,
+		&item.FirstRecommendRate,
+		&item.PositiveMentionRate,
+		&item.CitationRate,
+	)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return monitoringOverviewSnapshot{}, false, nil
+		}
+		return monitoringOverviewSnapshot{}, false, response.ErrInternal(50041, "query_failed", "failed to load monitoring overview")
+	}
+
+	return item, true, nil
+}
+
+func (s *MonitoringService) loadLatestSampledOverviewSnapshot(ctx context.Context, tenantID, brandID int64, collectionMode string, startDate, endDate time.Time) (monitoringOverviewSnapshot, bool, error) {
+	if endDate.Before(startDate) {
+		return monitoringOverviewSnapshot{}, false, nil
+	}
+
+	var item monitoringOverviewSnapshot
+	err := s.monitoringPool.QueryRow(ctx, `
+		SELECT
+			business_date,
+			desired_sample_count,
+			planned_sample_count,
+			actual_sample_count,
+			coverage_rate::double precision,
+			confidence_level,
+			trigger_source,
+			snapshot_updated_at,
+			mention_rate::double precision,
+			top1_mention_rate::double precision,
+			first_recommend_rate::double precision,
+			positive_mention_rate::double precision,
+			citation_rate::double precision
+		FROM monitoring_brand_daily
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date BETWEEN $4::date AND $5::date
+		  AND actual_sample_count > 0
+		ORDER BY business_date DESC
+		LIMIT 1
+	`, tenantID, brandID, collectionMode, startDate.Format("2006-01-02"), endDate.Format("2006-01-02")).Scan(
+		&item.Date,
+		&item.DesiredSampleCount,
+		&item.PlannedSampleCount,
+		&item.ActualSampleCount,
+		&item.CoverageRate,
+		&item.ConfidenceLevel,
+		&item.TriggerSource,
+		&item.SnapshotUpdatedAt,
+		&item.MentionRate,
+		&item.Top1MentionRate,
+		&item.FirstRecommendRate,
+		&item.PositiveMentionRate,
+		&item.CitationRate,
+	)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return monitoringOverviewSnapshot{}, false, nil
+		}
+		return monitoringOverviewSnapshot{}, false, response.ErrInternal(50041, "query_failed", "failed to load monitoring overview")
+	}
+
+	return item, true, nil
+}
+
+func applyOverviewSnapshot(overview *MonitoringOverview, snapshot monitoringOverviewSnapshot, derived monitoringDerivedMetrics) {
+	if overview == nil {
+		return
+	}
+
+	overview.DesiredSampleCount = snapshot.DesiredSampleCount
+	overview.PlannedSampleCount = snapshot.PlannedSampleCount
+	overview.ActualSampleCount = snapshot.ActualSampleCount
+	overview.CoverageRate = floatPointer(snapshot.CoverageRate)
+	overview.LastTriggerSource = stringPointer(snapshot.TriggerSource)
+	if strings.TrimSpace(snapshot.ConfidenceLevel) != "" {
+		overview.ConfidenceLevel = snapshot.ConfidenceLevel
+	}
+
+	if snapshot.ActualSampleCount <= 0 {
+		overview.LastSampledAt = nil
+		overview.MentionRate = nil
+		overview.Top1MentionRate = nil
+		overview.FirstRecommendRate = nil
+		overview.PositiveMentionRate = nil
+		overview.CitationRate = nil
+		return
+	}
+
+	applyDerivedRatesToOverviewSnapshot(&snapshot, derived)
+	overview.LastSampledAt = formatNullTime(snapshot.SnapshotUpdatedAt)
+	overview.MentionRate = floatPointer(snapshot.MentionRate)
+	overview.Top1MentionRate = floatPointer(snapshot.Top1MentionRate)
+	overview.FirstRecommendRate = floatPointer(snapshot.FirstRecommendRate)
+	overview.PositiveMentionRate = floatPointer(snapshot.PositiveMentionRate)
+	overview.CitationRate = floatPointer(snapshot.CitationRate)
+}
+
+func applyDerivedRatesToOverviewSnapshot(snapshot *monitoringOverviewSnapshot, derived monitoringDerivedMetrics) {
+	if snapshot == nil {
+		return
+	}
+
+	dateKey := snapshot.Date.Format("2006-01-02")
+	if currentPlatformStats, ok := derived.ByDatePlatform[dateKey]; ok {
+		snapshot.MentionRate = pointerFloat64ToNull(averageDerivedRateByPlatform(currentPlatformStats, func(stats monitoringDerivedRateStats) *float64 {
+			return stats.mentionRate()
+		}))
+	}
+	if stats, ok := derived.ByDate[dateKey]; ok && stats.hasSamples() {
+		snapshot.Top1MentionRate = pointerFloat64ToNull(stats.top1MentionRate())
+		snapshot.FirstRecommendRate = pointerFloat64ToNull(stats.firstRecommendRate())
+		snapshot.PositiveMentionRate = pointerFloat64ToNull(stats.positiveMentionRate())
+	}
+}
+
+func (s *MonitoringService) loadTimeBuckets(ctx context.Context, tenantID, brandID int64, startDate, endDate time.Time, collectionMode string, derived monitoringDerivedMetrics) ([]MonitoringTimeBucket, error) {
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			business_date,
+			sample_status,
+			mention_rate::double precision,
+			top1_mention_rate::double precision,
+			first_recommend_rate::double precision,
+			positive_mention_rate::double precision,
+			citation_rate::double precision,
+			planned_sample_count,
+			actual_sample_count,
+			coverage_rate::double precision,
+			trigger_source,
+			snapshot_updated_at
+		FROM monitoring_brand_daily
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date BETWEEN $4::date AND $5::date
+		ORDER BY business_date ASC
+	`, tenantID, brandID, collectionMode, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load monitoring time buckets")
+	}
+	defer rows.Close()
+
+	type bucketRow struct {
+		Date                time.Time
+		SampleStatus        string
+		MentionRate         sql.NullFloat64
+		Top1MentionRate     sql.NullFloat64
+		FirstRecommendRate  sql.NullFloat64
+		PositiveMentionRate sql.NullFloat64
+		CitationRate        sql.NullFloat64
+		PlannedSampleCount  int64
+		ActualSampleCount   int64
+		CoverageRate        sql.NullFloat64
+		TriggerSource       sql.NullString
+		SnapshotUpdatedAt   sql.NullTime
+	}
+
+	bucketMap := make(map[string]bucketRow)
+	for rows.Next() {
+		var item bucketRow
+		if scanErr := rows.Scan(
+			&item.Date,
+			&item.SampleStatus,
+			&item.MentionRate,
+			&item.Top1MentionRate,
+			&item.FirstRecommendRate,
+			&item.PositiveMentionRate,
+			&item.CitationRate,
+			&item.PlannedSampleCount,
+			&item.ActualSampleCount,
+			&item.CoverageRate,
+			&item.TriggerSource,
+			&item.SnapshotUpdatedAt,
+		); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse monitoring time buckets")
+		}
+		bucketMap[item.Date.Format("2006-01-02")] = item
+	}
+
+	buckets := make([]MonitoringTimeBucket, 0, int(endDate.Sub(startDate).Hours()/24)+1)
+	for cursor := startDate; !cursor.After(endDate); cursor = cursor.AddDate(0, 0, 1) {
+		key := cursor.Format("2006-01-02")
+		if item, ok := bucketMap[key]; ok {
+			if platformStats, ok := derived.ByDatePlatform[key]; ok {
+				item.MentionRate = pointerFloat64ToNull(averageDerivedRateByPlatform(platformStats, func(stats monitoringDerivedRateStats) *float64 {
+					return stats.mentionRate()
+				}))
+			}
+			if stats, ok := derived.ByDate[key]; ok && stats.hasSamples() {
+				item.Top1MentionRate = pointerFloat64ToNull(stats.top1MentionRate())
+				item.FirstRecommendRate = pointerFloat64ToNull(stats.firstRecommendRate())
+				item.PositiveMentionRate = pointerFloat64ToNull(stats.positiveMentionRate())
+			}
+			buckets = append(buckets, MonitoringTimeBucket{
+				Date:                key,
+				SampleStatus:        item.SampleStatus,
+				MetricValue:         floatPointer(item.MentionRate),
+				MentionRate:         floatPointer(item.MentionRate),
+				Top1MentionRate:     floatPointer(item.Top1MentionRate),
+				FirstRecommendRate:  floatPointer(item.FirstRecommendRate),
+				PositiveMentionRate: floatPointer(item.PositiveMentionRate),
+				CitationRate:        floatPointer(item.CitationRate),
+				PlannedSampleCount:  item.PlannedSampleCount,
+				ActualSampleCount:   item.ActualSampleCount,
+				CoverageRate:        floatPointer(item.CoverageRate),
+				TriggerSource:       stringPointer(item.TriggerSource),
+				SnapshotUpdatedAt:   formatNullTime(item.SnapshotUpdatedAt),
+			})
+			continue
+		}
+		buckets = append(buckets, MonitoringTimeBucket{
+			Date:         key,
+			SampleStatus: "unsampled",
+		})
+	}
+
+	return buckets, nil
+}
+
+func (s *MonitoringService) loadAccessStates(ctx context.Context, tenantID int64, installationID *int64, businessDate time.Time) (map[string]monitoringAccessState, error) {
+	states := map[string]monitoringAccessState{}
+	if installationID == nil {
+		return states, nil
+	}
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT ai_platform_id, access_status
+		FROM monitoring_platform_access_snapshots
+		WHERE tenant_id = $1
+		  AND installation_id = $2
+		  AND business_date = $3::date
+	`, tenantID, *installationID, businessDate.Format("2006-01-02"))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load platform access states")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var platformID string
+		var accessStatus string
+		if scanErr := rows.Scan(&platformID, &accessStatus); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse platform access states")
+		}
+		states[platformID] = monitoringAccessState{AccessStatus: accessStatus}
+	}
+
+	return states, nil
+}
+
+func (s *MonitoringService) loadPlatformBreakdown(ctx context.Context, tenantID, brandID int64, businessDate time.Time, collectionMode string, platforms []monitoringPlatformMetadata, accessStates map[string]monitoringAccessState, derived monitoringDerivedMetrics) ([]MonitoringPlatformDaily, error) {
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			ai_platform_id,
+			mention_rate::double precision,
+			top1_mention_rate::double precision,
+			platform_sample_status,
+			actual_sample_count,
+			last_sampled_at
+		FROM monitoring_brand_platform_daily
+		WHERE tenant_id = $1
+		  AND brand_id = $2
+		  AND collector_type = $3
+		  AND business_date = $4::date
+	`, tenantID, brandID, collectionMode, businessDate.Format("2006-01-02"))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load platform breakdown")
+	}
+	defer rows.Close()
+
+	type row struct {
+		MentionRate          sql.NullFloat64
+		Top1MentionRate      sql.NullFloat64
+		PlatformSampleStatus string
+		ActualSampleCount    int64
+		LastSampledAt        sql.NullTime
+	}
+
+	items := make(map[string]row)
+	for rows.Next() {
+		var platformID string
+		var item row
+		if scanErr := rows.Scan(
+			&platformID,
+			&item.MentionRate,
+			&item.Top1MentionRate,
+			&item.PlatformSampleStatus,
+			&item.ActualSampleCount,
+			&item.LastSampledAt,
+		); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse platform breakdown")
+		}
+		items[platformID] = item
+	}
+
+	dateKey := businessDate.Format("2006-01-02")
+	breakdown := make([]MonitoringPlatformDaily, 0, len(platforms))
+	for _, platform := range platforms {
+		if item, ok := items[platform.ID]; ok {
+			if platformStats, ok := derived.ByDatePlatform[dateKey][platform.ID]; ok && platformStats.hasSamples() {
+				item.MentionRate = pointerFloat64ToNull(platformStats.mentionRate())
+				item.Top1MentionRate = pointerFloat64ToNull(platformStats.top1MentionRate())
+			}
+			breakdown = append(breakdown, MonitoringPlatformDaily{
+				AIPlatformID:         platform.ID,
+				PlatformName:         platform.Name,
+				MentionRate:          floatPointer(item.MentionRate),
+				Top1MentionRate:      floatPointer(item.Top1MentionRate),
+				PlatformSampleStatus: derivePlatformSampleStatus(item.PlatformSampleStatus, accessStates[platform.ID]),
+				ActualSampleCount:    item.ActualSampleCount,
+				LastSampledAt:        formatNullTime(item.LastSampledAt),
+			})
+			continue
+		}
+
+		breakdown = append(breakdown, MonitoringPlatformDaily{
+			AIPlatformID:         platform.ID,
+			PlatformName:         platform.Name,
+			PlatformSampleStatus: derivePlatformSampleStatus("", accessStates[platform.ID]),
+		})
+	}
+
+	return breakdown, nil
+}
+
+func (s *MonitoringService) loadHotQuestions(ctx context.Context, tenantID, brandID int64, questions []monitoringConfiguredQuestion, businessDate time.Time, derived monitoringDerivedMetrics) ([]MonitoringHotQuestion, error) {
+	if len(questions) == 0 {
+		return []MonitoringHotQuestion{}, nil
+	}
+
+	questionIDs := configuredQuestionIDs(questions)
+	selectedDate := businessDate.Format("2006-01-02")
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		WITH stats AS (
+			SELECT
+				r.question_id,
+				AVG(CASE WHEN p.brand_mentioned IS TRUE THEN 1 ELSE 0 END)::double precision AS mention_rate,
+				MAX(r.completed_at) AS last_sampled_at
+			FROM question_monitor_runs r
+			LEFT JOIN question_monitor_parse_results p
+				ON p.tenant_id = r.tenant_id AND p.run_id = r.id
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.collector_type = $3
+			  AND r.status = 'succeeded'
+			  AND r.business_date = $4::date
+			  AND r.question_id = ANY($5)
+			GROUP BY r.question_id
+		),
+		latest_hash AS (
+			SELECT DISTINCT ON (r.question_id)
+				r.question_id,
+				r.question_hash
+			FROM question_monitor_runs r
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.collector_type = $3
+			  AND r.status = 'succeeded'
+			  AND r.business_date = $4::date
+			  AND r.question_id = ANY($5)
+			ORDER BY r.question_id, r.business_date DESC, COALESCE(r.completed_at, r.updated_at, r.created_at) DESC NULLS LAST, r.id DESC
+		)
+		SELECT
+			s.question_id,
+			h.question_hash,
+			s.mention_rate,
+			s.last_sampled_at
+		FROM stats s
+		LEFT JOIN latest_hash h ON h.question_id = s.question_id
+	`, tenantID, brandID, monitoringCollectorType, selectedDate, questionIDs)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load hot questions")
+	}
+	defer rows.Close()
+
+	type questionStat struct {
+		QuestionHash  []byte
+		MentionRate   sql.NullFloat64
+		LastSampledAt sql.NullTime
+	}
+
+	stats := make(map[int64]questionStat, len(questions))
+	for rows.Next() {
+		var questionID int64
+		var item questionStat
+		if scanErr := rows.Scan(&questionID, &item.QuestionHash, &item.MentionRate, &item.LastSampledAt); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse hot questions")
+		}
+		stats[questionID] = item
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50041, "scan_failed", "failed to iterate hot questions")
+	}
+
+	items := make([]MonitoringHotQuestion, 0, len(questions))
+	for _, question := range questions {
+		item := MonitoringHotQuestion{
+			QuestionID:   question.ID,
+			QuestionHash: encodeQuestionHash(question.QuestionHash),
+			QuestionText: question.QuestionText,
+		}
+		if stat, ok := stats[question.ID]; ok {
+			if len(stat.QuestionHash) > 0 {
+				item.QuestionHash = encodeQuestionHash(stat.QuestionHash)
+			}
+			item.MentionRate = floatPointer(stat.MentionRate)
+			item.LastSampledAt = formatNullTime(stat.LastSampledAt)
+		}
+		if questionStatsByDate, ok := derived.ByDateQuestion[selectedDate]; ok {
+			if derivedStats, ok := questionStatsByDate[question.ID]; ok && derivedStats.hasSamples() {
+				item.MentionRate = derivedStats.mentionRate()
+			}
+		}
+		items = append(items, item)
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) loadCitationRanking(ctx context.Context, tenantID, brandID int64, questionIDs []int64, startDate, endDate time.Time, accessStates map[string]monitoringAccessState) ([]MonitoringCitationRanking, error) {
+	if questionIDs != nil && len(questionIDs) == 0 {
+		return []MonitoringCitationRanking{}, nil
+	}
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		WITH run_counts AS (
+			SELECT
+				r.ai_platform_id,
+				COUNT(*) AS sample_count
+			FROM question_monitor_runs r
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.collector_type = $3
+			  AND r.status = 'succeeded'
+			  AND r.business_date BETWEEN $4::date AND $5::date
+			  AND ($6::bigint[] IS NULL OR r.question_id = ANY($6))
+			GROUP BY r.ai_platform_id
+		),
+		citation_counts AS (
+			SELECT
+				r.ai_platform_id,
+				COUNT(DISTINCT cf.run_id) FILTER (WHERE cf.article_id IS NOT NULL) AS cited_answer_count,
+				COUNT(DISTINCT cf.article_id) FILTER (WHERE cf.article_id IS NOT NULL) AS cited_article_count
+			FROM question_monitor_runs r
+			JOIN monitoring_citation_facts cf
+				ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.collector_type = $3
+			  AND r.status = 'succeeded'
+			  AND r.business_date BETWEEN $4::date AND $5::date
+			  AND ($6::bigint[] IS NULL OR r.question_id = ANY($6))
+			GROUP BY r.ai_platform_id
+		)
+		SELECT
+			rc.ai_platform_id,
+			COALESCE(cc.cited_answer_count, 0) AS cited_answer_count,
+			COALESCE(cc.cited_article_count, 0) AS cited_article_count,
+			CASE
+				WHEN rc.sample_count > 0 THEN COALESCE(cc.cited_answer_count, 0)::double precision / rc.sample_count
+				ELSE NULL
+			END AS citation_rate
+		FROM run_counts rc
+		LEFT JOIN citation_counts cc ON cc.ai_platform_id = rc.ai_platform_id
+		WHERE COALESCE(cc.cited_answer_count, 0) > 0
+		ORDER BY cited_answer_count DESC, cited_article_count DESC, rc.ai_platform_id ASC
+	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load citation ranking")
+	}
+	defer rows.Close()
+
+	items := make([]MonitoringCitationRanking, 0)
+	for rows.Next() {
+		var platformID string
+		var citedAnswerCount int64
+		var citedArticleCount int64
+		var citationRate sql.NullFloat64
+		if scanErr := rows.Scan(&platformID, &citedAnswerCount, &citedArticleCount, &citationRate); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse citation ranking")
+		}
+		items = append(items, MonitoringCitationRanking{
+			AIPlatformID:      platformID,
+			PlatformName:      platformDisplayName(platformID),
+			SampleStatus:      derivePlatformSampleStatus("", accessStates[platformID]),
+			CitedAnswerCount:  citedAnswerCount,
+			CitedArticleCount: citedArticleCount,
+			CitationRate:      floatPointer(citationRate),
+		})
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) loadCitedArticles(ctx context.Context, tenantID, brandID int64, questionIDs []int64, startDate, endDate time.Time) ([]MonitoringCitedArticle, error) {
+	if questionIDs != nil && len(questionIDs) == 0 {
+		return []MonitoringCitedArticle{}, nil
+	}
+
+	var totalSampleCount int64
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT COUNT(*)
+		FROM question_monitor_runs r
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.collector_type = $3
+		  AND r.status = 'succeeded'
+		  AND r.business_date BETWEEN $4::date AND $5::date
+		  AND ($6::bigint[] IS NULL OR r.question_id = ANY($6))
+	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs)).Scan(&totalSampleCount); err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to count cited article denominator")
+	}
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			cf.article_id,
+			COALESCE(MAX(alias.article_title_snapshot), '未命名文章') AS article_title,
+			COALESCE(MAX(alias.publish_platform_name_snapshot), '已发布内容') AS publish_platform,
+			COUNT(*) AS citation_count
+		FROM monitoring_citation_facts cf
+		JOIN question_monitor_runs r
+			ON r.tenant_id = cf.tenant_id AND r.id = cf.run_id
+		LEFT JOIN monitoring_article_url_aliases alias
+			ON alias.tenant_id = cf.tenant_id AND alias.article_id = cf.article_id
+		WHERE cf.tenant_id = $1
+		  AND cf.brand_id = $2
+		  AND cf.article_id IS NOT NULL
+		  AND r.collector_type = $3
+		  AND r.status = 'succeeded'
+		  AND r.business_date BETWEEN $4::date AND $5::date
+		  AND ($6::bigint[] IS NULL OR r.question_id = ANY($6))
+		GROUP BY cf.article_id
+		ORDER BY citation_count DESC, cf.article_id ASC
+		LIMIT 10
+	`, tenantID, brandID, monitoringCollectorType, startDate.Format("2006-01-02"), endDate.Format("2006-01-02"), nullableInt64Array(questionIDs))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load cited articles")
+	}
+	defer rows.Close()
+
+	items := make([]MonitoringCitedArticle, 0)
+	for rows.Next() {
+		var articleID int64
+		var title string
+		var publishPlatform string
+		var citationCount int64
+		if scanErr := rows.Scan(&articleID, &title, &publishPlatform, &citationCount); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse cited articles")
+		}
+		items = append(items, MonitoringCitedArticle{
+			ArticleID:       articleID,
+			ArticleTitle:    title,
+			PublishPlatform: publishPlatform,
+			CitationCount:   citationCount,
+			CitationRate:    divideAsPointer(citationCount, totalSampleCount),
+		})
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) loadQuestionText(ctx context.Context, tenantID, brandID, questionID int64) (string, error) {
+	var text string
+	if err := s.businessPool.QueryRow(ctx, `
+		SELECT question_text
+		FROM brand_questions
+		WHERE id = $1 AND tenant_id = $2 AND brand_id = $3 AND deleted_at IS NULL
+	`, questionID, tenantID, brandID).Scan(&text); err != nil {
+		if err == pgx.ErrNoRows {
+			return "", response.ErrNotFound(40441, "question_not_found", "question not found")
+		}
+		return "", response.ErrInternal(50041, "query_failed", "failed to load question")
+	}
+	return text, nil
+}
+
+func (s *MonitoringService) loadLatestQuestionHash(ctx context.Context, tenantID, brandID, questionID int64, fromDate, toDate time.Time) ([]byte, error) {
+	var hashBytes []byte
+	if err := s.monitoringPool.QueryRow(ctx, `
+		SELECT question_hash
+		FROM (
+			SELECT
+				question_hash,
+				business_date,
+				COALESCE(completed_at, updated_at, created_at) AS event_at
+			FROM question_monitor_runs
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND question_id = $3
+			  AND collector_type = $4
+			  AND business_date BETWEEN $5::date AND $6::date
+			UNION ALL
+			SELECT
+				question_hash,
+				business_date,
+				COALESCE(completed_at, callback_received_at, leased_at, planned_at, updated_at, created_at) AS event_at
+			FROM monitoring_collect_tasks
+			WHERE tenant_id = $1
+			  AND brand_id = $2
+			  AND question_id = $3
+			  AND collector_type = $4
+			  AND business_date BETWEEN $5::date AND $6::date
+		) AS hashes
+		ORDER BY business_date DESC, event_at DESC NULLS LAST
+		LIMIT 1
+	`, tenantID, brandID, questionID, monitoringCollectorType, fromDate.Format("2006-01-02"), toDate.Format("2006-01-02")).Scan(&hashBytes); err != nil {
+		if err == pgx.ErrNoRows {
+			return nil, nil
+		}
+		return nil, response.ErrInternal(50041, "query_failed", "failed to resolve question hash")
+	}
+	return hashBytes, nil
+}
+
+func (s *MonitoringService) loadLatestPlatformRuns(ctx context.Context, tenantID, brandID int64, brandName string, questionID int64, hashBytes []byte, fromDate, toDate time.Time, aiPlatformID *string) (map[string]monitoringLatestPlatformRun, error) {
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT DISTINCT ON (r.ai_platform_id)
+			r.ai_platform_id,
+			r.id,
+			r.completed_at,
+			r.provider_model,
+			r.raw_answer_text,
+			p.brand_mentioned,
+			p.brand_mention_position
+		FROM question_monitor_runs r
+		LEFT JOIN question_monitor_parse_results p
+			ON p.tenant_id = r.tenant_id AND p.run_id = r.id
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.question_id = $3
+		  AND r.question_hash = $4
+		  AND r.collector_type = $5
+		  AND r.status = 'succeeded'
+		  AND r.business_date BETWEEN $6::date AND $7::date
+		  AND ($8::text IS NULL OR r.ai_platform_id = $8)
+		ORDER BY r.ai_platform_id ASC, r.completed_at DESC NULLS LAST, r.id DESC
+	`, tenantID, brandID, questionID, hashBytes, monitoringCollectorType, fromDate.Format("2006-01-02"), toDate.Format("2006-01-02"), nullableString(aiPlatformID))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load question runs")
+	}
+	defer rows.Close()
+
+	items := make(map[string]monitoringLatestPlatformRun)
+	for rows.Next() {
+		var item monitoringLatestPlatformRun
+		if scanErr := rows.Scan(
+			&item.PlatformID,
+			&item.RunID,
+			&item.CompletedAt,
+			&item.ProviderModel,
+			&item.AnswerText,
+			&item.BrandMentioned,
+			&item.BrandMentionPosition,
+		); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse latest question runs")
+		}
+		summary := resolveMonitoringAnswerParseSummary(
+			item.AnswerText.String,
+			brandName,
+			monitoringStoredParseFields{
+				BrandMentioned:       boolPointer(item.BrandMentioned),
+				BrandMentionPosition: stringPointer(item.BrandMentionPosition),
+			},
+		)
+		item.BrandMentioned = sql.NullBool{Bool: summary.BrandMentioned, Valid: true}
+		item.BrandMentionPosition = pointerStringToNull(optionalString(summary.BrandMentionPosition))
+		items[item.PlatformID] = item
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) loadCitationsForRuns(ctx context.Context, tenantID int64, runIDs []int64) (map[int64][]MonitoringQuestionDetailCitation, error) {
+	result := make(map[int64][]MonitoringQuestionDetailCitation)
+	if len(runIDs) == 0 {
+		return result, nil
+	}
+
+	rows, err := s.monitoringPool.Query(ctx, `
+		SELECT
+			cf.run_id,
+			cf.cited_url,
+			cf.cited_title,
+			COALESCE(tm.site_name, gm.site_name, cf.site_key, cf.registrable_domain) AS site_name,
+			COALESCE(tm.site_key, gm.site_key, cf.site_key) AS site_key,
+			cf.article_id,
+			alias.article_title_snapshot AS article_title,
+			cf.resolution_status,
+			cf.resolution_confidence
+		FROM monitoring_citation_facts cf
+		LEFT JOIN LATERAL (
+			SELECT site_key, site_name
+			FROM site_domain_mappings
+			WHERE tenant_id = cf.tenant_id
+			  AND is_active = TRUE
+			  AND (
+				registrable_domain = cf.registrable_domain
+				OR registrable_domain = cf.site_key
+				OR cf.host = registrable_domain
+				OR cf.host LIKE '%.' || registrable_domain
+			  )
+			ORDER BY LENGTH(registrable_domain) DESC, id DESC
+			LIMIT 1
+		) tm ON TRUE
+		LEFT JOIN LATERAL (
+			SELECT site_key, site_name
+			FROM site_domain_mappings
+			WHERE tenant_id IS NULL
+			  AND is_active = TRUE
+			  AND (
+				registrable_domain = cf.registrable_domain
+				OR registrable_domain = cf.site_key
+				OR cf.host = registrable_domain
+				OR cf.host LIKE '%.' || registrable_domain
+			  )
+			ORDER BY LENGTH(registrable_domain) DESC, id DESC
+			LIMIT 1
+		) gm ON tm.site_key IS NULL
+		LEFT JOIN monitoring_article_url_aliases alias
+			ON alias.tenant_id = cf.tenant_id AND alias.article_id = cf.article_id
+		WHERE cf.tenant_id = $1
+		  AND cf.run_id = ANY($2)
+		ORDER BY cf.run_id ASC, cf.id ASC
+	`, tenantID, runIDs)
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load citations")
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var runID int64
+		var citedURL string
+		var citedTitle sql.NullString
+		var siteName string
+		var siteKey string
+		var articleID sql.NullInt64
+		var articleTitle sql.NullString
+		var resolutionStatus string
+		var resolutionConfidence string
+		if scanErr := rows.Scan(&runID, &citedURL, &citedTitle, &siteName, &siteKey, &articleID, &articleTitle, &resolutionStatus, &resolutionConfidence); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse citations")
+		}
+		result[runID] = append(result[runID], MonitoringQuestionDetailCitation{
+			CitedURL:             citedURL,
+			CitedTitle:           nullableStringValue(citedTitle),
+			SiteName:             siteName,
+			SiteKey:              siteKey,
+			FaviconURL:           faviconURL(siteKey),
+			ArticleID:            nullableInt64Value(articleID),
+			ArticleTitle:         nullableStringValue(articleTitle),
+			ResolutionStatus:     resolutionStatus,
+			ResolutionConfidence: resolutionConfidence,
+		})
+	}
+
+	return result, nil
+}
+
+func (s *MonitoringService) loadQuestionCitationAnalysis(ctx context.Context, tenantID, brandID, questionID int64, hashBytes []byte, fromDate, toDate time.Time, aiPlatformID *string) ([]MonitoringQuestionCitationStats, error) {
+	rows, err := s.monitoringPool.Query(ctx, `
+		WITH grouped AS (
+			SELECT
+				r.ai_platform_id,
+				COALESCE(tm.site_name, gm.site_name, cf.site_key, cf.registrable_domain) AS site_name,
+				COALESCE(tm.site_key, gm.site_key, cf.site_key) AS site_key,
+				COALESCE(tm.registrable_domain, gm.registrable_domain, cf.site_key, cf.registrable_domain) AS site_domain,
+				COUNT(cf.id) AS citation_count,
+				COUNT(*) FILTER (WHERE cf.article_id IS NOT NULL) AS content_citation_count
+			FROM question_monitor_runs r
+			JOIN monitoring_citation_facts cf
+				ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
+			LEFT JOIN LATERAL (
+				SELECT registrable_domain, site_key, site_name
+				FROM site_domain_mappings
+				WHERE tenant_id = cf.tenant_id
+				  AND is_active = TRUE
+				  AND (
+					registrable_domain = cf.registrable_domain
+					OR registrable_domain = cf.site_key
+					OR cf.host = registrable_domain
+					OR cf.host LIKE '%.' || registrable_domain
+				  )
+				ORDER BY LENGTH(registrable_domain) DESC, id DESC
+				LIMIT 1
+			) tm ON TRUE
+			LEFT JOIN LATERAL (
+				SELECT registrable_domain, site_key, site_name
+				FROM site_domain_mappings
+				WHERE tenant_id IS NULL
+				  AND is_active = TRUE
+				  AND (
+					registrable_domain = cf.registrable_domain
+					OR registrable_domain = cf.site_key
+					OR cf.host = registrable_domain
+					OR cf.host LIKE '%.' || registrable_domain
+				  )
+				ORDER BY LENGTH(registrable_domain) DESC, id DESC
+				LIMIT 1
+			) gm ON tm.site_key IS NULL
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.question_id = $3
+			  AND r.question_hash = $4
+			  AND r.collector_type = $5
+			  AND r.status = 'succeeded'
+			  AND r.business_date BETWEEN $6::date AND $7::date
+			  AND ($8::text IS NULL OR r.ai_platform_id = $8)
+			GROUP BY
+				r.ai_platform_id,
+				COALESCE(tm.site_name, gm.site_name, cf.site_key, cf.registrable_domain),
+				COALESCE(tm.site_key, gm.site_key, cf.site_key),
+				COALESCE(tm.registrable_domain, gm.registrable_domain, cf.site_key, cf.registrable_domain)
+		),
+		totals AS (
+			SELECT
+				ai_platform_id,
+				SUM(citation_count) AS total_citation_count
+			FROM grouped
+			GROUP BY ai_platform_id
+		)
+		SELECT
+			g.ai_platform_id,
+			g.site_name,
+			g.site_key,
+			g.site_domain,
+			g.citation_count,
+			CASE
+				WHEN t.total_citation_count > 0
+					THEN g.citation_count::double precision / t.total_citation_count::double precision
+				ELSE NULL
+			END AS citation_rate,
+			g.content_citation_count
+		FROM grouped g
+		JOIN totals t
+			ON t.ai_platform_id = g.ai_platform_id
+		ORDER BY g.ai_platform_id ASC, g.citation_count DESC, g.site_name ASC
+	`, tenantID, brandID, questionID, hashBytes, monitoringCollectorType, fromDate.Format("2006-01-02"), toDate.Format("2006-01-02"), nullableString(aiPlatformID))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load question citation analysis")
+	}
+	defer rows.Close()
+
+	items := make([]MonitoringQuestionCitationStats, 0)
+	for rows.Next() {
+		var platformID string
+		var siteName string
+		var siteKey string
+		var siteDomain string
+		var citationCount int64
+		var citationRate sql.NullFloat64
+		var contentCitationCount int64
+		if scanErr := rows.Scan(&platformID, &siteName, &siteKey, &siteDomain, &citationCount, &citationRate, &contentCitationCount); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse question citation analysis")
+		}
+		items = append(items, MonitoringQuestionCitationStats{
+			AIPlatformID:         platformID,
+			PlatformName:         platformDisplayName(platformID),
+			SiteName:             siteName,
+			SiteKey:              siteKey,
+			SiteDomain:           siteDomain,
+			CitationCount:        citationCount,
+			CitationRate:         floatPointer(citationRate),
+			ContentCitationCount: contentCitationCount,
+		})
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) loadQuestionContentCitations(ctx context.Context, tenantID, brandID, questionID int64, hashBytes []byte, fromDate, toDate time.Time, aiPlatformID *string) ([]MonitoringQuestionContentCitation, error) {
+	rows, err := s.monitoringPool.Query(ctx, `
+		WITH platform_totals AS (
+			SELECT
+				r.ai_platform_id,
+				COUNT(cf.id) AS total_citation_count
+			FROM question_monitor_runs r
+			JOIN monitoring_citation_facts cf
+				ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
+			WHERE r.tenant_id = $1
+			  AND r.brand_id = $2
+			  AND r.question_id = $3
+			  AND r.question_hash = $4
+			  AND r.collector_type = $5
+			  AND r.status = 'succeeded'
+			  AND r.business_date BETWEEN $6::date AND $7::date
+			  AND ($8::text IS NULL OR r.ai_platform_id = $8)
+			GROUP BY r.ai_platform_id
+		)
+		SELECT
+			cf.article_id,
+			COALESCE(MAX(alias.article_title_snapshot), '未命名文章') AS article_title,
+			COALESCE(MAX(alias.publish_platform_name_snapshot), '已发布内容') AS publish_platform,
+			r.ai_platform_id,
+			COUNT(*) AS citation_count,
+			MAX(pt.total_citation_count) AS total_citation_count
+		FROM question_monitor_runs r
+		JOIN monitoring_citation_facts cf
+			ON cf.tenant_id = r.tenant_id AND cf.run_id = r.id
+		JOIN platform_totals pt
+			ON pt.ai_platform_id = r.ai_platform_id
+		LEFT JOIN monitoring_article_url_aliases alias
+			ON alias.tenant_id = cf.tenant_id AND alias.article_id = cf.article_id
+		WHERE r.tenant_id = $1
+		  AND r.brand_id = $2
+		  AND r.question_id = $3
+		  AND r.question_hash = $4
+		  AND r.collector_type = $5
+		  AND r.status = 'succeeded'
+		  AND r.business_date BETWEEN $6::date AND $7::date
+		  AND cf.article_id IS NOT NULL
+		  AND ($8::text IS NULL OR r.ai_platform_id = $8)
+		GROUP BY cf.article_id, r.ai_platform_id
+		ORDER BY citation_count DESC, cf.article_id ASC
+	`, tenantID, brandID, questionID, hashBytes, monitoringCollectorType, fromDate.Format("2006-01-02"), toDate.Format("2006-01-02"), nullableString(aiPlatformID))
+	if err != nil {
+		return nil, response.ErrInternal(50041, "query_failed", "failed to load content citations")
+	}
+	defer rows.Close()
+
+	items := make([]MonitoringQuestionContentCitation, 0)
+	for rows.Next() {
+		var articleID int64
+		var articleTitle string
+		var publishPlatform string
+		var platformID string
+		var citationCount int64
+		var totalCitationCount int64
+		if scanErr := rows.Scan(&articleID, &articleTitle, &publishPlatform, &platformID, &citationCount, &totalCitationCount); scanErr != nil {
+			return nil, response.ErrInternal(50041, "scan_failed", "failed to parse content citations")
+		}
+		items = append(items, MonitoringQuestionContentCitation{
+			ArticleID:       articleID,
+			ArticleTitle:    articleTitle,
+			PublishPlatform: publishPlatform,
+			AIPlatformID:    platformID,
+			PlatformName:    platformDisplayName(platformID),
+			CitationCount:   citationCount,
+			CitationRate:    divideAsPointer(citationCount, totalCitationCount),
+		})
+	}
+
+	return items, nil
+}
+
+func (s *MonitoringService) ensureInstallationOnline(ctx context.Context, tenantID, installationID int64) error {
+	online, err := s.isInstallationOnline(ctx, tenantID, installationID)
+	if err != nil {
+		return err
+	}
+	if !online {
+		return response.ErrConflict(40941, "installation_offline", "primary monitoring installation is offline")
+	}
+	return nil
+}
+
+func (s *MonitoringService) isInstallationOnline(ctx context.Context, tenantID, installationID int64) (bool, error) {
+	var lastSeenAt sql.NullTime
+	err := s.businessPool.QueryRow(ctx, `
+		SELECT last_seen_at
+		FROM plugin_installations
+		WHERE id = $1
+		  AND tenant_id = $2
+		  AND status = 'active'
+		  AND deleted_at IS NULL
+	`, installationID, tenantID).Scan(&lastSeenAt)
+	if err != nil {
+		if err == pgx.ErrNoRows {
+			return false, nil
+		}
+		return false, response.ErrInternal(50041, "query_failed", "failed to inspect monitoring installation")
+	}
+
+	if !lastSeenAt.Valid || time.Since(lastSeenAt.Time) > monitoringOnlineDuration {
+		return false, nil
+	}
+	return true, nil
+}
+
+func parseDetailDateRange(dateFrom, dateTo string) (time.Time, time.Time, error) {
+	return parseDetailDateRangeAt(dateFrom, dateTo, time.Now(), monitoringBusinessLocation())
+}
+
+func parseDetailDateRangeAt(dateFrom, dateTo string, now time.Time, loc *time.Location) (time.Time, time.Time, error) {
+	if strings.TrimSpace(dateFrom) == "" && strings.TrimSpace(dateTo) == "" {
+		today := monitoringBusinessDayAt(now, loc)
+		return today, today, nil
+	}
+
+	if strings.TrimSpace(dateFrom) == "" || strings.TrimSpace(dateTo) == "" {
+		return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_date_range", "date_from and date_to must be provided together")
+	}
+
+	fromDate, err := parseMonitoringBusinessDateInLocation(dateFrom, loc)
+	if err != nil {
+		return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_date_range", "date_from must use YYYY-MM-DD")
+	}
+
+	toDate, err := parseMonitoringBusinessDateInLocation(dateTo, loc)
+	if err != nil {
+		return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_date_range", "date_to must use YYYY-MM-DD")
+	}
+
+	if fromDate.After(toDate) {
+		return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_date_range", "date_from must not be later than date_to")
+	}
+
+	return fromDate, toDate, nil
+}
+
+func resolveDashboardDateWindow(days int, businessDate string) (time.Time, time.Time, error) {
+	return resolveDashboardDateWindowAt(days, businessDate, time.Now(), monitoringBusinessLocation())
+}
+
+func resolveDashboardDateWindowAt(days int, businessDate string, now time.Time, loc *time.Location) (time.Time, time.Time, error) {
+	today := monitoringBusinessDayAt(now, loc)
+	earliestAllowed := today.AddDate(0, 0, -(maxTrackingDays - 1))
+
+	endDate := today
+	if strings.TrimSpace(businessDate) != "" {
+		parsedDate, err := parseMonitoringBusinessDateInLocation(businessDate, loc)
+		if err != nil {
+			return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_business_date", "business_date must use YYYY-MM-DD")
+		}
+		if parsedDate.After(today) {
+			return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_business_date", "business_date must not be later than today")
+		}
+		if parsedDate.Before(earliestAllowed) {
+			return time.Time{}, time.Time{}, response.ErrBadRequest(40031, "invalid_business_date", "business_date must be within the latest 30 days")
+		}
+		endDate = parsedDate
+	}
+
+	if days <= 0 {
+		days = maxTrackingDays
+	}
+	days = normalizeTrackingDays(days)
+
+	startDate := endDate.AddDate(0, 0, -(days - 1))
+	if startDate.Before(earliestAllowed) {
+		startDate = earliestAllowed
+	}
+	return startDate, endDate, nil
+}
+
+func trackingDateWindow(days int) (time.Time, time.Time) {
+	endDate := monitoringBusinessToday()
+	startDate := endDate.AddDate(0, 0, -(days - 1))
+	return startDate, endDate
+}
+
+func monitoringBusinessToday() time.Time {
+	return monitoringBusinessDayAt(time.Now(), monitoringBusinessLocation())
+}
+
+func monitoringBusinessDayAt(now time.Time, loc *time.Location) time.Time {
+	if loc == nil {
+		loc = time.Local
+	}
+	localNow := now.In(loc)
+	return time.Date(localNow.Year(), localNow.Month(), localNow.Day(), 0, 0, 0, 0, loc)
+}
+
+func parseMonitoringBusinessDateInLocation(value string, loc *time.Location) (time.Time, error) {
+	if loc == nil {
+		loc = time.Local
+	}
+	return time.ParseInLocation("2006-01-02", strings.TrimSpace(value), loc)
+}
+
+func monitoringRecentMetricsStart(startDate, endDate time.Time) time.Time {
+	recentStart := endDate.AddDate(0, 0, -1)
+	if startDate.After(recentStart) {
+		return startDate
+	}
+	return recentStart
+}
+
+func normalizeTrackingDays(days int) int {
+	if days <= 0 {
+		return defaultTrackingDays
+	}
+	if days > maxTrackingDays {
+		return maxTrackingDays
+	}
+	return days
+}
+
+func resolveMonitoringPlatforms(enabled []string) []monitoringPlatformMetadata {
+	if len(enabled) == 0 {
+		return defaultMonitoringPlatforms
+	}
+	platforms := make([]monitoringPlatformMetadata, 0, len(enabled))
+	seen := make(map[string]struct{}, len(enabled))
+	for _, item := range enabled {
+		id := strings.TrimSpace(item)
+		if id == "" {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		platforms = append(platforms, monitoringPlatformMetadata{
+			ID:   id,
+			Name: platformDisplayName(id),
+		})
+	}
+	if len(platforms) == 0 {
+		return defaultMonitoringPlatforms
+	}
+	return platforms
+}
+
+func platformDisplayName(platformID string) string {
+	if name, ok := monitoringPlatformNames[platformID]; ok {
+		return name
+	}
+	if platformID == "" {
+		return "未知平台"
+	}
+	return strings.ToUpper(platformID)
+}
+
+func derivePlatformSampleStatus(rawStatus string, accessState monitoringAccessState) string {
+	switch strings.TrimSpace(rawStatus) {
+	case "sampled":
+		return "sampled"
+	case "pending":
+		return "pending"
+	case "not_logged_in":
+		return "not_logged_in"
+	case "unavailable":
+		return "unavailable"
+	}
+
+	switch accessState.AccessStatus {
+	case "not_logged_in":
+		return "not_logged_in"
+	case "unavailable":
+		return "unavailable"
+	case "accessible":
+		return "pending"
+	default:
+		return "pending"
+	}
+}
+
+func divideAsPointer(numerator, denominator int64) *float64 {
+	if denominator <= 0 {
+		return nil
+	}
+	value := float64(numerator) / float64(denominator)
+	return &value
+}
+
+func pointerFloat64ToNull(value *float64) sql.NullFloat64 {
+	if value == nil {
+		return sql.NullFloat64{}
+	}
+	return sql.NullFloat64{Float64: *value, Valid: true}
+}
+
+func pointerStringToNull(value *string) sql.NullString {
+	if value == nil {
+		return sql.NullString{}
+	}
+	return sql.NullString{String: *value, Valid: true}
+}
+
+func floatPointer(value sql.NullFloat64) *float64 {
+	if !value.Valid {
+		return nil
+	}
+	v := value.Float64
+	return &v
+}
+
+func formatNullTime(value sql.NullTime) *string {
+	if !value.Valid {
+		return nil
+	}
+	text := value.Time.UTC().Format(time.RFC3339)
+	return &text
+}
+
+func stringPointer(value sql.NullString) *string {
+	if !value.Valid {
+		return nil
+	}
+	v := value.String
+	return &v
+}
+
+func nullableStringValue(value sql.NullString) *string {
+	if !value.Valid {
+		return nil
+	}
+	v := value.String
+	return &v
+}
+
+func boolPointer(value sql.NullBool) *bool {
+	if !value.Valid {
+		return nil
+	}
+	v := value.Bool
+	return &v
+}
+
+func nullableInt64Value(value sql.NullInt64) *int64 {
+	if !value.Valid {
+		return nil
+	}
+	v := value.Int64
+	return &v
+}
+
+func nullableInt64(value *int64) interface{} {
+	if value == nil {
+		return nil
+	}
+	return *value
+}
+
+func nullableInt64Array(values []int64) interface{} {
+	if values == nil {
+		return nil
+	}
+	return values
+}
+
+func nullableString(value *string) interface{} {
+	if value == nil {
+		return nil
+	}
+	trimmed := strings.TrimSpace(*value)
+	if trimmed == "" {
+		return nil
+	}
+	return trimmed
+}
+
+func encodeQuestionHash(hashBytes []byte) string {
+	if len(hashBytes) == 0 {
+		return ""
+	}
+	return "v1:" + hex.EncodeToString(hashBytes)
+}
+
+func decodeQuestionHash(value string) ([]byte, error) {
+	trimmed := strings.TrimSpace(value)
+	trimmed = strings.TrimPrefix(trimmed, "v1:")
+	if trimmed == "" {
+		return nil, fmt.Errorf("empty hash")
+	}
+	return hex.DecodeString(trimmed)
+}
+
+func seededQuestionHash(text string) []byte {
+	digest := md5.Sum([]byte(strings.TrimSpace(strings.ToLower(text))))
+	return digest[:]
+}
+
+func faviconURL(siteKey string) string {
+	siteKey = strings.TrimSpace(siteKey)
+	if siteKey == "" {
+		return ""
+	}
+	return fmt.Sprintf("https://%s/favicon.ico", siteKey)
+}
diff --git a/server/internal/tenant/app/monitoring_service_date_test.go b/server/internal/tenant/app/monitoring_service_date_test.go
new file mode 100644
index 0000000..f33934c
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_service_date_test.go
@@ -0,0 +1,67 @@
+package app
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+)
+
+func TestResolveDashboardDateWindowAtUsesBusinessTimezone(t *testing.T) {
+	loc := time.FixedZone("CST", 8*60*60)
+	now := time.Date(2026, 4, 12, 0, 5, 0, 0, loc)
+
+	startDate, endDate, err := resolveDashboardDateWindowAt(7, "2026-04-12", now, loc)
+	require.NoError(t, err)
+
+	assert.Equal(t, time.Date(2026, 4, 6, 0, 0, 0, 0, loc), startDate)
+	assert.Equal(t, time.Date(2026, 4, 12, 0, 0, 0, 0, loc), endDate)
+}
+
+func TestResolveDashboardDateWindowAtRejectsFutureBusinessDay(t *testing.T) {
+	loc := time.FixedZone("CST", 8*60*60)
+	now := time.Date(2026, 4, 12, 0, 5, 0, 0, loc)
+
+	_, _, err := resolveDashboardDateWindowAt(7, "2026-04-13", now, loc)
+	require.Error(t, err)
+
+	appErr := response.Normalize(err)
+	assert.Equal(t, 40031, appErr.Code)
+	assert.Equal(t, "invalid_business_date", appErr.Message)
+	assert.Equal(t, "business_date must not be later than today", appErr.Detail)
+}
+
+func TestParseDetailDateRangeAtDefaultsToCurrentBusinessDay(t *testing.T) {
+	loc := time.FixedZone("CST", 8*60*60)
+	now := time.Date(2026, 4, 12, 0, 5, 0, 0, loc)
+
+	fromDate, toDate, err := parseDetailDateRangeAt("", "", now, loc)
+	require.NoError(t, err)
+
+	expected := time.Date(2026, 4, 12, 0, 0, 0, 0, loc)
+	assert.Equal(t, expected, fromDate)
+	assert.Equal(t, expected, toDate)
+}
+
+func TestMonitoringBusinessDayAndDateAtUsesShanghaiTimezone(t *testing.T) {
+	now := time.Date(2026, 4, 11, 17, 19, 0, 0, time.UTC)
+
+	businessDay, businessDate := monitoringBusinessDayAndDateAt(now)
+
+	assert.Equal(t, time.Date(2026, 4, 12, 0, 0, 0, 0, monitoringBusinessLocation()), businessDay)
+	assert.Equal(t, "2026-04-12", businessDate)
+}
+
+func TestEncodeMonitoringProjectionRebuildEnvelopePreservesBusinessDate(t *testing.T) {
+	businessDay := time.Date(2026, 4, 12, 0, 0, 0, 0, monitoringBusinessLocation())
+
+	payload, err := encodeMonitoringProjectionRebuildEnvelope(1, 2, businessDay, "test")
+	require.NoError(t, err)
+
+	envelope, err := decodeMonitoringProjectionRebuildEnvelope(payload)
+	require.NoError(t, err)
+	assert.Equal(t, "2026-04-12", envelope.BusinessDate)
+}
diff --git a/server/internal/tenant/app/monitoring_time.go b/server/internal/tenant/app/monitoring_time.go
new file mode 100644
index 0000000..2e53bee
--- /dev/null
+++ b/server/internal/tenant/app/monitoring_time.go
@@ -0,0 +1,39 @@
+package app
+
+import (
+	"sync"
+	"time"
+)
+
+const monitoringBusinessTimeZoneName = "Asia/Shanghai"
+
+var (
+	monitoringBusinessLocationOnce  sync.Once
+	monitoringBusinessLocationValue *time.Location
+)
+
+func monitoringBusinessLocation() *time.Location {
+	monitoringBusinessLocationOnce.Do(func() {
+		loc, err := time.LoadLocation(monitoringBusinessTimeZoneName)
+		if err != nil {
+			monitoringBusinessLocationValue = time.FixedZone("UTC+8", 8*60*60)
+			return
+		}
+		monitoringBusinessLocationValue = loc
+	})
+
+	return monitoringBusinessLocationValue
+}
+
+func monitoringCanonicalBusinessDay(day time.Time) time.Time {
+	return monitoringBusinessDayAt(day, monitoringBusinessLocation())
+}
+
+func monitoringBusinessDayAndDateAt(now time.Time) (time.Time, string) {
+	businessDay := monitoringCanonicalBusinessDay(now)
+	return businessDay, businessDay.Format("2006-01-02")
+}
+
+func monitoringBusinessDateText(businessDay time.Time) string {
+	return monitoringCanonicalBusinessDay(businessDay).Format("2006-01-02")
+}
diff --git a/server/internal/tenant/transport/brand_handler.go b/server/internal/tenant/transport/brand_handler.go
index fbb9aa8..a4bf186 100644
--- a/server/internal/tenant/transport/brand_handler.go
+++ b/server/internal/tenant/transport/brand_handler.go
@@ -15,7 +15,7 @@ type BrandHandler struct {
 }
 
 func NewBrandHandler(a *bootstrap.App) *BrandHandler {
-	return &BrandHandler{svc: app.NewBrandService(a.DB, a.AuditLogs)}
+	return &BrandHandler{svc: app.NewBrandService(a.DB, a.MonitoringDB, a.AuditLogs)}
 }
 
 func (h *BrandHandler) List(c *gin.Context) {
diff --git a/server/internal/tenant/transport/monitoring_callback_handler.go b/server/internal/tenant/transport/monitoring_callback_handler.go
new file mode 100644
index 0000000..1b2c0ef
--- /dev/null
+++ b/server/internal/tenant/transport/monitoring_callback_handler.go
@@ -0,0 +1,162 @@
+package transport
+
+import (
+	"errors"
+	"io"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/geo-platform/tenant-api/internal/bootstrap"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+	"github.com/geo-platform/tenant-api/internal/tenant/app"
+)
+
+type MonitoringCallbackHandler struct {
+	svc *app.MonitoringCallbackService
+}
+
+func NewMonitoringCallbackHandler(a *bootstrap.App) *MonitoringCallbackHandler {
+	return &MonitoringCallbackHandler{
+		svc: app.NewMonitoringCallbackService(a.DB, a.MonitoringDB, a.RabbitMQ, a.LLM, a.Logger),
+	}
+}
+
+func (h *MonitoringCallbackHandler) Heartbeat(c *gin.Context) {
+	installationID, installationToken, ok := parseMonitoringInstallationHeaders(c)
+	if !ok {
+		return
+	}
+
+	var req app.MonitoringHeartbeatRequest
+	if err := bindOptionalJSON(c, &req); err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_params", err.Error()))
+		return
+	}
+
+	data, svcErr := h.svc.Heartbeat(c.Request.Context(), installationID, installationToken, req)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringCallbackHandler) LeaseTasks(c *gin.Context) {
+	installationID, installationToken, ok := parseMonitoringInstallationHeaders(c)
+	if !ok {
+		return
+	}
+
+	var req app.MonitoringLeaseTasksRequest
+	if err := bindOptionalJSON(c, &req); err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_params", err.Error()))
+		return
+	}
+
+	data, svcErr := h.svc.LeaseTasks(c.Request.Context(), installationID, installationToken, req)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringCallbackHandler) ResumeTasks(c *gin.Context) {
+	installationID, installationToken, ok := parseMonitoringInstallationHeaders(c)
+	if !ok {
+		return
+	}
+
+	var req app.MonitoringResumeTasksRequest
+	if err := bindOptionalJSON(c, &req); err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_params", err.Error()))
+		return
+	}
+
+	data, svcErr := h.svc.ResumeTasks(c.Request.Context(), installationID, installationToken, req)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringCallbackHandler) TaskResult(c *gin.Context) {
+	taskID, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_task_id", "task id must be a number"))
+		return
+	}
+
+	installationID, installationToken, ok := parseMonitoringInstallationHeaders(c)
+	if !ok {
+		return
+	}
+
+	var req app.MonitoringTaskResultRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_params", err.Error()))
+		return
+	}
+
+	data, svcErr := h.svc.HandleTaskResult(c.Request.Context(), installationID, installationToken, taskID, req)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringCallbackHandler) SkipTask(c *gin.Context) {
+	taskID, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_task_id", "task id must be a number"))
+		return
+	}
+
+	installationID, installationToken, ok := parseMonitoringInstallationHeaders(c)
+	if !ok {
+		return
+	}
+
+	var req app.MonitoringSkipTaskRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, response.ErrBadRequest(40041, "invalid_params", err.Error()))
+		return
+	}
+
+	data, svcErr := h.svc.SkipTask(c.Request.Context(), installationID, installationToken, taskID, req)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func parseMonitoringInstallationHeaders(c *gin.Context) (int64, string, bool) {
+	installationID, err := strconv.ParseInt(c.GetHeader("X-Geo-Installation-Id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrUnauthorized(40141, "invalid_installation_id", "installation id header is invalid"))
+		return 0, "", false
+	}
+
+	installationToken := c.GetHeader("X-Geo-Installation-Token")
+	if installationToken == "" {
+		response.Error(c, response.ErrUnauthorized(40141, "missing_installation_token", "installation token header is required"))
+		return 0, "", false
+	}
+
+	return installationID, installationToken, true
+}
+
+func bindOptionalJSON(c *gin.Context, target interface{}) error {
+	err := c.ShouldBindJSON(target)
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, io.EOF) {
+		return nil
+	}
+	return err
+}
diff --git a/server/internal/tenant/transport/monitoring_handler.go b/server/internal/tenant/transport/monitoring_handler.go
new file mode 100644
index 0000000..ca27fff
--- /dev/null
+++ b/server/internal/tenant/transport/monitoring_handler.go
@@ -0,0 +1,133 @@
+package transport
+
+import (
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/geo-platform/tenant-api/internal/bootstrap"
+	"github.com/geo-platform/tenant-api/internal/shared/response"
+	"github.com/geo-platform/tenant-api/internal/tenant/app"
+)
+
+type MonitoringHandler struct {
+	svc *app.MonitoringService
+}
+
+type monitoringCollectNowRequest struct {
+	KeywordID *int64 `json:"keyword_id"`
+}
+
+func NewMonitoringHandler(a *bootstrap.App) *MonitoringHandler {
+	return &MonitoringHandler{
+		svc: app.NewMonitoringService(a.DB, a.MonitoringDB),
+	}
+}
+
+func (h *MonitoringHandler) DashboardComposite(c *gin.Context) {
+	brandID, err := parseOptionalInt64(c.Query("brand_id"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_brand_id", "brand_id must be a number"))
+		return
+	}
+
+	keywordID, err := parseOptionalInt64Pointer(c.Query("keyword_id"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_keyword_id", "keyword_id must be a number"))
+		return
+	}
+
+	days, err := parseOptionalInt(c.Query("days"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_days", "days must be a number"))
+		return
+	}
+
+	data, svcErr := h.svc.DashboardComposite(c.Request.Context(), brandID, keywordID, days, c.Query("business_date"))
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringHandler) QuestionDetail(c *gin.Context) {
+	brandID, err := strconv.ParseInt(c.Param("brand_id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_brand_id", "brand_id must be a number"))
+		return
+	}
+
+	questionID, err := strconv.ParseInt(c.Param("question_id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_question_id", "question_id must be a number"))
+		return
+	}
+
+	var aiPlatformID *string
+	if value := c.Query("ai_platform_id"); value != "" {
+		trimmed := value
+		aiPlatformID = &trimmed
+	}
+
+	data, svcErr := h.svc.QuestionDetail(
+		c.Request.Context(),
+		brandID,
+		questionID,
+		c.Query("date_from"),
+		c.Query("date_to"),
+		c.Query("question_hash"),
+		aiPlatformID,
+	)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func (h *MonitoringHandler) CollectNow(c *gin.Context) {
+	brandID, err := strconv.ParseInt(c.Param("brand_id"), 10, 64)
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_brand_id", "brand_id must be a number"))
+		return
+	}
+
+	var req monitoringCollectNowRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, response.ErrBadRequest(40031, "invalid_collect_now_request", "collect-now request is invalid"))
+		return
+	}
+
+	data, svcErr := h.svc.CollectNow(c.Request.Context(), brandID, req.KeywordID)
+	if svcErr != nil {
+		response.Error(c, svcErr)
+		return
+	}
+	response.Success(c, data)
+}
+
+func parseOptionalInt64(raw string) (int64, error) {
+	if raw == "" {
+		return 0, nil
+	}
+	return strconv.ParseInt(raw, 10, 64)
+}
+
+func parseOptionalInt64Pointer(raw string) (*int64, error) {
+	if raw == "" {
+		return nil, nil
+	}
+	value, err := strconv.ParseInt(raw, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	return &value, nil
+}
+
+func parseOptionalInt(raw string) (int, error) {
+	if raw == "" {
+		return 0, nil
+	}
+	return strconv.Atoi(raw)
+}
diff --git a/server/internal/tenant/transport/router.go b/server/internal/tenant/transport/router.go
index 21816b8..cbe784a 100644
--- a/server/internal/tenant/transport/router.go
+++ b/server/internal/tenant/transport/router.go
@@ -20,6 +20,14 @@ func RegisterRoutes(app *bootstrap.App) {
 	callbacks.POST("/bind", pluginHandler.PluginBindCallback)
 	callbacks.POST("/publish", pluginHandler.PluginPublishCallback)
 
+	monitoringCallbackHandler := NewMonitoringCallbackHandler(app)
+	monitoringPlugin := app.Engine.Group("/api/plugin/monitoring")
+	monitoringPlugin.POST("/heartbeat", monitoringCallbackHandler.Heartbeat)
+	monitoringPlugin.POST("/tasks/lease", monitoringCallbackHandler.LeaseTasks)
+	monitoringPlugin.POST("/tasks/resume", monitoringCallbackHandler.ResumeTasks)
+	monitoringPlugin.POST("/tasks/:id/result", monitoringCallbackHandler.TaskResult)
+	monitoringPlugin.POST("/tasks/:id/skip", monitoringCallbackHandler.SkipTask)
+
 	protected := app.Engine.Group("/api")
 	protected.Use(auth.Middleware(app.JWT, app.Sessions))
 	protected.Use(middleware.TenantScope())
@@ -89,6 +97,12 @@ func RegisterRoutes(app *bootstrap.App) {
 	brands.PUT("/:id/competitors/:cid", brandHandler.UpdateCompetitor)
 	brands.DELETE("/:id/competitors/:cid", brandHandler.DeleteCompetitor)
 
+	monitoring := protected.Group("/tenant/monitoring")
+	monitoringHandler := NewMonitoringHandler(app)
+	monitoring.GET("/dashboard/composite", monitoringHandler.DashboardComposite)
+	monitoring.GET("/brands/:brand_id/questions/:question_id/detail", monitoringHandler.QuestionDetail)
+	monitoring.POST("/brands/:brand_id/collect-now", monitoringHandler.CollectNow)
+
 	knowledge := protected.Group("/tenant/knowledge")
 	knowledgeHandler := NewKnowledgeHandler(app)
 	knowledge.GET("/groups", knowledgeHandler.ListGroups)
diff --git a/server/internal/tenant/transport/router_test.go b/server/internal/tenant/transport/router_test.go
index 0b0f7f1..a5fd709 100644
--- a/server/internal/tenant/transport/router_test.go
+++ b/server/internal/tenant/transport/router_test.go
@@ -29,6 +29,7 @@ func TestProtectedRoutes_RequireAuth(t *testing.T) {
 		{http.MethodGet, "/api/tenant/templates"},
 		{http.MethodGet, "/api/tenant/articles"},
 		{http.MethodGet, "/api/tenant/brands"},
+		{http.MethodGet, "/api/tenant/monitoring/brands/:brand_id/questions/:question_id/detail"},
 		{http.MethodPost, "/api/tenant/brands"},
 	}
 
@@ -50,6 +51,11 @@ func TestPublicRoutes_NoAuth(t *testing.T) {
 	}{
 		{http.MethodPost, "/api/auth/login"},
 		{http.MethodPost, "/api/auth/refresh"},
+		{http.MethodPost, "/api/plugin/monitoring/heartbeat"},
+		{http.MethodPost, "/api/plugin/monitoring/tasks/lease"},
+		{http.MethodPost, "/api/plugin/monitoring/tasks/resume"},
+		{http.MethodPost, "/api/plugin/monitoring/tasks/:id/result"},
+		{http.MethodPost, "/api/plugin/monitoring/tasks/:id/skip"},
 		{http.MethodGet, "/api/health/live"},
 		{http.MethodGet, "/api/health/ready"},
 	}
diff --git a/server/migrations/20260410103000_create_monitoring_tables.down.sql b/server/migrations/20260410103000_create_monitoring_tables.down.sql
new file mode 100644
index 0000000..90c5d0f
--- /dev/null
+++ b/server/migrations/20260410103000_create_monitoring_tables.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenant_monitoring_quotas;
diff --git a/server/migrations/20260410103000_create_monitoring_tables.up.sql b/server/migrations/20260410103000_create_monitoring_tables.up.sql
new file mode 100644
index 0000000..1a9e0fe
--- /dev/null
+++ b/server/migrations/20260410103000_create_monitoring_tables.up.sql
@@ -0,0 +1,13 @@
+CREATE TABLE tenant_monitoring_quotas (
+    tenant_id                BIGINT PRIMARY KEY REFERENCES tenants(id),
+    max_brands               INT NOT NULL DEFAULT 1,
+    collection_mode          VARCHAR(20) NOT NULL DEFAULT 'plugin',
+    question_selection_mode  VARCHAR(20) NOT NULL DEFAULT 'best_effort_all',
+    collect_frequency        VARCHAR(20) NOT NULL DEFAULT 'daily',
+    enabled_platforms        JSONB NOT NULL DEFAULT '["deepseek","qwen","doubao"]'::jsonb,
+    primary_installation_id  BIGINT REFERENCES plugin_installations(id),
+    task_daily_hard_cap      INT NOT NULL DEFAULT 36,
+    plan_tier                VARCHAR(20) NOT NULL DEFAULT 'free',
+    created_at               TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at               TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
diff --git a/server/migrations_monitoring/20260410103000_create_monitoring_tables.down.sql b/server/migrations_monitoring/20260410103000_create_monitoring_tables.down.sql
new file mode 100644
index 0000000..1f06192
--- /dev/null
+++ b/server/migrations_monitoring/20260410103000_create_monitoring_tables.down.sql
@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS monitoring_brand_platform_daily;
+DROP TABLE IF EXISTS monitoring_brand_daily;
+DROP TABLE IF EXISTS monitoring_article_url_aliases;
+DROP TABLE IF EXISTS site_domain_mappings;
+DROP TABLE IF EXISTS monitoring_citation_facts;
+DROP TABLE IF EXISTS question_monitor_parse_results;
+DROP TABLE IF EXISTS question_monitor_runs;
+DROP TABLE IF EXISTS monitoring_collect_tasks;
+DROP TABLE IF EXISTS monitoring_platform_access_snapshots;
+DROP TABLE IF EXISTS monitoring_question_config_snapshots;
diff --git a/server/migrations_monitoring/20260410103000_create_monitoring_tables.up.sql b/server/migrations_monitoring/20260410103000_create_monitoring_tables.up.sql
new file mode 100644
index 0000000..c6dc327
--- /dev/null
+++ b/server/migrations_monitoring/20260410103000_create_monitoring_tables.up.sql
@@ -0,0 +1,239 @@
+CREATE TABLE monitoring_question_config_snapshots (
+    id                     BIGSERIAL PRIMARY KEY,
+    tenant_id              BIGINT NOT NULL,
+    brand_id               BIGINT NOT NULL,
+    question_id            BIGINT NOT NULL,
+    keyword_id             BIGINT,
+    question_hash          BYTEA NOT NULL,
+    question_text_snapshot TEXT NOT NULL,
+    monitor_enabled        BOOLEAN NOT NULL DEFAULT true,
+    superseded_at          TIMESTAMPTZ,
+    deleted_at             TIMESTAMPTZ,
+    projected_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    created_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_monitoring_question_snapshot UNIQUE (tenant_id, question_id, question_hash)
+);
+
+CREATE INDEX idx_monitoring_question_snapshot_active
+    ON monitoring_question_config_snapshots(tenant_id, brand_id, monitor_enabled, deleted_at, superseded_at);
+
+CREATE TABLE monitoring_platform_access_snapshots (
+    id              BIGSERIAL PRIMARY KEY,
+    tenant_id       BIGINT NOT NULL,
+    installation_id BIGINT NOT NULL,
+    ai_platform_id  VARCHAR(30) NOT NULL,
+    business_date   DATE NOT NULL,
+    access_status   VARCHAR(20) NOT NULL,
+    connected       BOOLEAN NOT NULL DEFAULT false,
+    accessible      BOOLEAN NOT NULL DEFAULT false,
+    detected_at     TIMESTAMPTZ NOT NULL,
+    reason_code     VARCHAR(50),
+    reason_message  TEXT,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_platform_access_snapshot UNIQUE (tenant_id, installation_id, ai_platform_id, business_date)
+);
+
+CREATE INDEX idx_platform_access_snapshot_lookup
+    ON monitoring_platform_access_snapshots(tenant_id, business_date, ai_platform_id, access_status);
+
+CREATE TABLE monitoring_collect_tasks (
+    id                   BIGSERIAL PRIMARY KEY,
+    tenant_id            BIGINT NOT NULL,
+    brand_id             BIGINT NOT NULL,
+    question_id          BIGINT NOT NULL,
+    question_hash        BYTEA NOT NULL,
+    ai_platform_id       VARCHAR(30) NOT NULL,
+    collector_type       VARCHAR(20) NOT NULL DEFAULT 'plugin',
+    trigger_source       VARCHAR(20) NOT NULL DEFAULT 'automatic',
+    run_mode             VARCHAR(30) NOT NULL DEFAULT 'plugin_standard',
+    business_date        DATE NOT NULL,
+    planned_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    status               VARCHAR(20) NOT NULL DEFAULT 'pending',
+    lease_token_hash     VARCHAR(128),
+    leased_to_executor   VARCHAR(100),
+    leased_at            TIMESTAMPTZ,
+    lease_expires_at     TIMESTAMPTZ,
+    callback_received_at TIMESTAMPTZ,
+    completed_at         TIMESTAMPTZ,
+    skip_reason          VARCHAR(50),
+    request_payload_json JSONB,
+    error_message        TEXT,
+    created_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_collect_task_idempotent
+        UNIQUE (tenant_id, brand_id, question_id, ai_platform_id, collector_type, run_mode, business_date)
+);
+
+CREATE INDEX idx_collect_tasks_lease
+    ON monitoring_collect_tasks(tenant_id, status, business_date, lease_expires_at);
+
+CREATE TABLE question_monitor_runs (
+    id                     BIGSERIAL PRIMARY KEY,
+    tenant_id              BIGINT NOT NULL,
+    brand_id               BIGINT NOT NULL,
+    question_id            BIGINT NOT NULL,
+    question_text_snapshot TEXT NOT NULL,
+    question_hash          BYTEA NOT NULL,
+    ai_platform_id         VARCHAR(30) NOT NULL,
+    collector_type         VARCHAR(20) NOT NULL DEFAULT 'plugin',
+    trigger_source         VARCHAR(20) NOT NULL DEFAULT 'automatic',
+    run_mode               VARCHAR(30) NOT NULL DEFAULT 'plugin_standard',
+    business_date          DATE NOT NULL,
+    provider_model         VARCHAR(100),
+    provider_request_id    VARCHAR(100),
+    request_id             VARCHAR(100),
+    raw_answer_text        TEXT,
+    raw_answer_storage_key TEXT,
+    raw_response_json      JSONB,
+    status                 VARCHAR(20) NOT NULL DEFAULT 'succeeded',
+    completed_at           TIMESTAMPTZ,
+    created_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_monitor_run_idempotent
+        UNIQUE (tenant_id, brand_id, question_id, ai_platform_id, collector_type, run_mode, business_date)
+);
+
+CREATE INDEX idx_monitor_runs_query
+    ON question_monitor_runs(tenant_id, business_date, ai_platform_id, brand_id);
+
+CREATE TABLE question_monitor_parse_results (
+    id                     BIGSERIAL PRIMARY KEY,
+    tenant_id              BIGINT NOT NULL,
+    run_id                 BIGINT NOT NULL REFERENCES question_monitor_runs(id) ON DELETE CASCADE,
+    brand_id               BIGINT NOT NULL,
+    question_id            BIGINT NOT NULL,
+    question_hash          BYTEA NOT NULL,
+    ai_platform_id         VARCHAR(30) NOT NULL,
+    business_date          DATE NOT NULL,
+    brand_mentioned        BOOLEAN,
+    brand_mention_position VARCHAR(20),
+    first_recommended      BOOLEAN,
+    sentiment_label        VARCHAR(20),
+    matched_brand_terms    JSONB,
+    parse_version          VARCHAR(40) NOT NULL DEFAULT 'v1',
+    parse_status           VARCHAR(20) NOT NULL DEFAULT 'succeeded',
+    created_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_question_parse_run UNIQUE (tenant_id, run_id)
+);
+
+CREATE INDEX idx_question_parse_lookup
+    ON question_monitor_parse_results(tenant_id, business_date, brand_id, question_id, ai_platform_id);
+
+CREATE TABLE monitoring_citation_facts (
+    id                    BIGSERIAL PRIMARY KEY,
+    tenant_id             BIGINT NOT NULL,
+    run_id                BIGINT NOT NULL REFERENCES question_monitor_runs(id) ON DELETE CASCADE,
+    brand_id              BIGINT NOT NULL,
+    ai_platform_id        VARCHAR(30) NOT NULL,
+    business_date         DATE NOT NULL,
+    cited_url             TEXT NOT NULL,
+    cited_title           TEXT,
+    normalized_url        TEXT NOT NULL,
+    host                  VARCHAR(255) NOT NULL,
+    registrable_domain    VARCHAR(255) NOT NULL,
+    subdomain             VARCHAR(255),
+    suffix                VARCHAR(50),
+    site_key              VARCHAR(255) NOT NULL,
+    article_id            BIGINT,
+    publish_record_id     BIGINT,
+    resolution_status     VARCHAR(20) NOT NULL DEFAULT 'resolved',
+    resolution_confidence VARCHAR(20) NOT NULL DEFAULT 'high',
+    created_at            TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_citation_facts_domain
+    ON monitoring_citation_facts(tenant_id, business_date, registrable_domain);
+
+CREATE INDEX idx_citation_facts_run
+    ON monitoring_citation_facts(run_id);
+
+CREATE TABLE site_domain_mappings (
+    id                 BIGSERIAL PRIMARY KEY,
+    tenant_id          BIGINT,
+    registrable_domain VARCHAR(255) NOT NULL,
+    site_key           VARCHAR(255) NOT NULL,
+    site_name          VARCHAR(255) NOT NULL,
+    is_active          BOOLEAN NOT NULL DEFAULT true,
+    created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX idx_site_domain_mappings_lookup
+    ON site_domain_mappings(tenant_id, registrable_domain, is_active);
+
+CREATE TABLE monitoring_article_url_aliases (
+    id                             BIGSERIAL PRIMARY KEY,
+    tenant_id                      BIGINT NOT NULL,
+    article_id                     BIGINT NOT NULL,
+    publish_record_id              BIGINT,
+    platform_id                    VARCHAR(64),
+    publish_platform_name_snapshot VARCHAR(100),
+    external_article_id            VARCHAR(128),
+    article_title_snapshot         TEXT,
+    original_url                   TEXT NOT NULL,
+    normalized_url                 TEXT NOT NULL,
+    last_path_segment              VARCHAR(255),
+    confidence                     VARCHAR(20) NOT NULL DEFAULT 'high',
+    created_at                     TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at                     TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX uk_article_url_alias
+    ON monitoring_article_url_aliases(tenant_id, normalized_url);
+
+CREATE TABLE monitoring_brand_daily (
+    id                       BIGSERIAL PRIMARY KEY,
+    tenant_id                BIGINT NOT NULL,
+    brand_id                 BIGINT NOT NULL,
+    collector_type           VARCHAR(20) NOT NULL DEFAULT 'plugin',
+    business_date            DATE NOT NULL,
+    sample_status            VARCHAR(20) NOT NULL,
+    desired_sample_count     INT NOT NULL DEFAULT 0,
+    planned_sample_count     INT NOT NULL DEFAULT 0,
+    actual_sample_count      INT NOT NULL DEFAULT 0,
+    coverage_rate            NUMERIC(8,4),
+    confidence_level         VARCHAR(20) NOT NULL,
+    trigger_source           VARCHAR(20),
+    snapshot_updated_at      TIMESTAMPTZ,
+    mentioned_count          INT NOT NULL DEFAULT 0,
+    top1_mentioned_count     INT NOT NULL DEFAULT 0,
+    first_recommended_count  INT NOT NULL DEFAULT 0,
+    positive_mentioned_count INT NOT NULL DEFAULT 0,
+    cited_answer_count       INT NOT NULL DEFAULT 0,
+    mention_rate             NUMERIC(8,4),
+    top1_mention_rate        NUMERIC(8,4),
+    first_recommend_rate     NUMERIC(8,4),
+    positive_mention_rate    NUMERIC(8,4),
+    citation_rate            NUMERIC(8,4),
+    created_at               TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at               TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_monitoring_brand_daily
+        UNIQUE (tenant_id, brand_id, collector_type, business_date)
+);
+
+CREATE INDEX idx_monitoring_brand_daily_lookup
+    ON monitoring_brand_daily(tenant_id, brand_id, business_date DESC, collector_type);
+
+CREATE TABLE monitoring_brand_platform_daily (
+    id                     BIGSERIAL PRIMARY KEY,
+    tenant_id              BIGINT NOT NULL,
+    brand_id               BIGINT NOT NULL,
+    ai_platform_id         VARCHAR(30) NOT NULL,
+    collector_type         VARCHAR(20) NOT NULL DEFAULT 'plugin',
+    business_date          DATE NOT NULL,
+    platform_sample_status VARCHAR(20) NOT NULL,
+    planned_sample_count   INT NOT NULL DEFAULT 0,
+    actual_sample_count    INT NOT NULL DEFAULT 0,
+    mention_rate           NUMERIC(8,4),
+    top1_mention_rate      NUMERIC(8,4),
+    last_sampled_at        TIMESTAMPTZ,
+    created_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at             TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT uk_monitoring_brand_platform_daily
+        UNIQUE (tenant_id, brand_id, ai_platform_id, collector_type, business_date)
+);
+
+CREATE INDEX idx_monitoring_brand_platform_daily_lookup
+    ON monitoring_brand_platform_daily(tenant_id, brand_id, business_date DESC, ai_platform_id);